diff --git "a/dist/ort-wasm-simd-threaded.jsep.mjs" "b/dist/ort-wasm-simd-threaded.jsep.mjs" new file mode 100755--- /dev/null +++ "b/dist/ort-wasm-simd-threaded.jsep.mjs" @@ -0,0 +1,9213 @@ +var ortWasmThreaded = (() => { + var _scriptName = import.meta.url; + + return ( +async function(moduleArg = {}) { + var moduleRtn; + +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(moduleArg) => Promise +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = moduleArg; + +// Set up the promise that indicates the Module is initialized +var readyPromiseResolve, readyPromiseReject; + +var readyPromise = new Promise((resolve, reject) => { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == "object"; + +var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined"; + +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer"; + +// Three configurations we can be running in: +// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false) +// 2) We could be the application main() thread proxied to worker. (with Emscripten -sPROXY_TO_WORKER) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false) +// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true) +// The way we signal to a worker that it is hosting a pthread is to construct +// it with a specific name. +var ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && self.name?.startsWith("em-pthread"); + +if (ENVIRONMENT_IS_NODE) { + // When building an ES module `require` is not normally available. + // We need to use `createRequire()` to construct the require()` function. + const {createRequire} = await import("module"); + /** @suppress{duplicate} */ var require = createRequire(import.meta.url); + var worker_threads = require("worker_threads"); + global.Worker = worker_threads.Worker; + ENVIRONMENT_IS_WORKER = !worker_threads.isMainThread; + // Under node we set `workerData` to `em-pthread` to signal that the worker + // is hosting a pthread. + ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && worker_threads["workerData"] == "em-pthread"; +} + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) +// include: /home/gs/onnxruntime/onnxruntime/wasm/pre.js +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. +// This file contains the pre-run code for the ORT WebAssembly module. The code in this file will be injected into the +// final module using Emscripten's `--pre-js` option. +/** + * Mount external data files of a model to an internal map, which will be used during session initialization. + * + * @param {string} externalDataFilesPath + * @param {Uint8Array} externalDataFilesData + */ Module["mountExternalData"] = (externalDataFilePath, externalDataFileData) => { + if (externalDataFilePath.startsWith("./")) { + externalDataFilePath = externalDataFilePath.substring(2); + } + const files = Module.MountedFiles || (Module.MountedFiles = new Map); + files.set(externalDataFilePath, externalDataFileData); +}; + +/** + * Unmount external data files of a model. + */ Module["unmountExternalData"] = () => { + delete Module.MountedFiles; +}; + +/** + * A workaround for SharedArrayBuffer when it is not available in the current context. + * + * We need this workaround because Emscripten generates code that assumes `SharedArrayBuffer` is always available and + * uses SharedArrayBuffer in this way: + * ```js + * buffer instanceof SharedArrayBuffer + * ``` + * + * This code will throw an error when SharedArrayBuffer is not available. Fortunately, we can use `WebAssembly.Memory` + * to create an instance of SharedArrayBuffer even when SharedArrayBuffer is not available in `globalThis`. + * + * While this workaround allows the WebAssembly module to be loaded, it does not provide multi-threading features when + * SharedArrayBuffer is not available in `globalThis`. The WebAssembly module will run well in a single thread, when: + * - Module['numThreads'] is set to 1, and + * - _OrtInit() is called with numThreads = 1. + * + * @suppress {checkVars} + */ var SharedArrayBuffer = globalThis.SharedArrayBuffer ?? new WebAssembly.Memory({ + initial: 0, + maximum: 0, + shared: true +}).buffer.constructor; + +// end include: /home/gs/onnxruntime/onnxruntime/wasm/pre.js +// include: /home/gs/onnxruntime/onnxruntime/wasm/pre-jsep.js +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. +// This file contains the pre-run code for the ORT WebAssembly module. The code in this file will be injected into the +// final module using Emscripten's `--pre-js` option. +// This file will only be used in build with flag `--use_jsep`. +// This is a wrapper for OrtRun() and OrtRunWithBinding() to ensure that Promises are handled correctly. +const jsepRunAsync = runAsyncFunc => async (...args) => { + try { + // Module.jsepSessionState should be null, unless we are in the middle of a session. + // If it is not null, it means that the previous session has not finished yet. + if (Module.jsepSessionState) { + throw new Error("Session already started"); + } + const state = (Module.jsepSessionState = { + sessionHandle: args[0], + errors: [] + }); + // Run the acyncified function: OrtRun() or OrtRunWithBinding() + const ret = await runAsyncFunc(...args); + // Check if the session is still valid. this object should be the same as the one we set above. + if (Module.jsepSessionState !== state) { + throw new Error("Session mismatch"); + } + // Flush the backend. This will submit all pending commands to the GPU. + Module.jsepBackend?.["flush"](); + // Await all pending promises. This includes GPU validation promises for diagnostic purposes. + const errorPromises = state.errors; + if (errorPromises.length > 0) { + let errors = await Promise.all(errorPromises); + errors = errors.filter(e => e); + if (errors.length > 0) { + throw new Error(errors.join("\n")); + } + } + return ret; + } finally { + Module.jsepSessionState = null; + } +}; + +/** + * initialize JSEP for WebGPU and WebNN. + */ Module["jsepInit"] = (name, params) => { + if (name === "webgpu") { + [Module.jsepBackend, Module.jsepAlloc, Module.jsepFree, Module.jsepCopy, Module.jsepCopyAsync, Module.jsepCreateKernel, Module.jsepReleaseKernel, Module.jsepRunKernel, Module.jsepCaptureBegin, Module.jsepCaptureEnd, Module.jsepReplay] = params; + // expose webgpu backend functions + const backend = Module.jsepBackend; + Module["jsepRegisterBuffer"] = (sessionId, index, buffer, size) => backend["registerBuffer"](sessionId, index, buffer, size); + Module["jsepGetBuffer"] = dataId => backend["getBuffer"](dataId); + Module["jsepCreateDownloader"] = (gpuBuffer, size, type) => backend["createDownloader"](gpuBuffer, size, type); + Module["jsepOnCreateSession"] = sessionId => { + backend["onCreateSession"](sessionId); + }; + Module["jsepOnReleaseSession"] = sessionId => { + backend["onReleaseSession"](sessionId); + }; + Module["jsepOnRunStart"] = sessionId => backend["onRunStart"](sessionId); + Module.jsepUploadExternalBuffer = (dataId, buffer) => { + backend["upload"](dataId, buffer); + }; + } else if (name === "webnn") { + // Functions called from EM_ASM need to be assigned in a way that can be minified. + // Functions called via emscripten::val::module_property need to be assigned by name so that the minifier doesn't + // change the name. + const backend = params[0]; + [Module.webnnReserveTensorId, Module.webnnReleaseTensorId, Module["webnnEnsureTensor"], Module.webnnUploadTensor, Module["webnnDownloadTensor"]] = params.slice(1); + // This function is called from both JS and an EM_ASM block, it needs both a minifiable name and an explicit name. + Module["webnnReleaseTensorId"] = Module.webnnReleaseTensorId; + Module["webnnUploadTensor"] = Module.webnnUploadTensor; + // Functions called from JS also need to have explicit names. + Module["webnnOnRunStart"] = sessionId => backend["onRunStart"](sessionId); + Module["webnnOnRunEnd"] = backend["onRunEnd"].bind(backend); + Module["webnnRegisterMLContext"] = (sessionId, mlContext) => { + backend["registerMLContext"](sessionId, mlContext); + }; + Module["webnnOnReleaseSession"] = sessionId => { + backend["onReleaseSession"](sessionId); + }; + Module["webnnCreateMLTensorDownloader"] = (tensorId, type) => backend["createMLTensorDownloader"](tensorId, type); + Module["webnnRegisterMLTensor"] = (sessionId, tensor, dataType, shape) => backend["registerMLTensor"](sessionId, tensor, dataType, shape); + Module["webnnCreateMLContext"] = optionsOrGpuDevice => backend["createMLContext"](optionsOrGpuDevice); + Module["webnnRegisterMLConstant"] = (externalFilePath, dataOffset, dataLength, builder, desc, shouldConvertInt64ToInt32) => backend["registerMLConstant"](externalFilePath, dataOffset, dataLength, builder, desc, Module.MountedFiles, shouldConvertInt64ToInt32); + Module["webnnRegisterGraphInput"] = backend["registerGraphInput"].bind(backend); + Module["webnnIsGraphInput"] = backend["isGraphInput"].bind(backend); + Module["webnnRegisterGraphOutput"] = backend["registerGraphOutput"].bind(backend); + Module["webnnIsGraphOutput"] = backend["isGraphOutput"].bind(backend); + Module["webnnCreateTemporaryTensor"] = backend["createTemporaryTensor"].bind(backend); + Module["webnnIsGraphInputOutputTypeSupported"] = backend["isGraphInputOutputTypeSupported"].bind(backend); + } +}; + +// end include: /home/gs/onnxruntime/onnxruntime/wasm/pre-jsep.js +// include: /home/gs/onnxruntime/onnxruntime/wasm/pre-async.js +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. +// This file contains the pre-run code for the ORT WebAssembly module. The code in this file will be injected into the +// final module using Emscripten's `--pre-js` option. +// This file will only be used in build with flag `-s ASYNCIFY=1`. +/** + * initialize for asyncify support. + */ let initAsyncImpl = () => { + // This is a simplified version of cwrap() with options.async === true (-sASYNCIFY=1) + // It removes some overhead in cwarp() and ccall() that we don't need. + // Currently in ASYNCIFY build, we only use this for the following functions: + // - OrtCreateSession() + // - OrtRun() + // - OrtRunWithBinding() + // - OrtBindInput() + // Note: about parameters "getFunc" and "setFunc": + // - Emscripten has different behaviors for Debug and Release builds for generating exported function wrapper. + // - In Debug build, it will generate a wrapper function for each exported function. For example, it generates a + // wrapper for OrtRun() like this (minified): + // ``` + // var _OrtRun = Module["_OrtRun"] = createExportWrapper("OrtRun"); + // ``` + // - In Release build, it will generate a lazy loading wrapper for each exported function. For example, it generates + // a wrapper for OrtRun() like this (minified): + // ``` + // d._OrtRun = (a, b, c, e, f, h, l, q) => (d._OrtRun = J.ka)(a, b, c, e, f, h, l, q); + // ``` + // The behavior of these two wrappers are different. The debug build will assign `Module["_OrtRun"]` only once + // because `createExportWrapper()` does not reset `Module["_OrtRun"]` inside. The release build, however, will + // reset d._OrtRun to J.ka when the first time it is called. + // The difference is important because we need to design the async wrapper in a way that it can handle both cases. + // Now, let's look at how the async wrapper is designed to work for both cases: + // - Debug build: + // 1. When Web assembly is being loaded, `Module["_OrtRun"]` is assigned to `createExportWrapper("OrtRun")`. + // 2. When the first time `Module["initAsync"]` is called, `Module["_OrtRun"]` is re-assigned to a new async + // wrapper function. + // Value of `Module["_OrtRun"]` will not be changed again. + // - Release build: + // 1. When Web assembly is being loaded, `Module["_OrtRun"]` is assigned to a lazy loading wrapper function. + // 2. When the first time `Module["initAsync"]` is called, `Module["_OrtRun"]` is re-assigned to a new async + // wrapper function. + // 3. When the first time `Module["_OrtRun"]` is called, the async wrapper will be called. It will call into this + // function: + // ``` + // (a, b, c, e, f, h, l, q) => (d._OrtRun = J.ka)(a, b, c, e, f, h, l, q); + // ``` + // This function will assign d._OrtRun (ie. the minimized `Module["_OrtRun"]`) to the real function (J.ka). + // 4. Since d._OrtRun is re-assigned, we need to update the async wrapper to re-assign its stored + // function to the updated value (J.ka), and re-assign the value of `d._OrtRun` back to the async wrapper. + // Value of `Module["_OrtRun"]` will not be changed again. + // The value of `Module["_OrtRun"]` will need to be assigned for 2 times for debug build and 4 times for release + // build. + // This is why we need this `getFunc` and `setFunc` parameters. They are used to get the current value of an + // exported function and set the new value of an exported function. + const wrapAsync = (func, getFunc, setFunc) => (...args) => { + // cache the async data before calling the function. + const previousAsync = Asyncify.currData; + const previousFunc = getFunc?.(); + const ret = func(...args); + const newFunc = getFunc?.(); + if (previousFunc !== newFunc) { + // The exported function has been updated. + // Set the sync function reference to the new function. + func = newFunc; + // Set the exported function back to the async wrapper. + setFunc(previousFunc); + // Remove getFunc and setFunc. They are no longer needed. + setFunc = null; + getFunc = null; + } + // If the async data has been changed, it means that the function started an async operation. + if (Asyncify.currData != previousAsync) { + // returns the promise + return Asyncify.whenDone(); + } + // the function is synchronous. returns the result. + return ret; + }; + // replace the original functions with asyncified versions + const wrapAsyncAPIs = funcNames => { + for (const funcName of funcNames) { + Module[funcName] = wrapAsync(Module[funcName], () => Module[funcName], v => (Module[funcName] = v)); + } + }; + wrapAsyncAPIs([ "_OrtAppendExecutionProvider", "_OrtCreateSession", "_OrtRun", "_OrtRunWithBinding", "_OrtBindInput" ]); + // If JSEP is enabled, wrap OrtRun() and OrtRunWithBinding() with asyncify. + if (typeof jsepRunAsync !== "undefined") { + Module["_OrtRun"] = jsepRunAsync(Module["_OrtRun"]); + Module["_OrtRunWithBinding"] = jsepRunAsync(Module["_OrtRunWithBinding"]); + } + // remove this function to make sure it is called only once. + initAsyncImpl = undefined; +}; + +Module["asyncInit"] = () => { + initAsyncImpl?.(); +}; + +// end include: /home/gs/onnxruntime/onnxruntime/wasm/pre-async.js +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; + +var thisProgram = "./this.program"; + +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ""; + +function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var readAsync, readBinary; + +if (ENVIRONMENT_IS_NODE) { + // These modules will usually be used on Node.js. Load them eagerly to avoid + // the complexity of lazy-loading. + var fs = require("fs"); + var nodePath = require("path"); + // EXPORT_ES6 + ENVIRONMENT_IS_NODE always requires use of import.meta.url, + // since there's no way getting the current absolute path of the module when + // support for that is not available. + if (!import.meta.url.startsWith("data:")) { + scriptDirectory = nodePath.dirname(require("url").fileURLToPath(import.meta.url)) + "/"; + } + // include: node_shell_read.js + readBinary = filename => { + // We need to re-wrap `file://` strings to URLs. + filename = isFileURI(filename) ? new URL(filename) : filename; + var ret = fs.readFileSync(filename); + return ret; + }; + readAsync = async (filename, binary = true) => { + // See the comment in the `readBinary` function. + filename = isFileURI(filename) ? new URL(filename) : filename; + var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); + return ret; + }; + // end include: node_shell_read.js + if (!Module["thisProgram"] && process.argv.length > 1) { + thisProgram = process.argv[1].replace(/\\/g, "/"); + } + arguments_ = process.argv.slice(2); + // MODULARIZE will export the module in the proper place outside, we don't need to export here + quit_ = (status, toThrow) => { + process.exitCode = status; + throw toThrow; + }; +} else // Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != "undefined" && document.currentScript) { + // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE, this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptName) { + scriptDirectory = _scriptName; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.startsWith("blob:")) { + scriptDirectory = ""; + } else { + scriptDirectory = scriptDirectory.slice(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1); + } + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + if (!ENVIRONMENT_IS_NODE) { + // include: web_or_worker_shell_read.js + if (ENVIRONMENT_IS_WORKER) { + readBinary = url => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response)); + }; + } + readAsync = async url => { + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use XHR on webview if URL is a file URL. + if (isFileURI(url)) { + return new Promise((resolve, reject) => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { + // file URLs can return 0 + resolve(xhr.response); + return; + } + reject(xhr.status); + }; + xhr.onerror = reject; + xhr.send(null); + }); + } + var response = await fetch(url, { + credentials: "same-origin" + }); + if (response.ok) { + return response.arrayBuffer(); + } + throw new Error(response.status + " : " + response.url); + }; + } +} else {} + +// Set up the out() and err() hooks, which are how we can print to stdout or +// stderr, respectively. +// Normally just binding console.log/console.error here works fine, but +// under node (with workers) we see missing/out-of-order messages so route +// directly to stdout and stderr. +// See https://github.com/emscripten-core/emscripten/issues/14804 +var defaultPrint = console.log.bind(console); + +var defaultPrintErr = console.error.bind(console); + +if (ENVIRONMENT_IS_NODE) { + defaultPrint = (...args) => fs.writeSync(1, args.join(" ") + "\n"); + defaultPrintErr = (...args) => fs.writeSync(2, args.join(" ") + "\n"); +} + +var out = defaultPrint; + +var err = defaultPrintErr; + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); + +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used. +moduleOverrides = null; + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// end include: shell.js +// include: preamble.js +// === Preamble library stuff === +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html +var wasmBinary = Module["wasmBinary"]; + +// Wasm globals +var wasmMemory; + +// For sending to workers. +var wasmModule; + +//======================================== +// Runtime essentials +//======================================== +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +// In STRICT mode, we only define assert() when ASSERTIONS is set. i.e. we +// don't define it at all in release modes. This matches the behaviour of +// MINIMAL_RUNTIME. +// TODO(sbc): Make this the default even without STRICT enabled. +/** @type {function(*, string=)} */ function assert(condition, text) { + if (!condition) { + // This build was created without ASSERTIONS defined. `assert()` should not + // ever be called in this configuration but in case there are callers in + // the wild leave this simple abort() implementation here for now. + abort(text); + } +} + +// Memory management +var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /* BigInt64Array type is not correctly defined in closure +/** not-@type {!BigInt64Array} */ HEAP64, /* BigUint64Array type is not correctly defined in closure +/** not-t@type {!BigUint64Array} */ HEAPU64, /** @type {!Float64Array} */ HEAPF64; + +var runtimeInitialized = false; + +/** + * Indicates whether filename is delivered via file protocol (as opposed to http/https) + * @noinline + */ var isFileURI = filename => filename.startsWith("file://"); + +// include: runtime_shared.js +// include: runtime_stack_check.js +// end include: runtime_stack_check.js +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +// include: runtime_debug.js +// end include: runtime_debug.js +// include: memoryprofiler.js +// end include: memoryprofiler.js +// include: growableHeap.js +// Support for growable heap + pthreads, where the buffer may change, so JS views +// must be updated. +function GROWABLE_HEAP_I8() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP8; +} + +function GROWABLE_HEAP_U8() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU8; +} + +function GROWABLE_HEAP_I16() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP16; +} + +function GROWABLE_HEAP_U16() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU16; +} + +function GROWABLE_HEAP_I32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP32; +} + +function GROWABLE_HEAP_U32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU32; +} + +function GROWABLE_HEAP_F32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPF32; +} + +function GROWABLE_HEAP_F64() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPF64; +} + +// end include: growableHeap.js +// include: runtime_pthread.js +// Pthread Web Worker handling code. +// This code runs only on pthread web workers and handles pthread setup +// and communication with the main thread via postMessage. +if (ENVIRONMENT_IS_PTHREAD) { + var wasmModuleReceived; + // Node.js support + if (ENVIRONMENT_IS_NODE) { + // Create as web-worker-like an environment as we can. + var parentPort = worker_threads["parentPort"]; + parentPort.on("message", msg => onmessage({ + data: msg + })); + Object.assign(globalThis, { + self: global, + postMessage: msg => parentPort.postMessage(msg) + }); + } + // Thread-local guard variable for one-time init of the JS state + var initializedJS = false; + function threadPrintErr(...args) { + var text = args.join(" "); + // See https://github.com/emscripten-core/emscripten/issues/14804 + if (ENVIRONMENT_IS_NODE) { + fs.writeSync(2, text + "\n"); + return; + } + console.error(text); + } + err = threadPrintErr; + function threadAlert(...args) { + var text = args.join(" "); + postMessage({ + cmd: "alert", + text, + threadId: _pthread_self() + }); + } + self.alert = threadAlert; + // Turn unhandled rejected promises into errors so that the main thread will be + // notified about them. + self.onunhandledrejection = e => { + throw e.reason || e; + }; + function handleMessage(e) { + try { + var msgData = e["data"]; + //dbg('msgData: ' + Object.keys(msgData)); + var cmd = msgData.cmd; + if (cmd === "load") { + // Preload command that is called once per worker to parse and load the Emscripten code. + // Until we initialize the runtime, queue up any further incoming messages. + let messageQueue = []; + self.onmessage = e => messageQueue.push(e); + // And add a callback for when the runtime is initialized. + self.startWorker = instance => { + // Notify the main thread that this thread has loaded. + postMessage({ + cmd: "loaded" + }); + // Process any messages that were queued before the thread was ready. + for (let msg of messageQueue) { + handleMessage(msg); + } + // Restore the real message handler. + self.onmessage = handleMessage; + }; + // Use `const` here to ensure that the variable is scoped only to + // that iteration, allowing safe reference from a closure. + for (const handler of msgData.handlers) { + // The the main module has a handler for a certain even, but no + // handler exists on the pthread worker, then proxy that handler + // back to the main thread. + if (!Module[handler] || Module[handler].proxy) { + Module[handler] = (...args) => { + postMessage({ + cmd: "callHandler", + handler, + args + }); + }; + // Rebind the out / err handlers if needed + if (handler == "print") out = Module[handler]; + if (handler == "printErr") err = Module[handler]; + } + } + wasmMemory = msgData.wasmMemory; + updateMemoryViews(); + wasmModuleReceived(msgData.wasmModule); + } else if (cmd === "run") { + // Call inside JS module to set up the stack frame for this pthread in JS module scope. + // This needs to be the first thing that we do, as we cannot call to any C/C++ functions + // until the thread stack is initialized. + establishStackSpace(msgData.pthread_ptr); + // Pass the thread address to wasm to store it for fast access. + __emscripten_thread_init(msgData.pthread_ptr, /*is_main=*/ 0, /*is_runtime=*/ 0, /*can_block=*/ 1, 0, 0); + PThread.threadInitTLS(); + // Await mailbox notifications with `Atomics.waitAsync` so we can start + // using the fast `Atomics.notify` notification path. + __emscripten_thread_mailbox_await(msgData.pthread_ptr); + if (!initializedJS) { + // Embind must initialize itself on all threads, as it generates support JS. + // We only do this once per worker since they get reused + __embind_initialize_bindings(); + initializedJS = true; + } + try { + invokeEntryPoint(msgData.start_routine, msgData.arg); + } catch (ex) { + if (ex != "unwind") { + // The pthread "crashed". Do not call `_emscripten_thread_exit` (which + // would make this thread joinable). Instead, re-throw the exception + // and let the top level handler propagate it back to the main thread. + throw ex; + } + } + } else if (msgData.target === "setimmediate") {} else if (cmd === "checkMailbox") { + if (initializedJS) { + checkMailbox(); + } + } else if (cmd) { + // The received message looks like something that should be handled by this message + // handler, (since there is a cmd field present), but is not one of the + // recognized commands: + err(`worker: received unknown command ${cmd}`); + err(msgData); + } + } catch (ex) { + __emscripten_thread_crashed(); + throw ex; + } + } + self.onmessage = handleMessage; +} + +// ENVIRONMENT_IS_PTHREAD +// end include: runtime_pthread.js +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module["HEAP8"] = HEAP8 = new Int8Array(b); + Module["HEAP16"] = HEAP16 = new Int16Array(b); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(b); + Module["HEAP32"] = HEAP32 = new Int32Array(b); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(b); + Module["HEAPF32"] = HEAPF32 = new Float32Array(b); + Module["HEAPF64"] = HEAPF64 = new Float64Array(b); + Module["HEAP64"] = HEAP64 = new BigInt64Array(b); + Module["HEAPU64"] = HEAPU64 = new BigUint64Array(b); +} + +// end include: runtime_shared.js +// In non-standalone/normal mode, we create the memory here. +// include: runtime_init_memory.js +// Create the wasm memory. (Note: this only applies if IMPORTED_MEMORY is defined) +// check for full engine support (use string 'subarray' to avoid closure compiler confusion) +if (!ENVIRONMENT_IS_PTHREAD) { + { + var INITIAL_MEMORY = 16777216; + /** @suppress {checkTypes} */ wasmMemory = new WebAssembly.Memory({ + "initial": INITIAL_MEMORY / 65536, + // In theory we should not need to emit the maximum if we want "unlimited" + // or 4GB of memory, but VMs error on that atm, see + // https://github.com/emscripten-core/emscripten/issues/14130 + // And in the pthreads case we definitely need to emit a maximum. So + // always emit one. + "maximum": 65536, + "shared": true + }); + } + updateMemoryViews(); +} + +// end include: runtime_init_memory.js +function preRun() { + callRuntimeCallbacks(onPreRuns); +} + +function initRuntime() { + runtimeInitialized = true; + if (ENVIRONMENT_IS_PTHREAD) return startWorker(Module); + wasmExports["qf"](); +} + +function postRun() { + if (ENVIRONMENT_IS_PTHREAD) return; +} + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; + +var dependenciesFulfilled = null; + +function addRunDependency(id) { + runDependencies++; +} + +function removeRunDependency(id) { + runDependencies--; + if (runDependencies == 0) { + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } +} + +/** @param {string|number=} what */ function abort(what) { + what = "Aborted(" + what + ")"; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + ABORT = true; + what += ". Build with -sASSERTIONS for more info."; + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + // Suppress closure compiler warning here. Closure compiler's builtin extern + // definition for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what); + readyPromiseReject(e); + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +var wasmBinaryFile; + +function findWasmBinary() { + if (Module["locateFile"]) { + return locateFile("ort-wasm-simd-threaded.jsep.wasm"); + } + // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too. + return new URL("ort-wasm-simd-threaded.jsep.wasm", import.meta.url).href; +} + +function getBinarySync(file) { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; +} + +async function getWasmBinary(binaryFile) { + // If we don't have the binary yet, load it asynchronously using readAsync. + if (!wasmBinary) { + // Fetch the binary using readAsync + try { + var response = await readAsync(binaryFile); + return new Uint8Array(response); + } catch {} + } + // Otherwise, getBinarySync should be able to get it synchronously + return getBinarySync(binaryFile); +} + +async function instantiateArrayBuffer(binaryFile, imports) { + try { + var binary = await getWasmBinary(binaryFile); + var instance = await WebAssembly.instantiate(binary, imports); + return instance; + } catch (reason) { + err(`failed to asynchronously prepare wasm: ${reason}`); + abort(reason); + } +} + +async function instantiateAsync(binary, binaryFile, imports) { + if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) { + try { + var response = fetch(binaryFile, { + credentials: "same-origin" + }); + var instantiationResult = await WebAssembly.instantiateStreaming(response, imports); + return instantiationResult; + } catch (reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err(`wasm streaming compile failed: ${reason}`); + err("falling back to ArrayBuffer instantiation"); + } + } + return instantiateArrayBuffer(binaryFile, imports); +} + +function getWasmImports() { + assignWasmImports(); + // prepare imports + return { + "a": wasmImports + }; +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +async function createWasm() { + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) { + wasmExports = instance.exports; + wasmExports = Asyncify.instrumentWasmExports(wasmExports); + wasmExports = applySignatureConversions(wasmExports); + registerTLSInit(wasmExports["Ag"]); + wasmTable = wasmExports["Bg"]; + // We now have the Wasm module loaded up, keep a reference to the compiled module so we can post it to the workers. + wasmModule = module; + removeRunDependency("wasm-instantiate"); + return wasmExports; + } + // wait for the pthread pool (if any) + addRunDependency("wasm-instantiate"); + // Prefer streaming instantiation if available. + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + return receiveInstance(result["instance"], result["module"]); + } + var info = getWasmImports(); + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module["instantiateWasm"]) { + return new Promise((resolve, reject) => { + Module["instantiateWasm"](info, (mod, inst) => { + receiveInstance(mod, inst); + resolve(mod.exports); + }); + }); + } + if (ENVIRONMENT_IS_PTHREAD) { + return new Promise(resolve => { + wasmModuleReceived = module => { + // Instantiate from the module posted from the main thread. + // We can just use sync instantiation in the worker. + var instance = new WebAssembly.Instance(module, getWasmImports()); + resolve(receiveInstance(instance, module)); + }; + }); + } + wasmBinaryFile ??= findWasmBinary(); + try { + var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info); + var exports = receiveInstantiationResult(result); + return exports; + } catch (e) { + // If instantiation fails, reject the module ready promise. + readyPromiseReject(e); + return Promise.reject(e); + } +} + +// === Body === +var ASM_CONSTS = { + 1635076: ($0, $1, $2, $3, $4) => { + if (typeof Module == "undefined" || !Module.MountedFiles) { + return 1; + } + let fileName = UTF8ToString(Number($0 >>> 0)); + if (fileName.startsWith("./")) { + fileName = fileName.substring(2); + } + const fileData = Module.MountedFiles.get(fileName); + if (!fileData) { + return 2; + } + const offset = Number($1 >>> 0); + const length = Number($2 >>> 0); + const dataIdOrBuffer = Number($3 >>> 0); + const loadType = $4; + if (offset + length > fileData.byteLength) { + return 3; + } + try { + const data = fileData.subarray(offset, offset + length); + switch (loadType) { + case 0: + GROWABLE_HEAP_U8().set(data, dataIdOrBuffer >>> 0); + break; + + case 1: + if (Module.webgpuUploadExternalBuffer) { + Module.webgpuUploadExternalBuffer(dataIdOrBuffer, data); + } else { + Module.jsepUploadExternalBuffer(dataIdOrBuffer, data); + } + break; + + default: + return 4; + } + return 0; + } catch { + return 4; + } + }, + 1635900: ($0, $1, $2) => { + const buffer = Number($0); + const buffer_size = Number($1); + const file_path = UTF8ToString($2); + const bytes = new Uint8Array(buffer_size); + bytes.set(GROWABLE_HEAP_U8().subarray(buffer >>> 0, buffer + buffer_size >>> 0)); + if (typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string") { + require("fs").writeFileSync(file_path, bytes); + } else { + const file = new File([ bytes ], file_path, { + type: "application/octet-stream" + }); + const url = URL.createObjectURL(file); + window.open(url, "_blank"); + } + }, + 1636424: ($0, $1, $2) => { + Module.webnnUploadTensor($0, GROWABLE_HEAP_U8().subarray($1 >>> 0, $1 + $2 >>> 0)); + }, + 1636488: () => Module.webnnReserveTensorId(), + 1636530: $0 => { + Module.webnnReleaseTensorId($0); + }, + 1636567: () => { + Module.jsepCaptureBegin(); + }, + 1636598: () => { + Module.jsepCaptureEnd(); + }, + 1636627: () => { + Module.jsepReplay(); + }, + 1636652: $0 => Module.jsepAlloc($0), + 1636685: $0 => Module.jsepFree($0), + 1636717: ($0, $1, $2) => { + Module.jsepCopy(Number($0), Number($1), Number($2), true); + }, + 1636780: ($0, $1, $2) => { + Module.jsepCopy(Number($0), Number($1), Number($2)); + }, + 1636837: () => (typeof wasmOffsetConverter !== "undefined"), + 1636894: $0 => { + Module.jsepCreateKernel("Abs", $0, undefined); + }, + 1636945: $0 => { + Module.jsepCreateKernel("Neg", $0, undefined); + }, + 1636996: $0 => { + Module.jsepCreateKernel("Floor", $0, undefined); + }, + 1637049: $0 => { + Module.jsepCreateKernel("Ceil", $0, undefined); + }, + 1637101: $0 => { + Module.jsepCreateKernel("Reciprocal", $0, undefined); + }, + 1637159: $0 => { + Module.jsepCreateKernel("Sqrt", $0, undefined); + }, + 1637211: $0 => { + Module.jsepCreateKernel("Exp", $0, undefined); + }, + 1637262: $0 => { + Module.jsepCreateKernel("Erf", $0, undefined); + }, + 1637313: $0 => { + Module.jsepCreateKernel("Sigmoid", $0, undefined); + }, + 1637368: ($0, $1, $2) => { + Module.jsepCreateKernel("HardSigmoid", $0, ({ + "alpha": $1, + "beta": $2 + })); + }, + 1637447: $0 => { + Module.jsepCreateKernel("Log", $0, undefined); + }, + 1637498: $0 => { + Module.jsepCreateKernel("Sin", $0, undefined); + }, + 1637549: $0 => { + Module.jsepCreateKernel("Cos", $0, undefined); + }, + 1637600: $0 => { + Module.jsepCreateKernel("Tan", $0, undefined); + }, + 1637651: $0 => { + Module.jsepCreateKernel("Asin", $0, undefined); + }, + 1637703: $0 => { + Module.jsepCreateKernel("Acos", $0, undefined); + }, + 1637755: $0 => { + Module.jsepCreateKernel("Atan", $0, undefined); + }, + 1637807: $0 => { + Module.jsepCreateKernel("Sinh", $0, undefined); + }, + 1637859: $0 => { + Module.jsepCreateKernel("Cosh", $0, undefined); + }, + 1637911: $0 => { + Module.jsepCreateKernel("Asinh", $0, undefined); + }, + 1637964: $0 => { + Module.jsepCreateKernel("Acosh", $0, undefined); + }, + 1638017: $0 => { + Module.jsepCreateKernel("Atanh", $0, undefined); + }, + 1638070: $0 => { + Module.jsepCreateKernel("Tanh", $0, undefined); + }, + 1638122: $0 => { + Module.jsepCreateKernel("Not", $0, undefined); + }, + 1638173: ($0, $1, $2) => { + Module.jsepCreateKernel("Clip", $0, ({ + "min": $1, + "max": $2 + })); + }, + 1638242: $0 => { + Module.jsepCreateKernel("Clip", $0, undefined); + }, + 1638294: ($0, $1) => { + Module.jsepCreateKernel("Elu", $0, ({ + "alpha": $1 + })); + }, + 1638352: $0 => { + Module.jsepCreateKernel("Gelu", $0, undefined); + }, + 1638404: $0 => { + Module.jsepCreateKernel("Relu", $0, undefined); + }, + 1638456: ($0, $1) => { + Module.jsepCreateKernel("LeakyRelu", $0, ({ + "alpha": $1 + })); + }, + 1638520: ($0, $1) => { + Module.jsepCreateKernel("ThresholdedRelu", $0, ({ + "alpha": $1 + })); + }, + 1638590: ($0, $1) => { + Module.jsepCreateKernel("Cast", $0, ({ + "to": $1 + })); + }, + 1638648: $0 => { + Module.jsepCreateKernel("Add", $0, undefined); + }, + 1638699: $0 => { + Module.jsepCreateKernel("Sub", $0, undefined); + }, + 1638750: $0 => { + Module.jsepCreateKernel("Mul", $0, undefined); + }, + 1638801: $0 => { + Module.jsepCreateKernel("Div", $0, undefined); + }, + 1638852: $0 => { + Module.jsepCreateKernel("Pow", $0, undefined); + }, + 1638903: $0 => { + Module.jsepCreateKernel("Equal", $0, undefined); + }, + 1638956: $0 => { + Module.jsepCreateKernel("Greater", $0, undefined); + }, + 1639011: $0 => { + Module.jsepCreateKernel("GreaterOrEqual", $0, undefined); + }, + 1639073: $0 => { + Module.jsepCreateKernel("Less", $0, undefined); + }, + 1639125: $0 => { + Module.jsepCreateKernel("LessOrEqual", $0, undefined); + }, + 1639184: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceMean", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1639359: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceMax", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1639533: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceMin", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1639707: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceProd", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1639882: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceSum", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1640056: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceL1", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1640229: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceL2", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1640402: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceLogSum", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1640579: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceSumSquare", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1640759: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("ReduceLogSumExp", $0, ({ + "keepDims": !!$1, + "noopWithEmptyAxes": !!$2, + "axes": $3 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0))) : [] + })); + }, + 1640939: $0 => { + Module.jsepCreateKernel("Where", $0, undefined); + }, + 1640992: ($0, $1, $2) => { + Module.jsepCreateKernel("Transpose", $0, ({ + "perm": $1 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($1) >>> 0, Number($2) >>> 0)) : [] + })); + }, + 1641116: ($0, $1, $2, $3) => { + Module.jsepCreateKernel("DepthToSpace", $0, ({ + "blocksize": $1, + "mode": UTF8ToString($2), + "format": $3 ? "NHWC" : "NCHW" + })); + }, + 1641249: ($0, $1, $2, $3) => { + Module.jsepCreateKernel("DepthToSpace", $0, ({ + "blocksize": $1, + "mode": UTF8ToString($2), + "format": $3 ? "NHWC" : "NCHW" + })); + }, + 1641382: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) => { + Module.jsepCreateKernel("ConvTranspose", $0, ({ + "format": $8 ? "NHWC" : "NCHW", + "autoPad": $1, + "dilations": [ $2 ], + "group": $3, + "kernelShape": [ $4 ], + "pads": [ $5, $6 ], + "strides": [ $7 ], + "wIsConst": () => (!!GROWABLE_HEAP_I8()[$9 >>> 0]), + "outputPadding": $10 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($10) >>> 0, Number($11) >>> 0)) : [], + "outputShape": $12 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($12) >>> 0, Number($13) >>> 0)) : [], + "activation": UTF8ToString($14) + })); + }, + 1641815: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) => { + Module.jsepCreateKernel("ConvTranspose", $0, ({ + "format": $7 ? "NHWC" : "NCHW", + "autoPad": $1, + "dilations": Array.from(GROWABLE_HEAP_I32().subarray(Number($2) >>> 0, (Number($2) >>> 0) + 2 >>> 0)), + "group": $3, + "kernelShape": Array.from(GROWABLE_HEAP_I32().subarray(Number($4) >>> 0, (Number($4) >>> 0) + 2 >>> 0)), + "pads": Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, (Number($5) >>> 0) + 4 >>> 0)), + "strides": Array.from(GROWABLE_HEAP_I32().subarray(Number($6) >>> 0, (Number($6) >>> 0) + 2 >>> 0)), + "wIsConst": () => (!!GROWABLE_HEAP_I8()[$8 >>> 0]), + "outputPadding": $9 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($9) >>> 0, Number($10) >>> 0)) : [], + "outputShape": $11 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($11) >>> 0, Number($12) >>> 0)) : [], + "activation": UTF8ToString($13) + })); + }, + 1642476: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) => { + Module.jsepCreateKernel("ConvTranspose", $0, ({ + "format": $8 ? "NHWC" : "NCHW", + "autoPad": $1, + "dilations": [ $2 ], + "group": $3, + "kernelShape": [ $4 ], + "pads": [ $5, $6 ], + "strides": [ $7 ], + "wIsConst": () => (!!GROWABLE_HEAP_I8()[$9 >>> 0]), + "outputPadding": $10 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($10) >>> 0, Number($11) >>> 0)) : [], + "outputShape": $12 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($12) >>> 0, Number($13) >>> 0)) : [], + "activation": UTF8ToString($14) + })); + }, + 1642909: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) => { + Module.jsepCreateKernel("ConvTranspose", $0, ({ + "format": $7 ? "NHWC" : "NCHW", + "autoPad": $1, + "dilations": Array.from(GROWABLE_HEAP_I32().subarray(Number($2) >>> 0, (Number($2) >>> 0) + 2 >>> 0)), + "group": $3, + "kernelShape": Array.from(GROWABLE_HEAP_I32().subarray(Number($4) >>> 0, (Number($4) >>> 0) + 2 >>> 0)), + "pads": Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, (Number($5) >>> 0) + 4 >>> 0)), + "strides": Array.from(GROWABLE_HEAP_I32().subarray(Number($6) >>> 0, (Number($6) >>> 0) + 2 >>> 0)), + "wIsConst": () => (!!GROWABLE_HEAP_I8()[$8 >>> 0]), + "outputPadding": $9 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($9) >>> 0, Number($10) >>> 0)) : [], + "outputShape": $11 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($11) >>> 0, Number($12) >>> 0)) : [], + "activation": UTF8ToString($13) + })); + }, + 1643570: ($0, $1) => { + Module.jsepCreateKernel("GlobalAveragePool", $0, ({ + "format": $1 ? "NHWC" : "NCHW" + })); + }, + 1643661: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) => { + Module.jsepCreateKernel("AveragePool", $0, ({ + "format": $13 ? "NHWC" : "NCHW", + "auto_pad": $1, + "ceil_mode": $2, + "count_include_pad": $3, + "storage_order": $4, + "dilations": $5 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, Number($6) >>> 0)) : [], + "kernel_shape": $7 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($7) >>> 0, Number($8) >>> 0)) : [], + "pads": $9 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($9) >>> 0, Number($10) >>> 0)) : [], + "strides": $11 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($11) >>> 0, Number($12) >>> 0)) : [] + })); + }, + 1644140: ($0, $1) => { + Module.jsepCreateKernel("GlobalAveragePool", $0, ({ + "format": $1 ? "NHWC" : "NCHW" + })); + }, + 1644231: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) => { + Module.jsepCreateKernel("AveragePool", $0, ({ + "format": $13 ? "NHWC" : "NCHW", + "auto_pad": $1, + "ceil_mode": $2, + "count_include_pad": $3, + "storage_order": $4, + "dilations": $5 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, Number($6) >>> 0)) : [], + "kernel_shape": $7 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($7) >>> 0, Number($8) >>> 0)) : [], + "pads": $9 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($9) >>> 0, Number($10) >>> 0)) : [], + "strides": $11 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($11) >>> 0, Number($12) >>> 0)) : [] + })); + }, + 1644710: ($0, $1) => { + Module.jsepCreateKernel("GlobalMaxPool", $0, ({ + "format": $1 ? "NHWC" : "NCHW" + })); + }, + 1644797: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) => { + Module.jsepCreateKernel("MaxPool", $0, ({ + "format": $13 ? "NHWC" : "NCHW", + "auto_pad": $1, + "ceil_mode": $2, + "count_include_pad": $3, + "storage_order": $4, + "dilations": $5 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, Number($6) >>> 0)) : [], + "kernel_shape": $7 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($7) >>> 0, Number($8) >>> 0)) : [], + "pads": $9 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($9) >>> 0, Number($10) >>> 0)) : [], + "strides": $11 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($11) >>> 0, Number($12) >>> 0)) : [] + })); + }, + 1645272: ($0, $1) => { + Module.jsepCreateKernel("GlobalMaxPool", $0, ({ + "format": $1 ? "NHWC" : "NCHW" + })); + }, + 1645359: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) => { + Module.jsepCreateKernel("MaxPool", $0, ({ + "format": $13 ? "NHWC" : "NCHW", + "auto_pad": $1, + "ceil_mode": $2, + "count_include_pad": $3, + "storage_order": $4, + "dilations": $5 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, Number($6) >>> 0)) : [], + "kernel_shape": $7 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($7) >>> 0, Number($8) >>> 0)) : [], + "pads": $9 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($9) >>> 0, Number($10) >>> 0)) : [], + "strides": $11 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($11) >>> 0, Number($12) >>> 0)) : [] + })); + }, + 1645834: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("Gemm", $0, ({ + "alpha": $1, + "beta": $2, + "transA": $3, + "transB": $4 + })); + }, + 1645938: $0 => { + Module.jsepCreateKernel("MatMul", $0, undefined); + }, + 1645992: ($0, $1, $2, $3) => { + Module.jsepCreateKernel("ArgMax", $0, ({ + "keepDims": !!$1, + "selectLastIndex": !!$2, + "axis": $3 + })); + }, + 1646100: ($0, $1, $2, $3) => { + Module.jsepCreateKernel("ArgMin", $0, ({ + "keepDims": !!$1, + "selectLastIndex": !!$2, + "axis": $3 + })); + }, + 1646208: ($0, $1) => { + Module.jsepCreateKernel("Softmax", $0, ({ + "axis": $1 + })); + }, + 1646271: ($0, $1) => { + Module.jsepCreateKernel("Concat", $0, ({ + "axis": $1 + })); + }, + 1646331: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("Split", $0, ({ + "axis": $1, + "numOutputs": $2, + "splitSizes": $3 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0)) : [] + })); + }, + 1646487: $0 => { + Module.jsepCreateKernel("Expand", $0, undefined); + }, + 1646541: ($0, $1) => { + Module.jsepCreateKernel("Gather", $0, ({ + "axis": Number($1) + })); + }, + 1646612: ($0, $1) => { + Module.jsepCreateKernel("GatherElements", $0, ({ + "axis": Number($1) + })); + }, + 1646691: ($0, $1) => { + Module.jsepCreateKernel("GatherND", $0, ({ + "batch_dims": Number($1) + })); + }, + 1646770: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) => { + Module.jsepCreateKernel("Resize", $0, ({ + "antialias": $1, + "axes": $2 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($2) >>> 0, Number($3) >>> 0)) : [], + "coordinateTransformMode": UTF8ToString($4), + "cubicCoeffA": $5, + "excludeOutside": $6, + "extrapolationValue": $7, + "keepAspectRatioPolicy": UTF8ToString($8), + "mode": UTF8ToString($9), + "nearestMode": UTF8ToString($10) + })); + }, + 1647132: ($0, $1, $2, $3, $4, $5, $6) => { + Module.jsepCreateKernel("Slice", $0, ({ + "starts": $1 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($1) >>> 0, Number($2) >>> 0)) : [], + "ends": $3 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0)) : [], + "axes": $5 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, Number($6) >>> 0)) : [] + })); + }, + 1647396: $0 => { + Module.jsepCreateKernel("Tile", $0, undefined); + }, + 1647448: ($0, $1, $2) => { + Module.jsepCreateKernel("InstanceNormalization", $0, ({ + "epsilon": $1, + "format": $2 ? "NHWC" : "NCHW" + })); + }, + 1647562: ($0, $1, $2) => { + Module.jsepCreateKernel("InstanceNormalization", $0, ({ + "epsilon": $1, + "format": $2 ? "NHWC" : "NCHW" + })); + }, + 1647676: $0 => { + Module.jsepCreateKernel("Range", $0, undefined); + }, + 1647729: ($0, $1) => { + Module.jsepCreateKernel("Einsum", $0, ({ + "equation": UTF8ToString($1) + })); + }, + 1647810: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("Pad", $0, ({ + "mode": $1, + "value": $2, + "pads": $3 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($3) >>> 0, Number($4) >>> 0)) : [] + })); + }, + 1647953: ($0, $1, $2, $3, $4, $5) => { + Module.jsepCreateKernel("BatchNormalization", $0, ({ + "epsilon": $1, + "momentum": $2, + "spatial": !!$4, + "trainingMode": !!$3, + "format": $5 ? "NHWC" : "NCHW" + })); + }, + 1648122: ($0, $1, $2, $3, $4, $5) => { + Module.jsepCreateKernel("BatchNormalization", $0, ({ + "epsilon": $1, + "momentum": $2, + "spatial": !!$4, + "trainingMode": !!$3, + "format": $5 ? "NHWC" : "NCHW" + })); + }, + 1648291: ($0, $1, $2) => { + Module.jsepCreateKernel("CumSum", $0, ({ + "exclusive": Number($1), + "reverse": Number($2) + })); + }, + 1648388: ($0, $1, $2) => { + Module.jsepCreateKernel("DequantizeLinear", $0, ({ + "axis": $1, + "blockSize": $2 + })); + }, + 1648478: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("GridSample", $0, ({ + "align_corners": $1, + "mode": UTF8ToString($2), + "padding_mode": UTF8ToString($3), + "format": $4 ? "NHWC" : "NCHW" + })); + }, + 1648648: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("GridSample", $0, ({ + "align_corners": $1, + "mode": UTF8ToString($2), + "padding_mode": UTF8ToString($3), + "format": $4 ? "NHWC" : "NCHW" + })); + }, + 1648818: ($0, $1) => { + Module.jsepCreateKernel("ScatterND", $0, ({ + "reduction": UTF8ToString($1) + })); + }, + 1648903: ($0, $1, $2, $3, $4, $5, $6, $7, $8) => { + Module.jsepCreateKernel("Attention", $0, ({ + "numHeads": $1, + "isUnidirectional": $2, + "maskFilterValue": $3, + "scale": $4, + "doRotary": $5, + "qkvHiddenSizes": $6 ? (Array.from(GROWABLE_HEAP_I32().subarray(Number($7) >>> 0, Number($7) + $6 >>> 0))) : [], + "pastPresentShareBuffer": !!$8 + })); + }, + 1649175: $0 => { + Module.jsepCreateKernel("BiasAdd", $0, undefined); + }, + 1649230: $0 => { + Module.jsepCreateKernel("BiasSplitGelu", $0, undefined); + }, + 1649291: $0 => { + Module.jsepCreateKernel("FastGelu", $0, undefined); + }, + 1649347: ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) => { + Module.jsepCreateKernel("Conv", $0, ({ + "format": $11 ? "NHWC" : "NCHW", + "auto_pad": $1, + "dilations": $2 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($2) >>> 0, Number($3) >>> 0)) : [], + "group": $4, + "kernel_shape": $5 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($5) >>> 0, Number($6) >>> 0)) : [], + "pads": $7 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($7) >>> 0, Number($8) >>> 0)) : [], + "strides": $9 ? Array.from(GROWABLE_HEAP_I32().subarray(Number($9) >>> 0, Number($10) >>> 0)) : [], + "w_is_const": () => (!!GROWABLE_HEAP_I8()[Number($12) >>> 0]), + "activation": UTF8ToString($13), + "activation_params": $14 ? Array.from(GROWABLE_HEAP_F32().subarray(Number($14) >>> 0, Number($15) >>> 0)) : [] + })); + }, + 1649931: $0 => { + Module.jsepCreateKernel("Gelu", $0, undefined); + }, + 1649983: ($0, $1, $2, $3, $4, $5, $6, $7, $8) => { + Module.jsepCreateKernel("GroupQueryAttention", $0, ({ + "numHeads": $1, + "kvNumHeads": $2, + "scale": $3, + "softcap": $4, + "doRotary": $5, + "rotaryInterleaved": $6, + "smoothSoftmax": $7, + "localWindowSize": $8 + })); + }, + 1650200: ($0, $1, $2, $3) => { + Module.jsepCreateKernel("LayerNormalization", $0, ({ + "axis": $1, + "epsilon": $2, + "simplified": !!$3 + })); + }, + 1650311: ($0, $1, $2, $3) => { + Module.jsepCreateKernel("LayerNormalization", $0, ({ + "axis": $1, + "epsilon": $2, + "simplified": !!$3 + })); + }, + 1650422: ($0, $1, $2, $3, $4, $5) => { + Module.jsepCreateKernel("MatMulNBits", $0, ({ + "k": $1, + "n": $2, + "accuracyLevel": $3, + "bits": $4, + "blockSize": $5 + })); + }, + 1650549: ($0, $1, $2, $3, $4, $5) => { + Module.jsepCreateKernel("MultiHeadAttention", $0, ({ + "numHeads": $1, + "isUnidirectional": $2, + "maskFilterValue": $3, + "scale": $4, + "doRotary": $5 + })); + }, + 1650708: ($0, $1) => { + Module.jsepCreateKernel("QuickGelu", $0, ({ + "alpha": $1 + })); + }, + 1650772: ($0, $1, $2, $3, $4) => { + Module.jsepCreateKernel("RotaryEmbedding", $0, ({ + "interleaved": !!$1, + "numHeads": $2, + "rotaryEmbeddingDim": $3, + "scale": $4 + })); + }, + 1650911: ($0, $1, $2) => { + Module.jsepCreateKernel("SkipLayerNormalization", $0, ({ + "epsilon": $1, + "simplified": !!$2 + })); + }, + 1651013: ($0, $1, $2) => { + Module.jsepCreateKernel("SkipLayerNormalization", $0, ({ + "epsilon": $1, + "simplified": !!$2 + })); + }, + 1651115: ($0, $1, $2, $3) => { + Module.jsepCreateKernel("GatherBlockQuantized", $0, ({ + "gatherAxis": $1, + "quantizeAxis": $2, + "blockSize": $3 + })); + }, + 1651236: $0 => { + Module.jsepReleaseKernel($0); + }, + 1651270: ($0, $1) => Module.jsepRunKernel(Number($0), Number($1), Module.jsepSessionState.sessionHandle, Module.jsepSessionState.errors) +}; + +function __asyncjs__jsepDownload(src_data, dst_data, bytes) { + return Asyncify.handleAsync(async () => { + await Module.jsepCopyAsync(Number(src_data), Number(dst_data), Number(bytes)); + }); +} + +function HaveOffsetConverter() { + return typeof wasmOffsetConverter !== "undefined"; +} + +// end include: preamble.js +class ExitStatus { + name="ExitStatus"; + constructor(status) { + this.message = `Program terminated with exit(${status})`; + this.status = status; + } +} + +var terminateWorker = worker => { + worker.terminate(); + // terminate() can be asynchronous, so in theory the worker can continue + // to run for some amount of time after termination. However from our POV + // the worker now dead and we don't want to hear from it again, so we stub + // out its message handler here. This avoids having to check in each of + // the onmessage handlers if the message was coming from valid worker. + worker.onmessage = e => {}; +}; + +var cleanupThread = pthread_ptr => { + var worker = PThread.pthreads[pthread_ptr]; + PThread.returnWorkerToPool(worker); +}; + +var callRuntimeCallbacks = callbacks => { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } +}; + +var onPreRuns = []; + +var addOnPreRun = cb => onPreRuns.unshift(cb); + +var spawnThread = threadParams => { + var worker = PThread.getNewWorker(); + if (!worker) { + // No available workers in the PThread pool. + return 6; + } + PThread.runningWorkers.push(worker); + // Add to pthreads map + PThread.pthreads[threadParams.pthread_ptr] = worker; + worker.pthread_ptr = threadParams.pthread_ptr; + var msg = { + cmd: "run", + start_routine: threadParams.startRoutine, + arg: threadParams.arg, + pthread_ptr: threadParams.pthread_ptr + }; + if (ENVIRONMENT_IS_NODE) { + // Mark worker as weakly referenced once we start executing a pthread, + // so that its existence does not prevent Node.js from exiting. This + // has no effect if the worker is already weakly referenced (e.g. if + // this worker was previously idle/unused). + worker.unref(); + } + // Ask the worker to start executing its pthread entry point function. + worker.postMessage(msg, threadParams.transferList); + return 0; +}; + +var runtimeKeepaliveCounter = 0; + +var keepRuntimeAlive = () => runtimeKeepaliveCounter > 0; + +var stackSave = () => _emscripten_stack_get_current(); + +var stackRestore = val => __emscripten_stack_restore(val); + +var stackAlloc = sz => __emscripten_stack_alloc(sz); + +var INT53_MAX = 9007199254740992; + +var INT53_MIN = -9007199254740992; + +var bigintToI53Checked = num => (num < INT53_MIN || num > INT53_MAX) ? NaN : Number(num); + +/** @type{function(number, (number|boolean), ...number)} */ var proxyToMainThread = (funcIndex, emAsmAddr, sync, ...callArgs) => { + // EM_ASM proxying is done by passing a pointer to the address of the EM_ASM + // content as `emAsmAddr`. JS library proxying is done by passing an index + // into `proxiedJSCallArgs` as `funcIndex`. If `emAsmAddr` is non-zero then + // `funcIndex` will be ignored. + // Additional arguments are passed after the first three are the actual + // function arguments. + // The serialization buffer contains the number of call params, and then + // all the args here. + // We also pass 'sync' to C separately, since C needs to look at it. + // Allocate a buffer, which will be copied by the C code. + // First passed parameter specifies the number of arguments to the function. + // When BigInt support is enabled, we must handle types in a more complex + // way, detecting at runtime if a value is a BigInt or not (as we have no + // type info here). To do that, add a "prefix" before each value that + // indicates if it is a BigInt, which effectively doubles the number of + // values we serialize for proxying. TODO: pack this? + var serializedNumCallArgs = callArgs.length * 2; + var sp = stackSave(); + var args = stackAlloc(serializedNumCallArgs * 8); + var b = ((args) >>> 3); + for (var i = 0; i < callArgs.length; i++) { + var arg = callArgs[i]; + if (typeof arg == "bigint") { + // The prefix is non-zero to indicate a bigint. + HEAP64[b + 2 * i] = 1n; + HEAP64[b + 2 * i + 1] = arg; + } else { + // The prefix is zero to indicate a JS Number. + HEAP64[b + 2 * i] = 0n; + GROWABLE_HEAP_F64()[b + 2 * i + 1 >>> 0] = arg; + } + } + var rtn = __emscripten_run_on_main_thread_js(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync); + stackRestore(sp); + return rtn; +}; + +function _proc_exit(code) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(0, 0, 1, code); + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + PThread.terminateAllThreads(); + ABORT = true; + } + quit_(code, new ExitStatus(code)); +} + +var handleException = e => { + // Certain exception types we do not treat as errors since they are used for + // internal control flow. + // 1. ExitStatus, which is thrown by exit() + // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others + // that wish to return to JS event loop. + if (e instanceof ExitStatus || e == "unwind") { + return EXITSTATUS; + } + quit_(1, e); +}; + +function exitOnMainThread(returnCode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(1, 0, 0, returnCode); + _exit(returnCode); +} + +/** @suppress {duplicate } */ /** @param {boolean|number=} implicit */ var exitJS = (status, implicit) => { + EXITSTATUS = status; + if (ENVIRONMENT_IS_PTHREAD) { + // implicit exit can never happen on a pthread + // When running in a pthread we propagate the exit back to the main thread + // where it can decide if the whole process should be shut down or not. + // The pthread may have decided not to exit its own runtime, for example + // because it runs a main loop, but that doesn't affect the main thread. + exitOnMainThread(status); + throw "unwind"; + } + _proc_exit(status); +}; + +var _exit = exitJS; + +var PThread = { + unusedWorkers: [], + runningWorkers: [], + tlsInitFunctions: [], + pthreads: {}, + init() { + if ((!(ENVIRONMENT_IS_PTHREAD))) { + PThread.initMainThread(); + } + }, + initMainThread() { + var pthreadPoolSize = Module["numThreads"] - 1; + // Start loading up the Worker pool, if requested. + while (pthreadPoolSize--) { + PThread.allocateUnusedWorker(); + } + // MINIMAL_RUNTIME takes care of calling loadWasmModuleToAllWorkers + // in postamble_minimal.js + addOnPreRun(() => { + addRunDependency("loading-workers"); + PThread.loadWasmModuleToAllWorkers(() => removeRunDependency("loading-workers")); + }); + }, + terminateAllThreads: () => { + // Attempt to kill all workers. Sadly (at least on the web) there is no + // way to terminate a worker synchronously, or to be notified when a + // worker in actually terminated. This means there is some risk that + // pthreads will continue to be executing after `worker.terminate` has + // returned. For this reason, we don't call `returnWorkerToPool` here or + // free the underlying pthread data structures. + for (var worker of PThread.runningWorkers) { + terminateWorker(worker); + } + for (var worker of PThread.unusedWorkers) { + terminateWorker(worker); + } + PThread.unusedWorkers = []; + PThread.runningWorkers = []; + PThread.pthreads = {}; + }, + returnWorkerToPool: worker => { + // We don't want to run main thread queued calls here, since we are doing + // some operations that leave the worker queue in an invalid state until + // we are completely done (it would be bad if free() ends up calling a + // queued pthread_create which looks at the global data structures we are + // modifying). To achieve that, defer the free() til the very end, when + // we are all done. + var pthread_ptr = worker.pthread_ptr; + delete PThread.pthreads[pthread_ptr]; + // Note: worker is intentionally not terminated so the pool can + // dynamically grow. + PThread.unusedWorkers.push(worker); + PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); + // Not a running Worker anymore + // Detach the worker from the pthread object, and return it to the + // worker pool as an unused worker. + worker.pthread_ptr = 0; + // Finally, free the underlying (and now-unused) pthread structure in + // linear memory. + __emscripten_thread_free_data(pthread_ptr); + }, + threadInitTLS() { + // Call thread init functions (these are the _emscripten_tls_init for each + // module loaded. + PThread.tlsInitFunctions.forEach(f => f()); + }, + loadWasmModuleToWorker: worker => new Promise(onFinishedLoading => { + worker.onmessage = e => { + var d = e["data"]; + var cmd = d.cmd; + // If this message is intended to a recipient that is not the main + // thread, forward it to the target thread. + if (d.targetThread && d.targetThread != _pthread_self()) { + var targetWorker = PThread.pthreads[d.targetThread]; + if (targetWorker) { + targetWorker.postMessage(d, d.transferList); + } else { + err(`Internal error! Worker sent a message "${cmd}" to target pthread ${d.targetThread}, but that thread no longer exists!`); + } + return; + } + if (cmd === "checkMailbox") { + checkMailbox(); + } else if (cmd === "spawnThread") { + spawnThread(d); + } else if (cmd === "cleanupThread") { + cleanupThread(d.thread); + } else if (cmd === "loaded") { + worker.loaded = true; + // Check that this worker doesn't have an associated pthread. + if (ENVIRONMENT_IS_NODE && !worker.pthread_ptr) { + // Once worker is loaded & idle, mark it as weakly referenced, + // so that mere existence of a Worker in the pool does not prevent + // Node.js from exiting the app. + worker.unref(); + } + onFinishedLoading(worker); + } else if (cmd === "alert") { + alert(`Thread ${d.threadId}: ${d.text}`); + } else if (d.target === "setimmediate") { + // Worker wants to postMessage() to itself to implement setImmediate() + // emulation. + worker.postMessage(d); + } else if (cmd === "callHandler") { + Module[d.handler](...d.args); + } else if (cmd) { + // The received message looks like something that should be handled by this message + // handler, (since there is a e.data.cmd field present), but is not one of the + // recognized commands: + err(`worker sent an unknown command ${cmd}`); + } + }; + worker.onerror = e => { + var message = "worker sent an error!"; + err(`${message} ${e.filename}:${e.lineno}: ${e.message}`); + throw e; + }; + if (ENVIRONMENT_IS_NODE) { + worker.on("message", data => worker.onmessage({ + data + })); + worker.on("error", e => worker.onerror(e)); + } + // When running on a pthread, none of the incoming parameters on the module + // object are present. Proxy known handlers back to the main thread if specified. + var handlers = []; + var knownHandlers = []; + for (var handler of knownHandlers) { + if (Module.propertyIsEnumerable(handler)) { + handlers.push(handler); + } + } + // Ask the new worker to load up the Emscripten-compiled page. This is a heavy operation. + worker.postMessage({ + cmd: "load", + handlers, + wasmMemory, + wasmModule + }); + }), + loadWasmModuleToAllWorkers(onMaybeReady) { + // Instantiation is synchronous in pthreads. + if (ENVIRONMENT_IS_PTHREAD) { + return onMaybeReady(); + } + let pthreadPoolReady = Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker)); + pthreadPoolReady.then(onMaybeReady); + }, + allocateUnusedWorker() { + var worker; + // If we're using module output, use bundler-friendly pattern. + // We need to generate the URL with import.meta.url as the base URL of the JS file + // instead of just using new URL(import.meta.url) because bundler's only recognize + // the first case in their bundling step. The latter ends up producing an invalid + // URL to import from the server (e.g., for webpack the file:// path). + worker = new Worker(new URL(import.meta.url), { + "type": "module", + // This is the way that we signal to the node worker that it is hosting + // a pthread. + "workerData": "em-pthread", + // This is the way that we signal to the Web Worker that it is hosting + // a pthread. + "name": "em-pthread" + }); + PThread.unusedWorkers.push(worker); + }, + getNewWorker() { + if (PThread.unusedWorkers.length == 0) { + // PTHREAD_POOL_SIZE_STRICT should show a warning and, if set to level `2`, return from the function. + PThread.allocateUnusedWorker(); + PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]); + } + return PThread.unusedWorkers.pop(); + } +}; + +var establishStackSpace = pthread_ptr => { + // If memory growth is enabled, the memory views may have gotten out of date, + // so resync them before accessing the pthread ptr below. + updateMemoryViews(); + var stackHigh = GROWABLE_HEAP_U32()[(((pthread_ptr) + (52)) >>> 2) >>> 0]; + var stackSize = GROWABLE_HEAP_U32()[(((pthread_ptr) + (56)) >>> 2) >>> 0]; + var stackLow = stackHigh - stackSize; + // Set stack limits used by `emscripten/stack.h` function. These limits are + // cached in wasm-side globals to make checks as fast as possible. + _emscripten_stack_set_limits(stackHigh, stackLow); + // Call inside wasm module to set up the stack frame for this pthread in wasm module scope + stackRestore(stackHigh); +}; + +/** + * @param {number} ptr + * @param {string} type + */ function getValue(ptr, type = "i8") { + if (type.endsWith("*")) type = "*"; + switch (type) { + case "i1": + return GROWABLE_HEAP_I8()[ptr >>> 0]; + + case "i8": + return GROWABLE_HEAP_I8()[ptr >>> 0]; + + case "i16": + return GROWABLE_HEAP_I16()[((ptr) >>> 1) >>> 0]; + + case "i32": + return GROWABLE_HEAP_I32()[((ptr) >>> 2) >>> 0]; + + case "i64": + return HEAP64[((ptr) >>> 3)]; + + case "float": + return GROWABLE_HEAP_F32()[((ptr) >>> 2) >>> 0]; + + case "double": + return GROWABLE_HEAP_F64()[((ptr) >>> 3) >>> 0]; + + case "*": + return GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0]; + + default: + abort(`invalid type for getValue: ${type}`); + } +} + +var invokeEntryPoint = (ptr, arg) => { + // An old thread on this worker may have been canceled without returning the + // `runtimeKeepaliveCounter` to zero. Reset it now so the new thread won't + // be affected. + runtimeKeepaliveCounter = 0; + // pthread entry points are always of signature 'void *ThreadMain(void *arg)' + // Native codebases sometimes spawn threads with other thread entry point + // signatures, such as void ThreadMain(void *arg), void *ThreadMain(), or + // void ThreadMain(). That is not acceptable per C/C++ specification, but + // x86 compiler ABI extensions enable that to work. If you find the + // following line to crash, either change the signature to "proper" void + // *ThreadMain(void *arg) form, or try linking with the Emscripten linker + // flag -sEMULATE_FUNCTION_POINTER_CASTS to add in emulation for this x86 + // ABI extension. + var result = (a1 => dynCall_ii(ptr, a1))(arg); + function finish(result) { + if (keepRuntimeAlive()) { + EXITSTATUS = result; + } else { + __emscripten_thread_exit(result); + } + } + finish(result); +}; + +var registerTLSInit = tlsInitFunc => PThread.tlsInitFunctions.push(tlsInitFunc); + +/** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ function setValue(ptr, value, type = "i8") { + if (type.endsWith("*")) type = "*"; + switch (type) { + case "i1": + GROWABLE_HEAP_I8()[ptr >>> 0] = value; + break; + + case "i8": + GROWABLE_HEAP_I8()[ptr >>> 0] = value; + break; + + case "i16": + GROWABLE_HEAP_I16()[((ptr) >>> 1) >>> 0] = value; + break; + + case "i32": + GROWABLE_HEAP_I32()[((ptr) >>> 2) >>> 0] = value; + break; + + case "i64": + HEAP64[((ptr) >>> 3)] = BigInt(value); + break; + + case "float": + GROWABLE_HEAP_F32()[((ptr) >>> 2) >>> 0] = value; + break; + + case "double": + GROWABLE_HEAP_F64()[((ptr) >>> 3) >>> 0] = value; + break; + + case "*": + GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0] = value; + break; + + default: + abort(`invalid type for setValue: ${type}`); + } +} + +var exceptionCaught = []; + +var uncaughtExceptionCount = 0; + +function ___cxa_begin_catch(ptr) { + ptr >>>= 0; + var info = new ExceptionInfo(ptr); + if (!info.get_caught()) { + info.set_caught(true); + uncaughtExceptionCount--; + } + info.set_rethrown(false); + exceptionCaught.push(info); + ___cxa_increment_exception_refcount(ptr); + return ___cxa_get_exception_ptr(ptr); +} + +var exceptionLast = 0; + +var ___cxa_end_catch = () => { + // Clear state flag. + _setThrew(0, 0); + // Call destructor if one is registered then clear it. + var info = exceptionCaught.pop(); + ___cxa_decrement_exception_refcount(info.excPtr); + exceptionLast = 0; +}; + +class ExceptionInfo { + // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it. + constructor(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + } + set_type(type) { + GROWABLE_HEAP_U32()[(((this.ptr) + (4)) >>> 2) >>> 0] = type; + } + get_type() { + return GROWABLE_HEAP_U32()[(((this.ptr) + (4)) >>> 2) >>> 0]; + } + set_destructor(destructor) { + GROWABLE_HEAP_U32()[(((this.ptr) + (8)) >>> 2) >>> 0] = destructor; + } + get_destructor() { + return GROWABLE_HEAP_U32()[(((this.ptr) + (8)) >>> 2) >>> 0]; + } + set_caught(caught) { + caught = caught ? 1 : 0; + GROWABLE_HEAP_I8()[(this.ptr) + (12) >>> 0] = caught; + } + get_caught() { + return GROWABLE_HEAP_I8()[(this.ptr) + (12) >>> 0] != 0; + } + set_rethrown(rethrown) { + rethrown = rethrown ? 1 : 0; + GROWABLE_HEAP_I8()[(this.ptr) + (13) >>> 0] = rethrown; + } + get_rethrown() { + return GROWABLE_HEAP_I8()[(this.ptr) + (13) >>> 0] != 0; + } + // Initialize native structure fields. Should be called once after allocated. + init(type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + } + set_adjusted_ptr(adjustedPtr) { + GROWABLE_HEAP_U32()[(((this.ptr) + (16)) >>> 2) >>> 0] = adjustedPtr; + } + get_adjusted_ptr() { + return GROWABLE_HEAP_U32()[(((this.ptr) + (16)) >>> 2) >>> 0]; + } +} + +function ___resumeException(ptr) { + ptr >>>= 0; + if (!exceptionLast) { + exceptionLast = ptr; + } + throw exceptionLast; +} + +var setTempRet0 = val => __emscripten_tempret_set(val); + +var findMatchingCatch = args => { + var thrown = exceptionLast; + if (!thrown) { + // just pass through the null ptr + setTempRet0(0); + return 0; + } + var info = new ExceptionInfo(thrown); + info.set_adjusted_ptr(thrown); + var thrownType = info.get_type(); + if (!thrownType) { + // just pass through the thrown ptr + setTempRet0(0); + return thrown; + } + // can_catch receives a **, add indirection + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var caughtType of args) { + if (caughtType === 0 || caughtType === thrownType) { + // Catch all clause matched or exactly the same type is caught + break; + } + var adjusted_ptr_addr = info.ptr + 16; + if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) { + setTempRet0(caughtType); + return thrown; + } + } + setTempRet0(thrownType); + return thrown; +}; + +function ___cxa_find_matching_catch_2() { + return findMatchingCatch([]); +} + +function ___cxa_find_matching_catch_3(arg0) { + arg0 >>>= 0; + return findMatchingCatch([ arg0 ]); +} + +function ___cxa_find_matching_catch_4(arg0, arg1) { + arg0 >>>= 0; + arg1 >>>= 0; + return findMatchingCatch([ arg0, arg1 ]); +} + +function ___cxa_find_matching_catch_5(arg0, arg1, arg2) { + arg0 >>>= 0; + arg1 >>>= 0; + arg2 >>>= 0; + return findMatchingCatch([ arg0, arg1, arg2 ]); +} + +function ___cxa_find_matching_catch_6(arg0, arg1, arg2, arg3) { + arg0 >>>= 0; + arg1 >>>= 0; + arg2 >>>= 0; + arg3 >>>= 0; + return findMatchingCatch([ arg0, arg1, arg2, arg3 ]); +} + +var ___cxa_rethrow = () => { + var info = exceptionCaught.pop(); + if (!info) { + abort("no exception to throw"); + } + var ptr = info.excPtr; + if (!info.get_rethrown()) { + // Only pop if the corresponding push was through rethrow_primary_exception + exceptionCaught.push(info); + info.set_rethrown(true); + info.set_caught(false); + uncaughtExceptionCount++; + } + exceptionLast = ptr; + throw exceptionLast; +}; + +function ___cxa_throw(ptr, type, destructor) { + ptr >>>= 0; + type >>>= 0; + destructor >>>= 0; + var info = new ExceptionInfo(ptr); + // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw exceptionLast; +} + +var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount; + +function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(2, 0, 1, pthread_ptr, attr, startRoutine, arg); + return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg); +} + +var _emscripten_has_threading_support = () => typeof SharedArrayBuffer != "undefined"; + +function ___pthread_create_js(pthread_ptr, attr, startRoutine, arg) { + pthread_ptr >>>= 0; + attr >>>= 0; + startRoutine >>>= 0; + arg >>>= 0; + if (!_emscripten_has_threading_support()) { + return 6; + } + // List of JS objects that will transfer ownership to the Worker hosting the thread + var transferList = []; + var error = 0; + // Synchronously proxy the thread creation to main thread if possible. If we + // need to transfer ownership of objects, then proxy asynchronously via + // postMessage. + if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) { + return pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg); + } + // If on the main thread, and accessing Canvas/OffscreenCanvas failed, abort + // with the detected error. + if (error) return error; + var threadParams = { + startRoutine, + pthread_ptr, + arg, + transferList + }; + if (ENVIRONMENT_IS_PTHREAD) { + // The prepopulated pool of web workers that can host pthreads is stored + // in the main JS thread. Therefore if a pthread is attempting to spawn a + // new thread, the thread creation must be deferred to the main JS thread. + threadParams.cmd = "spawnThread"; + postMessage(threadParams, transferList); + // When we defer thread creation this way, we have no way to detect thread + // creation synchronously today, so we have to assume success and return 0. + return 0; + } + // We are the main thread, so we have the pthread warmup pool in this + // thread and can fire off JS thread creation directly ourselves. + return spawnThread(threadParams); +} + +var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined; + +/** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number=} idx + * @param {number=} maxBytesToRead + * @return {string} + */ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => { + idx >>>= 0; + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. Also, use the length info to avoid running tiny + // strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, + // so that undefined/NaN means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.buffer instanceof ArrayBuffer ? heapOrArray.subarray(idx, endPtr) : heapOrArray.slice(idx, endPtr)); + } + var str = ""; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } + } + return str; +}; + +/** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index (i.e. maxBytesToRead will not + * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing + * frequent uses of UTF8ToString() with and without maxBytesToRead may throw + * JS JIT optimizations off, so it is worth to consider consistently using one + * @return {string} + */ var UTF8ToString = (ptr, maxBytesToRead) => { + ptr >>>= 0; + return ptr ? UTF8ArrayToString(GROWABLE_HEAP_U8(), ptr, maxBytesToRead) : ""; +}; + +var SYSCALLS = { + varargs: undefined, + getStr(ptr) { + var ret = UTF8ToString(ptr); + return ret; + } +}; + +function ___syscall_fcntl64(fd, cmd, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(3, 0, 1, fd, cmd, varargs); + varargs >>>= 0; + SYSCALLS.varargs = varargs; + return 0; +} + +function ___syscall_fstat64(fd, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(4, 0, 1, fd, buf); + buf >>>= 0; +} + +var lengthBytesUTF8 = str => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); + // possibly a lead surrogate + if (c <= 127) { + len++; + } else if (c <= 2047) { + len += 2; + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i; + } else { + len += 3; + } + } + return len; +}; + +var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { + outIdx >>>= 0; + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); + // possibly a lead surrogate + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | (u1 & 1023); + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++ >>> 0] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++ >>> 0] = 192 | (u >> 6); + heap[outIdx++ >>> 0] = 128 | (u & 63); + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++ >>> 0] = 224 | (u >> 12); + heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63); + heap[outIdx++ >>> 0] = 128 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + heap[outIdx++ >>> 0] = 240 | (u >> 18); + heap[outIdx++ >>> 0] = 128 | ((u >> 12) & 63); + heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63); + heap[outIdx++ >>> 0] = 128 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx >>> 0] = 0; + return outIdx - startIdx; +}; + +var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, GROWABLE_HEAP_U8(), outPtr, maxBytesToWrite); + +function ___syscall_getcwd(buf, size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(5, 0, 1, buf, size); + buf >>>= 0; + size >>>= 0; +} + +function ___syscall_getdents64(fd, dirp, count) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(6, 0, 1, fd, dirp, count); + dirp >>>= 0; + count >>>= 0; +} + +function ___syscall_ioctl(fd, op, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(7, 0, 1, fd, op, varargs); + varargs >>>= 0; + SYSCALLS.varargs = varargs; + return 0; +} + +function ___syscall_lstat64(path, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(8, 0, 1, path, buf); + path >>>= 0; + buf >>>= 0; +} + +function ___syscall_mkdirat(dirfd, path, mode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(9, 0, 1, dirfd, path, mode); + path >>>= 0; +} + +function ___syscall_newfstatat(dirfd, path, buf, flags) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(10, 0, 1, dirfd, path, buf, flags); + path >>>= 0; + buf >>>= 0; +} + +function ___syscall_openat(dirfd, path, flags, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(11, 0, 1, dirfd, path, flags, varargs); + path >>>= 0; + varargs >>>= 0; + SYSCALLS.varargs = varargs; +} + +function ___syscall_readlinkat(dirfd, path, buf, bufsize) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(12, 0, 1, dirfd, path, buf, bufsize); + path >>>= 0; + buf >>>= 0; + bufsize >>>= 0; +} + +function ___syscall_rmdir(path) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(13, 0, 1, path); + path >>>= 0; +} + +function ___syscall_stat64(path, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(14, 0, 1, path, buf); + path >>>= 0; + buf >>>= 0; +} + +function ___syscall_unlinkat(dirfd, path, flags) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(15, 0, 1, dirfd, path, flags); + path >>>= 0; +} + +var __abort_js = () => abort(""); + +var embindRepr = v => { + if (v === null) { + return "null"; + } + var t = typeof v; + if (t === "object" || t === "array" || t === "function") { + return v.toString(); + } else { + return "" + v; + } +}; + +var embind_init_charCodes = () => { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; +}; + +var embind_charCodes; + +var readLatin1String = ptr => { + var ret = ""; + var c = ptr; + while (GROWABLE_HEAP_U8()[c >>> 0]) { + ret += embind_charCodes[GROWABLE_HEAP_U8()[c++ >>> 0]]; + } + return ret; +}; + +var awaitingDependencies = {}; + +var registeredTypes = {}; + +var typeDependencies = {}; + +var BindingError; + +var throwBindingError = message => { + throw new BindingError(message); +}; + +var InternalError; + +/** @param {Object=} options */ function sharedRegisterType(rawType, registeredInstance, options = {}) { + var name = registeredInstance.name; + if (!rawType) { + throwBindingError(`type "${name}" must have a positive integer typeid pointer`); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError(`Cannot register type '${name}' twice`); + } + } + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach(cb => cb()); + } +} + +/** @param {Object=} options */ function registerType(rawType, registeredInstance, options = {}) { + return sharedRegisterType(rawType, registeredInstance, options); +} + +var integerReadValueFromPointer = (name, width, signed) => { + // integers are quite common, so generate very specialized functions + switch (width) { + case 1: + return signed ? pointer => GROWABLE_HEAP_I8()[pointer >>> 0] : pointer => GROWABLE_HEAP_U8()[pointer >>> 0]; + + case 2: + return signed ? pointer => GROWABLE_HEAP_I16()[((pointer) >>> 1) >>> 0] : pointer => GROWABLE_HEAP_U16()[((pointer) >>> 1) >>> 0]; + + case 4: + return signed ? pointer => GROWABLE_HEAP_I32()[((pointer) >>> 2) >>> 0] : pointer => GROWABLE_HEAP_U32()[((pointer) >>> 2) >>> 0]; + + case 8: + return signed ? pointer => HEAP64[((pointer) >>> 3)] : pointer => HEAPU64[((pointer) >>> 3)]; + + default: + throw new TypeError(`invalid integer width (${width}): ${name}`); + } +}; + +/** @suppress {globalThis} */ function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) { + primitiveType >>>= 0; + name >>>= 0; + size >>>= 0; + name = readLatin1String(name); + var isUnsignedType = (name.indexOf("u") != -1); + // maxRange comes through as -1 for uint64_t (see issue 13902). Work around that temporarily + if (isUnsignedType) { + maxRange = (1n << 64n) - 1n; + } + registerType(primitiveType, { + name, + "fromWireType": value => value, + "toWireType": function(destructors, value) { + if (typeof value != "bigint" && typeof value != "number") { + throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${this.name}`); + } + if (typeof value == "number") { + value = BigInt(value); + } + return value; + }, + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": integerReadValueFromPointer(name, size, !isUnsignedType), + destructorFunction: null + }); +} + +var GenericWireTypeSize = 8; + +/** @suppress {globalThis} */ function __embind_register_bool(rawType, name, trueValue, falseValue) { + rawType >>>= 0; + name >>>= 0; + name = readLatin1String(name); + registerType(rawType, { + name, + "fromWireType": function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + "toWireType": function(destructors, o) { + return o ? trueValue : falseValue; + }, + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": function(pointer) { + return this["fromWireType"](GROWABLE_HEAP_U8()[pointer >>> 0]); + }, + destructorFunction: null + }); +} + +var emval_freelist = []; + +var emval_handles = []; + +function __emval_decref(handle) { + handle >>>= 0; + if (handle > 9 && 0 === --emval_handles[handle + 1]) { + emval_handles[handle] = undefined; + emval_freelist.push(handle); + } +} + +var count_emval_handles = () => emval_handles.length / 2 - 5 - emval_freelist.length; + +var init_emval = () => { + // reserve 0 and some special values. These never get de-allocated. + emval_handles.push(0, 1, undefined, 1, null, 1, true, 1, false, 1); + Module["count_emval_handles"] = count_emval_handles; +}; + +var Emval = { + toValue: handle => { + if (!handle) { + throwBindingError("Cannot use deleted val. handle = " + handle); + } + return emval_handles[handle]; + }, + toHandle: value => { + switch (value) { + case undefined: + return 2; + + case null: + return 4; + + case true: + return 6; + + case false: + return 8; + + default: + { + const handle = emval_freelist.pop() || emval_handles.length; + emval_handles[handle] = value; + emval_handles[handle + 1] = 1; + return handle; + } + } + } +}; + +/** @suppress {globalThis} */ function readPointer(pointer) { + return this["fromWireType"](GROWABLE_HEAP_U32()[((pointer) >>> 2) >>> 0]); +} + +var EmValType = { + name: "emscripten::val", + "fromWireType": handle => { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + "toWireType": (destructors, value) => Emval.toHandle(value), + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": readPointer, + destructorFunction: null +}; + +function __embind_register_emval(rawType) { + rawType >>>= 0; + return registerType(rawType, EmValType); +} + +var floatReadValueFromPointer = (name, width) => { + switch (width) { + case 4: + return function(pointer) { + return this["fromWireType"](GROWABLE_HEAP_F32()[((pointer) >>> 2) >>> 0]); + }; + + case 8: + return function(pointer) { + return this["fromWireType"](GROWABLE_HEAP_F64()[((pointer) >>> 3) >>> 0]); + }; + + default: + throw new TypeError(`invalid float width (${width}): ${name}`); + } +}; + +var __embind_register_float = function(rawType, name, size) { + rawType >>>= 0; + name >>>= 0; + size >>>= 0; + name = readLatin1String(name); + registerType(rawType, { + name, + "fromWireType": value => value, + "toWireType": (destructors, value) => value, + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": floatReadValueFromPointer(name, size), + destructorFunction: null + }); +}; + +/** @suppress {globalThis} */ function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + primitiveType >>>= 0; + name >>>= 0; + size >>>= 0; + name = readLatin1String(name); + // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come + // out as 'i32 -1'. Always treat those as max u32. + if (maxRange === -1) { + maxRange = 4294967295; + } + var fromWireType = value => value; + if (minRange === 0) { + var bitshift = 32 - 8 * size; + fromWireType = value => (value << bitshift) >>> bitshift; + } + var isUnsignedType = (name.includes("unsigned")); + var checkAssertions = (value, toTypeName) => {}; + var toWireType; + if (isUnsignedType) { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + }; + } else { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + }; + } + registerType(primitiveType, { + name, + "fromWireType": fromWireType, + "toWireType": toWireType, + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": integerReadValueFromPointer(name, size, minRange !== 0), + destructorFunction: null + }); +} + +function __embind_register_memory_view(rawType, dataTypeIndex, name) { + rawType >>>= 0; + name >>>= 0; + var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array ]; + var TA = typeMapping[dataTypeIndex]; + function decodeMemoryView(handle) { + var size = GROWABLE_HEAP_U32()[((handle) >>> 2) >>> 0]; + var data = GROWABLE_HEAP_U32()[(((handle) + (4)) >>> 2) >>> 0]; + return new TA(GROWABLE_HEAP_I8().buffer, data, size); + } + name = readLatin1String(name); + registerType(rawType, { + name, + "fromWireType": decodeMemoryView, + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": decodeMemoryView + }, { + ignoreDuplicateRegistrations: true + }); +} + +function __embind_register_std_string(rawType, name) { + rawType >>>= 0; + name >>>= 0; + name = readLatin1String(name); + var stdStringIsUTF8 = true; + registerType(rawType, { + name, + // For some method names we use string keys here since they are part of + // the public/external API and/or used by the runtime-generated code. + "fromWireType"(value) { + var length = GROWABLE_HEAP_U32()[((value) >>> 2) >>> 0]; + var payload = value + 4; + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = payload; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = payload + i; + if (i == length || GROWABLE_HEAP_U8()[currentBytePtr >>> 0] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(GROWABLE_HEAP_U8()[payload + i >>> 0]); + } + str = a.join(""); + } + _free(value); + return str; + }, + "toWireType"(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + var length; + var valueIsOfTypeString = (typeof value == "string"); + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError("Cannot pass non-string to std::string"); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + // assumes POINTER_SIZE alignment + var base = _malloc(4 + length + 1); + var ptr = base + 4; + GROWABLE_HEAP_U32()[((base) >>> 2) >>> 0] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(base); + throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); + } + GROWABLE_HEAP_U8()[ptr + i >>> 0] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + GROWABLE_HEAP_U8()[ptr + i >>> 0] = value[i]; + } + } + } + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); +} + +var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined; + +var UTF16ToString = (ptr, maxBytesToRead) => { + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. + // Also, use the length info to avoid running tiny strings through + // TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && GROWABLE_HEAP_U16()[idx >>> 0]) ++idx; + endPtr = idx << 1; + if (endPtr - ptr > 32 && UTF16Decoder) return UTF16Decoder.decode(GROWABLE_HEAP_U8().slice(ptr, endPtr)); + // Fallback: decode without UTF16Decoder + var str = ""; + // If maxBytesToRead is not passed explicitly, it will be undefined, and the + // for-loop's condition will always evaluate to true. The loop is then + // terminated on the first null char. + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = GROWABLE_HEAP_I16()[(((ptr) + (i * 2)) >>> 1) >>> 0]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can + // pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + return str; +}; + +var stringToUTF16 = (str, outPtr, maxBytesToWrite) => { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 2147483647; + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; + // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); + // possibly a lead surrogate + GROWABLE_HEAP_I16()[((outPtr) >>> 1) >>> 0] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + GROWABLE_HEAP_I16()[((outPtr) >>> 1) >>> 0] = 0; + return outPtr - startPtr; +}; + +var lengthBytesUTF16 = str => str.length * 2; + +var UTF32ToString = (ptr, maxBytesToRead) => { + var i = 0; + var str = ""; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(i >= maxBytesToRead / 4)) { + var utf32 = GROWABLE_HEAP_I32()[(((ptr) + (i * 4)) >>> 2) >>> 0]; + if (utf32 == 0) break; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 65536) { + var ch = utf32 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; +}; + +var stringToUTF32 = (str, outPtr, maxBytesToWrite) => { + outPtr >>>= 0; + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 2147483647; + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + // possibly a lead surrogate + if (codeUnit >= 55296 && codeUnit <= 57343) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 65536 + ((codeUnit & 1023) << 10) | (trailSurrogate & 1023); + } + GROWABLE_HEAP_I32()[((outPtr) >>> 2) >>> 0] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + GROWABLE_HEAP_I32()[((outPtr) >>> 2) >>> 0] = 0; + return outPtr - startPtr; +}; + +var lengthBytesUTF32 = str => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) ++i; + // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + return len; +}; + +var __embind_register_std_wstring = function(rawType, charSize, name) { + rawType >>>= 0; + charSize >>>= 0; + name >>>= 0; + name = readLatin1String(name); + var decodeString, encodeString, readCharAt, lengthBytesUTF; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + readCharAt = pointer => GROWABLE_HEAP_U16()[((pointer) >>> 1) >>> 0]; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + readCharAt = pointer => GROWABLE_HEAP_U32()[((pointer) >>> 2) >>> 0]; + } + registerType(rawType, { + name, + "fromWireType": value => { + // Code mostly taken from _embind_register_std_string fromWireType + var length = GROWABLE_HEAP_U32()[((value) >>> 2) >>> 0]; + var str; + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || readCharAt(currentBytePtr) == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + _free(value); + return str; + }, + "toWireType": (destructors, value) => { + if (!(typeof value == "string")) { + throwBindingError(`Cannot pass non-string to C++ string type ${name}`); + } + // assumes POINTER_SIZE alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0] = length / charSize; + encodeString(value, ptr + 4, length + charSize); + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + argPackAdvance: GenericWireTypeSize, + "readValueFromPointer": readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); +}; + +var __embind_register_void = function(rawType, name) { + rawType >>>= 0; + name >>>= 0; + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, + // void return values can be optimized out sometimes + name, + argPackAdvance: 0, + "fromWireType": () => undefined, + // TODO: assert if anything else is given? + "toWireType": (destructors, o) => undefined + }); +}; + +function __emscripten_init_main_thread_js(tb) { + tb >>>= 0; + // Pass the thread address to the native code where they stored in wasm + // globals which act as a form of TLS. Global constructors trying + // to access this value will read the wrong value, but that is UB anyway. + __emscripten_thread_init(tb, /*is_main=*/ !ENVIRONMENT_IS_WORKER, /*is_runtime=*/ 1, /*can_block=*/ !ENVIRONMENT_IS_WEB, /*default_stacksize=*/ 131072, /*start_profiling=*/ false); + PThread.threadInitTLS(); +} + +var maybeExit = () => { + if (!keepRuntimeAlive()) { + try { + if (ENVIRONMENT_IS_PTHREAD) __emscripten_thread_exit(EXITSTATUS); else _exit(EXITSTATUS); + } catch (e) { + handleException(e); + } + } +}; + +var callUserCallback = func => { + if (ABORT) { + return; + } + try { + func(); + maybeExit(); + } catch (e) { + handleException(e); + } +}; + +function __emscripten_thread_mailbox_await(pthread_ptr) { + pthread_ptr >>>= 0; + if (typeof Atomics.waitAsync === "function") { + // Wait on the pthread's initial self-pointer field because it is easy and + // safe to access from sending threads that need to notify the waiting + // thread. + // TODO: How to make this work with wasm64? + var wait = Atomics.waitAsync(GROWABLE_HEAP_I32(), ((pthread_ptr) >>> 2), pthread_ptr); + wait.value.then(checkMailbox); + var waitingAsync = pthread_ptr + 128; + Atomics.store(GROWABLE_HEAP_I32(), ((waitingAsync) >>> 2), 1); + } +} + +var checkMailbox = () => { + // Only check the mailbox if we have a live pthread runtime. We implement + // pthread_self to return 0 if there is no live runtime. + var pthread_ptr = _pthread_self(); + if (pthread_ptr) { + // If we are using Atomics.waitAsync as our notification mechanism, wait + // for a notification before processing the mailbox to avoid missing any + // work that could otherwise arrive after we've finished processing the + // mailbox and before we're ready for the next notification. + __emscripten_thread_mailbox_await(pthread_ptr); + callUserCallback(__emscripten_check_mailbox); + } +}; + +function __emscripten_notify_mailbox_postmessage(targetThread, currThreadId) { + targetThread >>>= 0; + currThreadId >>>= 0; + if (targetThread == currThreadId) { + setTimeout(checkMailbox); + } else if (ENVIRONMENT_IS_PTHREAD) { + postMessage({ + targetThread, + cmd: "checkMailbox" + }); + } else { + var worker = PThread.pthreads[targetThread]; + if (!worker) { + return; + } + worker.postMessage({ + cmd: "checkMailbox" + }); + } +} + +var proxiedJSCallArgs = []; + +function __emscripten_receive_on_main_thread_js(funcIndex, emAsmAddr, callingThread, numCallArgs, args) { + emAsmAddr >>>= 0; + callingThread >>>= 0; + args >>>= 0; + // Sometimes we need to backproxy events to the calling thread (e.g. + // HTML5 DOM events handlers such as + // emscripten_set_mousemove_callback()), so keep track in a globally + // accessible variable about the thread that initiated the proxying. + numCallArgs /= 2; + proxiedJSCallArgs.length = numCallArgs; + var b = ((args) >>> 3); + for (var i = 0; i < numCallArgs; i++) { + if (HEAP64[b + 2 * i]) { + // It's a BigInt. + proxiedJSCallArgs[i] = HEAP64[b + 2 * i + 1]; + } else { + // It's a Number. + proxiedJSCallArgs[i] = GROWABLE_HEAP_F64()[b + 2 * i + 1 >>> 0]; + } + } + // Proxied JS library funcs use funcIndex and EM_ASM functions use emAsmAddr + var func = emAsmAddr ? ASM_CONSTS[emAsmAddr] : proxiedFunctionTable[funcIndex]; + PThread.currentProxiedOperationCallerThread = callingThread; + var rtn = func(...proxiedJSCallArgs); + PThread.currentProxiedOperationCallerThread = 0; + return rtn; +} + +var __emscripten_runtime_keepalive_clear = () => { + runtimeKeepaliveCounter = 0; +}; + +function __emscripten_thread_cleanup(thread) { + thread >>>= 0; + // Called when a thread needs to be cleaned up so it can be reused. + // A thread is considered reusable when it either returns from its + // entry point, calls pthread_exit, or acts upon a cancellation. + // Detached threads are responsible for calling this themselves, + // otherwise pthread_join is responsible for calling this. + if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread); else postMessage({ + cmd: "cleanupThread", + thread + }); +} + +function __emscripten_thread_set_strongref(thread) { + thread >>>= 0; + // Called when a thread needs to be strongly referenced. + // Currently only used for: + // - keeping the "main" thread alive in PROXY_TO_PTHREAD mode; + // - crashed threads that needs to propagate the uncaught exception + // back to the main thread. + if (ENVIRONMENT_IS_NODE) { + PThread.pthreads[thread].ref(); + } +} + +var getTypeName = type => { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; +}; + +var requireRegisteredType = (rawType, humanName) => { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`); + } + return impl; +}; + +var emval_returnValue = (returnType, destructorsRef, handle) => { + var destructors = []; + var result = returnType["toWireType"](destructors, handle); + if (destructors.length) { + // void, primitives and any other types w/o destructors don't need to allocate a handle + GROWABLE_HEAP_U32()[((destructorsRef) >>> 2) >>> 0] = Emval.toHandle(destructors); + } + return result; +}; + +function __emval_as(handle, returnType, destructorsRef) { + handle >>>= 0; + returnType >>>= 0; + destructorsRef >>>= 0; + handle = Emval.toValue(handle); + returnType = requireRegisteredType(returnType, "emval::as"); + return emval_returnValue(returnType, destructorsRef, handle); +} + +function __emval_as_int64(handle, returnType) { + handle >>>= 0; + returnType >>>= 0; + handle = Emval.toValue(handle); + returnType = requireRegisteredType(returnType, "emval::as"); + return returnType["toWireType"](null, handle); +} + +var runAndAbortIfError = func => { + try { + return func(); + } catch (e) { + abort(e); + } +}; + +var runtimeKeepalivePush = () => { + runtimeKeepaliveCounter += 1; +}; + +var runtimeKeepalivePop = () => { + runtimeKeepaliveCounter -= 1; +}; + +var Asyncify = { + instrumentWasmImports(imports) { + var importPattern = /^(invoke_.*|__asyncjs__.*)$/; + for (let [x, original] of Object.entries(imports)) { + if (typeof original == "function") { + let isAsyncifyImport = original.isAsync || importPattern.test(x); + } + } + }, + instrumentWasmExports(exports) { + var ret = {}; + for (let [x, original] of Object.entries(exports)) { + if (typeof original == "function") { + ret[x] = (...args) => { + Asyncify.exportCallStack.push(x); + try { + return original(...args); + } finally { + if (!ABORT) { + var y = Asyncify.exportCallStack.pop(); + Asyncify.maybeStopUnwind(); + } + } + }; + } else { + ret[x] = original; + } + } + return ret; + }, + State: { + Normal: 0, + Unwinding: 1, + Rewinding: 2, + Disabled: 3 + }, + state: 0, + StackSize: 65536, + currData: null, + handleSleepReturnValue: 0, + exportCallStack: [], + callStackNameToId: {}, + callStackIdToName: {}, + callStackId: 0, + asyncPromiseHandlers: null, + sleepCallbacks: [], + getCallStackId(funcName) { + var id = Asyncify.callStackNameToId[funcName]; + if (id === undefined) { + id = Asyncify.callStackId++; + Asyncify.callStackNameToId[funcName] = id; + Asyncify.callStackIdToName[id] = funcName; + } + return id; + }, + maybeStopUnwind() { + if (Asyncify.currData && Asyncify.state === Asyncify.State.Unwinding && Asyncify.exportCallStack.length === 0) { + // We just finished unwinding. + // Be sure to set the state before calling any other functions to avoid + // possible infinite recursion here (For example in debug pthread builds + // the dbg() function itself can call back into WebAssembly to get the + // current pthread_self() pointer). + Asyncify.state = Asyncify.State.Normal; + runtimeKeepalivePush(); + // Keep the runtime alive so that a re-wind can be done later. + runAndAbortIfError(_asyncify_stop_unwind); + if (typeof Fibers != "undefined") { + Fibers.trampoline(); + } + } + }, + whenDone() { + return new Promise((resolve, reject) => { + Asyncify.asyncPromiseHandlers = { + resolve, + reject + }; + }); + }, + allocateData() { + // An asyncify data structure has three fields: + // 0 current stack pos + // 4 max stack pos + // 8 id of function at bottom of the call stack (callStackIdToName[id] == name of js function) + // The Asyncify ABI only interprets the first two fields, the rest is for the runtime. + // We also embed a stack in the same memory region here, right next to the structure. + // This struct is also defined as asyncify_data_t in emscripten/fiber.h + var ptr = _malloc(12 + Asyncify.StackSize); + Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize); + Asyncify.setDataRewindFunc(ptr); + return ptr; + }, + setDataHeader(ptr, stack, stackSize) { + GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0] = stack; + GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0] = stack + stackSize; + }, + setDataRewindFunc(ptr) { + var bottomOfCallStack = Asyncify.exportCallStack[0]; + var rewindId = Asyncify.getCallStackId(bottomOfCallStack); + GROWABLE_HEAP_I32()[(((ptr) + (8)) >>> 2) >>> 0] = rewindId; + }, + getDataRewindFuncName(ptr) { + var id = GROWABLE_HEAP_I32()[(((ptr) + (8)) >>> 2) >>> 0]; + var name = Asyncify.callStackIdToName[id]; + return name; + }, + getDataRewindFunc(name) { + var func = wasmExports[name]; + return func; + }, + doRewind(ptr) { + var name = Asyncify.getDataRewindFuncName(ptr); + var func = Asyncify.getDataRewindFunc(name); + // Once we have rewound and the stack we no longer need to artificially + // keep the runtime alive. + runtimeKeepalivePop(); + return func(); + }, + handleSleep(startAsync) { + if (ABORT) return; + if (Asyncify.state === Asyncify.State.Normal) { + // Prepare to sleep. Call startAsync, and see what happens: + // if the code decided to call our callback synchronously, + // then no async operation was in fact begun, and we don't + // need to do anything. + var reachedCallback = false; + var reachedAfterCallback = false; + startAsync((handleSleepReturnValue = 0) => { + if (ABORT) return; + Asyncify.handleSleepReturnValue = handleSleepReturnValue; + reachedCallback = true; + if (!reachedAfterCallback) { + // We are happening synchronously, so no need for async. + return; + } + Asyncify.state = Asyncify.State.Rewinding; + runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData)); + if (typeof MainLoop != "undefined" && MainLoop.func) { + MainLoop.resume(); + } + var asyncWasmReturnValue, isError = false; + try { + asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData); + } catch (err) { + asyncWasmReturnValue = err; + isError = true; + } + // Track whether the return value was handled by any promise handlers. + var handled = false; + if (!Asyncify.currData) { + // All asynchronous execution has finished. + // `asyncWasmReturnValue` now contains the final + // return value of the exported async WASM function. + // Note: `asyncWasmReturnValue` is distinct from + // `Asyncify.handleSleepReturnValue`. + // `Asyncify.handleSleepReturnValue` contains the return + // value of the last C function to have executed + // `Asyncify.handleSleep()`, where as `asyncWasmReturnValue` + // contains the return value of the exported WASM function + // that may have called C functions that + // call `Asyncify.handleSleep()`. + var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers; + if (asyncPromiseHandlers) { + Asyncify.asyncPromiseHandlers = null; + (isError ? asyncPromiseHandlers.reject : asyncPromiseHandlers.resolve)(asyncWasmReturnValue); + handled = true; + } + } + if (isError && !handled) { + // If there was an error and it was not handled by now, we have no choice but to + // rethrow that error into the global scope where it can be caught only by + // `onerror` or `onunhandledpromiserejection`. + throw asyncWasmReturnValue; + } + }); + reachedAfterCallback = true; + if (!reachedCallback) { + // A true async operation was begun; start a sleep. + Asyncify.state = Asyncify.State.Unwinding; + // TODO: reuse, don't alloc/free every sleep + Asyncify.currData = Asyncify.allocateData(); + if (typeof MainLoop != "undefined" && MainLoop.func) { + MainLoop.pause(); + } + runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData)); + } + } else if (Asyncify.state === Asyncify.State.Rewinding) { + // Stop a resume. + Asyncify.state = Asyncify.State.Normal; + runAndAbortIfError(_asyncify_stop_rewind); + _free(Asyncify.currData); + Asyncify.currData = null; + // Call all sleep callbacks now that the sleep-resume is all done. + Asyncify.sleepCallbacks.forEach(callUserCallback); + } else { + abort(`invalid state: ${Asyncify.state}`); + } + return Asyncify.handleSleepReturnValue; + }, + handleAsync(startAsync) { + return Asyncify.handleSleep(wakeUp => { + // TODO: add error handling as a second param when handleSleep implements it. + startAsync().then(wakeUp); + }); + } +}; + +var __emval_await = function(promise) { + promise >>>= 0; + return Asyncify.handleAsync(async () => { + var value = await Emval.toValue(promise); + return Emval.toHandle(value); + }); +}; + +__emval_await.isAsync = true; + +var emval_methodCallers = []; + +function __emval_call(caller, handle, destructorsRef, args) { + caller >>>= 0; + handle >>>= 0; + destructorsRef >>>= 0; + args >>>= 0; + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + return caller(null, handle, destructorsRef, args); +} + +var emval_symbols = {}; + +var getStringOrSymbol = address => { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return readLatin1String(address); + } + return symbol; +}; + +function __emval_call_method(caller, objHandle, methodName, destructorsRef, args) { + caller >>>= 0; + objHandle >>>= 0; + methodName >>>= 0; + destructorsRef >>>= 0; + args >>>= 0; + caller = emval_methodCallers[caller]; + objHandle = Emval.toValue(objHandle); + methodName = getStringOrSymbol(methodName); + return caller(objHandle, objHandle[methodName], destructorsRef, args); +} + +function __emval_equals(first, second) { + first >>>= 0; + second >>>= 0; + first = Emval.toValue(first); + second = Emval.toValue(second); + return first == second; +} + +var emval_get_global = () => { + if (typeof globalThis == "object") { + return globalThis; + } + return (function() { + return Function; + })()("return this")(); +}; + +function __emval_get_global(name) { + name >>>= 0; + if (name === 0) { + return Emval.toHandle(emval_get_global()); + } else { + name = getStringOrSymbol(name); + return Emval.toHandle(emval_get_global()[name]); + } +} + +var emval_addMethodCaller = caller => { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; +}; + +var emval_lookupTypes = (argCount, argTypes) => { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(GROWABLE_HEAP_U32()[(((argTypes) + (i * 4)) >>> 2) >>> 0], "parameter " + i); + } + return a; +}; + +var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { + value: name +}); + +var reflectConstruct = Reflect.construct; + +function newFunc(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError(`new_ called with constructor type ${typeof (constructor)} which is not a function`); + } + /* + * Previously, the following line was just: + * function dummy() {}; + * Unfortunately, Chrome was preserving 'dummy' as the object's name, even + * though at creation, the 'dummy' has the correct constructor name. Thus, + * objects created with IMVU.new would show up in the debugger as 'dummy', + * which isn't very helpful. Using IMVU.createNamedFunction addresses the + * issue. Doubly-unfortunately, there's no way to write a test for this + * behavior. -NRD 2013.02.22 + */ var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {}); + dummy.prototype = constructor.prototype; + var obj = new dummy; + var r = constructor.apply(obj, argumentList); + return (r instanceof Object) ? r : obj; +} + +function __emval_get_method_caller(argCount, argTypes, kind) { + argTypes >>>= 0; + var types = emval_lookupTypes(argCount, argTypes); + var retType = types.shift(); + argCount--; + // remove the shifted off return type + var functionBody = `return function (obj, func, destructorsRef, args) {\n`; + var offset = 0; + var argsList = []; + // 'obj?, arg0, arg1, arg2, ... , argN' + if (kind === /* FUNCTION */ 0) { + argsList.push("obj"); + } + var params = [ "retType" ]; + var args = [ retType ]; + for (var i = 0; i < argCount; ++i) { + argsList.push("arg" + i); + params.push("argType" + i); + args.push(types[i]); + functionBody += ` var arg${i} = argType${i}.readValueFromPointer(args${offset ? "+" + offset : ""});\n`; + offset += types[i].argPackAdvance; + } + var invoker = kind === /* CONSTRUCTOR */ 1 ? "new func" : "func.call"; + functionBody += ` var rv = ${invoker}(${argsList.join(", ")});\n`; + if (!retType.isVoid) { + params.push("emval_returnValue"); + args.push(emval_returnValue); + functionBody += " return emval_returnValue(retType, destructorsRef, rv);\n"; + } + functionBody += "};\n"; + params.push(functionBody); + var invokerFunction = newFunc(Function, params)(...args); + var functionName = `methodCaller<(${types.map(t => t.name).join(", ")}) => ${retType.name}>`; + return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction)); +} + +function __emval_get_module_property(name) { + name >>>= 0; + name = getStringOrSymbol(name); + return Emval.toHandle(Module[name]); +} + +function __emval_get_property(handle, key) { + handle >>>= 0; + key >>>= 0; + handle = Emval.toValue(handle); + key = Emval.toValue(key); + return Emval.toHandle(handle[key]); +} + +function __emval_incref(handle) { + handle >>>= 0; + if (handle > 9) { + emval_handles[handle + 1] += 1; + } +} + +function __emval_new_array() { + return Emval.toHandle([]); +} + +function __emval_new_array_from_memory_view(view) { + view >>>= 0; + view = Emval.toValue(view); + // using for..loop is faster than Array.from + var a = new Array(view.length); + for (var i = 0; i < view.length; i++) a[i] = view[i]; + return Emval.toHandle(a); +} + +function __emval_new_cstring(v) { + v >>>= 0; + return Emval.toHandle(getStringOrSymbol(v)); +} + +function __emval_new_object() { + return Emval.toHandle({}); +} + +var runDestructors = destructors => { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } +}; + +function __emval_run_destructors(handle) { + handle >>>= 0; + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); +} + +function __emval_set_property(handle, key, value) { + handle >>>= 0; + key >>>= 0; + value >>>= 0; + handle = Emval.toValue(handle); + key = Emval.toValue(key); + value = Emval.toValue(value); + handle[key] = value; +} + +function __emval_take_value(type, arg) { + type >>>= 0; + arg >>>= 0; + type = requireRegisteredType(type, "_emval_take_value"); + var v = type["readValueFromPointer"](arg); + return Emval.toHandle(v); +} + +function __gmtime_js(time, tmPtr) { + time = bigintToI53Checked(time); + tmPtr >>>= 0; + var date = new Date(time * 1e3); + GROWABLE_HEAP_I32()[((tmPtr) >>> 2) >>> 0] = date.getUTCSeconds(); + GROWABLE_HEAP_I32()[(((tmPtr) + (4)) >>> 2) >>> 0] = date.getUTCMinutes(); + GROWABLE_HEAP_I32()[(((tmPtr) + (8)) >>> 2) >>> 0] = date.getUTCHours(); + GROWABLE_HEAP_I32()[(((tmPtr) + (12)) >>> 2) >>> 0] = date.getUTCDate(); + GROWABLE_HEAP_I32()[(((tmPtr) + (16)) >>> 2) >>> 0] = date.getUTCMonth(); + GROWABLE_HEAP_I32()[(((tmPtr) + (20)) >>> 2) >>> 0] = date.getUTCFullYear() - 1900; + GROWABLE_HEAP_I32()[(((tmPtr) + (24)) >>> 2) >>> 0] = date.getUTCDay(); + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = ((date.getTime() - start) / (1e3 * 60 * 60 * 24)) | 0; + GROWABLE_HEAP_I32()[(((tmPtr) + (28)) >>> 2) >>> 0] = yday; +} + +var isLeapYear = year => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + +var MONTH_DAYS_LEAP_CUMULATIVE = [ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 ]; + +var MONTH_DAYS_REGULAR_CUMULATIVE = [ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 ]; + +var ydayFromDate = date => { + var leap = isLeapYear(date.getFullYear()); + var monthDaysCumulative = (leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE); + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; + // -1 since it's days since Jan 1 + return yday; +}; + +function __localtime_js(time, tmPtr) { + time = bigintToI53Checked(time); + tmPtr >>>= 0; + var date = new Date(time * 1e3); + GROWABLE_HEAP_I32()[((tmPtr) >>> 2) >>> 0] = date.getSeconds(); + GROWABLE_HEAP_I32()[(((tmPtr) + (4)) >>> 2) >>> 0] = date.getMinutes(); + GROWABLE_HEAP_I32()[(((tmPtr) + (8)) >>> 2) >>> 0] = date.getHours(); + GROWABLE_HEAP_I32()[(((tmPtr) + (12)) >>> 2) >>> 0] = date.getDate(); + GROWABLE_HEAP_I32()[(((tmPtr) + (16)) >>> 2) >>> 0] = date.getMonth(); + GROWABLE_HEAP_I32()[(((tmPtr) + (20)) >>> 2) >>> 0] = date.getFullYear() - 1900; + GROWABLE_HEAP_I32()[(((tmPtr) + (24)) >>> 2) >>> 0] = date.getDay(); + var yday = ydayFromDate(date) | 0; + GROWABLE_HEAP_I32()[(((tmPtr) + (28)) >>> 2) >>> 0] = yday; + GROWABLE_HEAP_I32()[(((tmPtr) + (36)) >>> 2) >>> 0] = -(date.getTimezoneOffset() * 60); + // Attention: DST is in December in South, and some regions don't have DST at all. + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; + GROWABLE_HEAP_I32()[(((tmPtr) + (32)) >>> 2) >>> 0] = dst; +} + +var __mktime_js = function(tmPtr) { + tmPtr >>>= 0; + var ret = (() => { + var date = new Date(GROWABLE_HEAP_I32()[(((tmPtr) + (20)) >>> 2) >>> 0] + 1900, GROWABLE_HEAP_I32()[(((tmPtr) + (16)) >>> 2) >>> 0], GROWABLE_HEAP_I32()[(((tmPtr) + (12)) >>> 2) >>> 0], GROWABLE_HEAP_I32()[(((tmPtr) + (8)) >>> 2) >>> 0], GROWABLE_HEAP_I32()[(((tmPtr) + (4)) >>> 2) >>> 0], GROWABLE_HEAP_I32()[((tmPtr) >>> 2) >>> 0], 0); + // There's an ambiguous hour when the time goes back; the tm_isdst field is + // used to disambiguate it. Date() basically guesses, so we fix it up if it + // guessed wrong, or fill in tm_isdst with the guess if it's -1. + var dst = GROWABLE_HEAP_I32()[(((tmPtr) + (32)) >>> 2) >>> 0]; + var guessedOffset = date.getTimezoneOffset(); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dstOffset = Math.min(winterOffset, summerOffset); + // DST is in December in South + if (dst < 0) { + // Attention: some regions don't have DST at all. + GROWABLE_HEAP_I32()[(((tmPtr) + (32)) >>> 2) >>> 0] = Number(summerOffset != winterOffset && dstOffset == guessedOffset); + } else if ((dst > 0) != (dstOffset == guessedOffset)) { + var nonDstOffset = Math.max(winterOffset, summerOffset); + var trueOffset = dst > 0 ? dstOffset : nonDstOffset; + // Don't try setMinutes(date.getMinutes() + ...) -- it's messed up. + date.setTime(date.getTime() + (trueOffset - guessedOffset) * 6e4); + } + GROWABLE_HEAP_I32()[(((tmPtr) + (24)) >>> 2) >>> 0] = date.getDay(); + var yday = ydayFromDate(date) | 0; + GROWABLE_HEAP_I32()[(((tmPtr) + (28)) >>> 2) >>> 0] = yday; + // To match expected behavior, update fields from date + GROWABLE_HEAP_I32()[((tmPtr) >>> 2) >>> 0] = date.getSeconds(); + GROWABLE_HEAP_I32()[(((tmPtr) + (4)) >>> 2) >>> 0] = date.getMinutes(); + GROWABLE_HEAP_I32()[(((tmPtr) + (8)) >>> 2) >>> 0] = date.getHours(); + GROWABLE_HEAP_I32()[(((tmPtr) + (12)) >>> 2) >>> 0] = date.getDate(); + GROWABLE_HEAP_I32()[(((tmPtr) + (16)) >>> 2) >>> 0] = date.getMonth(); + GROWABLE_HEAP_I32()[(((tmPtr) + (20)) >>> 2) >>> 0] = date.getYear(); + var timeMs = date.getTime(); + if (isNaN(timeMs)) { + return -1; + } + // Return time in microseconds + return timeMs / 1e3; + })(); + return BigInt(ret); +}; + +function __mmap_js(len, prot, flags, fd, offset, allocated, addr) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(16, 0, 1, len, prot, flags, fd, offset, allocated, addr); + len >>>= 0; + offset = bigintToI53Checked(offset); + allocated >>>= 0; + addr >>>= 0; + return -52; +} + +function __munmap_js(addr, len, prot, flags, fd, offset) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(17, 0, 1, addr, len, prot, flags, fd, offset); + addr >>>= 0; + len >>>= 0; + offset = bigintToI53Checked(offset); +} + +var timers = {}; + +var _emscripten_get_now = () => performance.timeOrigin + performance.now(); + +function __setitimer_js(which, timeout_ms) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(18, 0, 1, which, timeout_ms); + // First, clear any existing timer. + if (timers[which]) { + clearTimeout(timers[which].id); + delete timers[which]; + } + // A timeout of zero simply cancels the current timeout so we have nothing + // more to do. + if (!timeout_ms) return 0; + var id = setTimeout(() => { + delete timers[which]; + callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now())); + }, timeout_ms); + timers[which] = { + id, + timeout_ms + }; + return 0; +} + +var __tzset_js = function(timezone, daylight, std_name, dst_name) { + timezone >>>= 0; + daylight >>>= 0; + std_name >>>= 0; + dst_name >>>= 0; + // TODO: Use (malleable) environment variables instead of system settings. + var currentYear = (new Date).getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + // Local standard timezone offset. Local standard time is not adjusted for + // daylight savings. This code uses the fact that getTimezoneOffset returns + // a greater value during Standard Time versus Daylight Saving Time (DST). + // Thus it determines the expected output during Standard Time, and it + // compares whether the output of the given date the same (Standard) or less + // (DST). + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + // timezone is specified as seconds west of UTC ("The external variable + // `timezone` shall be set to the difference, in seconds, between + // Coordinated Universal Time (UTC) and local standard time."), the same + // as returned by stdTimezoneOffset. + // See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html + GROWABLE_HEAP_U32()[((timezone) >>> 2) >>> 0] = stdTimezoneOffset * 60; + GROWABLE_HEAP_I32()[((daylight) >>> 2) >>> 0] = Number(winterOffset != summerOffset); + var extractZone = timezoneOffset => { + // Why inverse sign? + // Read here https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset + var sign = timezoneOffset >= 0 ? "-" : "+"; + var absOffset = Math.abs(timezoneOffset); + var hours = String(Math.floor(absOffset / 60)).padStart(2, "0"); + var minutes = String(absOffset % 60).padStart(2, "0"); + return `UTC${sign}${hours}${minutes}`; + }; + var winterName = extractZone(winterOffset); + var summerName = extractZone(summerOffset); + if (summerOffset < winterOffset) { + // Northern hemisphere + stringToUTF8(winterName, std_name, 17); + stringToUTF8(summerName, dst_name, 17); + } else { + stringToUTF8(winterName, dst_name, 17); + stringToUTF8(summerName, std_name, 17); + } +}; + +var _emscripten_date_now = () => Date.now(); + +var nowIsMonotonic = 1; + +var checkWasiClock = clock_id => clock_id >= 0 && clock_id <= 3; + +function _clock_time_get(clk_id, ignored_precision, ptime) { + ignored_precision = bigintToI53Checked(ignored_precision); + ptime >>>= 0; + if (!checkWasiClock(clk_id)) { + return 28; + } + var now; + // all wasi clocks but realtime are monotonic + if (clk_id === 0) { + now = _emscripten_date_now(); + } else if (nowIsMonotonic) { + now = _emscripten_get_now(); + } else { + return 52; + } + // "now" is in ms, and wasi times are in ns. + var nsec = Math.round(now * 1e3 * 1e3); + HEAP64[((ptime) >>> 3)] = BigInt(nsec); + return 0; +} + +var readEmAsmArgsArray = []; + +var readEmAsmArgs = (sigPtr, buf) => { + readEmAsmArgsArray.length = 0; + var ch; + // Most arguments are i32s, so shift the buffer pointer so it is a plain + // index into HEAP32. + while (ch = GROWABLE_HEAP_U8()[sigPtr++ >>> 0]) { + // Floats are always passed as doubles, so all types except for 'i' + // are 8 bytes and require alignment. + var wide = (ch != 105); + wide &= (ch != 112); + buf += wide && (buf % 8) ? 4 : 0; + readEmAsmArgsArray.push(// Special case for pointers under wasm64 or CAN_ADDRESS_2GB mode. + ch == 112 ? GROWABLE_HEAP_U32()[((buf) >>> 2) >>> 0] : ch == 106 ? HEAP64[((buf) >>> 3)] : ch == 105 ? GROWABLE_HEAP_I32()[((buf) >>> 2) >>> 0] : GROWABLE_HEAP_F64()[((buf) >>> 3) >>> 0]); + buf += wide ? 8 : 4; + } + return readEmAsmArgsArray; +}; + +var runEmAsmFunction = (code, sigPtr, argbuf) => { + var args = readEmAsmArgs(sigPtr, argbuf); + return ASM_CONSTS[code](...args); +}; + +function _emscripten_asm_const_int(code, sigPtr, argbuf) { + code >>>= 0; + sigPtr >>>= 0; + argbuf >>>= 0; + return runEmAsmFunction(code, sigPtr, argbuf); +} + +function _emscripten_asm_const_ptr(code, sigPtr, argbuf) { + code >>>= 0; + sigPtr >>>= 0; + argbuf >>>= 0; + return runEmAsmFunction(code, sigPtr, argbuf); +} + +var warnOnce = text => { + warnOnce.shown ||= {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + if (ENVIRONMENT_IS_NODE) text = "warning: " + text; + err(text); + } +}; + +var _emscripten_check_blocking_allowed = () => {}; + +function _emscripten_errn(str, len) { + str >>>= 0; + len >>>= 0; + return err(UTF8ToString(str, len)); +} + +var _emscripten_exit_with_live_runtime = () => { + runtimeKeepalivePush(); + throw "unwind"; +}; + +var getHeapMax = () => // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate +// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side +// for any code that deals with heap sizes, which would require special +// casing all heap size related code to treat 0 specially. +4294901760; + +function _emscripten_get_heap_max() { + return getHeapMax(); +} + +var _emscripten_has_asyncify = () => 1; + +var _emscripten_num_logical_cores = () => ENVIRONMENT_IS_NODE ? require("os").cpus().length : navigator["hardwareConcurrency"]; + +function _emscripten_pc_get_function(pc) { + pc >>>= 0; + abort("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER"); + return 0; +} + +var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment; + +var growMemory = size => { + var b = wasmMemory.buffer; + var pages = ((size - b.byteLength + 65535) / 65536) | 0; + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow(pages); + // .grow() takes a delta compared to the previous size + updateMemoryViews(); + return 1; + } catch (e) {} +}; + +function _emscripten_resize_heap(requestedSize) { + requestedSize >>>= 0; + var oldSize = GROWABLE_HEAP_U8().length; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + if (requestedSize <= oldSize) { + return false; + } + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + return false; + } + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + .2 / cutDown); + // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)); + var replacement = growMemory(newSize); + if (replacement) { + return true; + } + } + return false; +} + +/** @returns {number} */ var convertFrameToPC = frame => { + abort("Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER"); + // return 0 if we can't find any + return 0; +}; + +var UNWIND_CACHE = {}; + +var saveInUnwindCache = callstack => { + callstack.forEach(frame => { + var pc = convertFrameToPC(frame); + if (pc) { + UNWIND_CACHE[pc] = frame; + } + }); +}; + +var jsStackTrace = () => (new Error).stack.toString(); + +function _emscripten_stack_snapshot() { + var callstack = jsStackTrace().split("\n"); + if (callstack[0] == "Error") { + callstack.shift(); + } + saveInUnwindCache(callstack); + // Caches the stack snapshot so that emscripten_stack_unwind_buffer() can + // unwind from this spot. + UNWIND_CACHE.last_addr = convertFrameToPC(callstack[3]); + UNWIND_CACHE.last_stack = callstack; + return UNWIND_CACHE.last_addr; +} + +function _emscripten_stack_unwind_buffer(addr, buffer, count) { + addr >>>= 0; + buffer >>>= 0; + var stack; + if (UNWIND_CACHE.last_addr == addr) { + stack = UNWIND_CACHE.last_stack; + } else { + stack = jsStackTrace().split("\n"); + if (stack[0] == "Error") { + stack.shift(); + } + saveInUnwindCache(stack); + } + var offset = 3; + while (stack[offset] && convertFrameToPC(stack[offset]) != addr) { + ++offset; + } + for (var i = 0; i < count && stack[i + offset]; ++i) { + GROWABLE_HEAP_I32()[(((buffer) + (i * 4)) >>> 2) >>> 0] = convertFrameToPC(stack[i + offset]); + } + return i; +} + +var stringToUTF8OnStack = str => { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8(str, ret, size); + return ret; +}; + +var WebGPU = { + Internals: { + jsObjects: [], + jsObjectInsert: (ptr, jsObject) => { + WebGPU.Internals.jsObjects[ptr] = jsObject; + }, + bufferOnUnmaps: [], + futures: [], + futureInsert: (futureId, promise) => { + WebGPU.Internals.futures[futureId] = new Promise(resolve => promise.finally(() => resolve(futureId))); + } + }, + getJsObject: ptr => { + if (!ptr) return undefined; + return WebGPU.Internals.jsObjects[ptr]; + }, + importJsAdapter: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateAdapter(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsBindGroup: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateBindGroup(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsBindGroupLayout: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateBindGroupLayout(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsBuffer: (buffer, parentPtr = 0) => { + // At the moment, we do not allow importing pending buffers. + assert(buffer.mapState != "pending"); + var mapState = buffer.mapState == "mapped" ? 3 : 1; + var bufferPtr = _emwgpuCreateBuffer(parentPtr, mapState); + WebGPU.Internals.jsObjectInsert(bufferPtr, buffer); + if (buffer.mapState == "mapped") { + WebGPU.Internals.bufferOnUnmaps[bufferPtr] = []; + } + return bufferPtr; + }, + importJsCommandBuffer: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateCommandBuffer(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsCommandEncoder: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateCommandEncoder(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsComputePassEncoder: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateComputePassEncoder(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsComputePipeline: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateComputePipeline(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsDevice: (device, parentPtr = 0) => { + var queuePtr = _emwgpuCreateQueue(parentPtr); + var devicePtr = _emwgpuCreateDevice(parentPtr, queuePtr); + WebGPU.Internals.jsObjectInsert(queuePtr, device.queue); + WebGPU.Internals.jsObjectInsert(devicePtr, device); + return devicePtr; + }, + importJsPipelineLayout: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreatePipelineLayout(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsQuerySet: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateQuerySet(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsQueue: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateQueue(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsRenderBundle: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateRenderBundle(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsRenderBundleEncoder: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateRenderBundleEncoder(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsRenderPassEncoder: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateRenderPassEncoder(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsRenderPipeline: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateRenderPipeline(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsSampler: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateSampler(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsShaderModule: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateShaderModule(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsSurface: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateSurface(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsTexture: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateTexture(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + importJsTextureView: (obj, parentPtr = 0) => { + var ptr = _emwgpuCreateTextureView(parentPtr); + WebGPU.Internals.jsObjects[ptr] = obj; + return ptr; + }, + errorCallback: (callback, type, message, userdata) => { + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack(message); + ((a1, a2, a3) => dynCall_viii(callback, a1, a2, a3))(type, messagePtr, userdata); + stackRestore(sp); + }, + setStringView: (ptr, data, length) => { + GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0] = data; + GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0] = length; + }, + makeStringFromStringView: stringViewPtr => { + var ptr = GROWABLE_HEAP_U32()[((stringViewPtr) >>> 2) >>> 0]; + var length = GROWABLE_HEAP_U32()[(((stringViewPtr) + (4)) >>> 2) >>> 0]; + // UTF8ToString stops at the first null terminator character in the + // string regardless of the length. + return UTF8ToString(ptr, length); + }, + makeStringFromOptionalStringView: stringViewPtr => { + var ptr = GROWABLE_HEAP_U32()[((stringViewPtr) >>> 2) >>> 0]; + var length = GROWABLE_HEAP_U32()[(((stringViewPtr) + (4)) >>> 2) >>> 0]; + // If we don't have a valid string pointer, just return undefined when + // optional. + if (!ptr) { + if (length === 0) { + return ""; + } + return undefined; + } + // UTF8ToString stops at the first null terminator character in the + // string regardless of the length. + return UTF8ToString(ptr, length); + }, + makeColor: ptr => ({ + "r": GROWABLE_HEAP_F64()[((ptr) >>> 3) >>> 0], + "g": GROWABLE_HEAP_F64()[(((ptr) + (8)) >>> 3) >>> 0], + "b": GROWABLE_HEAP_F64()[(((ptr) + (16)) >>> 3) >>> 0], + "a": GROWABLE_HEAP_F64()[(((ptr) + (24)) >>> 3) >>> 0] + }), + makeExtent3D: ptr => ({ + "width": GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0], + "height": GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0], + "depthOrArrayLayers": GROWABLE_HEAP_U32()[(((ptr) + (8)) >>> 2) >>> 0] + }), + makeOrigin3D: ptr => ({ + "x": GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0], + "y": GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0], + "z": GROWABLE_HEAP_U32()[(((ptr) + (8)) >>> 2) >>> 0] + }), + makeTexelCopyTextureInfo: ptr => ({ + "texture": WebGPU.getJsObject(GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0]), + "mipLevel": GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0], + "origin": WebGPU.makeOrigin3D(ptr + 8), + "aspect": WebGPU.TextureAspect[GROWABLE_HEAP_U32()[(((ptr) + (20)) >>> 2) >>> 0]] + }), + makeTexelCopyBufferLayout: ptr => { + var bytesPerRow = GROWABLE_HEAP_U32()[(((ptr) + (8)) >>> 2) >>> 0]; + var rowsPerImage = GROWABLE_HEAP_U32()[(((ptr) + (12)) >>> 2) >>> 0]; + return { + "offset": (GROWABLE_HEAP_U32()[(((ptr + 4)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0]), + "bytesPerRow": bytesPerRow === 4294967295 ? undefined : bytesPerRow, + "rowsPerImage": rowsPerImage === 4294967295 ? undefined : rowsPerImage + }; + }, + makeTexelCopyBufferInfo: ptr => { + var layoutPtr = ptr + 0; + var bufferCopyView = WebGPU.makeTexelCopyBufferLayout(layoutPtr); + bufferCopyView["buffer"] = WebGPU.getJsObject(GROWABLE_HEAP_U32()[(((ptr) + (16)) >>> 2) >>> 0]); + return bufferCopyView; + }, + makePassTimestampWrites: ptr => { + if (ptr === 0) return undefined; + return { + "querySet": WebGPU.getJsObject(GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0]), + "beginningOfPassWriteIndex": GROWABLE_HEAP_U32()[(((ptr) + (8)) >>> 2) >>> 0], + "endOfPassWriteIndex": GROWABLE_HEAP_U32()[(((ptr) + (12)) >>> 2) >>> 0] + }; + }, + makePipelineConstants: (constantCount, constantsPtr) => { + if (!constantCount) return; + var constants = {}; + for (var i = 0; i < constantCount; ++i) { + var entryPtr = constantsPtr + 24 * i; + var key = WebGPU.makeStringFromStringView(entryPtr + 4); + constants[key] = GROWABLE_HEAP_F64()[(((entryPtr) + (16)) >>> 3) >>> 0]; + } + return constants; + }, + makePipelineLayout: layoutPtr => { + if (!layoutPtr) return "auto"; + return WebGPU.getJsObject(layoutPtr); + }, + makeComputeState: ptr => { + if (!ptr) return undefined; + var desc = { + "module": WebGPU.getJsObject(GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0]), + "constants": WebGPU.makePipelineConstants(GROWABLE_HEAP_U32()[(((ptr) + (16)) >>> 2) >>> 0], GROWABLE_HEAP_U32()[(((ptr) + (20)) >>> 2) >>> 0]), + "entryPoint": WebGPU.makeStringFromOptionalStringView(ptr + 8) + }; + return desc; + }, + makeComputePipelineDesc: descriptor => { + var desc = { + "label": WebGPU.makeStringFromOptionalStringView(descriptor + 4), + "layout": WebGPU.makePipelineLayout(GROWABLE_HEAP_U32()[(((descriptor) + (12)) >>> 2) >>> 0]), + "compute": WebGPU.makeComputeState(descriptor + 16) + }; + return desc; + }, + makeRenderPipelineDesc: descriptor => { + function makePrimitiveState(psPtr) { + if (!psPtr) return undefined; + return { + "topology": WebGPU.PrimitiveTopology[GROWABLE_HEAP_U32()[(((psPtr) + (4)) >>> 2) >>> 0]], + "stripIndexFormat": WebGPU.IndexFormat[GROWABLE_HEAP_U32()[(((psPtr) + (8)) >>> 2) >>> 0]], + "frontFace": WebGPU.FrontFace[GROWABLE_HEAP_U32()[(((psPtr) + (12)) >>> 2) >>> 0]], + "cullMode": WebGPU.CullMode[GROWABLE_HEAP_U32()[(((psPtr) + (16)) >>> 2) >>> 0]], + "unclippedDepth": !!(GROWABLE_HEAP_U32()[(((psPtr) + (20)) >>> 2) >>> 0]) + }; + } + function makeBlendComponent(bdPtr) { + if (!bdPtr) return undefined; + return { + "operation": WebGPU.BlendOperation[GROWABLE_HEAP_U32()[((bdPtr) >>> 2) >>> 0]], + "srcFactor": WebGPU.BlendFactor[GROWABLE_HEAP_U32()[(((bdPtr) + (4)) >>> 2) >>> 0]], + "dstFactor": WebGPU.BlendFactor[GROWABLE_HEAP_U32()[(((bdPtr) + (8)) >>> 2) >>> 0]] + }; + } + function makeBlendState(bsPtr) { + if (!bsPtr) return undefined; + return { + "alpha": makeBlendComponent(bsPtr + 12), + "color": makeBlendComponent(bsPtr + 0) + }; + } + function makeColorState(csPtr) { + var formatInt = GROWABLE_HEAP_U32()[(((csPtr) + (4)) >>> 2) >>> 0]; + return formatInt === 0 ? undefined : { + "format": WebGPU.TextureFormat[formatInt], + "blend": makeBlendState(GROWABLE_HEAP_U32()[(((csPtr) + (8)) >>> 2) >>> 0]), + "writeMask": GROWABLE_HEAP_U32()[(((csPtr) + (16)) >>> 2) >>> 0] + }; + } + function makeColorStates(count, csArrayPtr) { + var states = []; + for (var i = 0; i < count; ++i) { + states.push(makeColorState(csArrayPtr + 24 * i)); + } + return states; + } + function makeStencilStateFace(ssfPtr) { + return { + "compare": WebGPU.CompareFunction[GROWABLE_HEAP_U32()[((ssfPtr) >>> 2) >>> 0]], + "failOp": WebGPU.StencilOperation[GROWABLE_HEAP_U32()[(((ssfPtr) + (4)) >>> 2) >>> 0]], + "depthFailOp": WebGPU.StencilOperation[GROWABLE_HEAP_U32()[(((ssfPtr) + (8)) >>> 2) >>> 0]], + "passOp": WebGPU.StencilOperation[GROWABLE_HEAP_U32()[(((ssfPtr) + (12)) >>> 2) >>> 0]] + }; + } + function makeDepthStencilState(dssPtr) { + if (!dssPtr) return undefined; + return { + "format": WebGPU.TextureFormat[GROWABLE_HEAP_U32()[(((dssPtr) + (4)) >>> 2) >>> 0]], + "depthWriteEnabled": !!(GROWABLE_HEAP_U32()[(((dssPtr) + (8)) >>> 2) >>> 0]), + "depthCompare": WebGPU.CompareFunction[GROWABLE_HEAP_U32()[(((dssPtr) + (12)) >>> 2) >>> 0]], + "stencilFront": makeStencilStateFace(dssPtr + 16), + "stencilBack": makeStencilStateFace(dssPtr + 32), + "stencilReadMask": GROWABLE_HEAP_U32()[(((dssPtr) + (48)) >>> 2) >>> 0], + "stencilWriteMask": GROWABLE_HEAP_U32()[(((dssPtr) + (52)) >>> 2) >>> 0], + "depthBias": GROWABLE_HEAP_I32()[(((dssPtr) + (56)) >>> 2) >>> 0], + "depthBiasSlopeScale": GROWABLE_HEAP_F32()[(((dssPtr) + (60)) >>> 2) >>> 0], + "depthBiasClamp": GROWABLE_HEAP_F32()[(((dssPtr) + (64)) >>> 2) >>> 0] + }; + } + function makeVertexAttribute(vaPtr) { + return { + "format": WebGPU.VertexFormat[GROWABLE_HEAP_U32()[(((vaPtr) + (4)) >>> 2) >>> 0]], + "offset": (GROWABLE_HEAP_U32()[((((vaPtr + 4)) + (8)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[(((vaPtr) + (8)) >>> 2) >>> 0]), + "shaderLocation": GROWABLE_HEAP_U32()[(((vaPtr) + (16)) >>> 2) >>> 0] + }; + } + function makeVertexAttributes(count, vaArrayPtr) { + var vas = []; + for (var i = 0; i < count; ++i) { + vas.push(makeVertexAttribute(vaArrayPtr + i * 24)); + } + return vas; + } + function makeVertexBuffer(vbPtr) { + if (!vbPtr) return undefined; + var stepModeInt = GROWABLE_HEAP_U32()[(((vbPtr) + (4)) >>> 2) >>> 0]; + var attributeCountInt = GROWABLE_HEAP_U32()[(((vbPtr) + (16)) >>> 2) >>> 0]; + if (stepModeInt === 0 && attributeCountInt === 0) { + return null; + } + return { + "arrayStride": (GROWABLE_HEAP_U32()[((((vbPtr + 4)) + (8)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[(((vbPtr) + (8)) >>> 2) >>> 0]), + "stepMode": WebGPU.VertexStepMode[stepModeInt], + "attributes": makeVertexAttributes(attributeCountInt, GROWABLE_HEAP_U32()[(((vbPtr) + (20)) >>> 2) >>> 0]) + }; + } + function makeVertexBuffers(count, vbArrayPtr) { + if (!count) return undefined; + var vbs = []; + for (var i = 0; i < count; ++i) { + vbs.push(makeVertexBuffer(vbArrayPtr + i * 24)); + } + return vbs; + } + function makeVertexState(viPtr) { + if (!viPtr) return undefined; + var desc = { + "module": WebGPU.getJsObject(GROWABLE_HEAP_U32()[(((viPtr) + (4)) >>> 2) >>> 0]), + "constants": WebGPU.makePipelineConstants(GROWABLE_HEAP_U32()[(((viPtr) + (16)) >>> 2) >>> 0], GROWABLE_HEAP_U32()[(((viPtr) + (20)) >>> 2) >>> 0]), + "buffers": makeVertexBuffers(GROWABLE_HEAP_U32()[(((viPtr) + (24)) >>> 2) >>> 0], GROWABLE_HEAP_U32()[(((viPtr) + (28)) >>> 2) >>> 0]), + "entryPoint": WebGPU.makeStringFromOptionalStringView(viPtr + 8) + }; + return desc; + } + function makeMultisampleState(msPtr) { + if (!msPtr) return undefined; + return { + "count": GROWABLE_HEAP_U32()[(((msPtr) + (4)) >>> 2) >>> 0], + "mask": GROWABLE_HEAP_U32()[(((msPtr) + (8)) >>> 2) >>> 0], + "alphaToCoverageEnabled": !!(GROWABLE_HEAP_U32()[(((msPtr) + (12)) >>> 2) >>> 0]) + }; + } + function makeFragmentState(fsPtr) { + if (!fsPtr) return undefined; + var desc = { + "module": WebGPU.getJsObject(GROWABLE_HEAP_U32()[(((fsPtr) + (4)) >>> 2) >>> 0]), + "constants": WebGPU.makePipelineConstants(GROWABLE_HEAP_U32()[(((fsPtr) + (16)) >>> 2) >>> 0], GROWABLE_HEAP_U32()[(((fsPtr) + (20)) >>> 2) >>> 0]), + "targets": makeColorStates(GROWABLE_HEAP_U32()[(((fsPtr) + (24)) >>> 2) >>> 0], GROWABLE_HEAP_U32()[(((fsPtr) + (28)) >>> 2) >>> 0]), + "entryPoint": WebGPU.makeStringFromOptionalStringView(fsPtr + 8) + }; + return desc; + } + var desc = { + "label": WebGPU.makeStringFromOptionalStringView(descriptor + 4), + "layout": WebGPU.makePipelineLayout(GROWABLE_HEAP_U32()[(((descriptor) + (12)) >>> 2) >>> 0]), + "vertex": makeVertexState(descriptor + 16), + "primitive": makePrimitiveState(descriptor + 48), + "depthStencil": makeDepthStencilState(GROWABLE_HEAP_U32()[(((descriptor) + (72)) >>> 2) >>> 0]), + "multisample": makeMultisampleState(descriptor + 76), + "fragment": makeFragmentState(GROWABLE_HEAP_U32()[(((descriptor) + (92)) >>> 2) >>> 0]) + }; + return desc; + }, + fillLimitStruct: (limits, limitsOutPtr) => { + function setLimitValueU32(name, limitOffset) { + var limitValue = limits[name]; + GROWABLE_HEAP_I32()[(((limitsOutPtr) + (limitOffset)) >>> 2) >>> 0] = limitValue; + } + function setLimitValueU64(name, limitOffset) { + var limitValue = limits[name]; + HEAP64[(((limitsOutPtr) + (limitOffset)) >>> 3)] = BigInt(limitValue); + } + setLimitValueU32("maxTextureDimension1D", 4); + setLimitValueU32("maxTextureDimension2D", 8); + setLimitValueU32("maxTextureDimension3D", 12); + setLimitValueU32("maxTextureArrayLayers", 16); + setLimitValueU32("maxBindGroups", 20); + setLimitValueU32("maxBindGroupsPlusVertexBuffers", 24); + setLimitValueU32("maxBindingsPerBindGroup", 28); + setLimitValueU32("maxDynamicUniformBuffersPerPipelineLayout", 32); + setLimitValueU32("maxDynamicStorageBuffersPerPipelineLayout", 36); + setLimitValueU32("maxSampledTexturesPerShaderStage", 40); + setLimitValueU32("maxSamplersPerShaderStage", 44); + setLimitValueU32("maxStorageBuffersPerShaderStage", 48); + setLimitValueU32("maxStorageTexturesPerShaderStage", 52); + setLimitValueU32("maxUniformBuffersPerShaderStage", 56); + setLimitValueU32("minUniformBufferOffsetAlignment", 80); + setLimitValueU32("minStorageBufferOffsetAlignment", 84); + setLimitValueU64("maxUniformBufferBindingSize", 64); + setLimitValueU64("maxStorageBufferBindingSize", 72); + setLimitValueU32("maxVertexBuffers", 88); + setLimitValueU64("maxBufferSize", 96); + setLimitValueU32("maxVertexAttributes", 104); + setLimitValueU32("maxVertexBufferArrayStride", 108); + setLimitValueU32("maxInterStageShaderVariables", 112); + setLimitValueU32("maxColorAttachments", 116); + setLimitValueU32("maxColorAttachmentBytesPerSample", 120); + setLimitValueU32("maxComputeWorkgroupStorageSize", 124); + setLimitValueU32("maxComputeInvocationsPerWorkgroup", 128); + setLimitValueU32("maxComputeWorkgroupSizeX", 132); + setLimitValueU32("maxComputeWorkgroupSizeY", 136); + setLimitValueU32("maxComputeWorkgroupSizeZ", 140); + setLimitValueU32("maxComputeWorkgroupsPerDimension", 144); + }, + Int_BufferMapState: { + unmapped: 1, + pending: 2, + mapped: 3 + }, + Int_CompilationMessageType: { + error: 1, + warning: 2, + info: 3 + }, + Int_DeviceLostReason: { + undefined: 1, + unknown: 1, + destroyed: 2 + }, + Int_PreferredFormat: { + rgba8unorm: 18, + bgra8unorm: 23 + }, + WGSLLanguageFeatureName: { + 1: "readonly_and_readwrite_storage_textures", + 2: "packed_4x8_integer_dot_product", + 3: "unrestricted_pointer_parameters", + 4: "pointer_composite_access", + 5: "sized_binding_array" + }, + AddressMode: [ , "clamp-to-edge", "repeat", "mirror-repeat" ], + BlendFactor: [ , "zero", "one", "src", "one-minus-src", "src-alpha", "one-minus-src-alpha", "dst", "one-minus-dst", "dst-alpha", "one-minus-dst-alpha", "src-alpha-saturated", "constant", "one-minus-constant", "src1", "one-minus-src1", "src1alpha", "one-minus-src1alpha" ], + BlendOperation: [ , "add", "subtract", "reverse-subtract", "min", "max" ], + BufferBindingType: [ "binding-not-used", , "uniform", "storage", "read-only-storage" ], + BufferMapState: { + 1: "unmapped", + 2: "pending", + 3: "mapped" + }, + CompareFunction: [ , "never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always" ], + CompilationInfoRequestStatus: { + 1: "success", + 2: "callback-cancelled" + }, + CompositeAlphaMode: [ , "opaque", "premultiplied", "unpremultiplied", "inherit" ], + CullMode: [ , "none", "front", "back" ], + ErrorFilter: { + 1: "validation", + 2: "out-of-memory", + 3: "internal" + }, + FeatureLevel: [ , "compatibility", "core" ], + FeatureName: { + 1: "depth-clip-control", + 2: "depth32float-stencil8", + 3: "timestamp-query", + 4: "texture-compression-bc", + 5: "texture-compression-bc-sliced-3d", + 6: "texture-compression-etc2", + 7: "texture-compression-astc", + 8: "texture-compression-astc-sliced-3d", + 9: "indirect-first-instance", + 10: "shader-f16", + 11: "rg11b10ufloat-renderable", + 12: "bgra8unorm-storage", + 13: "float32-filterable", + 14: "float32-blendable", + 15: "clip-distances", + 16: "dual-source-blending", + 17: "subgroups", + 18: "core-features-and-limits", + 327688: "subgroups-f16", + 327693: "chromium-experimental-unorm16-texture-formats", + 327694: "chromium-experimental-snorm16-texture-formats", + 327733: "chromium-experimental-multi-draw-indirect" + }, + FilterMode: [ , "nearest", "linear" ], + FrontFace: [ , "ccw", "cw" ], + IndexFormat: [ , "uint16", "uint32" ], + LoadOp: [ , "load", "clear" ], + MipmapFilterMode: [ , "nearest", "linear" ], + OptionalBool: [ "false", "true" ], + PowerPreference: [ , "low-power", "high-performance" ], + PredefinedColorSpace: { + 1: "srgb", + 2: "display-p3" + }, + PrimitiveTopology: [ , "point-list", "line-list", "line-strip", "triangle-list", "triangle-strip" ], + QueryType: { + 1: "occlusion", + 2: "timestamp" + }, + SamplerBindingType: [ "binding-not-used", , "filtering", "non-filtering", "comparison" ], + Status: { + 1: "success", + 2: "error" + }, + StencilOperation: [ , "keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap" ], + StorageTextureAccess: [ "binding-not-used", , "write-only", "read-only", "read-write" ], + StoreOp: [ , "store", "discard" ], + SurfaceGetCurrentTextureStatus: { + 1: "success-optimal", + 2: "success-suboptimal", + 3: "timeout", + 4: "outdated", + 5: "lost", + 6: "error" + }, + TextureAspect: [ , "all", "stencil-only", "depth-only" ], + TextureDimension: [ , "1d", "2d", "3d" ], + TextureFormat: [ , "r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32float", "r32uint", "r32sint", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb10a2uint", "rgb10a2unorm", "rg11b10ufloat", "rgb9e5ufloat", "rg32float", "rg32uint", "rg32sint", "rgba16uint", "rgba16sint", "rgba16float", "rgba32float", "rgba32uint", "rgba32sint", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb" ], + TextureSampleType: [ "binding-not-used", , "float", "unfilterable-float", "depth", "sint", "uint" ], + TextureViewDimension: [ , "1d", "2d", "2d-array", "cube", "cube-array", "3d" ], + ToneMappingMode: { + 1: "standard", + 2: "extended" + }, + VertexFormat: { + 1: "uint8", + 2: "uint8x2", + 3: "uint8x4", + 4: "sint8", + 5: "sint8x2", + 6: "sint8x4", + 7: "unorm8", + 8: "unorm8x2", + 9: "unorm8x4", + 10: "snorm8", + 11: "snorm8x2", + 12: "snorm8x4", + 13: "uint16", + 14: "uint16x2", + 15: "uint16x4", + 16: "sint16", + 17: "sint16x2", + 18: "sint16x4", + 19: "unorm16", + 20: "unorm16x2", + 21: "unorm16x4", + 22: "snorm16", + 23: "snorm16x2", + 24: "snorm16x4", + 25: "float16", + 26: "float16x2", + 27: "float16x4", + 28: "float32", + 29: "float32x2", + 30: "float32x3", + 31: "float32x4", + 32: "uint32", + 33: "uint32x2", + 34: "uint32x3", + 35: "uint32x4", + 36: "sint32", + 37: "sint32x2", + 38: "sint32x3", + 39: "sint32x4", + 40: "unorm10-10-10-2", + 41: "unorm8x4-bgra" + }, + VertexStepMode: [ , "vertex", "instance" ], + FeatureNameString2Enum: { + "depth-clip-control": "1", + "depth32float-stencil8": "2", + "timestamp-query": "3", + "texture-compression-bc": "4", + "texture-compression-bc-sliced-3d": "5", + "texture-compression-etc2": "6", + "texture-compression-astc": "7", + "texture-compression-astc-sliced-3d": "8", + "indirect-first-instance": "9", + "shader-f16": "10", + "rg11b10ufloat-renderable": "11", + "bgra8unorm-storage": "12", + "float32-filterable": "13", + "float32-blendable": "14", + "clip-distances": "15", + "dual-source-blending": "16", + subgroups: "17", + "core-features-and-limits": "18", + "subgroups-f16": "327688", + "chromium-experimental-unorm16-texture-formats": "327693", + "chromium-experimental-snorm16-texture-formats": "327694", + "chromium-experimental-multi-draw-indirect": "327733" + }, + WGSLLanguageFeatureNameString2Enum: { + readonly_and_readwrite_storage_textures: "1", + packed_4x8_integer_dot_product: "2", + unrestricted_pointer_parameters: "3", + pointer_composite_access: "4", + sized_binding_array: "5" + } +}; + +function _emwgpuAdapterRequestDevice(adapterPtr, futureId, deviceLostFutureId, devicePtr, queuePtr, descriptor) { + adapterPtr >>>= 0; + futureId = bigintToI53Checked(futureId); + deviceLostFutureId = bigintToI53Checked(deviceLostFutureId); + devicePtr >>>= 0; + queuePtr >>>= 0; + descriptor >>>= 0; + var adapter = WebGPU.getJsObject(adapterPtr); + var desc = {}; + if (descriptor) { + var requiredFeatureCount = GROWABLE_HEAP_U32()[(((descriptor) + (12)) >>> 2) >>> 0]; + if (requiredFeatureCount) { + var requiredFeaturesPtr = GROWABLE_HEAP_U32()[(((descriptor) + (16)) >>> 2) >>> 0]; + // requiredFeaturesPtr is a pointer to an array of FeatureName which is an enum of size uint32_t + desc["requiredFeatures"] = Array.from(GROWABLE_HEAP_U32().subarray((((requiredFeaturesPtr) >>> 2)) >>> 0, ((requiredFeaturesPtr + requiredFeatureCount * 4) >>> 2) >>> 0), feature => WebGPU.FeatureName[feature]); + } + var limitsPtr = GROWABLE_HEAP_U32()[(((descriptor) + (20)) >>> 2) >>> 0]; + if (limitsPtr) { + var requiredLimits = {}; + function setLimitU32IfDefined(name, limitOffset) { + var ptr = limitsPtr + limitOffset; + var value = GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0]; + if (value != 4294967295) { + requiredLimits[name] = value; + } + } + function setLimitU64IfDefined(name, limitOffset) { + var ptr = limitsPtr + limitOffset; + // Handle WGPU_LIMIT_U64_UNDEFINED. + var limitPart1 = GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0]; + var limitPart2 = GROWABLE_HEAP_U32()[(((ptr) + (4)) >>> 2) >>> 0]; + if (limitPart1 != 4294967295 || limitPart2 != 4294967295) { + requiredLimits[name] = (GROWABLE_HEAP_U32()[(((ptr + 4)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0]); + } + } + setLimitU32IfDefined("maxTextureDimension1D", 4); + setLimitU32IfDefined("maxTextureDimension2D", 8); + setLimitU32IfDefined("maxTextureDimension3D", 12); + setLimitU32IfDefined("maxTextureArrayLayers", 16); + setLimitU32IfDefined("maxBindGroups", 20); + setLimitU32IfDefined("maxBindGroupsPlusVertexBuffers", 24); + setLimitU32IfDefined("maxDynamicUniformBuffersPerPipelineLayout", 32); + setLimitU32IfDefined("maxDynamicStorageBuffersPerPipelineLayout", 36); + setLimitU32IfDefined("maxSampledTexturesPerShaderStage", 40); + setLimitU32IfDefined("maxSamplersPerShaderStage", 44); + setLimitU32IfDefined("maxStorageBuffersPerShaderStage", 48); + setLimitU32IfDefined("maxStorageTexturesPerShaderStage", 52); + setLimitU32IfDefined("maxUniformBuffersPerShaderStage", 56); + setLimitU32IfDefined("minUniformBufferOffsetAlignment", 80); + setLimitU32IfDefined("minStorageBufferOffsetAlignment", 84); + setLimitU64IfDefined("maxUniformBufferBindingSize", 64); + setLimitU64IfDefined("maxStorageBufferBindingSize", 72); + setLimitU32IfDefined("maxVertexBuffers", 88); + setLimitU64IfDefined("maxBufferSize", 96); + setLimitU32IfDefined("maxVertexAttributes", 104); + setLimitU32IfDefined("maxVertexBufferArrayStride", 108); + setLimitU32IfDefined("maxInterStageShaderVariables", 112); + setLimitU32IfDefined("maxColorAttachments", 116); + setLimitU32IfDefined("maxColorAttachmentBytesPerSample", 120); + setLimitU32IfDefined("maxComputeWorkgroupStorageSize", 124); + setLimitU32IfDefined("maxComputeInvocationsPerWorkgroup", 128); + setLimitU32IfDefined("maxComputeWorkgroupSizeX", 132); + setLimitU32IfDefined("maxComputeWorkgroupSizeY", 136); + setLimitU32IfDefined("maxComputeWorkgroupSizeZ", 140); + setLimitU32IfDefined("maxComputeWorkgroupsPerDimension", 144); + desc["requiredLimits"] = requiredLimits; + } + var defaultQueuePtr = GROWABLE_HEAP_U32()[(((descriptor) + (24)) >>> 2) >>> 0]; + if (defaultQueuePtr) { + var defaultQueueDesc = { + "label": WebGPU.makeStringFromOptionalStringView(defaultQueuePtr + 4) + }; + desc["defaultQueue"] = defaultQueueDesc; + } + desc["label"] = WebGPU.makeStringFromOptionalStringView(descriptor + 4); + } + runtimeKeepalivePush(); + WebGPU.Internals.futureInsert(futureId, adapter.requestDevice(desc).then(device => { + runtimeKeepalivePop(); + WebGPU.Internals.jsObjectInsert(queuePtr, device.queue); + WebGPU.Internals.jsObjectInsert(devicePtr, device); + // Set up device lost promise resolution. + if (deviceLostFutureId) { + runtimeKeepalivePush(); + WebGPU.Internals.futureInsert(deviceLostFutureId, device.lost.then(info => { + runtimeKeepalivePop(); + // Unset the uncaptured error handler. + device.onuncapturederror = ev => {}; + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack(info.message); + _emwgpuOnDeviceLostCompleted(deviceLostFutureId, WebGPU.Int_DeviceLostReason[info.reason], messagePtr); + stackRestore(sp); + })); + } + // Set up uncaptured error handlers. + device.onuncapturederror = ev => { + var type = 5; + if (ev.error instanceof GPUValidationError) type = 2; else if (ev.error instanceof GPUOutOfMemoryError) type = 3; else if (ev.error instanceof GPUInternalError) type = 4; + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack(ev.error.message); + _emwgpuOnUncapturedError(devicePtr, type, messagePtr); + stackRestore(sp); + }; + _emwgpuOnRequestDeviceCompleted(futureId, 1, devicePtr, 0); + }, ex => { + runtimeKeepalivePop(); + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack(ex.message); + _emwgpuOnRequestDeviceCompleted(futureId, 3, devicePtr, messagePtr); + if (deviceLostFutureId) { + _emwgpuOnDeviceLostCompleted(deviceLostFutureId, 4, messagePtr); + } + stackRestore(sp); + })); +} + +function _emwgpuBufferDestroy(bufferPtr) { + bufferPtr >>>= 0; + var buffer = WebGPU.getJsObject(bufferPtr); + var onUnmap = WebGPU.Internals.bufferOnUnmaps[bufferPtr]; + if (onUnmap) { + for (var i = 0; i < onUnmap.length; ++i) { + onUnmap[i](); + } + delete WebGPU.Internals.bufferOnUnmaps[bufferPtr]; + } + buffer.destroy(); +} + +function _emwgpuBufferGetConstMappedRange(bufferPtr, offset, size) { + bufferPtr >>>= 0; + offset >>>= 0; + size >>>= 0; + var buffer = WebGPU.getJsObject(bufferPtr); + if (size === 0) warnOnce("getMappedRange size=0 no longer means WGPU_WHOLE_MAP_SIZE"); + if (size == 4294967295) size = undefined; + var mapped; + try { + mapped = buffer.getMappedRange(offset, size); + } catch (ex) { + return 0; + } + var data = _memalign(16, mapped.byteLength); + GROWABLE_HEAP_U8().set(new Uint8Array(mapped), data >>> 0); + WebGPU.Internals.bufferOnUnmaps[bufferPtr].push(() => _free(data)); + return data; +} + +function _emwgpuBufferGetMappedRange(bufferPtr, offset, size) { + bufferPtr >>>= 0; + offset >>>= 0; + size >>>= 0; + var buffer = WebGPU.getJsObject(bufferPtr); + if (size === 0) warnOnce("getMappedRange size=0 no longer means WGPU_WHOLE_MAP_SIZE"); + if (size == 4294967295) size = undefined; + var mapped; + try { + mapped = buffer.getMappedRange(offset, size); + } catch (ex) { + return 0; + } + var data = _memalign(16, mapped.byteLength); + GROWABLE_HEAP_U8().fill(0, data, mapped.byteLength); + WebGPU.Internals.bufferOnUnmaps[bufferPtr].push(() => { + new Uint8Array(mapped).set(GROWABLE_HEAP_U8().subarray(data >>> 0, data + mapped.byteLength >>> 0)); + _free(data); + }); + return data; +} + +var _emwgpuBufferMapAsync = function(bufferPtr, futureId, mode, offset, size) { + bufferPtr >>>= 0; + futureId = bigintToI53Checked(futureId); + mode = bigintToI53Checked(mode); + offset >>>= 0; + size >>>= 0; + var buffer = WebGPU.getJsObject(bufferPtr); + WebGPU.Internals.bufferOnUnmaps[bufferPtr] = []; + if (size == 4294967295) size = undefined; + runtimeKeepalivePush(); + WebGPU.Internals.futureInsert(futureId, buffer.mapAsync(mode, offset, size).then(() => { + runtimeKeepalivePop(); + _emwgpuOnMapAsyncCompleted(futureId, 1, 0); + }, ex => { + runtimeKeepalivePop(); + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack(ex.message); + var status = ex.name === "AbortError" ? 4 : ex.name === "OperationError" ? 3 : 0; + _emwgpuOnMapAsyncCompleted(futureId, status, messagePtr); + delete WebGPU.Internals.bufferOnUnmaps[bufferPtr]; + })); +}; + +function _emwgpuBufferUnmap(bufferPtr) { + bufferPtr >>>= 0; + var buffer = WebGPU.getJsObject(bufferPtr); + var onUnmap = WebGPU.Internals.bufferOnUnmaps[bufferPtr]; + if (!onUnmap) { + // Already unmapped + return; + } + for (var i = 0; i < onUnmap.length; ++i) { + onUnmap[i](); + } + delete WebGPU.Internals.bufferOnUnmaps[bufferPtr]; + buffer.unmap(); +} + +function _emwgpuDelete(ptr) { + ptr >>>= 0; + delete WebGPU.Internals.jsObjects[ptr]; +} + +function _emwgpuDeviceCreateBuffer(devicePtr, descriptor, bufferPtr) { + devicePtr >>>= 0; + descriptor >>>= 0; + bufferPtr >>>= 0; + var mappedAtCreation = !!(GROWABLE_HEAP_U32()[(((descriptor) + (32)) >>> 2) >>> 0]); + var desc = { + "label": WebGPU.makeStringFromOptionalStringView(descriptor + 4), + "usage": GROWABLE_HEAP_U32()[(((descriptor) + (16)) >>> 2) >>> 0], + "size": (GROWABLE_HEAP_U32()[((((descriptor + 4)) + (24)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[(((descriptor) + (24)) >>> 2) >>> 0]), + "mappedAtCreation": mappedAtCreation + }; + var device = WebGPU.getJsObject(devicePtr); + var buffer; + try { + buffer = device.createBuffer(desc); + } catch (ex) { + // The only exception should be RangeError if mapping at creation ran out of memory. + return false; + } + WebGPU.Internals.jsObjectInsert(bufferPtr, buffer); + if (mappedAtCreation) { + WebGPU.Internals.bufferOnUnmaps[bufferPtr] = []; + } + return true; +} + +function _emwgpuDeviceCreateShaderModule(devicePtr, descriptor, shaderModulePtr) { + devicePtr >>>= 0; + descriptor >>>= 0; + shaderModulePtr >>>= 0; + var nextInChainPtr = GROWABLE_HEAP_U32()[((descriptor) >>> 2) >>> 0]; + var sType = GROWABLE_HEAP_U32()[(((nextInChainPtr) + (4)) >>> 2) >>> 0]; + var desc = { + "label": WebGPU.makeStringFromOptionalStringView(descriptor + 4), + "code": "" + }; + switch (sType) { + case 2: + { + desc["code"] = WebGPU.makeStringFromStringView(nextInChainPtr + 8); + break; + } + } + var device = WebGPU.getJsObject(devicePtr); + WebGPU.Internals.jsObjectInsert(shaderModulePtr, device.createShaderModule(desc)); +} + +var _emwgpuDeviceDestroy = devicePtr => { + WebGPU.getJsObject(devicePtr).destroy(); +}; + +var _emwgpuDevicePopErrorScope = function(devicePtr, futureId) { + devicePtr >>>= 0; + futureId = bigintToI53Checked(futureId); + var device = WebGPU.getJsObject(devicePtr); + runtimeKeepalivePush(); + WebGPU.Internals.futureInsert(futureId, device.popErrorScope().then(gpuError => { + runtimeKeepalivePop(); + var type = 5; + if (!gpuError) type = 1; else if (gpuError instanceof GPUValidationError) type = 2; else if (gpuError instanceof GPUOutOfMemoryError) type = 3; else if (gpuError instanceof GPUInternalError) type = 4; + var sp = stackSave(); + var messagePtr = gpuError ? stringToUTF8OnStack(gpuError.message) : 0; + _emwgpuOnPopErrorScopeCompleted(futureId, 1, type, messagePtr); + stackRestore(sp); + }, ex => { + runtimeKeepalivePop(); + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack(ex.message); + _emwgpuOnPopErrorScopeCompleted(futureId, 1, 5, messagePtr); + stackRestore(sp); + })); +}; + +function _emwgpuInstanceRequestAdapter(instancePtr, futureId, options, adapterPtr) { + instancePtr >>>= 0; + futureId = bigintToI53Checked(futureId); + options >>>= 0; + adapterPtr >>>= 0; + var opts; + if (options) { + var featureLevel = GROWABLE_HEAP_U32()[(((options) + (4)) >>> 2) >>> 0]; + opts = { + "featureLevel": WebGPU.FeatureLevel[featureLevel], + "powerPreference": WebGPU.PowerPreference[GROWABLE_HEAP_U32()[(((options) + (8)) >>> 2) >>> 0]], + "forceFallbackAdapter": !!(GROWABLE_HEAP_U32()[(((options) + (12)) >>> 2) >>> 0]) + }; + var nextInChainPtr = GROWABLE_HEAP_U32()[((options) >>> 2) >>> 0]; + if (nextInChainPtr !== 0) { + var sType = GROWABLE_HEAP_U32()[(((nextInChainPtr) + (4)) >>> 2) >>> 0]; + var webxrOptions = nextInChainPtr; + opts.xrCompatible = !!(GROWABLE_HEAP_U32()[(((webxrOptions) + (8)) >>> 2) >>> 0]); + } + } + if (!("gpu" in navigator)) { + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack("WebGPU not available on this browser (navigator.gpu is not available)"); + _emwgpuOnRequestAdapterCompleted(futureId, 3, adapterPtr, messagePtr); + stackRestore(sp); + return; + } + runtimeKeepalivePush(); + WebGPU.Internals.futureInsert(futureId, navigator["gpu"]["requestAdapter"](opts).then(adapter => { + runtimeKeepalivePop(); + if (adapter) { + WebGPU.Internals.jsObjectInsert(adapterPtr, adapter); + _emwgpuOnRequestAdapterCompleted(futureId, 1, adapterPtr, 0); + } else { + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack("WebGPU not available on this browser (requestAdapter returned null)"); + _emwgpuOnRequestAdapterCompleted(futureId, 3, adapterPtr, messagePtr); + stackRestore(sp); + } + }, ex => { + runtimeKeepalivePop(); + var sp = stackSave(); + var messagePtr = stringToUTF8OnStack(ex.message); + _emwgpuOnRequestAdapterCompleted(futureId, 4, adapterPtr, messagePtr); + stackRestore(sp); + })); +} + +var _emwgpuWaitAny = function(futurePtr, futureCount, timeoutNSPtr) { + futurePtr >>>= 0; + futureCount >>>= 0; + timeoutNSPtr >>>= 0; + return Asyncify.handleAsync(async () => { + var promises = []; + if (timeoutNSPtr) { + var timeoutMS = (GROWABLE_HEAP_U32()[(((timeoutNSPtr + 4)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[((timeoutNSPtr) >>> 2) >>> 0]) / 1e6; + promises.length = futureCount + 1; + promises[futureCount] = new Promise(resolve => setTimeout(resolve, timeoutMS, 0)); + } else { + promises.length = futureCount; + } + for (var i = 0; i < futureCount; ++i) { + // If any of the FutureIDs are not tracked, it means it must be done. + var futureId = (GROWABLE_HEAP_U32()[((((futurePtr + i * 8) + 4)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[(((futurePtr + i * 8)) >>> 2) >>> 0]); + if (!(futureId in WebGPU.Internals.futures)) { + return futureId; + } + promises[i] = WebGPU.Internals.futures[futureId]; + } + const firstResolvedFuture = await Promise.race(promises); + delete WebGPU.Internals.futures[firstResolvedFuture]; + return firstResolvedFuture; + }); +}; + +_emwgpuWaitAny.isAsync = true; + +var ENV = {}; + +var getExecutableName = () => thisProgram || "./this.program"; + +var getEnvStrings = () => { + if (!getEnvStrings.strings) { + // Default values. + // Browser language detection #8751 + var lang = ((typeof navigator == "object" && navigator.languages && navigator.languages[0]) || "C").replace("-", "_") + ".UTF-8"; + var env = { + "USER": "web_user", + "LOGNAME": "web_user", + "PATH": "/", + "PWD": "/", + "HOME": "/home/web_user", + "LANG": lang, + "_": getExecutableName() + }; + // Apply the user-provided values, if any. + for (var x in ENV) { + // x is a key in ENV; if ENV[x] is undefined, that means it was + // explicitly set to be so. We allow user code to do that to + // force variables with default values to remain unset. + if (ENV[x] === undefined) delete env[x]; else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(`${x}=${env[x]}`); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; +}; + +var stringToAscii = (str, buffer) => { + for (var i = 0; i < str.length; ++i) { + GROWABLE_HEAP_I8()[buffer++ >>> 0] = str.charCodeAt(i); + } + // Null-terminate the string + GROWABLE_HEAP_I8()[buffer >>> 0] = 0; +}; + +var _environ_get = function(__environ, environ_buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(19, 0, 1, __environ, environ_buf); + __environ >>>= 0; + environ_buf >>>= 0; + var bufSize = 0; + getEnvStrings().forEach((string, i) => { + var ptr = environ_buf + bufSize; + GROWABLE_HEAP_U32()[(((__environ) + (i * 4)) >>> 2) >>> 0] = ptr; + stringToAscii(string, ptr); + bufSize += string.length + 1; + }); + return 0; +}; + +var _environ_sizes_get = function(penviron_count, penviron_buf_size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(20, 0, 1, penviron_count, penviron_buf_size); + penviron_count >>>= 0; + penviron_buf_size >>>= 0; + var strings = getEnvStrings(); + GROWABLE_HEAP_U32()[((penviron_count) >>> 2) >>> 0] = strings.length; + var bufSize = 0; + strings.forEach(string => bufSize += string.length + 1); + GROWABLE_HEAP_U32()[((penviron_buf_size) >>> 2) >>> 0] = bufSize; + return 0; +}; + +function _fd_close(fd) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(21, 0, 1, fd); + return 52; +} + +function _fd_read(fd, iov, iovcnt, pnum) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(22, 0, 1, fd, iov, iovcnt, pnum); + iov >>>= 0; + iovcnt >>>= 0; + pnum >>>= 0; + return 52; +} + +function _fd_seek(fd, offset, whence, newOffset) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(23, 0, 1, fd, offset, whence, newOffset); + offset = bigintToI53Checked(offset); + newOffset >>>= 0; + return 70; +} + +var printCharBuffers = [ null, [], [] ]; + +var printChar = (stream, curr) => { + var buffer = printCharBuffers[stream]; + if (curr === 0 || curr === 10) { + (stream === 1 ? out : err)(UTF8ArrayToString(buffer)); + buffer.length = 0; + } else { + buffer.push(curr); + } +}; + +function _fd_write(fd, iov, iovcnt, pnum) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(24, 0, 1, fd, iov, iovcnt, pnum); + iov >>>= 0; + iovcnt >>>= 0; + pnum >>>= 0; + // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 + var num = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = GROWABLE_HEAP_U32()[((iov) >>> 2) >>> 0]; + var len = GROWABLE_HEAP_U32()[(((iov) + (4)) >>> 2) >>> 0]; + iov += 8; + for (var j = 0; j < len; j++) { + printChar(fd, GROWABLE_HEAP_U8()[ptr + j >>> 0]); + } + num += len; + } + GROWABLE_HEAP_U32()[((pnum) >>> 2) >>> 0] = num; + return 0; +} + +function _llvm_eh_typeid_for(type) { + type >>>= 0; + return type; +} + +function _wgpuAdapterGetLimits(adapterPtr, limitsOutPtr) { + adapterPtr >>>= 0; + limitsOutPtr >>>= 0; + var adapter = WebGPU.getJsObject(adapterPtr); + WebGPU.fillLimitStruct(adapter.limits, limitsOutPtr); + return 1; +} + +function _wgpuAdapterHasFeature(adapterPtr, featureEnumValue) { + adapterPtr >>>= 0; + var adapter = WebGPU.getJsObject(adapterPtr); + return adapter.features.has(WebGPU.FeatureName[featureEnumValue]); +} + +var _wgpuBufferGetSize = function(bufferPtr) { + bufferPtr >>>= 0; + var ret = (() => { + var buffer = WebGPU.getJsObject(bufferPtr); + // 64-bit + return buffer.size; + })(); + return BigInt(ret); +}; + +var _wgpuBufferGetUsage = function(bufferPtr) { + bufferPtr >>>= 0; + var ret = (() => { + var buffer = WebGPU.getJsObject(bufferPtr); + return buffer.usage; + })(); + return BigInt(ret); +}; + +function _wgpuCommandEncoderBeginComputePass(encoderPtr, descriptor) { + encoderPtr >>>= 0; + descriptor >>>= 0; + var desc; + if (descriptor) { + desc = { + "label": WebGPU.makeStringFromOptionalStringView(descriptor + 4), + "timestampWrites": WebGPU.makePassTimestampWrites(GROWABLE_HEAP_U32()[(((descriptor) + (12)) >>> 2) >>> 0]) + }; + } + var commandEncoder = WebGPU.getJsObject(encoderPtr); + var ptr = _emwgpuCreateComputePassEncoder(0); + WebGPU.Internals.jsObjectInsert(ptr, commandEncoder.beginComputePass(desc)); + return ptr; +} + +function _wgpuCommandEncoderCopyBufferToBuffer(encoderPtr, srcPtr, srcOffset, dstPtr, dstOffset, size) { + encoderPtr >>>= 0; + srcPtr >>>= 0; + srcOffset = bigintToI53Checked(srcOffset); + dstPtr >>>= 0; + dstOffset = bigintToI53Checked(dstOffset); + size = bigintToI53Checked(size); + var commandEncoder = WebGPU.getJsObject(encoderPtr); + var src = WebGPU.getJsObject(srcPtr); + var dst = WebGPU.getJsObject(dstPtr); + commandEncoder.copyBufferToBuffer(src, srcOffset, dst, dstOffset, size); +} + +function _wgpuCommandEncoderFinish(encoderPtr, descriptor) { + encoderPtr >>>= 0; + descriptor >>>= 0; + // TODO: Use the descriptor. + var commandEncoder = WebGPU.getJsObject(encoderPtr); + var ptr = _emwgpuCreateCommandBuffer(0); + WebGPU.Internals.jsObjectInsert(ptr, commandEncoder.finish()); + return ptr; +} + +function _wgpuCommandEncoderResolveQuerySet(encoderPtr, querySetPtr, firstQuery, queryCount, destinationPtr, destinationOffset) { + encoderPtr >>>= 0; + querySetPtr >>>= 0; + destinationPtr >>>= 0; + destinationOffset = bigintToI53Checked(destinationOffset); + var commandEncoder = WebGPU.getJsObject(encoderPtr); + var querySet = WebGPU.getJsObject(querySetPtr); + var destination = WebGPU.getJsObject(destinationPtr); + commandEncoder.resolveQuerySet(querySet, firstQuery, queryCount, destination, destinationOffset); +} + +function _wgpuComputePassEncoderDispatchWorkgroups(passPtr, x, y, z) { + passPtr >>>= 0; + var pass = WebGPU.getJsObject(passPtr); + pass.dispatchWorkgroups(x, y, z); +} + +function _wgpuComputePassEncoderEnd(passPtr) { + passPtr >>>= 0; + var pass = WebGPU.getJsObject(passPtr); + pass.end(); +} + +function _wgpuComputePassEncoderSetBindGroup(passPtr, groupIndex, groupPtr, dynamicOffsetCount, dynamicOffsetsPtr) { + passPtr >>>= 0; + groupPtr >>>= 0; + dynamicOffsetCount >>>= 0; + dynamicOffsetsPtr >>>= 0; + var pass = WebGPU.getJsObject(passPtr); + var group = WebGPU.getJsObject(groupPtr); + if (dynamicOffsetCount == 0) { + pass.setBindGroup(groupIndex, group); + } else { + var offsets = []; + for (var i = 0; i < dynamicOffsetCount; i++, dynamicOffsetsPtr += 4) { + offsets.push(GROWABLE_HEAP_U32()[((dynamicOffsetsPtr) >>> 2) >>> 0]); + } + pass.setBindGroup(groupIndex, group, offsets); + } +} + +function _wgpuComputePassEncoderSetPipeline(passPtr, pipelinePtr) { + passPtr >>>= 0; + pipelinePtr >>>= 0; + var pass = WebGPU.getJsObject(passPtr); + var pipeline = WebGPU.getJsObject(pipelinePtr); + pass.setPipeline(pipeline); +} + +function _wgpuComputePassEncoderWriteTimestamp(encoderPtr, querySetPtr, queryIndex) { + encoderPtr >>>= 0; + querySetPtr >>>= 0; + var encoder = WebGPU.getJsObject(encoderPtr); + var querySet = WebGPU.getJsObject(querySetPtr); + encoder.writeTimestamp(querySet, queryIndex); +} + +function _wgpuComputePipelineGetBindGroupLayout(pipelinePtr, groupIndex) { + pipelinePtr >>>= 0; + var pipeline = WebGPU.getJsObject(pipelinePtr); + var ptr = _emwgpuCreateBindGroupLayout(0); + WebGPU.Internals.jsObjectInsert(ptr, pipeline.getBindGroupLayout(groupIndex)); + return ptr; +} + +var readI53FromI64 = ptr => GROWABLE_HEAP_U32()[((ptr) >>> 2) >>> 0] + GROWABLE_HEAP_I32()[(((ptr) + (4)) >>> 2) >>> 0] * 4294967296; + +function _wgpuDeviceCreateBindGroup(devicePtr, descriptor) { + devicePtr >>>= 0; + descriptor >>>= 0; + function makeEntry(entryPtr) { + var bufferPtr = GROWABLE_HEAP_U32()[(((entryPtr) + (8)) >>> 2) >>> 0]; + var samplerPtr = GROWABLE_HEAP_U32()[(((entryPtr) + (32)) >>> 2) >>> 0]; + var textureViewPtr = GROWABLE_HEAP_U32()[(((entryPtr) + (36)) >>> 2) >>> 0]; + var binding = GROWABLE_HEAP_U32()[(((entryPtr) + (4)) >>> 2) >>> 0]; + if (bufferPtr) { + var size = readI53FromI64((entryPtr) + (24)); + if (size == -1) size = undefined; + return { + "binding": binding, + "resource": { + "buffer": WebGPU.getJsObject(bufferPtr), + "offset": (GROWABLE_HEAP_U32()[((((entryPtr + 4)) + (16)) >>> 2) >>> 0] * 4294967296 + GROWABLE_HEAP_U32()[(((entryPtr) + (16)) >>> 2) >>> 0]), + "size": size + } + }; + } else if (samplerPtr) { + return { + "binding": binding, + "resource": WebGPU.getJsObject(samplerPtr) + }; + } else { + return { + "binding": binding, + "resource": WebGPU.getJsObject(textureViewPtr) + }; + } + } + function makeEntries(count, entriesPtrs) { + var entries = []; + for (var i = 0; i < count; ++i) { + entries.push(makeEntry(entriesPtrs + 40 * i)); + } + return entries; + } + var desc = { + "label": WebGPU.makeStringFromOptionalStringView(descriptor + 4), + "layout": WebGPU.getJsObject(GROWABLE_HEAP_U32()[(((descriptor) + (12)) >>> 2) >>> 0]), + "entries": makeEntries(GROWABLE_HEAP_U32()[(((descriptor) + (16)) >>> 2) >>> 0], GROWABLE_HEAP_U32()[(((descriptor) + (20)) >>> 2) >>> 0]) + }; + var device = WebGPU.getJsObject(devicePtr); + var ptr = _emwgpuCreateBindGroup(0); + WebGPU.Internals.jsObjectInsert(ptr, device.createBindGroup(desc)); + return ptr; +} + +function _wgpuDeviceCreateCommandEncoder(devicePtr, descriptor) { + devicePtr >>>= 0; + descriptor >>>= 0; + var desc; + if (descriptor) { + desc = { + "label": WebGPU.makeStringFromOptionalStringView(descriptor + 4) + }; + } + var device = WebGPU.getJsObject(devicePtr); + var ptr = _emwgpuCreateCommandEncoder(0); + WebGPU.Internals.jsObjectInsert(ptr, device.createCommandEncoder(desc)); + return ptr; +} + +function _wgpuDeviceCreateComputePipeline(devicePtr, descriptor) { + devicePtr >>>= 0; + descriptor >>>= 0; + var desc = WebGPU.makeComputePipelineDesc(descriptor); + var device = WebGPU.getJsObject(devicePtr); + var ptr = _emwgpuCreateComputePipeline(0); + WebGPU.Internals.jsObjectInsert(ptr, device.createComputePipeline(desc)); + return ptr; +} + +function _wgpuDeviceCreateQuerySet(devicePtr, descriptor) { + devicePtr >>>= 0; + descriptor >>>= 0; + var desc = { + "type": WebGPU.QueryType[GROWABLE_HEAP_U32()[(((descriptor) + (12)) >>> 2) >>> 0]], + "count": GROWABLE_HEAP_U32()[(((descriptor) + (16)) >>> 2) >>> 0] + }; + var device = WebGPU.getJsObject(devicePtr); + var ptr = _emwgpuCreateQuerySet(0); + WebGPU.Internals.jsObjectInsert(ptr, device.createQuerySet(desc)); + return ptr; +} + +var stringToNewUTF8 = str => { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8(str, ret, size); + return ret; +}; + +function _wgpuDeviceGetAdapterInfo(devicePtr, adapterInfo) { + devicePtr >>>= 0; + adapterInfo >>>= 0; + // TODO(crbug.com/377760848): Avoid duplicated code with wgpuAdapterGetInfo, + // for example by deferring to wgpuAdapterGetInfo from webgpu.cpp. + var device = WebGPU.getJsObject(devicePtr); + // Append all the strings together to condense into a single malloc. + var strs = device.adapterInfo.vendor + device.adapterInfo.architecture + device.adapterInfo.device + device.adapterInfo.description; + var strPtr = stringToNewUTF8(strs); + var vendorLen = lengthBytesUTF8(device.adapterInfo.vendor); + WebGPU.setStringView(adapterInfo + 4, strPtr, vendorLen); + strPtr += vendorLen; + var architectureLen = lengthBytesUTF8(device.adapterInfo.architecture); + WebGPU.setStringView(adapterInfo + 12, strPtr, architectureLen); + strPtr += architectureLen; + var deviceLen = lengthBytesUTF8(device.adapterInfo.device); + WebGPU.setStringView(adapterInfo + 20, strPtr, deviceLen); + strPtr += deviceLen; + var descriptionLen = lengthBytesUTF8(device.adapterInfo.description); + WebGPU.setStringView(adapterInfo + 28, strPtr, descriptionLen); + strPtr += descriptionLen; + GROWABLE_HEAP_I32()[(((adapterInfo) + (36)) >>> 2) >>> 0] = 2; + var adapterType = device.adapterInfo.isFallbackAdapter ? 3 : 4; + GROWABLE_HEAP_I32()[(((adapterInfo) + (40)) >>> 2) >>> 0] = adapterType; + GROWABLE_HEAP_I32()[(((adapterInfo) + (44)) >>> 2) >>> 0] = 0; + GROWABLE_HEAP_I32()[(((adapterInfo) + (48)) >>> 2) >>> 0] = 0; + return 1; +} + +var _wgpuDeviceGetFeatures = function(devicePtr, supportedFeatures) { + devicePtr >>>= 0; + supportedFeatures >>>= 0; + var device = WebGPU.getJsObject(devicePtr); + // Always allocate enough space for all the features, though some may be unused. + var featuresPtr = _malloc(device.features.size * 4); + var offset = 0; + var numFeatures = 0; + device.features.forEach(feature => { + var featureEnumValue = WebGPU.FeatureNameString2Enum[feature]; + if (featureEnumValue !== undefined) { + GROWABLE_HEAP_I32()[(((featuresPtr) + (offset)) >>> 2) >>> 0] = featureEnumValue; + offset += 4; + numFeatures++; + } + }); + GROWABLE_HEAP_U32()[(((supportedFeatures) + (4)) >>> 2) >>> 0] = featuresPtr; + GROWABLE_HEAP_U32()[((supportedFeatures) >>> 2) >>> 0] = numFeatures; +}; + +function _wgpuDeviceGetLimits(devicePtr, limitsOutPtr) { + devicePtr >>>= 0; + limitsOutPtr >>>= 0; + var device = WebGPU.getJsObject(devicePtr); + WebGPU.fillLimitStruct(device.limits, limitsOutPtr); + return 1; +} + +function _wgpuDeviceHasFeature(devicePtr, featureEnumValue) { + devicePtr >>>= 0; + var device = WebGPU.getJsObject(devicePtr); + return device.features.has(WebGPU.FeatureName[featureEnumValue]); +} + +function _wgpuDevicePushErrorScope(devicePtr, filter) { + devicePtr >>>= 0; + var device = WebGPU.getJsObject(devicePtr); + device.pushErrorScope(WebGPU.ErrorFilter[filter]); +} + +var _wgpuQueueSubmit = function(queuePtr, commandCount, commands) { + queuePtr >>>= 0; + commandCount >>>= 0; + commands >>>= 0; + var queue = WebGPU.getJsObject(queuePtr); + var cmds = Array.from(GROWABLE_HEAP_I32().subarray((((commands) >>> 2)) >>> 0, ((commands + commandCount * 4) >>> 2) >>> 0), id => WebGPU.getJsObject(id)); + queue.submit(cmds); +}; + +function _wgpuQueueWriteBuffer(queuePtr, bufferPtr, bufferOffset, data, size) { + queuePtr >>>= 0; + bufferPtr >>>= 0; + bufferOffset = bigintToI53Checked(bufferOffset); + data >>>= 0; + size >>>= 0; + var queue = WebGPU.getJsObject(queuePtr); + var buffer = WebGPU.getJsObject(bufferPtr); + // There is a size limitation for ArrayBufferView. Work around by passing in a subarray + // instead of the whole heap. crbug.com/1201109 + var subarray = GROWABLE_HEAP_U8().subarray(data >>> 0, data + size >>> 0); + queue.writeBuffer(buffer, bufferOffset, subarray, 0, size); +} + +/** @type {WebAssembly.Table} */ var wasmTable; + +PThread.init(); + +embind_init_charCodes(); + +BindingError = Module["BindingError"] = class BindingError extends Error { + constructor(message) { + super(message); + this.name = "BindingError"; + } +}; + +InternalError = Module["InternalError"] = class InternalError extends Error { + constructor(message) { + super(message); + this.name = "InternalError"; + } +}; + +init_emval(); + +// proxiedFunctionTable specifies the list of functions that can be called +// either synchronously or asynchronously from other threads in postMessage()d +// or internally queued events. This way a pthread in a Worker can synchronously +// access e.g. the DOM on the main thread. +var proxiedFunctionTable = [ _proc_exit, exitOnMainThread, pthreadCreateProxied, ___syscall_fcntl64, ___syscall_fstat64, ___syscall_getcwd, ___syscall_getdents64, ___syscall_ioctl, ___syscall_lstat64, ___syscall_mkdirat, ___syscall_newfstatat, ___syscall_openat, ___syscall_readlinkat, ___syscall_rmdir, ___syscall_stat64, ___syscall_unlinkat, __mmap_js, __munmap_js, __setitimer_js, _environ_get, _environ_sizes_get, _fd_close, _fd_read, _fd_seek, _fd_write ]; + +var wasmImports; + +function assignWasmImports() { + wasmImports = { + /** @export */ rd: HaveOffsetConverter, + /** @export */ Md: __asyncjs__jsepDownload, + /** @export */ v: ___cxa_begin_catch, + /** @export */ _: ___cxa_end_catch, + /** @export */ b: ___cxa_find_matching_catch_2, + /** @export */ o: ___cxa_find_matching_catch_3, + /** @export */ A: ___cxa_find_matching_catch_4, + /** @export */ F: ___cxa_find_matching_catch_5, + /** @export */ r: ___cxa_find_matching_catch_6, + /** @export */ uc: ___cxa_rethrow, + /** @export */ u: ___cxa_throw, + /** @export */ Bb: ___cxa_uncaught_exceptions, + /** @export */ pf: ___pthread_create_js, + /** @export */ g: ___resumeException, + /** @export */ tc: ___syscall_fcntl64, + /** @export */ of: ___syscall_fstat64, + /** @export */ nf: ___syscall_getcwd, + /** @export */ mf: ___syscall_getdents64, + /** @export */ lf: ___syscall_ioctl, + /** @export */ kf: ___syscall_lstat64, + /** @export */ jf: ___syscall_mkdirat, + /** @export */ hf: ___syscall_newfstatat, + /** @export */ qd: ___syscall_openat, + /** @export */ gf: ___syscall_readlinkat, + /** @export */ ff: ___syscall_rmdir, + /** @export */ ef: ___syscall_stat64, + /** @export */ df: ___syscall_unlinkat, + /** @export */ Ze: __abort_js, + /** @export */ nd: __embind_register_bigint, + /** @export */ Ye: __embind_register_bool, + /** @export */ Xe: __embind_register_emval, + /** @export */ md: __embind_register_float, + /** @export */ Ma: __embind_register_integer, + /** @export */ na: __embind_register_memory_view, + /** @export */ We: __embind_register_std_string, + /** @export */ rc: __embind_register_std_wstring, + /** @export */ Ve: __embind_register_void, + /** @export */ Ue: __emscripten_init_main_thread_js, + /** @export */ Te: __emscripten_notify_mailbox_postmessage, + /** @export */ Se: __emscripten_receive_on_main_thread_js, + /** @export */ Re: __emscripten_runtime_keepalive_clear, + /** @export */ ld: __emscripten_thread_cleanup, + /** @export */ Qe: __emscripten_thread_mailbox_await, + /** @export */ Pe: __emscripten_thread_set_strongref, + /** @export */ kd: __emval_as, + /** @export */ Oe: __emval_as_int64, + /** @export */ Ne: __emval_await, + /** @export */ Ab: __emval_call, + /** @export */ sa: __emval_call_method, + /** @export */ Me: __emval_decref, + /** @export */ Le: __emval_equals, + /** @export */ Ke: __emval_get_global, + /** @export */ ma: __emval_get_method_caller, + /** @export */ zb: __emval_get_module_property, + /** @export */ Je: __emval_get_property, + /** @export */ Z: __emval_incref, + /** @export */ qc: __emval_new_array, + /** @export */ Ie: __emval_new_array_from_memory_view, + /** @export */ ha: __emval_new_cstring, + /** @export */ lb: __emval_new_object, + /** @export */ He: __emval_run_destructors, + /** @export */ Ge: __emval_set_property, + /** @export */ fb: __emval_take_value, + /** @export */ Fe: __gmtime_js, + /** @export */ Ee: __localtime_js, + /** @export */ De: __mktime_js, + /** @export */ Ce: __mmap_js, + /** @export */ Be: __munmap_js, + /** @export */ Ae: __setitimer_js, + /** @export */ ze: __tzset_js, + /** @export */ cf: _clock_time_get, + /** @export */ C: _emscripten_asm_const_int, + /** @export */ pc: _emscripten_asm_const_ptr, + /** @export */ jd: _emscripten_check_blocking_allowed, + /** @export */ ye: _emscripten_date_now, + /** @export */ Tb: _emscripten_errn, + /** @export */ xe: _emscripten_exit_with_live_runtime, + /** @export */ we: _emscripten_get_heap_max, + /** @export */ ba: _emscripten_get_now, + /** @export */ ve: _emscripten_has_asyncify, + /** @export */ Sb: _emscripten_num_logical_cores, + /** @export */ id: _emscripten_pc_get_function, + /** @export */ ue: _emscripten_resize_heap, + /** @export */ te: _emscripten_stack_snapshot, + /** @export */ se: _emscripten_stack_unwind_buffer, + /** @export */ re: _emwgpuAdapterRequestDevice, + /** @export */ hd: _emwgpuBufferDestroy, + /** @export */ gd: _emwgpuBufferGetConstMappedRange, + /** @export */ fd: _emwgpuBufferGetMappedRange, + /** @export */ qe: _emwgpuBufferMapAsync, + /** @export */ oc: _emwgpuBufferUnmap, + /** @export */ wa: _emwgpuDelete, + /** @export */ pe: _emwgpuDeviceCreateBuffer, + /** @export */ oe: _emwgpuDeviceCreateShaderModule, + /** @export */ ne: _emwgpuDeviceDestroy, + /** @export */ me: _emwgpuDevicePopErrorScope, + /** @export */ le: _emwgpuInstanceRequestAdapter, + /** @export */ ke: _emwgpuWaitAny, + /** @export */ bf: _environ_get, + /** @export */ af: _environ_sizes_get, + /** @export */ je: _exit, + /** @export */ sc: _fd_close, + /** @export */ pd: _fd_read, + /** @export */ $e: _fd_seek, + /** @export */ od: _fd_write, + /** @export */ Rb: invoke_di, + /** @export */ Qb: invoke_dii, + /** @export */ qa: invoke_diii, + /** @export */ S: invoke_diiii, + /** @export */ R: invoke_diiiii, + /** @export */ Ca: invoke_fffffff, + /** @export */ Ga: invoke_fi, + /** @export */ ed: invoke_fii, + /** @export */ nc: invoke_fiif, + /** @export */ ie: invoke_fiii, + /** @export */ Y: invoke_fiiii, + /** @export */ y: invoke_i, + /** @export */ c: invoke_ii, + /** @export */ dd: invoke_iid, + /** @export */ va: invoke_iif, + /** @export */ he: invoke_iifii, + /** @export */ cd: invoke_iifjii, + /** @export */ h: invoke_iii, + /** @export */ eb: invoke_iiif, + /** @export */ Ja: invoke_iiifii, + /** @export */ d: invoke_iiii, + /** @export */ ja: invoke_iiiifi, + /** @export */ k: invoke_iiiii, + /** @export */ ge: invoke_iiiiid, + /** @export */ j: invoke_iiiiii, + /** @export */ Pb: invoke_iiiiiif, + /** @export */ s: invoke_iiiiiii, + /** @export */ t: invoke_iiiiiiii, + /** @export */ q: invoke_iiiiiiiii, + /** @export */ yb: invoke_iiiiiiiiii, + /** @export */ O: invoke_iiiiiiiiiii, + /** @export */ Ba: invoke_iiiiiiiiiiii, + /** @export */ oa: invoke_iiiiiiiiiiiii, + /** @export */ mc: invoke_iiiiiiiiiiiiiifii, + /** @export */ kb: invoke_iiiiiiiiiiiiiiiiiiifii, + /** @export */ lc: invoke_iiiiiiiiiiiiiiiiiiiifi, + /** @export */ xb: invoke_iiiiiiiiiiijijji, + /** @export */ bd: invoke_iiiiiiiiijii, + /** @export */ ad: invoke_iiiiiiiij, + /** @export */ $c: invoke_iiiiiiiijjjfi, + /** @export */ jb: invoke_iiiiiiij, + /** @export */ _c: invoke_iiiiiijjjii, + /** @export */ kc: invoke_iiiiij, + /** @export */ ra: invoke_iiiiiji, + /** @export */ Ob: invoke_iiiiijiiiii, + /** @export */ wb: invoke_iiiiijji, + /** @export */ da: invoke_iiiij, + /** @export */ la: invoke_iiiiji, + /** @export */ Zc: invoke_iiiijii, + /** @export */ N: invoke_iiiijiiiiiiiiii, + /** @export */ Yc: invoke_iiiijjii, + /** @export */ Ya: invoke_iiiijjj, + /** @export */ H: invoke_iiij, + /** @export */ Xc: invoke_iiiji, + /** @export */ vb: invoke_iiijii, + /** @export */ fe: invoke_iiijiii, + /** @export */ Aa: invoke_iiijiiii, + /** @export */ La: invoke_iiijjj, + /** @export */ B: invoke_iij, + /** @export */ jc: invoke_iiji, + /** @export */ Wc: invoke_iijiiii, + /** @export */ Vc: invoke_iijijji, + /** @export */ Uc: invoke_iijijjijiji, + /** @export */ ic: invoke_iijjji, + /** @export */ ee: invoke_iijjjii, + /** @export */ Xa: invoke_ij, + /** @export */ aa: invoke_ijii, + /** @export */ ib: invoke_ijiii, + /** @export */ hc: invoke_ijiiiiji, + /** @export */ hb: invoke_ijiij, + /** @export */ db: invoke_ijiijji, + /** @export */ Tc: invoke_ijijji, + /** @export */ Sc: invoke_j, + /** @export */ gc: invoke_jfi, + /** @export */ fa: invoke_ji, + /** @export */ K: invoke_jii, + /** @export */ D: invoke_jiii, + /** @export */ Ia: invoke_jiij, + /** @export */ U: invoke_jiijjiif, + /** @export */ Rc: invoke_jiijjiii, + /** @export */ Qc: invoke_jij, + /** @export */ Pc: invoke_jj, + /** @export */ X: invoke_jjj, + /** @export */ e: invoke_v, + /** @export */ cb: invoke_vfiii, + /** @export */ l: invoke_vi, + /** @export */ Oc: invoke_vid, + /** @export */ Wa: invoke_vidi, + /** @export */ pa: invoke_vif, + /** @export */ Nb: invoke_viffiii, + /** @export */ i: invoke_vii, + /** @export */ Nc: invoke_viid, + /** @export */ V: invoke_viif, + /** @export */ ua: invoke_viiff, + /** @export */ Mb: invoke_viifiifijjjii, + /** @export */ ub: invoke_viifiii, + /** @export */ f: invoke_viii, + /** @export */ de: invoke_viiid, + /** @export */ ce: invoke_viiif, + /** @export */ m: invoke_viiii, + /** @export */ Mc: invoke_viiiiff, + /** @export */ n: invoke_viiiii, + /** @export */ be: invoke_viiiiid, + /** @export */ Lc: invoke_viiiiidiidi, + /** @export */ ae: invoke_viiiiif, + /** @export */ Kc: invoke_viiiiiff, + /** @export */ Jc: invoke_viiiiifi, + /** @export */ $d: invoke_viiiiifiiiiii, + /** @export */ p: invoke_viiiiii, + /** @export */ _d: invoke_viiiiiiffii, + /** @export */ Va: invoke_viiiiiiffjfiiiii, + /** @export */ Lb: invoke_viiiiiiffjifiiiii, + /** @export */ Ua: invoke_viiiiiiffjiiiii, + /** @export */ fc: invoke_viiiiiifiii, + /** @export */ E: invoke_viiiiiii, + /** @export */ G: invoke_viiiiiiii, + /** @export */ J: invoke_viiiiiiiii, + /** @export */ bb: invoke_viiiiiiiiidi, + /** @export */ Zd: invoke_viiiiiiiiifi, + /** @export */ Kb: invoke_viiiiiiiiifiiii, + /** @export */ $: invoke_viiiiiiiiii, + /** @export */ ga: invoke_viiiiiiiiiii, + /** @export */ Ha: invoke_viiiiiiiiiiii, + /** @export */ Fa: invoke_viiiiiiiiiiiii, + /** @export */ Ta: invoke_viiiiiiiiiiiiii, + /** @export */ Yd: invoke_viiiiiiiiiiiiiifi, + /** @export */ ab: invoke_viiiiiiiiiiiiiii, + /** @export */ Ea: invoke_viiiiiiiiiiiiiiii, + /** @export */ Ic: invoke_viiiiiiiiiiiiiiiiii, + /** @export */ gb: invoke_viiiiiiiiiiiiiiiiiii, + /** @export */ Jb: invoke_viiiiiiiiiiiiiiiiiiii, + /** @export */ Sa: invoke_viiiiiiiiiiiiiiiiiiiiiii, + /** @export */ Xd: invoke_viiiiiiiijj, + /** @export */ za: invoke_viiiiiiijiiiiii, + /** @export */ Wd: invoke_viiiiiiijjj, + /** @export */ Vd: invoke_viiiiiijii, + /** @export */ Ud: invoke_viiiiiijiifiii, + /** @export */ ec: invoke_viiiiiijiiiiii, + /** @export */ Ra: invoke_viiiiiijjiiiii, + /** @export */ W: invoke_viiiiij, + /** @export */ tb: invoke_viiiiiji, + /** @export */ Hc: invoke_viiiiijiiiiii, + /** @export */ Ib: invoke_viiiiijjiiiii, + /** @export */ ta: invoke_viiiiijjji, + /** @export */ Qa: invoke_viiiij, + /** @export */ Gc: invoke_viiiiji, + /** @export */ Hb: invoke_viiiijii, + /** @export */ sb: invoke_viiiijj, + /** @export */ dc: invoke_viiiijjj, + /** @export */ P: invoke_viiij, + /** @export */ Gb: invoke_viiiji, + /** @export */ ka: invoke_viiijii, + /** @export */ Td: invoke_viiijiiiii, + /** @export */ ea: invoke_viiijiiiiii, + /** @export */ rb: invoke_viiijiiiiiii, + /** @export */ cc: invoke_viiijiiiiiiiiii, + /** @export */ Fc: invoke_viiijiiiiiiiiiiiiiii, + /** @export */ bc: invoke_viiijij, + /** @export */ Ec: invoke_viiijiji, + /** @export */ Dc: invoke_viiijji, + /** @export */ $a: invoke_viiijjiii, + /** @export */ Cc: invoke_viiijjiiiiii, + /** @export */ qb: invoke_viiijjjii, + /** @export */ z: invoke_viij, + /** @export */ T: invoke_viiji, + /** @export */ ya: invoke_viijii, + /** @export */ Ka: invoke_viijiii, + /** @export */ Sd: invoke_viijiiiiiiiiii, + /** @export */ ac: invoke_viijiiiijiii, + /** @export */ Fb: invoke_viijijj, + /** @export */ L: invoke_viijj, + /** @export */ pb: invoke_viijji, + /** @export */ Da: invoke_viijjiii, + /** @export */ Bc: invoke_viijjijjjjiii, + /** @export */ Ac: invoke_viijjjiii, + /** @export */ Rd: invoke_viijjjiiiiii, + /** @export */ x: invoke_vij, + /** @export */ I: invoke_viji, + /** @export */ ca: invoke_vijii, + /** @export */ Qd: invoke_vijiii, + /** @export */ $b: invoke_vijiiiiiiiiii, + /** @export */ zc: invoke_vijiiiiiiijjii, + /** @export */ Pa: invoke_vijij, + /** @export */ _a: invoke_vijj, + /** @export */ _b: invoke_vijjfffiii, + /** @export */ Za: invoke_vijji, + /** @export */ Zb: invoke_vijjii, + /** @export */ Pd: invoke_vijjiii, + /** @export */ Od: invoke_vijjiiiii, + /** @export */ Yb: invoke_vijjiiiiii, + /** @export */ Xb: invoke_vijjiiiiiii, + /** @export */ ob: invoke_vijjj, + /** @export */ yc: invoke_vijjjiiiiij, + /** @export */ Wb: invoke_vijjjiiji, + /** @export */ ia: invoke_vijjjjjjifiiiii, + /** @export */ xc: invoke_vijjjjjjjjjjjjji, + /** @export */ M: invoke_vj, + /** @export */ nb: invoke_vjiiiiii, + /** @export */ Nd: invoke_vjiij, + /** @export */ xa: invoke_vjjjjfiii, + /** @export */ Q: invoke_vjjjjjiiii, + /** @export */ Eb: invoke_vjjjjjjfffifiiiiii, + /** @export */ Oa: invoke_vjjjjjjfffifijiiiii, + /** @export */ Na: invoke_vjjjjjjffjifiiiiii, + /** @export */ Db: invoke_vjjjjjjjjfffiiifiiiii, + /** @export */ Cb: invoke_vjjjjjjjjfffjifiiiiii, + /** @export */ w: _llvm_eh_typeid_for, + /** @export */ a: wasmMemory, + /** @export */ _e: _proc_exit, + /** @export */ Ld: _wgpuAdapterGetLimits, + /** @export */ Kd: _wgpuAdapterHasFeature, + /** @export */ mb: _wgpuBufferGetSize, + /** @export */ wc: _wgpuBufferGetUsage, + /** @export */ Jd: _wgpuCommandEncoderBeginComputePass, + /** @export */ Id: _wgpuCommandEncoderCopyBufferToBuffer, + /** @export */ Hd: _wgpuCommandEncoderFinish, + /** @export */ Gd: _wgpuCommandEncoderResolveQuerySet, + /** @export */ Fd: _wgpuComputePassEncoderDispatchWorkgroups, + /** @export */ Vb: _wgpuComputePassEncoderEnd, + /** @export */ Ed: _wgpuComputePassEncoderSetBindGroup, + /** @export */ Dd: _wgpuComputePassEncoderSetPipeline, + /** @export */ Cd: _wgpuComputePassEncoderWriteTimestamp, + /** @export */ Bd: _wgpuComputePipelineGetBindGroupLayout, + /** @export */ Ad: _wgpuDeviceCreateBindGroup, + /** @export */ Ub: _wgpuDeviceCreateCommandEncoder, + /** @export */ zd: _wgpuDeviceCreateComputePipeline, + /** @export */ yd: _wgpuDeviceCreateQuerySet, + /** @export */ xd: _wgpuDeviceGetAdapterInfo, + /** @export */ wd: _wgpuDeviceGetFeatures, + /** @export */ vd: _wgpuDeviceGetLimits, + /** @export */ ud: _wgpuDeviceHasFeature, + /** @export */ vc: _wgpuDevicePushErrorScope, + /** @export */ td: _wgpuQueueSubmit, + /** @export */ sd: _wgpuQueueWriteBuffer + }; +} + +var wasmExports = await createWasm(); + +var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["qf"])(); + +var ___getTypeName = a0 => (___getTypeName = wasmExports["rf"])(a0); + +var __embind_initialize_bindings = () => (__embind_initialize_bindings = wasmExports["sf"])(); + +var _OrtInit = Module["_OrtInit"] = (a0, a1) => (_OrtInit = Module["_OrtInit"] = wasmExports["tf"])(a0, a1); + +var _OrtGetLastError = Module["_OrtGetLastError"] = (a0, a1) => (_OrtGetLastError = Module["_OrtGetLastError"] = wasmExports["uf"])(a0, a1); + +var _OrtCreateSessionOptions = Module["_OrtCreateSessionOptions"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (_OrtCreateSessionOptions = Module["_OrtCreateSessionOptions"] = wasmExports["vf"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var _OrtAppendExecutionProvider = Module["_OrtAppendExecutionProvider"] = (a0, a1, a2, a3, a4) => (_OrtAppendExecutionProvider = Module["_OrtAppendExecutionProvider"] = wasmExports["wf"])(a0, a1, a2, a3, a4); + +var _OrtAddFreeDimensionOverride = Module["_OrtAddFreeDimensionOverride"] = (a0, a1, a2) => (_OrtAddFreeDimensionOverride = Module["_OrtAddFreeDimensionOverride"] = wasmExports["xf"])(a0, a1, a2); + +var _OrtAddSessionConfigEntry = Module["_OrtAddSessionConfigEntry"] = (a0, a1, a2) => (_OrtAddSessionConfigEntry = Module["_OrtAddSessionConfigEntry"] = wasmExports["yf"])(a0, a1, a2); + +var _OrtReleaseSessionOptions = Module["_OrtReleaseSessionOptions"] = a0 => (_OrtReleaseSessionOptions = Module["_OrtReleaseSessionOptions"] = wasmExports["zf"])(a0); + +var _OrtCreateSession = Module["_OrtCreateSession"] = (a0, a1, a2) => (_OrtCreateSession = Module["_OrtCreateSession"] = wasmExports["Af"])(a0, a1, a2); + +var _OrtReleaseSession = Module["_OrtReleaseSession"] = a0 => (_OrtReleaseSession = Module["_OrtReleaseSession"] = wasmExports["Bf"])(a0); + +var _OrtGetInputOutputCount = Module["_OrtGetInputOutputCount"] = (a0, a1, a2) => (_OrtGetInputOutputCount = Module["_OrtGetInputOutputCount"] = wasmExports["Cf"])(a0, a1, a2); + +var _OrtGetInputOutputMetadata = Module["_OrtGetInputOutputMetadata"] = (a0, a1, a2, a3) => (_OrtGetInputOutputMetadata = Module["_OrtGetInputOutputMetadata"] = wasmExports["Df"])(a0, a1, a2, a3); + +var _OrtFree = Module["_OrtFree"] = a0 => (_OrtFree = Module["_OrtFree"] = wasmExports["Ef"])(a0); + +var _OrtCreateTensor = Module["_OrtCreateTensor"] = (a0, a1, a2, a3, a4, a5) => (_OrtCreateTensor = Module["_OrtCreateTensor"] = wasmExports["Ff"])(a0, a1, a2, a3, a4, a5); + +var _OrtGetTensorData = Module["_OrtGetTensorData"] = (a0, a1, a2, a3, a4) => (_OrtGetTensorData = Module["_OrtGetTensorData"] = wasmExports["Gf"])(a0, a1, a2, a3, a4); + +var _OrtReleaseTensor = Module["_OrtReleaseTensor"] = a0 => (_OrtReleaseTensor = Module["_OrtReleaseTensor"] = wasmExports["Hf"])(a0); + +var _OrtCreateRunOptions = Module["_OrtCreateRunOptions"] = (a0, a1, a2, a3) => (_OrtCreateRunOptions = Module["_OrtCreateRunOptions"] = wasmExports["If"])(a0, a1, a2, a3); + +var _OrtAddRunConfigEntry = Module["_OrtAddRunConfigEntry"] = (a0, a1, a2) => (_OrtAddRunConfigEntry = Module["_OrtAddRunConfigEntry"] = wasmExports["Jf"])(a0, a1, a2); + +var _OrtReleaseRunOptions = Module["_OrtReleaseRunOptions"] = a0 => (_OrtReleaseRunOptions = Module["_OrtReleaseRunOptions"] = wasmExports["Kf"])(a0); + +var _OrtCreateBinding = Module["_OrtCreateBinding"] = a0 => (_OrtCreateBinding = Module["_OrtCreateBinding"] = wasmExports["Lf"])(a0); + +var _OrtBindInput = Module["_OrtBindInput"] = (a0, a1, a2) => (_OrtBindInput = Module["_OrtBindInput"] = wasmExports["Mf"])(a0, a1, a2); + +var _OrtBindOutput = Module["_OrtBindOutput"] = (a0, a1, a2, a3) => (_OrtBindOutput = Module["_OrtBindOutput"] = wasmExports["Nf"])(a0, a1, a2, a3); + +var _OrtClearBoundOutputs = Module["_OrtClearBoundOutputs"] = a0 => (_OrtClearBoundOutputs = Module["_OrtClearBoundOutputs"] = wasmExports["Of"])(a0); + +var _OrtReleaseBinding = Module["_OrtReleaseBinding"] = a0 => (_OrtReleaseBinding = Module["_OrtReleaseBinding"] = wasmExports["Pf"])(a0); + +var _OrtRunWithBinding = Module["_OrtRunWithBinding"] = (a0, a1, a2, a3, a4) => (_OrtRunWithBinding = Module["_OrtRunWithBinding"] = wasmExports["Qf"])(a0, a1, a2, a3, a4); + +var _OrtRun = Module["_OrtRun"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (_OrtRun = Module["_OrtRun"] = wasmExports["Rf"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var _OrtEndProfiling = Module["_OrtEndProfiling"] = a0 => (_OrtEndProfiling = Module["_OrtEndProfiling"] = wasmExports["Sf"])(a0); + +var _OrtGetWebGpuDevice = Module["_OrtGetWebGpuDevice"] = a0 => (_OrtGetWebGpuDevice = Module["_OrtGetWebGpuDevice"] = wasmExports["Tf"])(a0); + +var _JsepOutput = Module["_JsepOutput"] = (a0, a1, a2) => (_JsepOutput = Module["_JsepOutput"] = wasmExports["Uf"])(a0, a1, a2); + +var _JsepGetNodeName = Module["_JsepGetNodeName"] = a0 => (_JsepGetNodeName = Module["_JsepGetNodeName"] = wasmExports["Vf"])(a0); + +var _pthread_self = () => (_pthread_self = wasmExports["Wf"])(); + +var _free = Module["_free"] = a0 => (_free = Module["_free"] = wasmExports["Xf"])(a0); + +var _malloc = Module["_malloc"] = a0 => (_malloc = Module["_malloc"] = wasmExports["Yf"])(a0); + +var _wgpuBufferRelease = Module["_wgpuBufferRelease"] = a0 => (_wgpuBufferRelease = Module["_wgpuBufferRelease"] = wasmExports["Zf"])(a0); + +var _wgpuCreateInstance = Module["_wgpuCreateInstance"] = a0 => (_wgpuCreateInstance = Module["_wgpuCreateInstance"] = wasmExports["_f"])(a0); + +var _emwgpuCreateBindGroup = a0 => (_emwgpuCreateBindGroup = wasmExports["$f"])(a0); + +var _emwgpuCreateBindGroupLayout = a0 => (_emwgpuCreateBindGroupLayout = wasmExports["ag"])(a0); + +var _emwgpuCreateCommandBuffer = a0 => (_emwgpuCreateCommandBuffer = wasmExports["bg"])(a0); + +var _emwgpuCreateCommandEncoder = a0 => (_emwgpuCreateCommandEncoder = wasmExports["cg"])(a0); + +var _emwgpuCreateComputePassEncoder = a0 => (_emwgpuCreateComputePassEncoder = wasmExports["dg"])(a0); + +var _emwgpuCreateComputePipeline = a0 => (_emwgpuCreateComputePipeline = wasmExports["eg"])(a0); + +var _emwgpuCreatePipelineLayout = a0 => (_emwgpuCreatePipelineLayout = wasmExports["fg"])(a0); + +var _emwgpuCreateQuerySet = a0 => (_emwgpuCreateQuerySet = wasmExports["gg"])(a0); + +var _emwgpuCreateRenderBundle = a0 => (_emwgpuCreateRenderBundle = wasmExports["hg"])(a0); + +var _emwgpuCreateRenderBundleEncoder = a0 => (_emwgpuCreateRenderBundleEncoder = wasmExports["ig"])(a0); + +var _emwgpuCreateRenderPassEncoder = a0 => (_emwgpuCreateRenderPassEncoder = wasmExports["jg"])(a0); + +var _emwgpuCreateRenderPipeline = a0 => (_emwgpuCreateRenderPipeline = wasmExports["kg"])(a0); + +var _emwgpuCreateSampler = a0 => (_emwgpuCreateSampler = wasmExports["lg"])(a0); + +var _emwgpuCreateSurface = a0 => (_emwgpuCreateSurface = wasmExports["mg"])(a0); + +var _emwgpuCreateTexture = a0 => (_emwgpuCreateTexture = wasmExports["ng"])(a0); + +var _emwgpuCreateTextureView = a0 => (_emwgpuCreateTextureView = wasmExports["og"])(a0); + +var _emwgpuCreateAdapter = a0 => (_emwgpuCreateAdapter = wasmExports["pg"])(a0); + +var _emwgpuCreateBuffer = (a0, a1) => (_emwgpuCreateBuffer = wasmExports["qg"])(a0, a1); + +var _emwgpuCreateDevice = (a0, a1) => (_emwgpuCreateDevice = wasmExports["rg"])(a0, a1); + +var _emwgpuCreateQueue = a0 => (_emwgpuCreateQueue = wasmExports["sg"])(a0); + +var _emwgpuCreateShaderModule = a0 => (_emwgpuCreateShaderModule = wasmExports["tg"])(a0); + +var _emwgpuOnDeviceLostCompleted = (a0, a1, a2) => (_emwgpuOnDeviceLostCompleted = wasmExports["ug"])(a0, a1, a2); + +var _emwgpuOnMapAsyncCompleted = (a0, a1, a2) => (_emwgpuOnMapAsyncCompleted = wasmExports["vg"])(a0, a1, a2); + +var _emwgpuOnPopErrorScopeCompleted = (a0, a1, a2, a3) => (_emwgpuOnPopErrorScopeCompleted = wasmExports["wg"])(a0, a1, a2, a3); + +var _emwgpuOnRequestAdapterCompleted = (a0, a1, a2, a3) => (_emwgpuOnRequestAdapterCompleted = wasmExports["xg"])(a0, a1, a2, a3); + +var _emwgpuOnRequestDeviceCompleted = (a0, a1, a2, a3) => (_emwgpuOnRequestDeviceCompleted = wasmExports["yg"])(a0, a1, a2, a3); + +var _emwgpuOnUncapturedError = (a0, a1, a2) => (_emwgpuOnUncapturedError = wasmExports["zg"])(a0, a1, a2); + +var __emscripten_tls_init = () => (__emscripten_tls_init = wasmExports["Ag"])(); + +var __emscripten_thread_init = (a0, a1, a2, a3, a4, a5) => (__emscripten_thread_init = wasmExports["Cg"])(a0, a1, a2, a3, a4, a5); + +var __emscripten_thread_crashed = () => (__emscripten_thread_crashed = wasmExports["Dg"])(); + +var __emscripten_run_on_main_thread_js = (a0, a1, a2, a3, a4) => (__emscripten_run_on_main_thread_js = wasmExports["Eg"])(a0, a1, a2, a3, a4); + +var __emscripten_thread_free_data = a0 => (__emscripten_thread_free_data = wasmExports["Fg"])(a0); + +var __emscripten_thread_exit = a0 => (__emscripten_thread_exit = wasmExports["Gg"])(a0); + +var __emscripten_timeout = (a0, a1) => (__emscripten_timeout = wasmExports["Hg"])(a0, a1); + +var __emscripten_check_mailbox = () => (__emscripten_check_mailbox = wasmExports["Ig"])(); + +var _memalign = (a0, a1) => (_memalign = wasmExports["Jg"])(a0, a1); + +var _setThrew = (a0, a1) => (_setThrew = wasmExports["Kg"])(a0, a1); + +var __emscripten_tempret_set = a0 => (__emscripten_tempret_set = wasmExports["Lg"])(a0); + +var _emscripten_stack_set_limits = (a0, a1) => (_emscripten_stack_set_limits = wasmExports["Mg"])(a0, a1); + +var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["Ng"])(a0); + +var __emscripten_stack_alloc = a0 => (__emscripten_stack_alloc = wasmExports["Og"])(a0); + +var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["Pg"])(); + +var ___cxa_decrement_exception_refcount = a0 => (___cxa_decrement_exception_refcount = wasmExports["Qg"])(a0); + +var ___cxa_increment_exception_refcount = a0 => (___cxa_increment_exception_refcount = wasmExports["Rg"])(a0); + +var ___cxa_can_catch = (a0, a1, a2) => (___cxa_can_catch = wasmExports["Sg"])(a0, a1, a2); + +var ___cxa_get_exception_ptr = a0 => (___cxa_get_exception_ptr = wasmExports["Tg"])(a0); + +var dynCall_vii = Module["dynCall_vii"] = (a0, a1, a2) => (dynCall_vii = Module["dynCall_vii"] = wasmExports["Ug"])(a0, a1, a2); + +var dynCall_iiii = Module["dynCall_iiii"] = (a0, a1, a2, a3) => (dynCall_iiii = Module["dynCall_iiii"] = wasmExports["Vg"])(a0, a1, a2, a3); + +var dynCall_iii = Module["dynCall_iii"] = (a0, a1, a2) => (dynCall_iii = Module["dynCall_iii"] = wasmExports["Wg"])(a0, a1, a2); + +var dynCall_ii = Module["dynCall_ii"] = (a0, a1) => (dynCall_ii = Module["dynCall_ii"] = wasmExports["Xg"])(a0, a1); + +var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = wasmExports["Yg"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_vi = Module["dynCall_vi"] = (a0, a1) => (dynCall_vi = Module["dynCall_vi"] = wasmExports["Zg"])(a0, a1); + +var dynCall_v = Module["dynCall_v"] = a0 => (dynCall_v = Module["dynCall_v"] = wasmExports["_g"])(a0); + +var dynCall_iiiiii = Module["dynCall_iiiiii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiiiii = Module["dynCall_iiiiii"] = wasmExports["$g"])(a0, a1, a2, a3, a4, a5); + +var dynCall_viii = Module["dynCall_viii"] = (a0, a1, a2, a3) => (dynCall_viii = Module["dynCall_viii"] = wasmExports["ah"])(a0, a1, a2, a3); + +var dynCall_i = Module["dynCall_i"] = a0 => (dynCall_i = Module["dynCall_i"] = wasmExports["bh"])(a0); + +var dynCall_iiiii = Module["dynCall_iiiii"] = (a0, a1, a2, a3, a4) => (dynCall_iiiii = Module["dynCall_iiiii"] = wasmExports["ch"])(a0, a1, a2, a3, a4); + +var dynCall_viiii = Module["dynCall_viiii"] = (a0, a1, a2, a3, a4) => (dynCall_viiii = Module["dynCall_viiii"] = wasmExports["dh"])(a0, a1, a2, a3, a4); + +var dynCall_viiiii = Module["dynCall_viiiii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_viiiii = Module["dynCall_viiiii"] = wasmExports["eh"])(a0, a1, a2, a3, a4, a5); + +var dynCall_vijii = Module["dynCall_vijii"] = (a0, a1, a2, a3, a4) => (dynCall_vijii = Module["dynCall_vijii"] = wasmExports["fh"])(a0, a1, a2, a3, a4); + +var dynCall_vijjiii = Module["dynCall_vijjiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_vijjiii = Module["dynCall_vijjiii"] = wasmExports["gh"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_vijj = Module["dynCall_vijj"] = (a0, a1, a2, a3) => (dynCall_vijj = Module["dynCall_vijj"] = wasmExports["hh"])(a0, a1, a2, a3); + +var dynCall_vijji = Module["dynCall_vijji"] = (a0, a1, a2, a3, a4) => (dynCall_vijji = Module["dynCall_vijji"] = wasmExports["ih"])(a0, a1, a2, a3, a4); + +var dynCall_diii = Module["dynCall_diii"] = (a0, a1, a2, a3) => (dynCall_diii = Module["dynCall_diii"] = wasmExports["jh"])(a0, a1, a2, a3); + +var dynCall_viiij = Module["dynCall_viiij"] = (a0, a1, a2, a3, a4) => (dynCall_viiij = Module["dynCall_viiij"] = wasmExports["kh"])(a0, a1, a2, a3, a4); + +var dynCall_iiij = Module["dynCall_iiij"] = (a0, a1, a2, a3) => (dynCall_iiij = Module["dynCall_iiij"] = wasmExports["lh"])(a0, a1, a2, a3); + +var dynCall_viijii = Module["dynCall_viijii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_viijii = Module["dynCall_viijii"] = wasmExports["mh"])(a0, a1, a2, a3, a4, a5); + +var dynCall_iif = Module["dynCall_iif"] = (a0, a1, a2) => (dynCall_iif = Module["dynCall_iif"] = wasmExports["nh"])(a0, a1, a2); + +var dynCall_jiii = Module["dynCall_jiii"] = (a0, a1, a2, a3) => (dynCall_jiii = Module["dynCall_jiii"] = wasmExports["oh"])(a0, a1, a2, a3); + +var dynCall_viijijj = Module["dynCall_viijijj"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viijijj = Module["dynCall_viijijj"] = wasmExports["ph"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_vij = Module["dynCall_vij"] = (a0, a1, a2) => (dynCall_vij = Module["dynCall_vij"] = wasmExports["qh"])(a0, a1, a2); + +var dynCall_viij = Module["dynCall_viij"] = (a0, a1, a2, a3) => (dynCall_viij = Module["dynCall_viij"] = wasmExports["rh"])(a0, a1, a2, a3); + +var dynCall_iiiiid = Module["dynCall_iiiiid"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiiiid = Module["dynCall_iiiiid"] = wasmExports["sh"])(a0, a1, a2, a3, a4, a5); + +var dynCall_viijj = Module["dynCall_viijj"] = (a0, a1, a2, a3, a4) => (dynCall_viijj = Module["dynCall_viijj"] = wasmExports["th"])(a0, a1, a2, a3, a4); + +var dynCall_iij = Module["dynCall_iij"] = (a0, a1, a2) => (dynCall_iij = Module["dynCall_iij"] = wasmExports["uh"])(a0, a1, a2); + +var dynCall_iiiiij = Module["dynCall_iiiiij"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiiiij = Module["dynCall_iiiiij"] = wasmExports["vh"])(a0, a1, a2, a3, a4, a5); + +var dynCall_j = Module["dynCall_j"] = a0 => (dynCall_j = Module["dynCall_j"] = wasmExports["wh"])(a0); + +var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = wasmExports["xh"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = wasmExports["yh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_iiiiijiiiii = Module["dynCall_iiiiijiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_iiiiijiiiii = Module["dynCall_iiiiijiiiii"] = wasmExports["zh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_iiiiiiiiiii = Module["dynCall_iiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_iiiiiiiiiii = Module["dynCall_iiiiiiiiiii"] = wasmExports["Ah"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_vijjjiiiiij = Module["dynCall_vijjjiiiiij"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_vijjjiiiiij = Module["dynCall_vijjjiiiiij"] = wasmExports["Bh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_viiiiii = Module["dynCall_viiiiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiiii = Module["dynCall_viiiiii"] = wasmExports["Ch"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viji = Module["dynCall_viji"] = (a0, a1, a2, a3) => (dynCall_viji = Module["dynCall_viji"] = wasmExports["Dh"])(a0, a1, a2, a3); + +var dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = wasmExports["Eh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_fi = Module["dynCall_fi"] = (a0, a1) => (dynCall_fi = Module["dynCall_fi"] = wasmExports["Fh"])(a0, a1); + +var dynCall_fii = Module["dynCall_fii"] = (a0, a1, a2) => (dynCall_fii = Module["dynCall_fii"] = wasmExports["Gh"])(a0, a1, a2); + +var dynCall_ji = Module["dynCall_ji"] = (a0, a1) => (dynCall_ji = Module["dynCall_ji"] = wasmExports["Hh"])(a0, a1); + +var dynCall_di = Module["dynCall_di"] = (a0, a1) => (dynCall_di = Module["dynCall_di"] = wasmExports["Ih"])(a0, a1); + +var dynCall_jii = Module["dynCall_jii"] = (a0, a1, a2) => (dynCall_jii = Module["dynCall_jii"] = wasmExports["Jh"])(a0, a1, a2); + +var dynCall_dii = Module["dynCall_dii"] = (a0, a1, a2) => (dynCall_dii = Module["dynCall_dii"] = wasmExports["Kh"])(a0, a1, a2); + +var dynCall_viijiii = Module["dynCall_viijiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viijiii = Module["dynCall_viijiii"] = wasmExports["Lh"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = wasmExports["Mh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_iiiiiiiij = Module["dynCall_iiiiiiiij"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_iiiiiiiij = Module["dynCall_iiiiiiiij"] = wasmExports["Nh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = wasmExports["Oh"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viiji = Module["dynCall_viiji"] = (a0, a1, a2, a3, a4) => (dynCall_viiji = Module["dynCall_viiji"] = wasmExports["Ph"])(a0, a1, a2, a3, a4); + +var dynCall_viiiiij = Module["dynCall_viiiiij"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiiij = Module["dynCall_viiiiij"] = wasmExports["Qh"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viijjjiiiiii = Module["dynCall_viijjjiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_viijjjiiiiii = Module["dynCall_viijjjiiiiii"] = wasmExports["Rh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_viiijiiiiiii = Module["dynCall_viiijiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_viiijiiiiiii = Module["dynCall_viiijiiiiiii"] = wasmExports["Sh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_iiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_iiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiii"] = wasmExports["Th"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = wasmExports["Uh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_viiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) => (dynCall_viiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiii"] = wasmExports["Vh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + +var dynCall_viid = Module["dynCall_viid"] = (a0, a1, a2, a3) => (dynCall_viid = Module["dynCall_viid"] = wasmExports["Wh"])(a0, a1, a2, a3); + +var dynCall_vid = Module["dynCall_vid"] = (a0, a1, a2) => (dynCall_vid = Module["dynCall_vid"] = wasmExports["Xh"])(a0, a1, a2); + +var dynCall_viiiiiiiiiii = Module["dynCall_viiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_viiiiiiiiiii = Module["dynCall_viiiiiiiiiii"] = wasmExports["Yh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_viiijjjii = Module["dynCall_viiijjjii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_viiijjjii = Module["dynCall_viiijjjii"] = wasmExports["Zh"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_iid = Module["dynCall_iid"] = (a0, a1, a2) => (dynCall_iid = Module["dynCall_iid"] = wasmExports["_h"])(a0, a1, a2); + +var dynCall_viiiij = Module["dynCall_viiiij"] = (a0, a1, a2, a3, a4, a5) => (dynCall_viiiij = Module["dynCall_viiiij"] = wasmExports["$h"])(a0, a1, a2, a3, a4, a5); + +var dynCall_viiijiiiii = Module["dynCall_viiijiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_viiijiiiii = Module["dynCall_viiijiiiii"] = wasmExports["ai"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_jj = Module["dynCall_jj"] = (a0, a1) => (dynCall_jj = Module["dynCall_jj"] = wasmExports["bi"])(a0, a1); + +var dynCall_iiiijii = Module["dynCall_iiiijii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiijii = Module["dynCall_iiiijii"] = wasmExports["ci"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_iiijii = Module["dynCall_iiijii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiijii = Module["dynCall_iiijii"] = wasmExports["di"])(a0, a1, a2, a3, a4, a5); + +var dynCall_viiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) => (dynCall_viiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiii"] = wasmExports["ei"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + +var dynCall_iiijjj = Module["dynCall_iiijjj"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiijjj = Module["dynCall_iiijjj"] = wasmExports["fi"])(a0, a1, a2, a3, a4, a5); + +var dynCall_ij = Module["dynCall_ij"] = (a0, a1) => (dynCall_ij = Module["dynCall_ij"] = wasmExports["gi"])(a0, a1); + +var dynCall_viiiiji = Module["dynCall_viiiiji"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiiji = Module["dynCall_viiiiji"] = wasmExports["hi"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_iijjji = Module["dynCall_iijjji"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iijjji = Module["dynCall_iijjji"] = wasmExports["ii"])(a0, a1, a2, a3, a4, a5); + +var dynCall_vjiiiiii = Module["dynCall_vjiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_vjiiiiii = Module["dynCall_vjiiiiii"] = wasmExports["ji"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_vijjiiiii = Module["dynCall_vijjiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_vijjiiiii = Module["dynCall_vijjiiiii"] = wasmExports["ki"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_jiij = Module["dynCall_jiij"] = (a0, a1, a2, a3) => (dynCall_jiij = Module["dynCall_jiij"] = wasmExports["li"])(a0, a1, a2, a3); + +var dynCall_iijijjijiji = Module["dynCall_iijijjijiji"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_iijijjijiji = Module["dynCall_iijijjijiji"] = wasmExports["mi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_iijijji = Module["dynCall_iijijji"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iijijji = Module["dynCall_iijijji"] = wasmExports["ni"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_ijijji = Module["dynCall_ijijji"] = (a0, a1, a2, a3, a4, a5) => (dynCall_ijijji = Module["dynCall_ijijji"] = wasmExports["oi"])(a0, a1, a2, a3, a4, a5); + +var dynCall_iiiiiiij = Module["dynCall_iiiiiiij"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_iiiiiiij = Module["dynCall_iiiiiiij"] = wasmExports["pi"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viiijjiii = Module["dynCall_viiijjiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_viiijjiii = Module["dynCall_viiijjiii"] = wasmExports["qi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_vif = Module["dynCall_vif"] = (a0, a1, a2) => (dynCall_vif = Module["dynCall_vif"] = wasmExports["ri"])(a0, a1, a2); + +var dynCall_viif = Module["dynCall_viif"] = (a0, a1, a2, a3) => (dynCall_viif = Module["dynCall_viif"] = wasmExports["si"])(a0, a1, a2, a3); + +var dynCall_iiiiijji = Module["dynCall_iiiiijji"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_iiiiijji = Module["dynCall_iiiiijji"] = wasmExports["ti"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_iiiiji = Module["dynCall_iiiiji"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiiiji = Module["dynCall_iiiiji"] = wasmExports["ui"])(a0, a1, a2, a3, a4, a5); + +var dynCall_iiiifi = Module["dynCall_iiiifi"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiiifi = Module["dynCall_iiiifi"] = wasmExports["vi"])(a0, a1, a2, a3, a4, a5); + +var dynCall_iiiiiiiiijii = Module["dynCall_iiiiiiiiijii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_iiiiiiiiijii = Module["dynCall_iiiiiiiiijii"] = wasmExports["wi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_iiiijjii = Module["dynCall_iiiijjii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_iiiijjii = Module["dynCall_iiiijjii"] = wasmExports["xi"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_iiiiiijjjii = Module["dynCall_iiiiiijjjii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_iiiiiijjjii = Module["dynCall_iiiiiijjjii"] = wasmExports["yi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_iiijiii = Module["dynCall_iiijiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiijiii = Module["dynCall_iiijiii"] = wasmExports["zi"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_iiiiiiiijjjfi = Module["dynCall_iiiiiiiijjjfi"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_iiiiiiiijjjfi = Module["dynCall_iiiiiiiijjjfi"] = wasmExports["Ai"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_iijiiii = Module["dynCall_iijiiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iijiiii = Module["dynCall_iijiiii"] = wasmExports["Bi"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiiijj = Module["dynCall_viiiijj"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiijj = Module["dynCall_viiiijj"] = wasmExports["Ci"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_iijjjii = Module["dynCall_iijjjii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iijjjii = Module["dynCall_iijjjii"] = wasmExports["Di"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_jij = Module["dynCall_jij"] = (a0, a1, a2) => (dynCall_jij = Module["dynCall_jij"] = wasmExports["Ei"])(a0, a1, a2); + +var dynCall_jjj = Module["dynCall_jjj"] = (a0, a1, a2) => (dynCall_jjj = Module["dynCall_jjj"] = wasmExports["Fi"])(a0, a1, a2); + +var dynCall_iiji = Module["dynCall_iiji"] = (a0, a1, a2, a3) => (dynCall_iiji = Module["dynCall_iiji"] = wasmExports["Gi"])(a0, a1, a2, a3); + +var dynCall_viffiii = Module["dynCall_viffiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viffiii = Module["dynCall_viffiii"] = wasmExports["Hi"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viifiii = Module["dynCall_viifiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viifiii = Module["dynCall_viifiii"] = wasmExports["Ii"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiiiidiidi = Module["dynCall_viiiiidiidi"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiiiidiidi = Module["dynCall_viiiiidiidi"] = wasmExports["Ji"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_viiiiiiiiidi = Module["dynCall_viiiiiiiiidi"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_viiiiiiiiidi = Module["dynCall_viiiiiiiiidi"] = wasmExports["Ki"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_viiiiiiiiiiiiiifi = Module["dynCall_viiiiiiiiiiiiiifi"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) => (dynCall_viiiiiiiiiiiiiifi = Module["dynCall_viiiiiiiiiiiiiifi"] = wasmExports["Li"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + +var dynCall_ijii = Module["dynCall_ijii"] = (a0, a1, a2, a3) => (dynCall_ijii = Module["dynCall_ijii"] = wasmExports["Mi"])(a0, a1, a2, a3); + +var dynCall_viijiiiijiii = Module["dynCall_viijiiiijiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_viijiiiijiii = Module["dynCall_viijiiiijiii"] = wasmExports["Ni"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_vijjjjjjjjjjjjji = Module["dynCall_vijjjjjjjjjjjjji"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) => (dynCall_vijjjjjjjjjjjjji = Module["dynCall_vijjjjjjjjjjjjji"] = wasmExports["Oi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + +var dynCall_viiijii = Module["dynCall_viiijii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiijii = Module["dynCall_viiijii"] = wasmExports["Pi"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_vijjjiiji = Module["dynCall_vijjjiiji"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_vijjjiiji = Module["dynCall_vijjjiiji"] = wasmExports["Qi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_iiiijiiiiiiiiii = Module["dynCall_iiiijiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => (dynCall_iiiijiiiiiiiiii = Module["dynCall_iiiijiiiiiiiiii"] = wasmExports["Ri"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + +var dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = wasmExports["Si"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_vj = Module["dynCall_vj"] = (a0, a1) => (dynCall_vj = Module["dynCall_vj"] = wasmExports["Ti"])(a0, a1); + +var dynCall_vfiii = Module["dynCall_vfiii"] = (a0, a1, a2, a3, a4) => (dynCall_vfiii = Module["dynCall_vfiii"] = wasmExports["Ui"])(a0, a1, a2, a3, a4); + +var dynCall_viiiiff = Module["dynCall_viiiiff"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiiff = Module["dynCall_viiiiff"] = wasmExports["Vi"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiiiiff = Module["dynCall_viiiiiff"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiiiiff = Module["dynCall_viiiiiff"] = wasmExports["Wi"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viiff = Module["dynCall_viiff"] = (a0, a1, a2, a3, a4) => (dynCall_viiff = Module["dynCall_viiff"] = wasmExports["Xi"])(a0, a1, a2, a3, a4); + +var dynCall_viiiiiiiiifiiii = Module["dynCall_viiiiiiiiifiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => (dynCall_viiiiiiiiifiiii = Module["dynCall_viiiiiiiiifiiii"] = wasmExports["Yi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + +var dynCall_viiiiiiiijj = Module["dynCall_viiiiiiiijj"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiiiiiiijj = Module["dynCall_viiiiiiiijj"] = wasmExports["Zi"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_iiiiiiiiiiiiiifii = Module["dynCall_iiiiiiiiiiiiiifii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) => (dynCall_iiiiiiiiiiiiiifii = Module["dynCall_iiiiiiiiiiiiiifii"] = wasmExports["_i"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + +var dynCall_viiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) => (dynCall_viiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiii"] = wasmExports["$i"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + +var dynCall_iiiiiiiiiiiiiiiiiiifii = Module["dynCall_iiiiiiiiiiiiiiiiiiifii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) => (dynCall_iiiiiiiiiiiiiiiiiiifii = Module["dynCall_iiiiiiiiiiiiiiiiiiifii"] = wasmExports["aj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); + +var dynCall_vijjiiiiiii = Module["dynCall_vijjiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_vijjiiiiiii = Module["dynCall_vijjiiiiiii"] = wasmExports["bj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_iiiijjj = Module["dynCall_iiiijjj"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiijjj = Module["dynCall_iiiijjj"] = wasmExports["cj"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_fffffff = Module["dynCall_fffffff"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_fffffff = Module["dynCall_fffffff"] = wasmExports["dj"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiiiiijiifiii = Module["dynCall_viiiiiijiifiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) => (dynCall_viiiiiijiifiii = Module["dynCall_viiiiiijiifiii"] = wasmExports["ej"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + +var dynCall_vjjjjjjffjifiiiiii = Module["dynCall_vjjjjjjffjifiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) => (dynCall_vjjjjjjffjifiiiiii = Module["dynCall_vjjjjjjffjifiiiiii"] = wasmExports["fj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); + +var dynCall_viiiiiiffjifiiiii = Module["dynCall_viiiiiiffjifiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) => (dynCall_viiiiiiffjifiiiii = Module["dynCall_viiiiiiffjifiiiii"] = wasmExports["gj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + +var dynCall_viiiiiiffjfiiiii = Module["dynCall_viiiiiiffjfiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) => (dynCall_viiiiiiffjfiiiii = Module["dynCall_viiiiiiffjfiiiii"] = wasmExports["hj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + +var dynCall_viiiiiiffjiiiii = Module["dynCall_viiiiiiffjiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => (dynCall_viiiiiiffjiiiii = Module["dynCall_viiiiiiffjiiiii"] = wasmExports["ij"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + +var dynCall_vjjjjjjjjfffjifiiiiii = Module["dynCall_vjjjjjjjjfffjifiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) => (dynCall_vjjjjjjjjfffjifiiiiii = Module["dynCall_vjjjjjjjjfffjifiiiiii"] = wasmExports["jj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + +var dynCall_vjjjjjjfffifijiiiii = Module["dynCall_vjjjjjjfffifijiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) => (dynCall_vjjjjjjfffifijiiiii = Module["dynCall_vjjjjjjfffifijiiiii"] = wasmExports["kj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); + +var dynCall_vjjjjjjfffifiiiiii = Module["dynCall_vjjjjjjfffifiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) => (dynCall_vjjjjjjfffifiiiiii = Module["dynCall_vjjjjjjfffifiiiiii"] = wasmExports["lj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); + +var dynCall_vjjjjjjjjfffiiifiiiii = Module["dynCall_vjjjjjjjjfffiiifiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) => (dynCall_vjjjjjjjjfffiiifiiiii = Module["dynCall_vjjjjjjjjfffiiifiiiii"] = wasmExports["mj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + +var dynCall_vijiiiiiiiiii = Module["dynCall_vijiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_vijiiiiiiiiii = Module["dynCall_vijiiiiiiiiii"] = wasmExports["nj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_vijjfffiii = Module["dynCall_vijjfffiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_vijjfffiii = Module["dynCall_vijjfffiii"] = wasmExports["oj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_jiijjiif = Module["dynCall_jiijjiif"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_jiijjiif = Module["dynCall_jiijjiif"] = wasmExports["pj"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_vijjjjjjifiiiii = Module["dynCall_vijjjjjjifiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => (dynCall_vijjjjjjifiiiii = Module["dynCall_vijjjjjjifiiiii"] = wasmExports["qj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + +var dynCall_vjjjjjiiii = Module["dynCall_vjjjjjiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_vjjjjjiiii = Module["dynCall_vjjjjjiiii"] = wasmExports["rj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_vjjjjfiii = Module["dynCall_vjjjjfiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_vjjjjfiii = Module["dynCall_vjjjjfiii"] = wasmExports["sj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_viiiiiijiiiiii = Module["dynCall_viiiiiijiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) => (dynCall_viiiiiijiiiiii = Module["dynCall_viiiiiijiiiiii"] = wasmExports["tj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + +var dynCall_vijjii = Module["dynCall_vijjii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_vijjii = Module["dynCall_vijjii"] = wasmExports["uj"])(a0, a1, a2, a3, a4, a5); + +var dynCall_viiiiijjiiiii = Module["dynCall_viiiiijjiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_viiiiijjiiiii = Module["dynCall_viiiiijjiiiii"] = wasmExports["vj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_iiiiiji = Module["dynCall_iiiiiji"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiiiji = Module["dynCall_iiiiiji"] = wasmExports["wj"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiiiijiiiiii = Module["dynCall_viiiiijiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_viiiiijiiiiii = Module["dynCall_viiiiijiiiiii"] = wasmExports["xj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_iiiiiiiiiiii = Module["dynCall_iiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_iiiiiiiiiiii = Module["dynCall_iiiiiiiiiiii"] = wasmExports["yj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_viiijiiiiii = Module["dynCall_viiijiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiijiiiiii = Module["dynCall_viiijiiiiii"] = wasmExports["zj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_viiiijii = Module["dynCall_viiiijii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiiijii = Module["dynCall_viiiijii"] = wasmExports["Aj"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viijjiii = Module["dynCall_viijjiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viijjiii = Module["dynCall_viijjiii"] = wasmExports["Bj"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viiiji = Module["dynCall_viiiji"] = (a0, a1, a2, a3, a4, a5) => (dynCall_viiiji = Module["dynCall_viiiji"] = wasmExports["Cj"])(a0, a1, a2, a3, a4, a5); + +var dynCall_viiiiiijii = Module["dynCall_viiiiiijii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_viiiiiijii = Module["dynCall_viiiiiijii"] = wasmExports["Dj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_viiiiijjji = Module["dynCall_viiiiijjji"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_viiiiijjji = Module["dynCall_viiiiijjji"] = wasmExports["Ej"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_vijiii = Module["dynCall_vijiii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_vijiii = Module["dynCall_vijiii"] = wasmExports["Fj"])(a0, a1, a2, a3, a4, a5); + +var dynCall_iiijiiii = Module["dynCall_iiijiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_iiijiiii = Module["dynCall_iiijiiii"] = wasmExports["Gj"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viiiiiijjiiiii = Module["dynCall_viiiiiijjiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) => (dynCall_viiiiiijjiiiii = Module["dynCall_viiiiiijjiiiii"] = wasmExports["Hj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + +var dynCall_viiiiiiijiiiiii = Module["dynCall_viiiiiiijiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => (dynCall_viiiiiiijiiiiii = Module["dynCall_viiiiiiijiiiiii"] = wasmExports["Ij"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + +var dynCall_viiiiiji = Module["dynCall_viiiiiji"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiiiiji = Module["dynCall_viiiiiji"] = wasmExports["Jj"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_fiif = Module["dynCall_fiif"] = (a0, a1, a2, a3) => (dynCall_fiif = Module["dynCall_fiif"] = wasmExports["Kj"])(a0, a1, a2, a3); + +var dynCall_viijjjiii = Module["dynCall_viijjjiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_viijjjiii = Module["dynCall_viijjjiii"] = wasmExports["Lj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_viiiiiifiii = Module["dynCall_viiiiiifiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiiiiifiii = Module["dynCall_viiiiiifiii"] = wasmExports["Mj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_viijji = Module["dynCall_viijji"] = (a0, a1, a2, a3, a4, a5) => (dynCall_viijji = Module["dynCall_viijji"] = wasmExports["Nj"])(a0, a1, a2, a3, a4, a5); + +var dynCall_iiiiiiiiiiijijji = Module["dynCall_iiiiiiiiiiijijji"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) => (dynCall_iiiiiiiiiiijijji = Module["dynCall_iiiiiiiiiiijijji"] = wasmExports["Oj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + +var dynCall_jiijjiii = Module["dynCall_jiijjiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_jiijjiii = Module["dynCall_jiijjiii"] = wasmExports["Pj"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viifiifijjjii = Module["dynCall_viifiifijjjii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_viifiifijjjii = Module["dynCall_viifiifijjjii"] = wasmExports["Qj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_viiiiiiiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) => (dynCall_viiiiiiiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiiiiiiii"] = wasmExports["Rj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); + +var dynCall_viiiiifiiiiii = Module["dynCall_viiiiifiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_viiiiifiiiiii = Module["dynCall_viiiiifiiiiii"] = wasmExports["Sj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_vijjiiiiii = Module["dynCall_vijjiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_vijjiiiiii = Module["dynCall_vijjiiiiii"] = wasmExports["Tj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +var dynCall_vijiiiiiiijjii = Module["dynCall_vijiiiiiiijjii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) => (dynCall_vijiiiiiiijjii = Module["dynCall_vijiiiiiiijjii"] = wasmExports["Uj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + +var dynCall_viiiiiiiiiiii = Module["dynCall_viiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_viiiiiiiiiiii = Module["dynCall_viiiiiiiiiiii"] = wasmExports["Vj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_viiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) => (dynCall_viiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiii"] = wasmExports["Wj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); + +var dynCall_viiiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) => (dynCall_viiiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiiii"] = wasmExports["Xj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); + +var dynCall_viiijiiiiiiiiiiiiiii = Module["dynCall_viiijiiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) => (dynCall_viiijiiiiiiiiiiiiiii = Module["dynCall_viiijiiiiiiiiiiiiiii"] = wasmExports["Yj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); + +var dynCall_viiiijjj = Module["dynCall_viiiijjj"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiiijjj = Module["dynCall_viiiijjj"] = wasmExports["Zj"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viiiiiiijjj = Module["dynCall_viiiiiiijjj"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiiiiiijjj = Module["dynCall_viiiiiiijjj"] = wasmExports["_j"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_iiiiiiiiiiiiiiiiiiiifi = Module["dynCall_iiiiiiiiiiiiiiiiiiiifi"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) => (dynCall_iiiiiiiiiiiiiiiiiiiifi = Module["dynCall_iiiiiiiiiiiiiiiiiiiifi"] = wasmExports["$j"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); + +var dynCall_viiijiiiiiiiiii = Module["dynCall_viiijiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => (dynCall_viiijiiiiiiiiii = Module["dynCall_viiijiiiiiiiiii"] = wasmExports["ak"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + +var dynCall_viiiiif = Module["dynCall_viiiiif"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiiif = Module["dynCall_viiiiif"] = wasmExports["bk"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiif = Module["dynCall_viiif"] = (a0, a1, a2, a3, a4) => (dynCall_viiif = Module["dynCall_viiif"] = wasmExports["ck"])(a0, a1, a2, a3, a4); + +var dynCall_viiiiiiiiifi = Module["dynCall_viiiiiiiiifi"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_viiiiiiiiifi = Module["dynCall_viiiiiiiiifi"] = wasmExports["dk"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_viiiiid = Module["dynCall_viiiiid"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiiid = Module["dynCall_viiiiid"] = wasmExports["ek"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiid = Module["dynCall_viiid"] = (a0, a1, a2, a3, a4) => (dynCall_viiid = Module["dynCall_viiid"] = wasmExports["fk"])(a0, a1, a2, a3, a4); + +var dynCall_iiif = Module["dynCall_iiif"] = (a0, a1, a2, a3) => (dynCall_iiif = Module["dynCall_iiif"] = wasmExports["gk"])(a0, a1, a2, a3); + +var dynCall_iiiij = Module["dynCall_iiiij"] = (a0, a1, a2, a3, a4) => (dynCall_iiiij = Module["dynCall_iiiij"] = wasmExports["hk"])(a0, a1, a2, a3, a4); + +var dynCall_iiiiiif = Module["dynCall_iiiiiif"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiiiif = Module["dynCall_iiiiiif"] = wasmExports["ik"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_vijij = Module["dynCall_vijij"] = (a0, a1, a2, a3, a4) => (dynCall_vijij = Module["dynCall_vijij"] = wasmExports["jk"])(a0, a1, a2, a3, a4); + +var dynCall_viiijji = Module["dynCall_viiijji"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiijji = Module["dynCall_viiijji"] = wasmExports["kk"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiiiiiffii = Module["dynCall_viiiiiiffii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiiiiiffii = Module["dynCall_viiiiiiffii"] = wasmExports["lk"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + +var dynCall_iifii = Module["dynCall_iifii"] = (a0, a1, a2, a3, a4) => (dynCall_iifii = Module["dynCall_iifii"] = wasmExports["mk"])(a0, a1, a2, a3, a4); + +var dynCall_viiiiifi = Module["dynCall_viiiiifi"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiiiifi = Module["dynCall_viiiiifi"] = wasmExports["nk"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_iifjii = Module["dynCall_iifjii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iifjii = Module["dynCall_iifjii"] = wasmExports["ok"])(a0, a1, a2, a3, a4, a5); + +var dynCall_vidi = Module["dynCall_vidi"] = (a0, a1, a2, a3) => (dynCall_vidi = Module["dynCall_vidi"] = wasmExports["pk"])(a0, a1, a2, a3); + +var dynCall_viiijiji = Module["dynCall_viiijiji"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiijiji = Module["dynCall_viiijiji"] = wasmExports["qk"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_viiijij = Module["dynCall_viiijij"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiijij = Module["dynCall_viiijij"] = wasmExports["rk"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_vijjj = Module["dynCall_vijjj"] = (a0, a1, a2, a3, a4) => (dynCall_vijjj = Module["dynCall_vijjj"] = wasmExports["sk"])(a0, a1, a2, a3, a4); + +var dynCall_vjiij = Module["dynCall_vjiij"] = (a0, a1, a2, a3, a4) => (dynCall_vjiij = Module["dynCall_vjiij"] = wasmExports["tk"])(a0, a1, a2, a3, a4); + +var dynCall_diiiii = Module["dynCall_diiiii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_diiiii = Module["dynCall_diiiii"] = wasmExports["uk"])(a0, a1, a2, a3, a4, a5); + +var dynCall_diiii = Module["dynCall_diiii"] = (a0, a1, a2, a3, a4) => (dynCall_diiii = Module["dynCall_diiii"] = wasmExports["vk"])(a0, a1, a2, a3, a4); + +var dynCall_iiiji = Module["dynCall_iiiji"] = (a0, a1, a2, a3, a4) => (dynCall_iiiji = Module["dynCall_iiiji"] = wasmExports["wk"])(a0, a1, a2, a3, a4); + +var dynCall_ijiijji = Module["dynCall_ijiijji"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_ijiijji = Module["dynCall_ijiijji"] = wasmExports["xk"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_viiijjiiiiii = Module["dynCall_viiijjiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_viiijjiiiiii = Module["dynCall_viiijjiiiiii"] = wasmExports["yk"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + +var dynCall_viijjijjjjiii = Module["dynCall_viijjijjjjiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) => (dynCall_viijjijjjjiii = Module["dynCall_viijjijjjjiii"] = wasmExports["zk"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + +var dynCall_ijiii = Module["dynCall_ijiii"] = (a0, a1, a2, a3, a4) => (dynCall_ijiii = Module["dynCall_ijiii"] = wasmExports["Ak"])(a0, a1, a2, a3, a4); + +var dynCall_ijiiiiji = Module["dynCall_ijiiiiji"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_ijiiiiji = Module["dynCall_ijiiiiji"] = wasmExports["Bk"])(a0, a1, a2, a3, a4, a5, a6, a7); + +var dynCall_iiifii = Module["dynCall_iiifii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiifii = Module["dynCall_iiifii"] = wasmExports["Ck"])(a0, a1, a2, a3, a4, a5); + +var dynCall_ijiij = Module["dynCall_ijiij"] = (a0, a1, a2, a3, a4) => (dynCall_ijiij = Module["dynCall_ijiij"] = wasmExports["Dk"])(a0, a1, a2, a3, a4); + +var dynCall_viijiiiiiiiiii = Module["dynCall_viijiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) => (dynCall_viijiiiiiiiiii = Module["dynCall_viijiiiiiiiiii"] = wasmExports["Ek"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + +var dynCall_fiiii = Module["dynCall_fiiii"] = (a0, a1, a2, a3, a4) => (dynCall_fiiii = Module["dynCall_fiiii"] = wasmExports["Fk"])(a0, a1, a2, a3, a4); + +var dynCall_jfi = Module["dynCall_jfi"] = (a0, a1, a2) => (dynCall_jfi = Module["dynCall_jfi"] = wasmExports["Gk"])(a0, a1, a2); + +var dynCall_viiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) => (dynCall_viiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiii"] = wasmExports["Hk"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + +var dynCall_viiiiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) => (dynCall_viiiiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiiiii"] = wasmExports["Ik"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + +var dynCall_fiii = Module["dynCall_fiii"] = (a0, a1, a2, a3) => (dynCall_fiii = Module["dynCall_fiii"] = wasmExports["Jk"])(a0, a1, a2, a3); + +var _asyncify_start_unwind = a0 => (_asyncify_start_unwind = wasmExports["Kk"])(a0); + +var _asyncify_stop_unwind = () => (_asyncify_stop_unwind = wasmExports["Lk"])(); + +var _asyncify_start_rewind = a0 => (_asyncify_start_rewind = wasmExports["Mk"])(a0); + +var _asyncify_stop_rewind = () => (_asyncify_stop_rewind = wasmExports["Nk"])(); + +function invoke_iiii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_iiii(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iii(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_iii(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vii(index, a1, a2) { + var sp = stackSave(); + try { + dynCall_vii(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ii(index, a1) { + var sp = stackSave(); + try { + return dynCall_ii(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index, a1) { + var sp = stackSave(); + try { + dynCall_vi(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_v(index) { + var sp = stackSave(); + try { + dynCall_v(index); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iiiiiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_vijii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiiiii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index, a1, a2, a3) { + var sp = stackSave(); + try { + dynCall_viii(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_vijjiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_viiii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_iiiii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiiiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_viiiii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_i(index) { + var sp = stackSave(); + try { + return dynCall_i(index); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiij(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_iiij(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_viijii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jiii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_jiii(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_viijijj(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viijijj(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vij(index, a1, a2) { + var sp = stackSave(); + try { + dynCall_vij(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viij(index, a1, a2, a3) { + var sp = stackSave(); + try { + dynCall_viij(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iif(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_iif(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iij(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_iij(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijj(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_viijj(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + return dynCall_iiiiijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjjiiiiij(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_vijjjiiiiij(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + dynCall_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fi(index, a1) { + var sp = stackSave(); + try { + return dynCall_fi(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ji(index, a1) { + var sp = stackSave(); + try { + return dynCall_ji(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_di(index, a1) { + var sp = stackSave(); + try { + return dynCall_di(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijj(index, a1, a2, a3) { + var sp = stackSave(); + try { + dynCall_vijj(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiijii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viijiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiijii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viiiijii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + dynCall_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viji(index, a1, a2, a3) { + var sp = stackSave(); + try { + dynCall_viji(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiij(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiij(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiji(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_viiji(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jii(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_jii(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_viiiiij(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiiiij(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijjjiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + dynCall_viijjjiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + dynCall_viiijiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viid(index, a1, a2, a3) { + var sp = stackSave(); + try { + dynCall_viid(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vid(index, a1, a2) { + var sp = stackSave(); + try { + dynCall_vid(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiij(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_viiij(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijji(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_vijji(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iid(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_iid(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiij(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_viiiij(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + dynCall_viiijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijjjii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + dynCall_viiijjjii(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ij(index, a1) { + var sp = stackSave(); + try { + return dynCall_ij(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + var sp = stackSave(); + try { + dynCall_viijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiijii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiijii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jiij(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_jiij(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_iiijjj(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiijjj(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjiiiiii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_vjiiiiii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + dynCall_vijjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiji(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiiiji(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iijjji(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iijjji(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iijijjijiji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + return dynCall_iijijjijiji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iijijji(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iijijji(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ijijji(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_ijijji(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jj(index, a1) { + var sp = stackSave(); + try { + return dynCall_jj(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_iiiijii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iiiijii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vif(index, a1, a2) { + var sp = stackSave(); + try { + dynCall_vif(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiij(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_iiiiiiij(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + dynCall_viiijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viif(index, a1, a2, a3) { + var sp = stackSave(); + try { + dynCall_viif(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiijji(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_iiiiijji(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiji(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiiiji(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiifi(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiiifi(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiijjii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_iiiijjii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiijjjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + return dynCall_iiiiiijjjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiijiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iiijiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiijjjfi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiijjjfi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iijiiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iijiiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiijj(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiiijj(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iijjjii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iijjjii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jij(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_jij(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_jjj(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_jjj(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_iiji(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_iiji(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viffiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viffiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viifiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viifiii(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiidiidi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_viiiiidiidi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijiiiijiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + dynCall_viijiiiijiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjjjjjjjjjjjji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { + var sp = stackSave(); + try { + dynCall_vijjjjjjjjjjjjji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjjiiji(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + dynCall_vijjjiiji(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + var sp = stackSave(); + try { + return dynCall_iiiijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vj(index, a1) { + var sp = stackSave(); + try { + dynCall_vj(index, a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiifiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiifiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vfiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_vfiii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiff(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiiiff(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiff(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_viiff(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiff(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viiiiiff(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiijj(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_viiiiiiiijj(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiiiiifii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiiiiifii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fiiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_fiiii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiiiiiiiiiifii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiiiiiiiiiifii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_vijjiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiijjj(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iiiijjj(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiijiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + var sp = stackSave(); + try { + dynCall_viiiiiijiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjjjjjjffjifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) { + var sp = stackSave(); + try { + dynCall_vjjjjjjffjifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiffjifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { + var sp = stackSave(); + try { + dynCall_viiiiiiffjifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiffjfiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { + var sp = stackSave(); + try { + dynCall_viiiiiiffjfiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiffjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + var sp = stackSave(); + try { + dynCall_viiiiiiffjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjjjjjjjjfffjifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) { + var sp = stackSave(); + try { + dynCall_vjjjjjjjjfffjifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjjjjjjfffifijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) { + var sp = stackSave(); + try { + dynCall_vjjjjjjfffifijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjjjjjjfffifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) { + var sp = stackSave(); + try { + dynCall_vjjjjjjfffifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjjjjjjjjfffiiifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) { + var sp = stackSave(); + try { + dynCall_vjjjjjjjjfffiiifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + dynCall_vijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjfffiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + dynCall_vijjfffiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jiijjiif(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_jiijjiif(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_vijjjjjjifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + var sp = stackSave(); + try { + dynCall_vijjjjjjifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjjjjjiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + dynCall_vjjjjjiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjjjjfiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + dynCall_vjjjjfiii(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fffffff(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_fffffff(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jfi(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_jfi(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_viiiiiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + var sp = stackSave(); + try { + dynCall_viiiiiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiijjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + dynCall_viiiiijjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiji(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iiiiiji(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + dynCall_viiiiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_vijjii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_viiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijjiii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viijjiii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiji(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_viiiji(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + dynCall_viiiiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ijii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_ijii(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiijjji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + dynCall_viiiiijjji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijiii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_vijiii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fii(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_fii(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiijiiii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_iiijiiii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiijjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + var sp = stackSave(); + try { + dynCall_viiiiiijjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + var sp = stackSave(); + try { + dynCall_viiiiiiijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiji(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viiiiiji(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fiif(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_fiif(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_dii(index, a1, a2) { + var sp = stackSave(); + try { + return dynCall_dii(index, a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijjjiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + dynCall_viijjjiii(index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_viiiiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijji(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_viijji(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiijijji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiijijji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jiijjiii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_jiijjiii(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_viifiifijjjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + dynCall_viifiifijjjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + dynCall_viiiiifiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + dynCall_vijjiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijiiiiiiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + var sp = stackSave(); + try { + dynCall_vijiiiiiiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) { + var sp = stackSave(); + try { + dynCall_viiijiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiijjj(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viiiijjj(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiijjj(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_viiiiiiijjj(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiiiiiiiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiiiiiiiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + var sp = stackSave(); + try { + dynCall_viiijiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiif(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiiiif(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiif(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_viiif(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiid(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiiiid(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiid(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_viiid(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiidi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiidi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiif(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_iiiiiif(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijij(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_vijij(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijji(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiijji(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiffii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + var sp = stackSave(); + try { + dynCall_viiiiiiffii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iifii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_iifii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiifi(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viiiiifi(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iifjii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iifjii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vidi(index, a1, a2, a3) { + var sp = stackSave(); + try { + dynCall_vidi(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijiji(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + dynCall_viiijiji(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijij(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + dynCall_viiijij(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vijjj(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_vijjj(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiij(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_iiiij(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiif(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_iiif(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fiii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_fiii(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vjiij(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + dynCall_vjiij(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_diii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return dynCall_diii(index, a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_diiiii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_diiiii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_diiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_diiii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiji(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_iiiji(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ijiijji(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return dynCall_ijiijji(index, a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiijjiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + var sp = stackSave(); + try { + dynCall_viiijjiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ijiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_ijiii(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viijjijjjjiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + var sp = stackSave(); + try { + dynCall_viijjijjjjiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ijiiiiji(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + return dynCall_ijiiiiji(index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiifii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiifii(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ijiij(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return dynCall_ijiij(index, a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_j(index) { + var sp = stackSave(); + try { + return dynCall_j(index); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + return 0n; + } +} + +function invoke_iiiiij(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiiiij(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiid(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return dynCall_iiiiid(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +// Argument name here must shadow the `wasmExports` global so +// that it is recognised by metadce and minify-import-export-names +// passes. +function applySignatureConversions(wasmExports) { + // First, make a copy of the incoming exports object + wasmExports = Object.assign({}, wasmExports); + var makeWrapper_pp = f => a0 => f(a0) >>> 0; + var makeWrapper_p = f => () => f() >>> 0; + var makeWrapper_ppp = f => (a0, a1) => f(a0, a1) >>> 0; + wasmExports["rf"] = makeWrapper_pp(wasmExports["rf"]); + wasmExports["Wf"] = makeWrapper_p(wasmExports["Wf"]); + wasmExports["Yf"] = makeWrapper_pp(wasmExports["Yf"]); + wasmExports["Jg"] = makeWrapper_ppp(wasmExports["Jg"]); + wasmExports["Og"] = makeWrapper_pp(wasmExports["Og"]); + wasmExports["Pg"] = makeWrapper_p(wasmExports["Pg"]); + wasmExports["Tg"] = makeWrapper_pp(wasmExports["Tg"]); + return wasmExports; +} + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === +Module["stackSave"] = stackSave; + +Module["stackRestore"] = stackRestore; + +Module["stackAlloc"] = stackAlloc; + +Module["setValue"] = setValue; + +Module["getValue"] = getValue; + +Module["UTF8ToString"] = UTF8ToString; + +Module["stringToUTF8"] = stringToUTF8; + +Module["lengthBytesUTF8"] = lengthBytesUTF8; + +function run() { + if (runDependencies > 0) { + dependenciesFulfilled = run; + return; + } + if ((ENVIRONMENT_IS_PTHREAD)) { + readyPromiseResolve(Module); + initRuntime(); + return; + } + preRun(); + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + dependenciesFulfilled = run; + return; + } + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + readyPromiseResolve(Module); + postRun(); + } + { + doRun(); + } +} + +run(); + +// end include: postamble.js +// include: /home/gs/onnxruntime/onnxruntime/wasm/js_post_js.js +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. +Module["PTR_SIZE"] = 4; + +// end include: /home/gs/onnxruntime/onnxruntime/wasm/js_post_js.js +// include: /home/gs/onnxruntime/onnxruntime/wasm/post-webgpu.js +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. +// This file contains the post-run code for the ORT WebAssembly module. The code in this file will be injected into the +// final module using Emscripten's `--post-js` option. +// This file will only be used in build with flag `--use_webgpu`. +/** + * This function is called only once when initializing the WebGPU backend. + * + * @param {(gpuDevice: GPUDevice) => void} setDefaultDevice A callback function to set the default device. + */ Module["webgpuInit"] = setDefaultDevice => { + /** + * a map from GPUDevice to [deviceId, instanceHandle, deviceHandle] + * + * only stores custom devices (ie. devices created by the user, not the default device created by ORT) + * + * key is the GPUDevice object. + * + * value is a tuple of 3 elements: + * - deviceId: a unique ID for the device. Must be positive integer. + * - instanceHandle: the instance handle(pointer) of the device. + * - deviceHandle: the device handle(pointer) of the device. + * + * @type {WeakMap} + */ const webgpuActiveDevices = new WeakMap; + /** + * a number that is used to assign a unique ID to the next custom device. + */ let webgpuNextDeviceId = 1; + /** + * a function to set the default device. + * + * @type {(gpuDevice: GPUDevice) => void} + */ const webgpuSetDefaultDevice = setDefaultDevice; + /** + * the current device that is being used to create a WebGPU EP inference session. + * + * the value of this variable is only valid during the creation of a WebGPU EP inference session. + * + * @type {GPUDevice|undefined} + */ let webgpuCurrentDevice = undefined; + /** + * the current device ID that is being used to create a WebGPU EP inference session. + * + * the value of this variable is only valid during the creation of a WebGPU EP inference session. + * + * @type {number|undefined} + */ let webgpuCurrentDeviceId = undefined; + /** + * This function is called only when a custom device is used, during preparation of session options. + * + * @param {GPUDevice} device the user provided device object. + * @returns {undefined|[number, number, number]} a tuple of device id, instance handle, and device handle. + */ Module["webgpuRegisterDevice"] = device => { + if (webgpuCurrentDeviceId !== undefined) { + throw new Error("another WebGPU EP inference session is being created."); + } + if (device) { + let deviceInfo = webgpuActiveDevices.get(device); + if (!deviceInfo) { + const instanceHandle = _wgpuCreateInstance(0); + const deviceHandle = WebGPU.importJsDevice(device, instanceHandle); + deviceInfo = [ webgpuNextDeviceId++, instanceHandle, deviceHandle ]; + webgpuActiveDevices.set(device, deviceInfo); + } + // The current device ID is a temporary storage for the device ID to be used in the session that is being created. + // Soon after `webgpuRegisterDevice` (this function) is called, `webgpuOnCreateSession` will be called so that the + // value of `webgpuCurrentDeviceId` is used and reset then. + webgpuCurrentDevice = device; + webgpuCurrentDeviceId = deviceInfo[0]; + return deviceInfo; + } else { + webgpuCurrentDevice = undefined; + webgpuCurrentDeviceId = 0; + return undefined; + } + }; + const webgpuActiveSessions = new Map; + Module["webgpuOnCreateSession"] = sessionHandle => { + if (webgpuCurrentDeviceId === undefined) { + // do nothing if webgpuCurrentDeviceId is undefined. + // this means no WebGPU EP is being created. + return; + } + const deviceId = webgpuCurrentDeviceId; + webgpuCurrentDeviceId = undefined; + if (sessionHandle) { + // when session created successfully + const deviceHandle = _OrtGetWebGpuDevice(deviceId); + webgpuActiveSessions.set(sessionHandle, deviceHandle); + if (deviceId === 0) { + const device = webgpuCurrentDevice ?? WebGPU.getJsObject(deviceHandle); + webgpuSetDefaultDevice(device); + } + } + webgpuCurrentDevice = undefined; + }; + Module["webgpuOnReleaseSession"] = sessionHandle => { + webgpuActiveSessions.delete(sessionHandle); + }; + const gpuBufferMetadataSymbol = Symbol("gpuBufferMetadata"); + Module["webgpuRegisterBuffer"] = (buffer, sessionHandle, bufferHandle) => { + if (bufferHandle) { + // This is a buffer that was created by ORT. Metadata is [bufferHandle, NaN] + buffer[gpuBufferMetadataSymbol] = [ bufferHandle, NaN ]; + return bufferHandle; + } else { + // This is a buffer that was created by the user. Metadata is [bufferHandle, refCount] + const metadata = buffer[gpuBufferMetadataSymbol]; + if (metadata) { + metadata[1]++; + return metadata[0]; + } + const deviceHandle = webgpuActiveSessions.get(sessionHandle); + if (deviceHandle === undefined) { + throw new Error("Invalid session handle passed to webgpuRegisterBuffer"); + } + const bufferHandle = WebGPU.importJsBuffer(buffer, deviceHandle); + buffer[gpuBufferMetadataSymbol] = [ bufferHandle, 1 ]; + return bufferHandle; + } + }; + Module["webgpuUnregisterBuffer"] = buffer => { + const metadata = buffer[gpuBufferMetadataSymbol]; + if (!metadata) { + throw new Error("Buffer is not registered"); + } + metadata[1]--; + // For buffers created by ORT, metadata[1] will always be NaN. This function will not release the buffer. + // Instead, the buffer will be released when user calls `Tensor.dispose()` in JavaScript. + if (metadata[1] === 0) { + _wgpuBufferRelease(metadata[0]); + delete buffer[gpuBufferMetadataSymbol]; + } + }; + Module["webgpuGetBuffer"] = bufferHandle => WebGPU.getJsObject(bufferHandle); + Module["webgpuCreateDownloader"] = (gpuBuffer, bufferSize, sessionHandle) => { + const deviceHandle = webgpuActiveSessions.get(sessionHandle); + if (deviceHandle === undefined) { + throw new Error("Invalid session handle passed to webgpuRegisterBuffer"); + } + const buffer = gpuBuffer; + const device = WebGPU.getJsObject(deviceHandle); + const originalSize = bufferSize; + const size = Math.ceil(Number(originalSize) / 16) * 16; + return async () => { + // prettier-ignore + // the line above is used to force prettier to skip formatting the next statement. + // this is because prettier will remove the quotes around the property names, but we need to keep them + // because otherwise closure compiler may rename them and break the code. + const gpuReadBufferDescriptor = { + "size": size, + "usage": 9 + }; + const gpuReadBuffer = device.createBuffer(gpuReadBufferDescriptor); + try { + const commandEncoder = device.createCommandEncoder(); + commandEncoder.copyBufferToBuffer(buffer, 0, gpuReadBuffer, 0, size); + device.queue.submit([ commandEncoder.finish() ]); + await gpuReadBuffer.mapAsync(GPUMapMode.READ); + const arrayBuffer = gpuReadBuffer.getMappedRange(); + return arrayBuffer.slice(0, originalSize); + } finally { + gpuReadBuffer.destroy(); + } + }; + }; + // Setup a callback function for loading external buffers (model weights). + Module.webgpuUploadExternalBuffer = (bufferHandle, data) => { + const srcArrayBuffer = data.buffer; + const srcOffset = data.byteOffset; + const srcLength = data.byteLength; + const size = Math.ceil(Number(srcLength) / 16) * 16; + const gpuBuffer = WebGPU.getJsObject(bufferHandle); + // get current device + if (!webgpuCurrentDevice) { + const deviceHandle = _OrtGetWebGpuDevice(webgpuCurrentDeviceId); + webgpuCurrentDevice = WebGPU.getJsObject(deviceHandle); + } + // create gpu buffer + // prettier-ignore + // the line above is used to force prettier to skip formatting the next statement. + // this is because prettier will remove the quotes around the property names, but we need to keep them + // because otherwise closure compiler may rename them and break the code. + const gpuBufferForUploadingDescriptor = { + "mappedAtCreation": true, + "size": size, + "usage": 6 + }; + const gpuBufferForUploading = webgpuCurrentDevice.createBuffer(gpuBufferForUploadingDescriptor); + // copy (upload) data + const arrayBuffer = gpuBufferForUploading.getMappedRange(); + new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength)); + gpuBufferForUploading.unmap(); + // GPU copy + const commandEncoder = webgpuCurrentDevice.createCommandEncoder(); + commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuBuffer, 0, size); + webgpuCurrentDevice.queue.submit([ commandEncoder.finish() ]); + gpuBufferForUploading.destroy(); + }; +}; + +// end include: /home/gs/onnxruntime/onnxruntime/wasm/post-webgpu.js +// include: postamble_modularize.js +// In MODULARIZE mode we wrap the generated code in a factory function +// and return either the Module itself, or a promise of the module. +// We assign to the `moduleRtn` global here and configure closure to see +// this as and extern so it won't get minified. +moduleRtn = readyPromise; + + + return moduleRtn; +} +); +})(); +export default ortWasmThreaded; +var isPthread = globalThis.self?.name?.startsWith('em-pthread'); +var isNode = typeof globalThis.process?.versions?.node == 'string'; +if (isNode) isPthread = (await import('worker_threads')).workerData === 'em-pthread'; + +// When running as a pthread, construct a new instance on startup +isPthread && ortWasmThreaded();