@yowasp/openfpgaloader 0.0.0-experimental0

package/gen/bundle.js

@@ -0,0 +1,4902 @@
+// gen/openFPGALoader.mjs
+var instantiate = (() => {
+  var _scriptDir = import.meta.url;
+  return function(moduleArg = {}) {
+    var Module = moduleArg;
+    var readyPromiseResolve, readyPromiseReject;
+    Module["ready"] = new Promise((resolve, reject) => {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+    function assert() {
+    }
+    var moduleOverrides = Object.assign({}, Module);
+    var arguments_ = [];
+    var thisProgram = "./this.program";
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    var ENVIRONMENT_IS_WEB = false;
+    var ENVIRONMENT_IS_WORKER = true;
+    var ENVIRONMENT_IS_NODE = false;
+    var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false;
+    var scriptDirectory = "";
+    function locateFile(path) {
+      return scriptDirectory + path;
+    }
+    var read_, readAsync, readBinary;
+    if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+      if (ENVIRONMENT_IS_WORKER) {
+        scriptDirectory = self.location.href;
+      } else if (typeof document != "undefined" && document.currentScript) {
+        scriptDirectory = document.currentScript.src;
+      }
+      if (_scriptDir) {
+        scriptDirectory = _scriptDir;
+      }
+      if (scriptDirectory.indexOf("blob:") !== 0) {
+        scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
+      } else {
+        scriptDirectory = "";
+      }
+      {
+        read_ = (url) => {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", url, false);
+          xhr.send(null);
+          return xhr.responseText;
+        };
+        if (ENVIRONMENT_IS_WORKER) {
+          readBinary = (url) => {
+            var xhr = new XMLHttpRequest();
+            xhr.open("GET", url, false);
+            xhr.responseType = "arraybuffer";
+            xhr.send(null);
+            return new Uint8Array(xhr.response);
+          };
+        }
+        readAsync = (url, onload, onerror) => {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", url, true);
+          xhr.responseType = "arraybuffer";
+          xhr.onload = () => {
+            if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+              onload(xhr.response);
+              return;
+            }
+            onerror();
+          };
+          xhr.onerror = onerror;
+          xhr.send(null);
+        };
+      }
+    } else {
+    }
+    var out = console.log.bind(console);
+    var err = console.error.bind(console);
+    Object.assign(Module, moduleOverrides);
+    moduleOverrides = null;
+    var wasmBinary;
+    if (typeof WebAssembly != "object") {
+      abort("no native wasm support detected");
+    }
+    var wasmMemory;
+    var wasmModule;
+    var ABORT = false;
+    var EXITSTATUS;
+    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
+    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);
+    }
+    var INITIAL_MEMORY = 33554432;
+    if (ENVIRONMENT_IS_PTHREAD) {
+      wasmMemory = Module["wasmMemory"];
+    } else {
+      {
+        wasmMemory = new WebAssembly.Memory({ "initial": INITIAL_MEMORY / 65536, "maximum": INITIAL_MEMORY / 65536, "shared": true });
+        if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
+          err("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag");
+          if (ENVIRONMENT_IS_NODE) {
+            err("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)");
+          }
+          throw Error("bad memory");
+        }
+      }
+    }
+    updateMemoryViews();
+    INITIAL_MEMORY = wasmMemory.buffer.byteLength;
+    var __ATPRERUN__ = [];
+    var __ATINIT__ = [];
+    var __ATMAIN__ = [];
+    var __ATEXIT__ = [];
+    var __ATPOSTRUN__ = [];
+    var runtimeInitialized = false;
+    var runtimeExited = false;
+    function preRun() {
+      callRuntimeCallbacks(__ATPRERUN__);
+    }
+    function initRuntime() {
+      runtimeInitialized = true;
+      if (ENVIRONMENT_IS_PTHREAD)
+        return;
+      if (!Module["noFSInit"] && !FS.init.initialized)
+        FS.init();
+      FS.ignorePermissions = false;
+      TTY.init();
+      PIPEFS.root = FS.mount(PIPEFS, {}, null);
+      callRuntimeCallbacks(__ATINIT__);
+    }
+    function preMain() {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return;
+      callRuntimeCallbacks(__ATMAIN__);
+    }
+    function exitRuntime() {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return;
+      ___funcs_on_exit();
+      callRuntimeCallbacks(__ATEXIT__);
+      FS.quit();
+      TTY.shutdown();
+      PThread.terminateAllThreads();
+      runtimeExited = true;
+    }
+    function postRun() {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return;
+      callRuntimeCallbacks(__ATPOSTRUN__);
+    }
+    function addOnPreRun(cb) {
+      __ATPRERUN__.unshift(cb);
+    }
+    function addOnInit(cb) {
+      __ATINIT__.unshift(cb);
+    }
+    var runDependencies = 0;
+    var runDependencyWatcher = null;
+    var dependenciesFulfilled = null;
+    function getUniqueRunDependency(id) {
+      return id;
+    }
+    function addRunDependency(id) {
+      runDependencies++;
+    }
+    function removeRunDependency(id) {
+      runDependencies--;
+      if (runDependencies == 0) {
+        if (runDependencyWatcher !== null) {
+          clearInterval(runDependencyWatcher);
+          runDependencyWatcher = null;
+        }
+        if (dependenciesFulfilled) {
+          var callback = dependenciesFulfilled;
+          dependenciesFulfilled = null;
+          callback();
+        }
+      }
+    }
+    function abort(what) {
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      EXITSTATUS = 1;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject(e);
+      throw e;
+    }
+    var dataURIPrefix = "data:application/octet-stream;base64,";
+    var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
+    var wasmBinaryFile;
+    if (Module["locateFile"]) {
+      wasmBinaryFile = "openFPGALoader.wasm";
+      if (!isDataURI(wasmBinaryFile)) {
+        wasmBinaryFile = locateFile(wasmBinaryFile);
+      }
+    } else {
+      wasmBinaryFile = new URL("openFPGALoader.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";
+    }
+    function getBinaryPromise(binaryFile) {
+      if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+        if (typeof fetch == "function") {
+          return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
+            if (!response["ok"]) {
+              throw "failed to load wasm binary file at '" + binaryFile + "'";
+            }
+            return response["arrayBuffer"]();
+          }).catch(() => getBinarySync(binaryFile));
+        }
+      }
+      return Promise.resolve().then(() => getBinarySync(binaryFile));
+    }
+    function instantiateArrayBuffer(binaryFile, imports, receiver) {
+      return getBinaryPromise(binaryFile).then((binary) => WebAssembly.instantiate(binary, imports)).then((instance) => instance).then(receiver, (reason) => {
+        err(`failed to asynchronously prepare wasm: ${reason}`);
+        abort(reason);
+      });
+    }
+    function instantiateAsync(binary, binaryFile, imports, callback) {
+      if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
+        return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
+          var result = WebAssembly.instantiateStreaming(response, imports);
+          return result.then(callback, function(reason) {
+            err(`wasm streaming compile failed: ${reason}`);
+            err("falling back to ArrayBuffer instantiation");
+            return instantiateArrayBuffer(binaryFile, imports, callback);
+          });
+        });
+      }
+      return instantiateArrayBuffer(binaryFile, imports, callback);
+    }
+    function createWasm() {
+      var info = { "a": wasmImports };
+      function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        wasmExports = Asyncify.instrumentWasmExports(wasmExports);
+        registerTLSInit(wasmExports["eb"]);
+        wasmTable = wasmExports["_a"];
+        addOnInit(wasmExports["Za"]);
+        wasmModule = module;
+        removeRunDependency("wasm-instantiate");
+        return wasmExports;
+      }
+      addRunDependency("wasm-instantiate");
+      function receiveInstantiationResult(result) {
+        receiveInstance(result["instance"], result["module"]);
+      }
+      instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
+      return {};
+    }
+    function __asyncjs__em_libusb_wait_async(ptr, expected_value, timeout) {
+      return Asyncify.handleAsync(async () => {
+        await Atomics.waitAsync(HEAP32, ptr >> 2, expected_value, timeout).value;
+      });
+    }
+    function usbi_em_promise_catch(handle) {
+      let promise = Emval.toValue(handle);
+      promise = promise.then((value) => ({ error: 0, value }), (error) => {
+        console.error(error);
+        let errorCode = -99;
+        if (error instanceof DOMException) {
+          const ERROR_CODES = { NetworkError: -1, DataError: -2, TypeMismatchError: -2, IndexSizeError: -2, SecurityError: -3, NotFoundError: -5, InvalidStateError: -6, TimeoutError: -7, AbortError: -10, NotSupportedError: -12 };
+          errorCode = ERROR_CODES[error.name] ?? errorCode;
+        } else if (error instanceof RangeError || error instanceof TypeError) {
+          errorCode = -2;
+        }
+        return { error: errorCode, value: void 0 };
+      });
+      return Emval.toHandle(promise);
+    }
+    function usbi_em_copy_from_dataview(dst, src) {
+      src = Emval.toValue(src);
+      src = new Uint8Array(src.buffer, src.byteOffset, src.byteLength);
+      HEAPU8.set(src, dst);
+    }
+    function usbi_em_device_safe_open_close(device, open) {
+      device = Emval.toValue(device);
+      const symbol = Symbol.for("libusb.open_close_chain");
+      let promiseChain = device[symbol] ?? Promise.resolve(0);
+      device[symbol] = promiseChain = promiseChain.then(async (refCount) => {
+        if (open) {
+          if (!refCount++) {
+            await device.open();
+          }
+        } else {
+          if (!--refCount) {
+            await device.close();
+          }
+        }
+        return refCount;
+      });
+      return Emval.toHandle(promiseChain);
+    }
+    function ExitStatus(status) {
+      this.name = "ExitStatus";
+      this.message = `Program terminated with exit(${status})`;
+      this.status = status;
+    }
+    var terminateWorker = (worker) => {
+      worker.terminate();
+      worker.onmessage = (e) => {
+      };
+    };
+    var killThread = (pthread_ptr) => {
+      var worker = PThread.pthreads[pthread_ptr];
+      delete PThread.pthreads[pthread_ptr];
+      terminateWorker(worker);
+      __emscripten_thread_free_data(pthread_ptr);
+      PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);
+      worker.pthread_ptr = 0;
+    };
+    var cancelThread = (pthread_ptr) => {
+      var worker = PThread.pthreads[pthread_ptr];
+      worker.postMessage({ "cmd": "cancel" });
+    };
+    var cleanupThread = (pthread_ptr) => {
+      var worker = PThread.pthreads[pthread_ptr];
+      PThread.returnWorkerToPool(worker);
+    };
+    var spawnThread = (threadParams) => {
+      var worker = PThread.getNewWorker();
+      if (!worker) {
+        return 6;
+      }
+      PThread.runningWorkers.push(worker);
+      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 };
+      worker.postMessage(msg, threadParams.transferList);
+      return 0;
+    };
+    var runtimeKeepaliveCounter = 0;
+    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+    var PATH = { isAbs: (path) => path.charAt(0) === "/", splitPath: (filename) => {
+      var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+      return splitPathRe.exec(filename).slice(1);
+    }, normalizeArray: (parts, allowAboveRoot) => {
+      var up = 0;
+      for (var i = parts.length - 1; i >= 0; i--) {
+        var last = parts[i];
+        if (last === ".") {
+          parts.splice(i, 1);
+        } else if (last === "..") {
+          parts.splice(i, 1);
+          up++;
+        } else if (up) {
+          parts.splice(i, 1);
+          up--;
+        }
+      }
+      if (allowAboveRoot) {
+        for (; up; up--) {
+          parts.unshift("..");
+        }
+      }
+      return parts;
+    }, normalize: (path) => {
+      var isAbsolute = PATH.isAbs(path), trailingSlash = path.substr(-1) === "/";
+      path = PATH.normalizeArray(path.split("/").filter((p) => !!p), !isAbsolute).join("/");
+      if (!path && !isAbsolute) {
+        path = ".";
+      }
+      if (path && trailingSlash) {
+        path += "/";
+      }
+      return (isAbsolute ? "/" : "") + path;
+    }, dirname: (path) => {
+      var result = PATH.splitPath(path), root = result[0], dir = result[1];
+      if (!root && !dir) {
+        return ".";
+      }
+      if (dir) {
+        dir = dir.substr(0, dir.length - 1);
+      }
+      return root + dir;
+    }, basename: (path) => {
+      if (path === "/")
+        return "/";
+      path = PATH.normalize(path);
+      path = path.replace(/\/$/, "");
+      var lastSlash = path.lastIndexOf("/");
+      if (lastSlash === -1)
+        return path;
+      return path.substr(lastSlash + 1);
+    }, join: function() {
+      var paths = Array.prototype.slice.call(arguments);
+      return PATH.normalize(paths.join("/"));
+    }, join2: (l, r) => PATH.normalize(l + "/" + r) };
+    var initRandomFill = () => {
+      if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
+        return (view) => (view.set(crypto.getRandomValues(new Uint8Array(view.byteLength))), view);
+      } else
+        abort("initRandomDevice");
+    };
+    var randomFill = (view) => (randomFill = initRandomFill())(view);
+    var PATH_FS = { resolve: function() {
+      var resolvedPath = "", resolvedAbsolute = false;
+      for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        var path = i >= 0 ? arguments[i] : FS.cwd();
+        if (typeof path != "string") {
+          throw new TypeError("Arguments to path.resolve must be strings");
+        } else if (!path) {
+          return "";
+        }
+        resolvedPath = path + "/" + resolvedPath;
+        resolvedAbsolute = PATH.isAbs(path);
+      }
+      resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
+      return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+    }, relative: (from, to) => {
+      from = PATH_FS.resolve(from).substr(1);
+      to = PATH_FS.resolve(to).substr(1);
+      function trim(arr) {
+        var start = 0;
+        for (; start < arr.length; start++) {
+          if (arr[start] !== "")
+            break;
+        }
+        var end = arr.length - 1;
+        for (; end >= 0; end--) {
+          if (arr[end] !== "")
+            break;
+        }
+        if (start > end)
+          return [];
+        return arr.slice(start, end - start + 1);
+      }
+      var fromParts = trim(from.split("/"));
+      var toParts = trim(to.split("/"));
+      var length = Math.min(fromParts.length, toParts.length);
+      var samePartsLength = length;
+      for (var i = 0; i < length; i++) {
+        if (fromParts[i] !== toParts[i]) {
+          samePartsLength = i;
+          break;
+        }
+      }
+      var outputParts = [];
+      for (var i = samePartsLength; i < fromParts.length; i++) {
+        outputParts.push("..");
+      }
+      outputParts = outputParts.concat(toParts.slice(samePartsLength));
+      return outputParts.join("/");
+    } };
+    var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
+    var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
+      var endIdx = idx + maxBytesToRead;
+      var endPtr = idx;
+      while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+        ++endPtr;
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.buffer instanceof SharedArrayBuffer ? heapOrArray.slice(idx, endPtr) : heapOrArray.subarray(idx, endPtr));
+      }
+      var str = "";
+      while (idx < endPtr) {
+        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;
+    };
+    var FS_stdin_getChar_buffer = [];
+    var lengthBytesUTF8 = (str) => {
+      var len = 0;
+      for (var i = 0; i < str.length; ++i) {
+        var c = str.charCodeAt(i);
+        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) => {
+      if (!(maxBytesToWrite > 0))
+        return 0;
+      var startIdx = outIdx;
+      var endIdx = outIdx + maxBytesToWrite - 1;
+      for (var i = 0; i < str.length; ++i) {
+        var u = str.charCodeAt(i);
+        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++] = u;
+        } else if (u <= 2047) {
+          if (outIdx + 1 >= endIdx)
+            break;
+          heap[outIdx++] = 192 | u >> 6;
+          heap[outIdx++] = 128 | u & 63;
+        } else if (u <= 65535) {
+          if (outIdx + 2 >= endIdx)
+            break;
+          heap[outIdx++] = 224 | u >> 12;
+          heap[outIdx++] = 128 | u >> 6 & 63;
+          heap[outIdx++] = 128 | u & 63;
+        } else {
+          if (outIdx + 3 >= endIdx)
+            break;
+          heap[outIdx++] = 240 | u >> 18;
+          heap[outIdx++] = 128 | u >> 12 & 63;
+          heap[outIdx++] = 128 | u >> 6 & 63;
+          heap[outIdx++] = 128 | u & 63;
+        }
+      }
+      heap[outIdx] = 0;
+      return outIdx - startIdx;
+    };
+    function intArrayFromString(stringy, dontAddNull, length) {
+      var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+      var u8array = new Array(len);
+      var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+      if (dontAddNull)
+        u8array.length = numBytesWritten;
+      return u8array;
+    }
+    var FS_stdin_getChar = () => {
+      if (!FS_stdin_getChar_buffer.length) {
+        var result = null;
+        if (typeof window != "undefined" && typeof window.prompt == "function") {
+          result = window.prompt("Input: ");
+          if (result !== null) {
+            result += "\n";
+          }
+        } else if (typeof readline == "function") {
+          result = readline();
+          if (result !== null) {
+            result += "\n";
+          }
+        }
+        if (!result) {
+          return null;
+        }
+        FS_stdin_getChar_buffer = intArrayFromString(result, true);
+      }
+      return FS_stdin_getChar_buffer.shift();
+    };
+    var TTY = { ttys: [], init() {
+    }, shutdown() {
+    }, register(dev, ops) {
+      TTY.ttys[dev] = { input: [], output: [], ops };
+      FS.registerDevice(dev, TTY.stream_ops);
+    }, stream_ops: { open(stream) {
+      var tty = TTY.ttys[stream.node.rdev];
+      if (!tty) {
+        throw new FS.ErrnoError(43);
+      }
+      stream.tty = tty;
+      stream.seekable = false;
+    }, close(stream) {
+      stream.tty.ops.fsync(stream.tty);
+    }, fsync(stream) {
+      stream.tty.ops.fsync(stream.tty);
+    }, read(stream, buffer, offset, length, pos) {
+      if (!stream.tty || !stream.tty.ops.get_char) {
+        throw new FS.ErrnoError(60);
+      }
+      var bytesRead = 0;
+      for (var i = 0; i < length; i++) {
+        var result;
+        try {
+          result = stream.tty.ops.get_char(stream.tty);
+        } catch (e) {
+          throw new FS.ErrnoError(29);
+        }
+        if (result === void 0 && bytesRead === 0) {
+          throw new FS.ErrnoError(6);
+        }
+        if (result === null || result === void 0)
+          break;
+        bytesRead++;
+        buffer[offset + i] = result;
+      }
+      if (bytesRead) {
+        stream.node.timestamp = Date.now();
+      }
+      return bytesRead;
+    }, write(stream, buffer, offset, length, pos) {
+      if (!stream.tty || !stream.tty.ops.put_char) {
+        throw new FS.ErrnoError(60);
+      }
+      try {
+        for (var i = 0; i < length; i++) {
+          stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+        }
+      } catch (e) {
+        throw new FS.ErrnoError(29);
+      }
+      if (length) {
+        stream.node.timestamp = Date.now();
+      }
+      return i;
+    } }, default_tty_ops: { get_char(tty) {
+      return FS_stdin_getChar();
+    }, put_char(tty, val) {
+      if (val === null || val === 10) {
+        out(UTF8ArrayToString(tty.output, 0));
+        tty.output = [];
+      } else {
+        if (val != 0)
+          tty.output.push(val);
+      }
+    }, fsync(tty) {
+      if (tty.output && tty.output.length > 0) {
+        out(UTF8ArrayToString(tty.output, 0));
+        tty.output = [];
+      }
+    }, ioctl_tcgets(tty) {
+      return { c_iflag: 25856, c_oflag: 5, c_cflag: 191, c_lflag: 35387, c_cc: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
+    }, ioctl_tcsets(tty, optional_actions, data) {
+      return 0;
+    }, ioctl_tiocgwinsz(tty) {
+      return [24, 80];
+    } }, default_tty1_ops: { put_char(tty, val) {
+      if (val === null || val === 10) {
+        err(UTF8ArrayToString(tty.output, 0));
+        tty.output = [];
+      } else {
+        if (val != 0)
+          tty.output.push(val);
+      }
+    }, fsync(tty) {
+      if (tty.output && tty.output.length > 0) {
+        err(UTF8ArrayToString(tty.output, 0));
+        tty.output = [];
+      }
+    } } };
+    var mmapAlloc = (size) => {
+      abort();
+    };
+    var MEMFS = { ops_table: null, mount(mount) {
+      return MEMFS.createNode(null, "/", 16384 | 511, 0);
+    }, createNode(parent, name, mode, dev) {
+      if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+        throw new FS.ErrnoError(63);
+      }
+      MEMFS.ops_table ||= { dir: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, lookup: MEMFS.node_ops.lookup, mknod: MEMFS.node_ops.mknod, rename: MEMFS.node_ops.rename, unlink: MEMFS.node_ops.unlink, rmdir: MEMFS.node_ops.rmdir, readdir: MEMFS.node_ops.readdir, symlink: MEMFS.node_ops.symlink }, stream: { llseek: MEMFS.stream_ops.llseek } }, file: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: { llseek: MEMFS.stream_ops.llseek, read: MEMFS.stream_ops.read, write: MEMFS.stream_ops.write, allocate: MEMFS.stream_ops.allocate, mmap: MEMFS.stream_ops.mmap, msync: MEMFS.stream_ops.msync } }, link: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, readlink: MEMFS.node_ops.readlink }, stream: {} }, chrdev: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: FS.chrdev_stream_ops } };
+      var node = FS.createNode(parent, name, mode, dev);
+      if (FS.isDir(node.mode)) {
+        node.node_ops = MEMFS.ops_table.dir.node;
+        node.stream_ops = MEMFS.ops_table.dir.stream;
+        node.contents = {};
+      } else if (FS.isFile(node.mode)) {
+        node.node_ops = MEMFS.ops_table.file.node;
+        node.stream_ops = MEMFS.ops_table.file.stream;
+        node.usedBytes = 0;
+        node.contents = null;
+      } else if (FS.isLink(node.mode)) {
+        node.node_ops = MEMFS.ops_table.link.node;
+        node.stream_ops = MEMFS.ops_table.link.stream;
+      } else if (FS.isChrdev(node.mode)) {
+        node.node_ops = MEMFS.ops_table.chrdev.node;
+        node.stream_ops = MEMFS.ops_table.chrdev.stream;
+      }
+      node.timestamp = Date.now();
+      if (parent) {
+        parent.contents[name] = node;
+        parent.timestamp = node.timestamp;
+      }
+      return node;
+    }, getFileDataAsTypedArray(node) {
+      if (!node.contents)
+        return new Uint8Array(0);
+      if (node.contents.subarray)
+        return node.contents.subarray(0, node.usedBytes);
+      return new Uint8Array(node.contents);
+    }, expandFileStorage(node, newCapacity) {
+      var prevCapacity = node.contents ? node.contents.length : 0;
+      if (prevCapacity >= newCapacity)
+        return;
+      var CAPACITY_DOUBLING_MAX = 1024 * 1024;
+      newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
+      if (prevCapacity != 0)
+        newCapacity = Math.max(newCapacity, 256);
+      var oldContents = node.contents;
+      node.contents = new Uint8Array(newCapacity);
+      if (node.usedBytes > 0)
+        node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
+    }, resizeFileStorage(node, newSize) {
+      if (node.usedBytes == newSize)
+        return;
+      if (newSize == 0) {
+        node.contents = null;
+        node.usedBytes = 0;
+      } else {
+        var oldContents = node.contents;
+        node.contents = new Uint8Array(newSize);
+        if (oldContents) {
+          node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
+        }
+        node.usedBytes = newSize;
+      }
+    }, node_ops: { getattr(node) {
+      var attr = {};
+      attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+      attr.ino = node.id;
+      attr.mode = node.mode;
+      attr.nlink = 1;
+      attr.uid = 0;
+      attr.gid = 0;
+      attr.rdev = node.rdev;
+      if (FS.isDir(node.mode)) {
+        attr.size = 4096;
+      } else if (FS.isFile(node.mode)) {
+        attr.size = node.usedBytes;
+      } else if (FS.isLink(node.mode)) {
+        attr.size = node.link.length;
+      } else {
+        attr.size = 0;
+      }
+      attr.atime = new Date(node.timestamp);
+      attr.mtime = new Date(node.timestamp);
+      attr.ctime = new Date(node.timestamp);
+      attr.blksize = 4096;
+      attr.blocks = Math.ceil(attr.size / attr.blksize);
+      return attr;
+    }, setattr(node, attr) {
+      if (attr.mode !== void 0) {
+        node.mode = attr.mode;
+      }
+      if (attr.timestamp !== void 0) {
+        node.timestamp = attr.timestamp;
+      }
+      if (attr.size !== void 0) {
+        MEMFS.resizeFileStorage(node, attr.size);
+      }
+    }, lookup(parent, name) {
+      throw FS.genericErrors[44];
+    }, mknod(parent, name, mode, dev) {
+      return MEMFS.createNode(parent, name, mode, dev);
+    }, rename(old_node, new_dir, new_name) {
+      if (FS.isDir(old_node.mode)) {
+        var new_node;
+        try {
+          new_node = FS.lookupNode(new_dir, new_name);
+        } catch (e) {
+        }
+        if (new_node) {
+          for (var i in new_node.contents) {
+            throw new FS.ErrnoError(55);
+          }
+        }
+      }
+      delete old_node.parent.contents[old_node.name];
+      old_node.parent.timestamp = Date.now();
+      old_node.name = new_name;
+      new_dir.contents[new_name] = old_node;
+      new_dir.timestamp = old_node.parent.timestamp;
+      old_node.parent = new_dir;
+    }, unlink(parent, name) {
+      delete parent.contents[name];
+      parent.timestamp = Date.now();
+    }, rmdir(parent, name) {
+      var node = FS.lookupNode(parent, name);
+      for (var i in node.contents) {
+        throw new FS.ErrnoError(55);
+      }
+      delete parent.contents[name];
+      parent.timestamp = Date.now();
+    }, readdir(node) {
+      var entries = [".", ".."];
+      for (var key of Object.keys(node.contents)) {
+        entries.push(key);
+      }
+      return entries;
+    }, symlink(parent, newname, oldpath) {
+      var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
+      node.link = oldpath;
+      return node;
+    }, readlink(node) {
+      if (!FS.isLink(node.mode)) {
+        throw new FS.ErrnoError(28);
+      }
+      return node.link;
+    } }, stream_ops: { read(stream, buffer, offset, length, position) {
+      var contents = stream.node.contents;
+      if (position >= stream.node.usedBytes)
+        return 0;
+      var size = Math.min(stream.node.usedBytes - position, length);
+      if (size > 8 && contents.subarray) {
+        buffer.set(contents.subarray(position, position + size), offset);
+      } else {
+        for (var i = 0; i < size; i++)
+          buffer[offset + i] = contents[position + i];
+      }
+      return size;
+    }, write(stream, buffer, offset, length, position, canOwn) {
+      if (!length)
+        return 0;
+      var node = stream.node;
+      node.timestamp = Date.now();
+      if (buffer.subarray && (!node.contents || node.contents.subarray)) {
+        if (canOwn) {
+          node.contents = buffer.subarray(offset, offset + length);
+          node.usedBytes = length;
+          return length;
+        } else if (node.usedBytes === 0 && position === 0) {
+          node.contents = buffer.slice(offset, offset + length);
+          node.usedBytes = length;
+          return length;
+        } else if (position + length <= node.usedBytes) {
+          node.contents.set(buffer.subarray(offset, offset + length), position);
+          return length;
+        }
+      }
+      MEMFS.expandFileStorage(node, position + length);
+      if (node.contents.subarray && buffer.subarray) {
+        node.contents.set(buffer.subarray(offset, offset + length), position);
+      } else {
+        for (var i = 0; i < length; i++) {
+          node.contents[position + i] = buffer[offset + i];
+        }
+      }
+      node.usedBytes = Math.max(node.usedBytes, position + length);
+      return length;
+    }, llseek(stream, offset, whence) {
+      var position = offset;
+      if (whence === 1) {
+        position += stream.position;
+      } else if (whence === 2) {
+        if (FS.isFile(stream.node.mode)) {
+          position += stream.node.usedBytes;
+        }
+      }
+      if (position < 0) {
+        throw new FS.ErrnoError(28);
+      }
+      return position;
+    }, allocate(stream, offset, length) {
+      MEMFS.expandFileStorage(stream.node, offset + length);
+      stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
+    }, mmap(stream, length, position, prot, flags) {
+      if (!FS.isFile(stream.node.mode)) {
+        throw new FS.ErrnoError(43);
+      }
+      var ptr;
+      var allocated;
+      var contents = stream.node.contents;
+      if (!(flags & 2) && contents.buffer === HEAP8.buffer) {
+        allocated = false;
+        ptr = contents.byteOffset;
+      } else {
+        if (position > 0 || position + length < contents.length) {
+          if (contents.subarray) {
+            contents = contents.subarray(position, position + length);
+          } else {
+            contents = Array.prototype.slice.call(contents, position, position + length);
+          }
+        }
+        allocated = true;
+        ptr = mmapAlloc(length);
+        if (!ptr) {
+          throw new FS.ErrnoError(48);
+        }
+        HEAP8.set(contents, ptr);
+      }
+      return { ptr, allocated };
+    }, msync(stream, buffer, offset, length, mmapFlags) {
+      MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
+      return 0;
+    } } };
+    var asyncLoad = (url, onload, onerror, noRunDep) => {
+      var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : "";
+      readAsync(url, (arrayBuffer) => {
+        assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
+        onload(new Uint8Array(arrayBuffer));
+        if (dep)
+          removeRunDependency(dep);
+      }, (event) => {
+        if (onerror) {
+          onerror();
+        } else {
+          throw `Loading data file "${url}" failed.`;
+        }
+      });
+      if (dep)
+        addRunDependency(dep);
+    };
+    var FS_createDataFile = (parent, name, fileData, canRead, canWrite, canOwn) => {
+      FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn);
+    };
+    var preloadPlugins = [];
+    var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
+      if (typeof Browser != "undefined")
+        Browser.init();
+      var handled = false;
+      preloadPlugins.forEach((plugin) => {
+        if (handled)
+          return;
+        if (plugin["canHandle"](fullname)) {
+          plugin["handle"](byteArray, fullname, finish, onerror);
+          handled = true;
+        }
+      });
+      return handled;
+    };
+    var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+      var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+      var dep = getUniqueRunDependency(`cp ${fullname}`);
+      function processData(byteArray) {
+        function finish(byteArray2) {
+          preFinish?.();
+          if (!dontCreateFile) {
+            FS_createDataFile(parent, name, byteArray2, canRead, canWrite, canOwn);
+          }
+          onload?.();
+          removeRunDependency(dep);
+        }
+        if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
+          onerror?.();
+          removeRunDependency(dep);
+        })) {
+          return;
+        }
+        finish(byteArray);
+      }
+      addRunDependency(dep);
+      if (typeof url == "string") {
+        asyncLoad(url, (byteArray) => processData(byteArray), onerror);
+      } else {
+        processData(url);
+      }
+    };
+    var FS_modeStringToFlags = (str) => {
+      var flagModes = { "r": 0, "r+": 2, "w": 512 | 64 | 1, "w+": 512 | 64 | 2, "a": 1024 | 64 | 1, "a+": 1024 | 64 | 2 };
+      var flags = flagModes[str];
+      if (typeof flags == "undefined") {
+        throw new Error(`Unknown file open mode: ${str}`);
+      }
+      return flags;
+    };
+    var FS_getMode = (canRead, canWrite) => {
+      var mode = 0;
+      if (canRead)
+        mode |= 292 | 73;
+      if (canWrite)
+        mode |= 146;
+      return mode;
+    };
+    var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, ErrnoError: null, genericErrors: {}, filesystems: null, syncFSRequests: 0, lookupPath(path, opts = {}) {
+      path = PATH_FS.resolve(path);
+      if (!path)
+        return { path: "", node: null };
+      var defaults = { follow_mount: true, recurse_count: 0 };
+      opts = Object.assign(defaults, opts);
+      if (opts.recurse_count > 8) {
+        throw new FS.ErrnoError(32);
+      }
+      var parts = path.split("/").filter((p) => !!p);
+      var current = FS.root;
+      var current_path = "/";
+      for (var i = 0; i < parts.length; i++) {
+        var islast = i === parts.length - 1;
+        if (islast && opts.parent) {
+          break;
+        }
+        current = FS.lookupNode(current, parts[i]);
+        current_path = PATH.join2(current_path, parts[i]);
+        if (FS.isMountpoint(current)) {
+          if (!islast || islast && opts.follow_mount) {
+            current = current.mounted.root;
+          }
+        }
+        if (!islast || opts.follow) {
+          var count = 0;
+          while (FS.isLink(current.mode)) {
+            var link = FS.readlink(current_path);
+            current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
+            var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
+            current = lookup.node;
+            if (count++ > 40) {
+              throw new FS.ErrnoError(32);
+            }
+          }
+        }
+      }
+      return { path: current_path, node: current };
+    }, getPath(node) {
+      var path;
+      while (true) {
+        if (FS.isRoot(node)) {
+          var mount = node.mount.mountpoint;
+          if (!path)
+            return mount;
+          return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
+        }
+        path = path ? `${node.name}/${path}` : node.name;
+        node = node.parent;
+      }
+    }, hashName(parentid, name) {
+      var hash = 0;
+      for (var i = 0; i < name.length; i++) {
+        hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+      }
+      return (parentid + hash >>> 0) % FS.nameTable.length;
+    }, hashAddNode(node) {
+      var hash = FS.hashName(node.parent.id, node.name);
+      node.name_next = FS.nameTable[hash];
+      FS.nameTable[hash] = node;
+    }, hashRemoveNode(node) {
+      var hash = FS.hashName(node.parent.id, node.name);
+      if (FS.nameTable[hash] === node) {
+        FS.nameTable[hash] = node.name_next;
+      } else {
+        var current = FS.nameTable[hash];
+        while (current) {
+          if (current.name_next === node) {
+            current.name_next = node.name_next;
+            break;
+          }
+          current = current.name_next;
+        }
+      }
+    }, lookupNode(parent, name) {
+      var errCode = FS.mayLookup(parent);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode, parent);
+      }
+      var hash = FS.hashName(parent.id, name);
+      for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+        var nodeName = node.name;
+        if (node.parent.id === parent.id && nodeName === name) {
+          return node;
+        }
+      }
+      return FS.lookup(parent, name);
+    }, createNode(parent, name, mode, rdev) {
+      var node = new FS.FSNode(parent, name, mode, rdev);
+      FS.hashAddNode(node);
+      return node;
+    }, destroyNode(node) {
+      FS.hashRemoveNode(node);
+    }, isRoot(node) {
+      return node === node.parent;
+    }, isMountpoint(node) {
+      return !!node.mounted;
+    }, isFile(mode) {
+      return (mode & 61440) === 32768;
+    }, isDir(mode) {
+      return (mode & 61440) === 16384;
+    }, isLink(mode) {
+      return (mode & 61440) === 40960;
+    }, isChrdev(mode) {
+      return (mode & 61440) === 8192;
+    }, isBlkdev(mode) {
+      return (mode & 61440) === 24576;
+    }, isFIFO(mode) {
+      return (mode & 61440) === 4096;
+    }, isSocket(mode) {
+      return (mode & 49152) === 49152;
+    }, flagsToPermissionString(flag) {
+      var perms = ["r", "w", "rw"][flag & 3];
+      if (flag & 512) {
+        perms += "w";
+      }
+      return perms;
+    }, nodePermissions(node, perms) {
+      if (FS.ignorePermissions) {
+        return 0;
+      }
+      if (perms.includes("r") && !(node.mode & 292)) {
+        return 2;
+      } else if (perms.includes("w") && !(node.mode & 146)) {
+        return 2;
+      } else if (perms.includes("x") && !(node.mode & 73)) {
+        return 2;
+      }
+      return 0;
+    }, mayLookup(dir) {
+      var errCode = FS.nodePermissions(dir, "x");
+      if (errCode)
+        return errCode;
+      if (!dir.node_ops.lookup)
+        return 2;
+      return 0;
+    }, mayCreate(dir, name) {
+      try {
+        var node = FS.lookupNode(dir, name);
+        return 20;
+      } catch (e) {
+      }
+      return FS.nodePermissions(dir, "wx");
+    }, mayDelete(dir, name, isdir) {
+      var node;
+      try {
+        node = FS.lookupNode(dir, name);
+      } catch (e) {
+        return e.errno;
+      }
+      var errCode = FS.nodePermissions(dir, "wx");
+      if (errCode) {
+        return errCode;
+      }
+      if (isdir) {
+        if (!FS.isDir(node.mode)) {
+          return 54;
+        }
+        if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+          return 10;
+        }
+      } else {
+        if (FS.isDir(node.mode)) {
+          return 31;
+        }
+      }
+      return 0;
+    }, mayOpen(node, flags) {
+      if (!node) {
+        return 44;
+      }
+      if (FS.isLink(node.mode)) {
+        return 32;
+      } else if (FS.isDir(node.mode)) {
+        if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
+          return 31;
+        }
+      }
+      return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+    }, MAX_OPEN_FDS: 4096, nextfd() {
+      for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
+        if (!FS.streams[fd]) {
+          return fd;
+        }
+      }
+      throw new FS.ErrnoError(33);
+    }, getStreamChecked(fd) {
+      var stream = FS.getStream(fd);
+      if (!stream) {
+        throw new FS.ErrnoError(8);
+      }
+      return stream;
+    }, getStream: (fd) => FS.streams[fd], createStream(stream, fd = -1) {
+      if (!FS.FSStream) {
+        FS.FSStream = function() {
+          this.shared = {};
+        };
+        FS.FSStream.prototype = {};
+        Object.defineProperties(FS.FSStream.prototype, { object: { get() {
+          return this.node;
+        }, set(val) {
+          this.node = val;
+        } }, isRead: { get() {
+          return (this.flags & 2097155) !== 1;
+        } }, isWrite: { get() {
+          return (this.flags & 2097155) !== 0;
+        } }, isAppend: { get() {
+          return this.flags & 1024;
+        } }, flags: { get() {
+          return this.shared.flags;
+        }, set(val) {
+          this.shared.flags = val;
+        } }, position: { get() {
+          return this.shared.position;
+        }, set(val) {
+          this.shared.position = val;
+        } } });
+      }
+      stream = Object.assign(new FS.FSStream(), stream);
+      if (fd == -1) {
+        fd = FS.nextfd();
+      }
+      stream.fd = fd;
+      FS.streams[fd] = stream;
+      return stream;
+    }, closeStream(fd) {
+      FS.streams[fd] = null;
+    }, chrdev_stream_ops: { open(stream) {
+      var device = FS.getDevice(stream.node.rdev);
+      stream.stream_ops = device.stream_ops;
+      stream.stream_ops.open?.(stream);
+    }, llseek() {
+      throw new FS.ErrnoError(70);
+    } }, major: (dev) => dev >> 8, minor: (dev) => dev & 255, makedev: (ma, mi) => ma << 8 | mi, registerDevice(dev, ops) {
+      FS.devices[dev] = { stream_ops: ops };
+    }, getDevice: (dev) => FS.devices[dev], getMounts(mount) {
+      var mounts = [];
+      var check = [mount];
+      while (check.length) {
+        var m = check.pop();
+        mounts.push(m);
+        check.push.apply(check, m.mounts);
+      }
+      return mounts;
+    }, syncfs(populate, callback) {
+      if (typeof populate == "function") {
+        callback = populate;
+        populate = false;
+      }
+      FS.syncFSRequests++;
+      if (FS.syncFSRequests > 1) {
+        err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
+      }
+      var mounts = FS.getMounts(FS.root.mount);
+      var completed = 0;
+      function doCallback(errCode) {
+        FS.syncFSRequests--;
+        return callback(errCode);
+      }
+      function done(errCode) {
+        if (errCode) {
+          if (!done.errored) {
+            done.errored = true;
+            return doCallback(errCode);
+          }
+          return;
+        }
+        if (++completed >= mounts.length) {
+          doCallback(null);
+        }
+      }
+      mounts.forEach((mount) => {
+        if (!mount.type.syncfs) {
+          return done(null);
+        }
+        mount.type.syncfs(mount, populate, done);
+      });
+    }, mount(type, opts, mountpoint) {
+      var root = mountpoint === "/";
+      var pseudo = !mountpoint;
+      var node;
+      if (root && FS.root) {
+        throw new FS.ErrnoError(10);
+      } else if (!root && !pseudo) {
+        var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+        mountpoint = lookup.path;
+        node = lookup.node;
+        if (FS.isMountpoint(node)) {
+          throw new FS.ErrnoError(10);
+        }
+        if (!FS.isDir(node.mode)) {
+          throw new FS.ErrnoError(54);
+        }
+      }
+      var mount = { type, opts, mountpoint, mounts: [] };
+      var mountRoot = type.mount(mount);
+      mountRoot.mount = mount;
+      mount.root = mountRoot;
+      if (root) {
+        FS.root = mountRoot;
+      } else if (node) {
+        node.mounted = mount;
+        if (node.mount) {
+          node.mount.mounts.push(mount);
+        }
+      }
+      return mountRoot;
+    }, unmount(mountpoint) {
+      var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+      if (!FS.isMountpoint(lookup.node)) {
+        throw new FS.ErrnoError(28);
+      }
+      var node = lookup.node;
+      var mount = node.mounted;
+      var mounts = FS.getMounts(mount);
+      Object.keys(FS.nameTable).forEach((hash) => {
+        var current = FS.nameTable[hash];
+        while (current) {
+          var next = current.name_next;
+          if (mounts.includes(current.mount)) {
+            FS.destroyNode(current);
+          }
+          current = next;
+        }
+      });
+      node.mounted = null;
+      var idx = node.mount.mounts.indexOf(mount);
+      node.mount.mounts.splice(idx, 1);
+    }, lookup(parent, name) {
+      return parent.node_ops.lookup(parent, name);
+    }, mknod(path, mode, dev) {
+      var lookup = FS.lookupPath(path, { parent: true });
+      var parent = lookup.node;
+      var name = PATH.basename(path);
+      if (!name || name === "." || name === "..") {
+        throw new FS.ErrnoError(28);
+      }
+      var errCode = FS.mayCreate(parent, name);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      if (!parent.node_ops.mknod) {
+        throw new FS.ErrnoError(63);
+      }
+      return parent.node_ops.mknod(parent, name, mode, dev);
+    }, create(path, mode) {
+      mode = mode !== void 0 ? mode : 438;
+      mode &= 4095;
+      mode |= 32768;
+      return FS.mknod(path, mode, 0);
+    }, mkdir(path, mode) {
+      mode = mode !== void 0 ? mode : 511;
+      mode &= 511 | 512;
+      mode |= 16384;
+      return FS.mknod(path, mode, 0);
+    }, mkdirTree(path, mode) {
+      var dirs = path.split("/");
+      var d = "";
+      for (var i = 0; i < dirs.length; ++i) {
+        if (!dirs[i])
+          continue;
+        d += "/" + dirs[i];
+        try {
+          FS.mkdir(d, mode);
+        } catch (e) {
+          if (e.errno != 20)
+            throw e;
+        }
+      }
+    }, mkdev(path, mode, dev) {
+      if (typeof dev == "undefined") {
+        dev = mode;
+        mode = 438;
+      }
+      mode |= 8192;
+      return FS.mknod(path, mode, dev);
+    }, symlink(oldpath, newpath) {
+      if (!PATH_FS.resolve(oldpath)) {
+        throw new FS.ErrnoError(44);
+      }
+      var lookup = FS.lookupPath(newpath, { parent: true });
+      var parent = lookup.node;
+      if (!parent) {
+        throw new FS.ErrnoError(44);
+      }
+      var newname = PATH.basename(newpath);
+      var errCode = FS.mayCreate(parent, newname);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      if (!parent.node_ops.symlink) {
+        throw new FS.ErrnoError(63);
+      }
+      return parent.node_ops.symlink(parent, newname, oldpath);
+    }, rename(old_path, new_path) {
+      var old_dirname = PATH.dirname(old_path);
+      var new_dirname = PATH.dirname(new_path);
+      var old_name = PATH.basename(old_path);
+      var new_name = PATH.basename(new_path);
+      var lookup, old_dir, new_dir;
+      lookup = FS.lookupPath(old_path, { parent: true });
+      old_dir = lookup.node;
+      lookup = FS.lookupPath(new_path, { parent: true });
+      new_dir = lookup.node;
+      if (!old_dir || !new_dir)
+        throw new FS.ErrnoError(44);
+      if (old_dir.mount !== new_dir.mount) {
+        throw new FS.ErrnoError(75);
+      }
+      var old_node = FS.lookupNode(old_dir, old_name);
+      var relative = PATH_FS.relative(old_path, new_dirname);
+      if (relative.charAt(0) !== ".") {
+        throw new FS.ErrnoError(28);
+      }
+      relative = PATH_FS.relative(new_path, old_dirname);
+      if (relative.charAt(0) !== ".") {
+        throw new FS.ErrnoError(55);
+      }
+      var new_node;
+      try {
+        new_node = FS.lookupNode(new_dir, new_name);
+      } catch (e) {
+      }
+      if (old_node === new_node) {
+        return;
+      }
+      var isdir = FS.isDir(old_node.mode);
+      var errCode = FS.mayDelete(old_dir, old_name, isdir);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      if (!old_dir.node_ops.rename) {
+        throw new FS.ErrnoError(63);
+      }
+      if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
+        throw new FS.ErrnoError(10);
+      }
+      if (new_dir !== old_dir) {
+        errCode = FS.nodePermissions(old_dir, "w");
+        if (errCode) {
+          throw new FS.ErrnoError(errCode);
+        }
+      }
+      FS.hashRemoveNode(old_node);
+      try {
+        old_dir.node_ops.rename(old_node, new_dir, new_name);
+      } catch (e) {
+        throw e;
+      } finally {
+        FS.hashAddNode(old_node);
+      }
+    }, rmdir(path) {
+      var lookup = FS.lookupPath(path, { parent: true });
+      var parent = lookup.node;
+      var name = PATH.basename(path);
+      var node = FS.lookupNode(parent, name);
+      var errCode = FS.mayDelete(parent, name, true);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      if (!parent.node_ops.rmdir) {
+        throw new FS.ErrnoError(63);
+      }
+      if (FS.isMountpoint(node)) {
+        throw new FS.ErrnoError(10);
+      }
+      parent.node_ops.rmdir(parent, name);
+      FS.destroyNode(node);
+    }, readdir(path) {
+      var lookup = FS.lookupPath(path, { follow: true });
+      var node = lookup.node;
+      if (!node.node_ops.readdir) {
+        throw new FS.ErrnoError(54);
+      }
+      return node.node_ops.readdir(node);
+    }, unlink(path) {
+      var lookup = FS.lookupPath(path, { parent: true });
+      var parent = lookup.node;
+      if (!parent) {
+        throw new FS.ErrnoError(44);
+      }
+      var name = PATH.basename(path);
+      var node = FS.lookupNode(parent, name);
+      var errCode = FS.mayDelete(parent, name, false);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      if (!parent.node_ops.unlink) {
+        throw new FS.ErrnoError(63);
+      }
+      if (FS.isMountpoint(node)) {
+        throw new FS.ErrnoError(10);
+      }
+      parent.node_ops.unlink(parent, name);
+      FS.destroyNode(node);
+    }, readlink(path) {
+      var lookup = FS.lookupPath(path);
+      var link = lookup.node;
+      if (!link) {
+        throw new FS.ErrnoError(44);
+      }
+      if (!link.node_ops.readlink) {
+        throw new FS.ErrnoError(28);
+      }
+      return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
+    }, stat(path, dontFollow) {
+      var lookup = FS.lookupPath(path, { follow: !dontFollow });
+      var node = lookup.node;
+      if (!node) {
+        throw new FS.ErrnoError(44);
+      }
+      if (!node.node_ops.getattr) {
+        throw new FS.ErrnoError(63);
+      }
+      return node.node_ops.getattr(node);
+    }, lstat(path) {
+      return FS.stat(path, true);
+    }, chmod(path, mode, dontFollow) {
+      var node;
+      if (typeof path == "string") {
+        var lookup = FS.lookupPath(path, { follow: !dontFollow });
+        node = lookup.node;
+      } else {
+        node = path;
+      }
+      if (!node.node_ops.setattr) {
+        throw new FS.ErrnoError(63);
+      }
+      node.node_ops.setattr(node, { mode: mode & 4095 | node.mode & ~4095, timestamp: Date.now() });
+    }, lchmod(path, mode) {
+      FS.chmod(path, mode, true);
+    }, fchmod(fd, mode) {
+      var stream = FS.getStreamChecked(fd);
+      FS.chmod(stream.node, mode);
+    }, chown(path, uid, gid, dontFollow) {
+      var node;
+      if (typeof path == "string") {
+        var lookup = FS.lookupPath(path, { follow: !dontFollow });
+        node = lookup.node;
+      } else {
+        node = path;
+      }
+      if (!node.node_ops.setattr) {
+        throw new FS.ErrnoError(63);
+      }
+      node.node_ops.setattr(node, { timestamp: Date.now() });
+    }, lchown(path, uid, gid) {
+      FS.chown(path, uid, gid, true);
+    }, fchown(fd, uid, gid) {
+      var stream = FS.getStreamChecked(fd);
+      FS.chown(stream.node, uid, gid);
+    }, truncate(path, len) {
+      if (len < 0) {
+        throw new FS.ErrnoError(28);
+      }
+      var node;
+      if (typeof path == "string") {
+        var lookup = FS.lookupPath(path, { follow: true });
+        node = lookup.node;
+      } else {
+        node = path;
+      }
+      if (!node.node_ops.setattr) {
+        throw new FS.ErrnoError(63);
+      }
+      if (FS.isDir(node.mode)) {
+        throw new FS.ErrnoError(31);
+      }
+      if (!FS.isFile(node.mode)) {
+        throw new FS.ErrnoError(28);
+      }
+      var errCode = FS.nodePermissions(node, "w");
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      node.node_ops.setattr(node, { size: len, timestamp: Date.now() });
+    }, ftruncate(fd, len) {
+      var stream = FS.getStreamChecked(fd);
+      if ((stream.flags & 2097155) === 0) {
+        throw new FS.ErrnoError(28);
+      }
+      FS.truncate(stream.node, len);
+    }, utime(path, atime, mtime) {
+      var lookup = FS.lookupPath(path, { follow: true });
+      var node = lookup.node;
+      node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) });
+    }, open(path, flags, mode) {
+      if (path === "") {
+        throw new FS.ErrnoError(44);
+      }
+      flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
+      mode = typeof mode == "undefined" ? 438 : mode;
+      if (flags & 64) {
+        mode = mode & 4095 | 32768;
+      } else {
+        mode = 0;
+      }
+      var node;
+      if (typeof path == "object") {
+        node = path;
+      } else {
+        path = PATH.normalize(path);
+        try {
+          var lookup = FS.lookupPath(path, { follow: !(flags & 131072) });
+          node = lookup.node;
+        } catch (e) {
+        }
+      }
+      var created = false;
+      if (flags & 64) {
+        if (node) {
+          if (flags & 128) {
+            throw new FS.ErrnoError(20);
+          }
+        } else {
+          node = FS.mknod(path, mode, 0);
+          created = true;
+        }
+      }
+      if (!node) {
+        throw new FS.ErrnoError(44);
+      }
+      if (FS.isChrdev(node.mode)) {
+        flags &= ~512;
+      }
+      if (flags & 65536 && !FS.isDir(node.mode)) {
+        throw new FS.ErrnoError(54);
+      }
+      if (!created) {
+        var errCode = FS.mayOpen(node, flags);
+        if (errCode) {
+          throw new FS.ErrnoError(errCode);
+        }
+      }
+      if (flags & 512 && !created) {
+        FS.truncate(node, 0);
+      }
+      flags &= ~(128 | 512 | 131072);
+      var stream = FS.createStream({ node, path: FS.getPath(node), flags, seekable: true, position: 0, stream_ops: node.stream_ops, ungotten: [], error: false });
+      if (stream.stream_ops.open) {
+        stream.stream_ops.open(stream);
+      }
+      if (Module["logReadFiles"] && !(flags & 1)) {
+        if (!FS.readFiles)
+          FS.readFiles = {};
+        if (!(path in FS.readFiles)) {
+          FS.readFiles[path] = 1;
+        }
+      }
+      return stream;
+    }, close(stream) {
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if (stream.getdents)
+        stream.getdents = null;
+      try {
+        if (stream.stream_ops.close) {
+          stream.stream_ops.close(stream);
+        }
+      } catch (e) {
+        throw e;
+      } finally {
+        FS.closeStream(stream.fd);
+      }
+      stream.fd = null;
+    }, isClosed(stream) {
+      return stream.fd === null;
+    }, llseek(stream, offset, whence) {
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if (!stream.seekable || !stream.stream_ops.llseek) {
+        throw new FS.ErrnoError(70);
+      }
+      if (whence != 0 && whence != 1 && whence != 2) {
+        throw new FS.ErrnoError(28);
+      }
+      stream.position = stream.stream_ops.llseek(stream, offset, whence);
+      stream.ungotten = [];
+      return stream.position;
+    }, read(stream, buffer, offset, length, position) {
+      if (length < 0 || position < 0) {
+        throw new FS.ErrnoError(28);
+      }
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if ((stream.flags & 2097155) === 1) {
+        throw new FS.ErrnoError(8);
+      }
+      if (FS.isDir(stream.node.mode)) {
+        throw new FS.ErrnoError(31);
+      }
+      if (!stream.stream_ops.read) {
+        throw new FS.ErrnoError(28);
+      }
+      var seeking = typeof position != "undefined";
+      if (!seeking) {
+        position = stream.position;
+      } else if (!stream.seekable) {
+        throw new FS.ErrnoError(70);
+      }
+      var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+      if (!seeking)
+        stream.position += bytesRead;
+      return bytesRead;
+    }, write(stream, buffer, offset, length, position, canOwn) {
+      if (length < 0 || position < 0) {
+        throw new FS.ErrnoError(28);
+      }
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if ((stream.flags & 2097155) === 0) {
+        throw new FS.ErrnoError(8);
+      }
+      if (FS.isDir(stream.node.mode)) {
+        throw new FS.ErrnoError(31);
+      }
+      if (!stream.stream_ops.write) {
+        throw new FS.ErrnoError(28);
+      }
+      if (stream.seekable && stream.flags & 1024) {
+        FS.llseek(stream, 0, 2);
+      }
+      var seeking = typeof position != "undefined";
+      if (!seeking) {
+        position = stream.position;
+      } else if (!stream.seekable) {
+        throw new FS.ErrnoError(70);
+      }
+      var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+      if (!seeking)
+        stream.position += bytesWritten;
+      return bytesWritten;
+    }, allocate(stream, offset, length) {
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if (offset < 0 || length <= 0) {
+        throw new FS.ErrnoError(28);
+      }
+      if ((stream.flags & 2097155) === 0) {
+        throw new FS.ErrnoError(8);
+      }
+      if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
+        throw new FS.ErrnoError(43);
+      }
+      if (!stream.stream_ops.allocate) {
+        throw new FS.ErrnoError(138);
+      }
+      stream.stream_ops.allocate(stream, offset, length);
+    }, mmap(stream, length, position, prot, flags) {
+      if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
+        throw new FS.ErrnoError(2);
+      }
+      if ((stream.flags & 2097155) === 1) {
+        throw new FS.ErrnoError(2);
+      }
+      if (!stream.stream_ops.mmap) {
+        throw new FS.ErrnoError(43);
+      }
+      return stream.stream_ops.mmap(stream, length, position, prot, flags);
+    }, msync(stream, buffer, offset, length, mmapFlags) {
+      if (!stream.stream_ops.msync) {
+        return 0;
+      }
+      return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
+    }, munmap: (stream) => 0, ioctl(stream, cmd, arg) {
+      if (!stream.stream_ops.ioctl) {
+        throw new FS.ErrnoError(59);
+      }
+      return stream.stream_ops.ioctl(stream, cmd, arg);
+    }, readFile(path, opts = {}) {
+      opts.flags = opts.flags || 0;
+      opts.encoding = opts.encoding || "binary";
+      if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
+        throw new Error(`Invalid encoding type "${opts.encoding}"`);
+      }
+      var ret;
+      var stream = FS.open(path, opts.flags);
+      var stat = FS.stat(path);
+      var length = stat.size;
+      var buf = new Uint8Array(length);
+      FS.read(stream, buf, 0, length, 0);
+      if (opts.encoding === "utf8") {
+        ret = UTF8ArrayToString(buf, 0);
+      } else if (opts.encoding === "binary") {
+        ret = buf;
+      }
+      FS.close(stream);
+      return ret;
+    }, writeFile(path, data, opts = {}) {
+      opts.flags = opts.flags || 577;
+      var stream = FS.open(path, opts.flags, opts.mode);
+      if (typeof data == "string") {
+        var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
+        var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
+        FS.write(stream, buf, 0, actualNumBytes, void 0, opts.canOwn);
+      } else if (ArrayBuffer.isView(data)) {
+        FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
+      } else {
+        throw new Error("Unsupported data type");
+      }
+      FS.close(stream);
+    }, cwd: () => FS.currentPath, chdir(path) {
+      var lookup = FS.lookupPath(path, { follow: true });
+      if (lookup.node === null) {
+        throw new FS.ErrnoError(44);
+      }
+      if (!FS.isDir(lookup.node.mode)) {
+        throw new FS.ErrnoError(54);
+      }
+      var errCode = FS.nodePermissions(lookup.node, "x");
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      FS.currentPath = lookup.path;
+    }, createDefaultDirectories() {
+      FS.mkdir("/tmp");
+      FS.mkdir("/home");
+      FS.mkdir("/home/web_user");
+    }, createDefaultDevices() {
+      FS.mkdir("/dev");
+      FS.registerDevice(FS.makedev(1, 3), { read: () => 0, write: (stream, buffer, offset, length, pos) => length });
+      FS.mkdev("/dev/null", FS.makedev(1, 3));
+      TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+      TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+      FS.mkdev("/dev/tty", FS.makedev(5, 0));
+      FS.mkdev("/dev/tty1", FS.makedev(6, 0));
+      var randomBuffer = new Uint8Array(1024), randomLeft = 0;
+      var randomByte = () => {
+        if (randomLeft === 0) {
+          randomLeft = randomFill(randomBuffer).byteLength;
+        }
+        return randomBuffer[--randomLeft];
+      };
+      FS.createDevice("/dev", "random", randomByte);
+      FS.createDevice("/dev", "urandom", randomByte);
+      FS.mkdir("/dev/shm");
+      FS.mkdir("/dev/shm/tmp");
+    }, createSpecialDirectories() {
+      FS.mkdir("/proc");
+      var proc_self = FS.mkdir("/proc/self");
+      FS.mkdir("/proc/self/fd");
+      FS.mount({ mount() {
+        var node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
+        node.node_ops = { lookup(parent, name) {
+          var fd = +name;
+          var stream = FS.getStreamChecked(fd);
+          var ret = { parent: null, mount: { mountpoint: "fake" }, node_ops: { readlink: () => stream.path } };
+          ret.parent = ret;
+          return ret;
+        } };
+        return node;
+      } }, {}, "/proc/self/fd");
+    }, createStandardStreams() {
+      if (Module["stdin"]) {
+        FS.createDevice("/dev", "stdin", Module["stdin"]);
+      } else {
+        FS.symlink("/dev/tty", "/dev/stdin");
+      }
+      if (Module["stdout"]) {
+        FS.createDevice("/dev", "stdout", null, Module["stdout"]);
+      } else {
+        FS.symlink("/dev/tty", "/dev/stdout");
+      }
+      if (Module["stderr"]) {
+        FS.createDevice("/dev", "stderr", null, Module["stderr"]);
+      } else {
+        FS.symlink("/dev/tty1", "/dev/stderr");
+      }
+      var stdin = FS.open("/dev/stdin", 0);
+      var stdout = FS.open("/dev/stdout", 1);
+      var stderr = FS.open("/dev/stderr", 1);
+    }, ensureErrnoError() {
+      if (FS.ErrnoError)
+        return;
+      FS.ErrnoError = function ErrnoError(errno, node) {
+        this.name = "ErrnoError";
+        this.node = node;
+        this.setErrno = function(errno2) {
+          this.errno = errno2;
+        };
+        this.setErrno(errno);
+        this.message = "FS error";
+      };
+      FS.ErrnoError.prototype = new Error();
+      FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+      [44].forEach((code) => {
+        FS.genericErrors[code] = new FS.ErrnoError(code);
+        FS.genericErrors[code].stack = "<generic error, no stack>";
+      });
+    }, staticInit() {
+      FS.ensureErrnoError();
+      FS.nameTable = new Array(4096);
+      FS.mount(MEMFS, {}, "/");
+      FS.createDefaultDirectories();
+      FS.createDefaultDevices();
+      FS.createSpecialDirectories();
+      FS.filesystems = { "MEMFS": MEMFS };
+    }, init(input, output, error) {
+      FS.init.initialized = true;
+      FS.ensureErrnoError();
+      Module["stdin"] = input || Module["stdin"];
+      Module["stdout"] = output || Module["stdout"];
+      Module["stderr"] = error || Module["stderr"];
+      FS.createStandardStreams();
+    }, quit() {
+      FS.init.initialized = false;
+      _fflush(0);
+      for (var i = 0; i < FS.streams.length; i++) {
+        var stream = FS.streams[i];
+        if (!stream) {
+          continue;
+        }
+        FS.close(stream);
+      }
+    }, findObject(path, dontResolveLastLink) {
+      var ret = FS.analyzePath(path, dontResolveLastLink);
+      if (!ret.exists) {
+        return null;
+      }
+      return ret.object;
+    }, analyzePath(path, dontResolveLastLink) {
+      try {
+        var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+        path = lookup.path;
+      } catch (e) {
+      }
+      var ret = { isRoot: false, exists: false, error: 0, name: null, path: null, object: null, parentExists: false, parentPath: null, parentObject: null };
+      try {
+        var lookup = FS.lookupPath(path, { parent: true });
+        ret.parentExists = true;
+        ret.parentPath = lookup.path;
+        ret.parentObject = lookup.node;
+        ret.name = PATH.basename(path);
+        lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+        ret.exists = true;
+        ret.path = lookup.path;
+        ret.object = lookup.node;
+        ret.name = lookup.node.name;
+        ret.isRoot = lookup.path === "/";
+      } catch (e) {
+        ret.error = e.errno;
+      }
+      return ret;
+    }, createPath(parent, path, canRead, canWrite) {
+      parent = typeof parent == "string" ? parent : FS.getPath(parent);
+      var parts = path.split("/").reverse();
+      while (parts.length) {
+        var part = parts.pop();
+        if (!part)
+          continue;
+        var current = PATH.join2(parent, part);
+        try {
+          FS.mkdir(current);
+        } catch (e) {
+        }
+        parent = current;
+      }
+      return current;
+    }, createFile(parent, name, properties, canRead, canWrite) {
+      var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+      var mode = FS_getMode(canRead, canWrite);
+      return FS.create(path, mode);
+    }, createDataFile(parent, name, data, canRead, canWrite, canOwn) {
+      var path = name;
+      if (parent) {
+        parent = typeof parent == "string" ? parent : FS.getPath(parent);
+        path = name ? PATH.join2(parent, name) : parent;
+      }
+      var mode = FS_getMode(canRead, canWrite);
+      var node = FS.create(path, mode);
+      if (data) {
+        if (typeof data == "string") {
+          var arr = new Array(data.length);
+          for (var i = 0, len = data.length; i < len; ++i)
+            arr[i] = data.charCodeAt(i);
+          data = arr;
+        }
+        FS.chmod(node, mode | 146);
+        var stream = FS.open(node, 577);
+        FS.write(stream, data, 0, data.length, 0, canOwn);
+        FS.close(stream);
+        FS.chmod(node, mode);
+      }
+    }, createDevice(parent, name, input, output) {
+      var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+      var mode = FS_getMode(!!input, !!output);
+      if (!FS.createDevice.major)
+        FS.createDevice.major = 64;
+      var dev = FS.makedev(FS.createDevice.major++, 0);
+      FS.registerDevice(dev, { open(stream) {
+        stream.seekable = false;
+      }, close(stream) {
+        if (output?.buffer?.length) {
+          output(10);
+        }
+      }, read(stream, buffer, offset, length, pos) {
+        var bytesRead = 0;
+        for (var i = 0; i < length; i++) {
+          var result;
+          try {
+            result = input();
+          } catch (e) {
+            throw new FS.ErrnoError(29);
+          }
+          if (result === void 0 && bytesRead === 0) {
+            throw new FS.ErrnoError(6);
+          }
+          if (result === null || result === void 0)
+            break;
+          bytesRead++;
+          buffer[offset + i] = result;
+        }
+        if (bytesRead) {
+          stream.node.timestamp = Date.now();
+        }
+        return bytesRead;
+      }, write(stream, buffer, offset, length, pos) {
+        for (var i = 0; i < length; i++) {
+          try {
+            output(buffer[offset + i]);
+          } catch (e) {
+            throw new FS.ErrnoError(29);
+          }
+        }
+        if (length) {
+          stream.node.timestamp = Date.now();
+        }
+        return i;
+      } });
+      return FS.mkdev(path, mode, dev);
+    }, forceLoadFile(obj) {
+      if (obj.isDevice || obj.isFolder || obj.link || obj.contents)
+        return true;
+      if (typeof XMLHttpRequest != "undefined") {
+        throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+      } else if (read_) {
+        try {
+          obj.contents = intArrayFromString(read_(obj.url), true);
+          obj.usedBytes = obj.contents.length;
+        } catch (e) {
+          throw new FS.ErrnoError(29);
+        }
+      } else {
+        throw new Error("Cannot load without read() or XMLHttpRequest.");
+      }
+    }, createLazyFile(parent, name, url, canRead, canWrite) {
+      function LazyUint8Array() {
+        this.lengthKnown = false;
+        this.chunks = [];
+      }
+      LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+        if (idx > this.length - 1 || idx < 0) {
+          return void 0;
+        }
+        var chunkOffset = idx % this.chunkSize;
+        var chunkNum = idx / this.chunkSize | 0;
+        return this.getter(chunkNum)[chunkOffset];
+      };
+      LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+        this.getter = getter;
+      };
+      LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+        var xhr = new XMLHttpRequest();
+        xhr.open("HEAD", url, false);
+        xhr.send(null);
+        if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304))
+          throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+        var datalength = Number(xhr.getResponseHeader("Content-length"));
+        var header;
+        var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+        var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
+        var chunkSize = 1024 * 1024;
+        if (!hasByteServing)
+          chunkSize = datalength;
+        var doXHR = (from, to) => {
+          if (from > to)
+            throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+          if (to > datalength - 1)
+            throw new Error("only " + datalength + " bytes available! programmer error!");
+          var xhr2 = new XMLHttpRequest();
+          xhr2.open("GET", url, false);
+          if (datalength !== chunkSize)
+            xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to);
+          xhr2.responseType = "arraybuffer";
+          if (xhr2.overrideMimeType) {
+            xhr2.overrideMimeType("text/plain; charset=x-user-defined");
+          }
+          xhr2.send(null);
+          if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304))
+            throw new Error("Couldn't load " + url + ". Status: " + xhr2.status);
+          if (xhr2.response !== void 0) {
+            return new Uint8Array(xhr2.response || []);
+          }
+          return intArrayFromString(xhr2.responseText || "", true);
+        };
+        var lazyArray2 = this;
+        lazyArray2.setDataGetter((chunkNum) => {
+          var start = chunkNum * chunkSize;
+          var end = (chunkNum + 1) * chunkSize - 1;
+          end = Math.min(end, datalength - 1);
+          if (typeof lazyArray2.chunks[chunkNum] == "undefined") {
+            lazyArray2.chunks[chunkNum] = doXHR(start, end);
+          }
+          if (typeof lazyArray2.chunks[chunkNum] == "undefined")
+            throw new Error("doXHR failed!");
+          return lazyArray2.chunks[chunkNum];
+        });
+        if (usesGzip || !datalength) {
+          chunkSize = datalength = 1;
+          datalength = this.getter(0).length;
+          chunkSize = datalength;
+          out("LazyFiles on gzip forces download of the whole file when length is accessed");
+        }
+        this._length = datalength;
+        this._chunkSize = chunkSize;
+        this.lengthKnown = true;
+      };
+      if (typeof XMLHttpRequest != "undefined") {
+        if (!ENVIRONMENT_IS_WORKER)
+          throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
+        var lazyArray = new LazyUint8Array();
+        Object.defineProperties(lazyArray, { length: { get: function() {
+          if (!this.lengthKnown) {
+            this.cacheLength();
+          }
+          return this._length;
+        } }, chunkSize: { get: function() {
+          if (!this.lengthKnown) {
+            this.cacheLength();
+          }
+          return this._chunkSize;
+        } } });
+        var properties = { isDevice: false, contents: lazyArray };
+      } else {
+        var properties = { isDevice: false, url };
+      }
+      var node = FS.createFile(parent, name, properties, canRead, canWrite);
+      if (properties.contents) {
+        node.contents = properties.contents;
+      } else if (properties.url) {
+        node.contents = null;
+        node.url = properties.url;
+      }
+      Object.defineProperties(node, { usedBytes: { get: function() {
+        return this.contents.length;
+      } } });
+      var stream_ops = {};
+      var keys = Object.keys(node.stream_ops);
+      keys.forEach((key) => {
+        var fn = node.stream_ops[key];
+        stream_ops[key] = function forceLoadLazyFile() {
+          FS.forceLoadFile(node);
+          return fn.apply(null, arguments);
+        };
+      });
+      function writeChunks(stream, buffer, offset, length, position) {
+        var contents = stream.node.contents;
+        if (position >= contents.length)
+          return 0;
+        var size = Math.min(contents.length - position, length);
+        if (contents.slice) {
+          for (var i = 0; i < size; i++) {
+            buffer[offset + i] = contents[position + i];
+          }
+        } else {
+          for (var i = 0; i < size; i++) {
+            buffer[offset + i] = contents.get(position + i);
+          }
+        }
+        return size;
+      }
+      stream_ops.read = (stream, buffer, offset, length, position) => {
+        FS.forceLoadFile(node);
+        return writeChunks(stream, buffer, offset, length, position);
+      };
+      stream_ops.mmap = (stream, length, position, prot, flags) => {
+        FS.forceLoadFile(node);
+        var ptr = mmapAlloc(length);
+        if (!ptr) {
+          throw new FS.ErrnoError(48);
+        }
+        writeChunks(stream, HEAP8, ptr, length, position);
+        return { ptr, allocated: true };
+      };
+      node.stream_ops = stream_ops;
+      return node;
+    } };
+    var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+    var SYSCALLS = { DEFAULT_POLLMASK: 5, calculateAt(dirfd, path, allowEmpty) {
+      if (PATH.isAbs(path)) {
+        return path;
+      }
+      var dir;
+      if (dirfd === -100) {
+        dir = FS.cwd();
+      } else {
+        var dirstream = SYSCALLS.getStreamFromFD(dirfd);
+        dir = dirstream.path;
+      }
+      if (path.length == 0) {
+        if (!allowEmpty) {
+          throw new FS.ErrnoError(44);
+        }
+        return dir;
+      }
+      return PATH.join2(dir, path);
+    }, doStat(func, path, buf) {
+      try {
+        var stat = func(path);
+      } catch (e) {
+        if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
+          return -54;
+        }
+        throw e;
+      }
+      HEAP32[buf >> 2] = stat.dev;
+      HEAP32[buf + 4 >> 2] = stat.mode;
+      HEAPU32[buf + 8 >> 2] = stat.nlink;
+      HEAP32[buf + 12 >> 2] = stat.uid;
+      HEAP32[buf + 16 >> 2] = stat.gid;
+      HEAP32[buf + 20 >> 2] = stat.rdev;
+      HEAP64[buf + 24 >> 3] = BigInt(stat.size);
+      HEAP32[buf + 32 >> 2] = 4096;
+      HEAP32[buf + 36 >> 2] = stat.blocks;
+      var atime = stat.atime.getTime();
+      var mtime = stat.mtime.getTime();
+      var ctime = stat.ctime.getTime();
+      HEAP64[buf + 40 >> 3] = BigInt(Math.floor(atime / 1e3));
+      HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3;
+      HEAP64[buf + 56 >> 3] = BigInt(Math.floor(mtime / 1e3));
+      HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3;
+      HEAP64[buf + 72 >> 3] = BigInt(Math.floor(ctime / 1e3));
+      HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3;
+      HEAP64[buf + 88 >> 3] = BigInt(stat.ino);
+      return 0;
+    }, doMsync(addr, stream, len, flags, offset) {
+      if (!FS.isFile(stream.node.mode)) {
+        throw new FS.ErrnoError(43);
+      }
+      if (flags & 2) {
+        return 0;
+      }
+      var buffer = HEAPU8.slice(addr, addr + len);
+      FS.msync(stream, buffer, offset, len, flags);
+    }, varargs: void 0, get() {
+      var ret = HEAP32[+SYSCALLS.varargs >> 2];
+      SYSCALLS.varargs += 4;
+      return ret;
+    }, getp() {
+      return SYSCALLS.get();
+    }, getStr(ptr) {
+      var ret = UTF8ToString(ptr);
+      return ret;
+    }, getStreamFromFD(fd) {
+      var stream = FS.getStreamChecked(fd);
+      return stream;
+    } };
+    var withStackSave = (f) => {
+      var stack = stackSave();
+      var ret = f();
+      stackRestore(stack);
+      return ret;
+    };
+    var MAX_INT53 = 9007199254740992;
+    var MIN_INT53 = -9007199254740992;
+    var bigintToI53Checked = (num) => num < MIN_INT53 || num > MAX_INT53 ? NaN : Number(num);
+    var proxyToMainThread = function(index, sync) {
+      var numCallArgs = arguments.length - 2;
+      var outerArgs = arguments;
+      return withStackSave(() => {
+        var serializedNumCallArgs = numCallArgs * 2;
+        var args = stackAlloc(serializedNumCallArgs * 8);
+        var b = args >> 3;
+        for (var i = 0; i < numCallArgs; i++) {
+          var arg = outerArgs[2 + i];
+          if (typeof arg == "bigint") {
+            HEAP64[b + 2 * i] = 1n;
+            HEAP64[b + 2 * i + 1] = arg;
+          } else {
+            HEAP64[b + 2 * i] = 0n;
+            HEAPF64[b + 2 * i + 1] = arg;
+          }
+        }
+        return __emscripten_run_on_main_thread_js(index, serializedNumCallArgs, args, sync);
+      });
+    };
+    function _proc_exit(code) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(0, 1, code);
+      EXITSTATUS = code;
+      if (!keepRuntimeAlive()) {
+        PThread.terminateAllThreads();
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    }
+    var exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      if (ENVIRONMENT_IS_PTHREAD) {
+        exitOnMainThread(status);
+        throw "unwind";
+      }
+      if (!keepRuntimeAlive()) {
+        exitRuntime();
+      }
+      _proc_exit(status);
+    };
+    var _exit = exitJS;
+    var handleException = (e) => {
+      if (e instanceof ExitStatus || e == "unwind") {
+        return EXITSTATUS;
+      }
+      quit_(1, e);
+    };
+    var PThread = { unusedWorkers: [], runningWorkers: [], tlsInitFunctions: [], pthreads: {}, init() {
+      if (ENVIRONMENT_IS_PTHREAD) {
+        PThread.initWorker();
+      } else {
+        PThread.initMainThread();
+      }
+    }, initMainThread() {
+      addOnPreRun(() => {
+        addRunDependency("loading-workers");
+        PThread.loadWasmModuleToAllWorkers(() => removeRunDependency("loading-workers"));
+      });
+    }, initWorker() {
+      noExitRuntime = false;
+    }, setExitStatus: (status) => EXITSTATUS = status, terminateAllThreads__deps: ["$terminateWorker"], terminateAllThreads: () => {
+      for (var worker of PThread.runningWorkers) {
+        terminateWorker(worker);
+      }
+      for (var worker of PThread.unusedWorkers) {
+        terminateWorker(worker);
+      }
+      PThread.unusedWorkers = [];
+      PThread.runningWorkers = [];
+      PThread.pthreads = [];
+    }, returnWorkerToPool: (worker) => {
+      var pthread_ptr = worker.pthread_ptr;
+      delete PThread.pthreads[pthread_ptr];
+      PThread.unusedWorkers.push(worker);
+      PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);
+      worker.pthread_ptr = 0;
+      __emscripten_thread_free_data(pthread_ptr);
+    }, receiveObjectTransfer(data) {
+    }, threadInitTLS() {
+      PThread.tlsInitFunctions.forEach((f) => f());
+    }, loadWasmModuleToWorker: (worker) => new Promise((onFinishedLoading) => {
+      worker.onmessage = (e) => {
+        var d = e["data"];
+        var cmd = d["cmd"];
+        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 === "killThread") {
+          killThread(d["thread"]);
+        } else if (cmd === "cancelThread") {
+          cancelThread(d["thread"]);
+        } else if (cmd === "loaded") {
+          worker.loaded = true;
+          onFinishedLoading(worker);
+        } else if (cmd === "alert") {
+          alert(`Thread ${d["threadId"]}: ${d["text"]}`);
+        } else if (d.target === "setimmediate") {
+          worker.postMessage(d);
+        } else if (cmd === "callHandler") {
+          Module[d["handler"]](...d["args"]);
+        } else if (cmd) {
+          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;
+      };
+      var handlers = [];
+      var knownHandlers = [];
+      for (var handler of knownHandlers) {
+        if (Module.hasOwnProperty(handler)) {
+          handlers.push(handler);
+        }
+      }
+      worker.postMessage({ "cmd": "load", "handlers": handlers, "urlOrBlob": Module["mainScriptUrlOrBlob"], "wasmMemory": wasmMemory, "wasmModule": wasmModule });
+    }), loadWasmModuleToAllWorkers(onMaybeReady) {
+      onMaybeReady();
+    }, allocateUnusedWorker() {
+      var worker;
+      if (!Module["locateFile"]) {
+        worker = new Worker(new URL("openFPGALoader.worker.js", import.meta.url), { type: "module" });
+      } else {
+        var pthreadMainJs = locateFile("openFPGALoader.worker.js");
+        worker = new Worker(pthreadMainJs, { type: "module" });
+      }
+      PThread.unusedWorkers.push(worker);
+    }, getNewWorker() {
+      if (PThread.unusedWorkers.length == 0) {
+        PThread.allocateUnusedWorker();
+        PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
+      }
+      return PThread.unusedWorkers.pop();
+    } };
+    Module["PThread"] = PThread;
+    var callRuntimeCallbacks = (callbacks) => {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    };
+    var establishStackSpace = () => {
+      var pthread_ptr = _pthread_self();
+      var stackHigh = HEAPU32[pthread_ptr + 52 >> 2];
+      var stackSize = HEAPU32[pthread_ptr + 56 >> 2];
+      var stackLow = stackHigh - stackSize;
+      _emscripten_stack_set_limits(stackHigh, stackLow);
+      stackRestore(stackHigh);
+    };
+    Module["establishStackSpace"] = establishStackSpace;
+    function exitOnMainThread(returnCode) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(1, 0, returnCode);
+      _exit(returnCode);
+    }
+    var invokeEntryPoint = (ptr, arg) => {
+      runtimeKeepaliveCounter = 0;
+      var result = ((a1) => dynCall_ii.apply(null, [ptr, a1]))(arg);
+      function finish(result2) {
+        if (keepRuntimeAlive()) {
+          PThread.setExitStatus(result2);
+        } else {
+          __emscripten_thread_exit(result2);
+        }
+      }
+      finish(result);
+    };
+    Module["invokeEntryPoint"] = invokeEntryPoint;
+    var noExitRuntime = false;
+    var registerTLSInit = (tlsInitFunc) => PThread.tlsInitFunctions.push(tlsInitFunc);
+    var ___assert_fail = (condition, filename, line, func) => {
+      abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
+    };
+    var exceptionCaught = [];
+    var uncaughtExceptionCount = 0;
+    var ___cxa_begin_catch = (ptr) => {
+      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(info.excPtr);
+      return info.get_exception_ptr();
+    };
+    var exceptionLast = 0;
+    var ___cxa_end_catch = () => {
+      _setThrew(0, 0);
+      var info = exceptionCaught.pop();
+      ___cxa_decrement_exception_refcount(info.excPtr);
+      exceptionLast = 0;
+    };
+    function ExceptionInfo(excPtr) {
+      this.excPtr = excPtr;
+      this.ptr = excPtr - 24;
+      this.set_type = function(type) {
+        HEAPU32[this.ptr + 4 >> 2] = type;
+      };
+      this.get_type = function() {
+        return HEAPU32[this.ptr + 4 >> 2];
+      };
+      this.set_destructor = function(destructor) {
+        HEAPU32[this.ptr + 8 >> 2] = destructor;
+      };
+      this.get_destructor = function() {
+        return HEAPU32[this.ptr + 8 >> 2];
+      };
+      this.set_caught = function(caught) {
+        caught = caught ? 1 : 0;
+        HEAP8[this.ptr + 12 >> 0] = caught;
+      };
+      this.get_caught = function() {
+        return HEAP8[this.ptr + 12 >> 0] != 0;
+      };
+      this.set_rethrown = function(rethrown) {
+        rethrown = rethrown ? 1 : 0;
+        HEAP8[this.ptr + 13 >> 0] = rethrown;
+      };
+      this.get_rethrown = function() {
+        return HEAP8[this.ptr + 13 >> 0] != 0;
+      };
+      this.init = function(type, destructor) {
+        this.set_adjusted_ptr(0);
+        this.set_type(type);
+        this.set_destructor(destructor);
+      };
+      this.set_adjusted_ptr = function(adjustedPtr) {
+        HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
+      };
+      this.get_adjusted_ptr = function() {
+        return HEAPU32[this.ptr + 16 >> 2];
+      };
+      this.get_exception_ptr = function() {
+        var isPointer = ___cxa_is_pointer_type(this.get_type());
+        if (isPointer) {
+          return HEAPU32[this.excPtr >> 2];
+        }
+        var adjusted = this.get_adjusted_ptr();
+        if (adjusted !== 0)
+          return adjusted;
+        return this.excPtr;
+      };
+    }
+    var ___resumeException = (ptr) => {
+      if (!exceptionLast) {
+        exceptionLast = ptr;
+      }
+      throw exceptionLast;
+    };
+    var findMatchingCatch = (args) => {
+      var thrown = exceptionLast;
+      if (!thrown) {
+        setTempRet0(0);
+        return 0;
+      }
+      var info = new ExceptionInfo(thrown);
+      info.set_adjusted_ptr(thrown);
+      var thrownType = info.get_type();
+      if (!thrownType) {
+        setTempRet0(0);
+        return thrown;
+      }
+      for (var arg in args) {
+        var caughtType = args[arg];
+        if (caughtType === 0 || caughtType === thrownType) {
+          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;
+    };
+    var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
+    var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch([arg0]);
+    var ___cxa_find_matching_catch_4 = (arg0, arg1) => findMatchingCatch([arg0, arg1]);
+    var ___cxa_rethrow = () => {
+      var info = exceptionCaught.pop();
+      if (!info) {
+        abort("no exception to throw");
+      }
+      var ptr = info.excPtr;
+      if (!info.get_rethrown()) {
+        exceptionCaught.push(info);
+        info.set_rethrown(true);
+        info.set_caught(false);
+        uncaughtExceptionCount++;
+      }
+      exceptionLast = ptr;
+      throw exceptionLast;
+    };
+    var ___cxa_throw = (ptr, type, destructor) => {
+      var info = new ExceptionInfo(ptr);
+      info.init(type, destructor);
+      exceptionLast = ptr;
+      uncaughtExceptionCount++;
+      throw exceptionLast;
+    };
+    var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
+    var ___emscripten_init_main_thread_js = (tb) => {
+      __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1, !ENVIRONMENT_IS_WEB, 65536, false);
+      PThread.threadInitTLS();
+    };
+    var ___emscripten_thread_cleanup = (thread) => {
+      if (!ENVIRONMENT_IS_PTHREAD)
+        cleanupThread(thread);
+      else
+        postMessage({ "cmd": "cleanupThread", "thread": thread });
+    };
+    function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(2, 1, pthread_ptr, attr, startRoutine, arg);
+      return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg);
+    }
+    var ___pthread_create_js = (pthread_ptr, attr, startRoutine, arg) => {
+      if (typeof SharedArrayBuffer == "undefined") {
+        err("Current environment does not support SharedArrayBuffer, pthreads are not available!");
+        return 6;
+      }
+      var transferList = [];
+      var error = 0;
+      if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
+        return pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg);
+      }
+      if (error)
+        return error;
+      var threadParams = { startRoutine, pthread_ptr, arg, transferList };
+      if (ENVIRONMENT_IS_PTHREAD) {
+        threadParams.cmd = "spawnThread";
+        postMessage(threadParams, transferList);
+        return 0;
+      }
+      return spawnThread(threadParams);
+    };
+    var setErrNo = (value) => {
+      HEAP32[___errno_location() >> 2] = value;
+      return value;
+    };
+    function ___syscall_fcntl64(fd, cmd, varargs) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(3, 1, fd, cmd, varargs);
+      SYSCALLS.varargs = varargs;
+      try {
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        switch (cmd) {
+          case 0: {
+            var arg = SYSCALLS.get();
+            if (arg < 0) {
+              return -28;
+            }
+            while (FS.streams[arg]) {
+              arg++;
+            }
+            var newStream;
+            newStream = FS.createStream(stream, arg);
+            return newStream.fd;
+          }
+          case 1:
+          case 2:
+            return 0;
+          case 3:
+            return stream.flags;
+          case 4: {
+            var arg = SYSCALLS.get();
+            stream.flags |= arg;
+            return 0;
+          }
+          case 5: {
+            var arg = SYSCALLS.getp();
+            var offset = 0;
+            HEAP16[arg + offset >> 1] = 2;
+            return 0;
+          }
+          case 6:
+          case 7:
+            return 0;
+          case 16:
+          case 8:
+            return -28;
+          case 9:
+            setErrNo(28);
+            return -1;
+          default: {
+            return -28;
+          }
+        }
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_ioctl(fd, op, varargs) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(4, 1, fd, op, varargs);
+      SYSCALLS.varargs = varargs;
+      try {
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        switch (op) {
+          case 21509: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          case 21505: {
+            if (!stream.tty)
+              return -59;
+            if (stream.tty.ops.ioctl_tcgets) {
+              var termios = stream.tty.ops.ioctl_tcgets(stream);
+              var argp = SYSCALLS.getp();
+              HEAP32[argp >> 2] = termios.c_iflag || 0;
+              HEAP32[argp + 4 >> 2] = termios.c_oflag || 0;
+              HEAP32[argp + 8 >> 2] = termios.c_cflag || 0;
+              HEAP32[argp + 12 >> 2] = termios.c_lflag || 0;
+              for (var i = 0; i < 32; i++) {
+                HEAP8[argp + i + 17 >> 0] = termios.c_cc[i] || 0;
+              }
+              return 0;
+            }
+            return 0;
+          }
+          case 21510:
+          case 21511:
+          case 21512: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          case 21506:
+          case 21507:
+          case 21508: {
+            if (!stream.tty)
+              return -59;
+            if (stream.tty.ops.ioctl_tcsets) {
+              var argp = SYSCALLS.getp();
+              var c_iflag = HEAP32[argp >> 2];
+              var c_oflag = HEAP32[argp + 4 >> 2];
+              var c_cflag = HEAP32[argp + 8 >> 2];
+              var c_lflag = HEAP32[argp + 12 >> 2];
+              var c_cc = [];
+              for (var i = 0; i < 32; i++) {
+                c_cc.push(HEAP8[argp + i + 17 >> 0]);
+              }
+              return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc });
+            }
+            return 0;
+          }
+          case 21519: {
+            if (!stream.tty)
+              return -59;
+            var argp = SYSCALLS.getp();
+            HEAP32[argp >> 2] = 0;
+            return 0;
+          }
+          case 21520: {
+            if (!stream.tty)
+              return -59;
+            return -28;
+          }
+          case 21531: {
+            var argp = SYSCALLS.getp();
+            return FS.ioctl(stream, op, argp);
+          }
+          case 21523: {
+            if (!stream.tty)
+              return -59;
+            if (stream.tty.ops.ioctl_tiocgwinsz) {
+              var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+              var argp = SYSCALLS.getp();
+              HEAP16[argp >> 1] = winsize[0];
+              HEAP16[argp + 2 >> 1] = winsize[1];
+            }
+            return 0;
+          }
+          case 21524: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          case 21515: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          default:
+            return -28;
+        }
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_openat(dirfd, path, flags, varargs) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(5, 1, dirfd, path, flags, varargs);
+      SYSCALLS.varargs = varargs;
+      try {
+        path = SYSCALLS.getStr(path);
+        path = SYSCALLS.calculateAt(dirfd, path);
+        var mode = varargs ? SYSCALLS.get() : 0;
+        return FS.open(path, flags, mode).fd;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    var PIPEFS = { BUCKET_BUFFER_SIZE: 8192, mount(mount) {
+      return FS.createNode(null, "/", 16384 | 511, 0);
+    }, createPipe() {
+      var pipe = { buckets: [], refcnt: 2 };
+      pipe.buckets.push({ buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: 0, roffset: 0 });
+      var rName = PIPEFS.nextname();
+      var wName = PIPEFS.nextname();
+      var rNode = FS.createNode(PIPEFS.root, rName, 4096, 0);
+      var wNode = FS.createNode(PIPEFS.root, wName, 4096, 0);
+      rNode.pipe = pipe;
+      wNode.pipe = pipe;
+      var readableStream = FS.createStream({ path: rName, node: rNode, flags: 0, seekable: false, stream_ops: PIPEFS.stream_ops });
+      rNode.stream = readableStream;
+      var writableStream = FS.createStream({ path: wName, node: wNode, flags: 1, seekable: false, stream_ops: PIPEFS.stream_ops });
+      wNode.stream = writableStream;
+      return { readable_fd: readableStream.fd, writable_fd: writableStream.fd };
+    }, stream_ops: { poll(stream) {
+      var pipe = stream.node.pipe;
+      if ((stream.flags & 2097155) === 1) {
+        return 256 | 4;
+      }
+      if (pipe.buckets.length > 0) {
+        for (var i = 0; i < pipe.buckets.length; i++) {
+          var bucket = pipe.buckets[i];
+          if (bucket.offset - bucket.roffset > 0) {
+            return 64 | 1;
+          }
+        }
+      }
+      return 0;
+    }, ioctl(stream, request, varargs) {
+      return 28;
+    }, fsync(stream) {
+      return 28;
+    }, read(stream, buffer, offset, length, position) {
+      var pipe = stream.node.pipe;
+      var currentLength = 0;
+      for (var i = 0; i < pipe.buckets.length; i++) {
+        var bucket = pipe.buckets[i];
+        currentLength += bucket.offset - bucket.roffset;
+      }
+      var data = buffer.subarray(offset, offset + length);
+      if (length <= 0) {
+        return 0;
+      }
+      if (currentLength == 0) {
+        throw new FS.ErrnoError(6);
+      }
+      var toRead = Math.min(currentLength, length);
+      var totalRead = toRead;
+      var toRemove = 0;
+      for (var i = 0; i < pipe.buckets.length; i++) {
+        var currBucket = pipe.buckets[i];
+        var bucketSize = currBucket.offset - currBucket.roffset;
+        if (toRead <= bucketSize) {
+          var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset);
+          if (toRead < bucketSize) {
+            tmpSlice = tmpSlice.subarray(0, toRead);
+            currBucket.roffset += toRead;
+          } else {
+            toRemove++;
+          }
+          data.set(tmpSlice);
+          break;
+        } else {
+          var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset);
+          data.set(tmpSlice);
+          data = data.subarray(tmpSlice.byteLength);
+          toRead -= tmpSlice.byteLength;
+          toRemove++;
+        }
+      }
+      if (toRemove && toRemove == pipe.buckets.length) {
+        toRemove--;
+        pipe.buckets[toRemove].offset = 0;
+        pipe.buckets[toRemove].roffset = 0;
+      }
+      pipe.buckets.splice(0, toRemove);
+      return totalRead;
+    }, write(stream, buffer, offset, length, position) {
+      var pipe = stream.node.pipe;
+      var data = buffer.subarray(offset, offset + length);
+      var dataLen = data.byteLength;
+      if (dataLen <= 0) {
+        return 0;
+      }
+      var currBucket = null;
+      if (pipe.buckets.length == 0) {
+        currBucket = { buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: 0, roffset: 0 };
+        pipe.buckets.push(currBucket);
+      } else {
+        currBucket = pipe.buckets[pipe.buckets.length - 1];
+      }
+      assert(currBucket.offset <= PIPEFS.BUCKET_BUFFER_SIZE);
+      var freeBytesInCurrBuffer = PIPEFS.BUCKET_BUFFER_SIZE - currBucket.offset;
+      if (freeBytesInCurrBuffer >= dataLen) {
+        currBucket.buffer.set(data, currBucket.offset);
+        currBucket.offset += dataLen;
+        return dataLen;
+      } else if (freeBytesInCurrBuffer > 0) {
+        currBucket.buffer.set(data.subarray(0, freeBytesInCurrBuffer), currBucket.offset);
+        currBucket.offset += freeBytesInCurrBuffer;
+        data = data.subarray(freeBytesInCurrBuffer, data.byteLength);
+      }
+      var numBuckets = data.byteLength / PIPEFS.BUCKET_BUFFER_SIZE | 0;
+      var remElements = data.byteLength % PIPEFS.BUCKET_BUFFER_SIZE;
+      for (var i = 0; i < numBuckets; i++) {
+        var newBucket = { buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: PIPEFS.BUCKET_BUFFER_SIZE, roffset: 0 };
+        pipe.buckets.push(newBucket);
+        newBucket.buffer.set(data.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE));
+        data = data.subarray(PIPEFS.BUCKET_BUFFER_SIZE, data.byteLength);
+      }
+      if (remElements > 0) {
+        var newBucket = { buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: data.byteLength, roffset: 0 };
+        pipe.buckets.push(newBucket);
+        newBucket.buffer.set(data);
+      }
+      return dataLen;
+    }, close(stream) {
+      var pipe = stream.node.pipe;
+      pipe.refcnt--;
+      if (pipe.refcnt === 0) {
+        pipe.buckets = null;
+      }
+    } }, nextname() {
+      if (!PIPEFS.nextname.current) {
+        PIPEFS.nextname.current = 0;
+      }
+      return "pipe[" + PIPEFS.nextname.current++ + "]";
+    } };
+    function ___syscall_pipe(fdPtr) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(6, 1, fdPtr);
+      try {
+        if (fdPtr == 0) {
+          throw new FS.ErrnoError(21);
+        }
+        var res = PIPEFS.createPipe();
+        HEAP32[fdPtr >> 2] = res.readable_fd;
+        HEAP32[fdPtr + 4 >> 2] = res.writable_fd;
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_poll(fds, nfds, timeout) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(7, 1, fds, nfds, timeout);
+      try {
+        var nonzero = 0;
+        for (var i = 0; i < nfds; i++) {
+          var pollfd = fds + 8 * i;
+          var fd = HEAP32[pollfd >> 2];
+          var events = HEAP16[pollfd + 4 >> 1];
+          var mask = 32;
+          var stream = FS.getStream(fd);
+          if (stream) {
+            mask = SYSCALLS.DEFAULT_POLLMASK;
+            if (stream.stream_ops.poll) {
+              mask = stream.stream_ops.poll(stream, -1);
+            }
+          }
+          mask &= events | 8 | 16;
+          if (mask)
+            nonzero++;
+          HEAP16[pollfd + 6 >> 1] = mask;
+        }
+        return nonzero;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    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 (HEAPU8[c]) {
+        ret += embind_charCodes[HEAPU8[c++]];
+      }
+      return ret;
+    };
+    var awaitingDependencies = {};
+    var registeredTypes = {};
+    var typeDependencies = {};
+    var BindingError;
+    var throwBindingError = (message) => {
+      throw new BindingError(message);
+    };
+    var InternalError;
+    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());
+      }
+    }
+    function registerType(rawType, registeredInstance, options = {}) {
+      if (!("argPackAdvance" in registeredInstance)) {
+        throw new TypeError("registerType registeredInstance requires argPackAdvance");
+      }
+      return sharedRegisterType(rawType, registeredInstance, options);
+    }
+    var integerReadValueFromPointer = (name, width, signed) => {
+      switch (width) {
+        case 1:
+          return signed ? (pointer) => HEAP8[pointer >> 0] : (pointer) => HEAPU8[pointer >> 0];
+        case 2:
+          return signed ? (pointer) => HEAP16[pointer >> 1] : (pointer) => HEAPU16[pointer >> 1];
+        case 4:
+          return signed ? (pointer) => HEAP32[pointer >> 2] : (pointer) => HEAPU32[pointer >> 2];
+        case 8:
+          return signed ? (pointer) => HEAP64[pointer >> 3] : (pointer) => HEAPU64[pointer >> 3];
+        default:
+          throw new TypeError(`invalid integer width (${width}): ${name}`);
+      }
+    };
+    var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
+      name = readLatin1String(name);
+      var isUnsignedType = name.indexOf("u") != -1;
+      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 (value < minRange || value > maxRange) {
+          throw new TypeError(`Passing a number "${embindRepr(value)}" from JS side to C/C++ side to an argument of type "${name}", which is outside the valid range [${minRange}, ${maxRange}]!`);
+        }
+        return value;
+      }, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": integerReadValueFromPointer(name, size, !isUnsignedType), destructorFunction: null });
+    };
+    var GenericWireTypeSize = 8;
+    var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
+      name = readLatin1String(name);
+      registerType(rawType, { name, "fromWireType": function(wt) {
+        return !!wt;
+      }, "toWireType": function(destructors, o) {
+        return o ? trueValue : falseValue;
+      }, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": function(pointer) {
+        return this["fromWireType"](HEAPU8[pointer]);
+      }, destructorFunction: null });
+    };
+    function handleAllocatorInit() {
+      Object.assign(HandleAllocator.prototype, { get(id) {
+        return this.allocated[id];
+      }, has(id) {
+        return this.allocated[id] !== void 0;
+      }, allocate(handle) {
+        var id = this.freelist.pop() || this.allocated.length;
+        this.allocated[id] = handle;
+        return id;
+      }, free(id) {
+        this.allocated[id] = void 0;
+        this.freelist.push(id);
+      } });
+    }
+    function HandleAllocator() {
+      this.allocated = [void 0];
+      this.freelist = [];
+    }
+    var emval_handles = new HandleAllocator();
+    var __emval_decref = (handle) => {
+      if (handle >= emval_handles.reserved && 0 === --emval_handles.get(handle).refcount) {
+        emval_handles.free(handle);
+      }
+    };
+    var count_emval_handles = () => {
+      var count = 0;
+      for (var i = emval_handles.reserved; i < emval_handles.allocated.length; ++i) {
+        if (emval_handles.allocated[i] !== void 0) {
+          ++count;
+        }
+      }
+      return count;
+    };
+    var init_emval = () => {
+      emval_handles.allocated.push({ value: void 0 }, { value: null }, { value: true }, { value: false });
+      emval_handles.reserved = emval_handles.allocated.length;
+      Module["count_emval_handles"] = count_emval_handles;
+    };
+    var Emval = { toValue: (handle) => {
+      if (!handle) {
+        throwBindingError("Cannot use deleted val. handle = " + handle);
+      }
+      return emval_handles.get(handle).value;
+    }, toHandle: (value) => {
+      switch (value) {
+        case void 0:
+          return 1;
+        case null:
+          return 2;
+        case true:
+          return 3;
+        case false:
+          return 4;
+        default: {
+          return emval_handles.allocate({ refcount: 1, value });
+        }
+      }
+    } };
+    function simpleReadValueFromPointer(pointer) {
+      return this["fromWireType"](HEAP32[pointer >> 2]);
+    }
+    var __embind_register_emval = (rawType, name) => {
+      name = readLatin1String(name);
+      registerType(rawType, { name, "fromWireType": (handle) => {
+        var rv = Emval.toValue(handle);
+        __emval_decref(handle);
+        return rv;
+      }, "toWireType": (destructors, value) => Emval.toHandle(value), "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: null });
+    };
+    var floatReadValueFromPointer = (name, width) => {
+      switch (width) {
+        case 4:
+          return function(pointer) {
+            return this["fromWireType"](HEAPF32[pointer >> 2]);
+          };
+        case 8:
+          return function(pointer) {
+            return this["fromWireType"](HEAPF64[pointer >> 3]);
+          };
+        default:
+          throw new TypeError(`invalid float width (${width}): ${name}`);
+      }
+    };
+    var __embind_register_float = (rawType, name, size) => {
+      name = readLatin1String(name);
+      registerType(rawType, { name, "fromWireType": (value) => value, "toWireType": (destructors, value) => value, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": floatReadValueFromPointer(name, size), destructorFunction: null });
+    };
+    var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
+      name = readLatin1String(name);
+      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);
+          return value;
+        };
+      }
+      registerType(primitiveType, { name, "fromWireType": fromWireType, "toWireType": toWireType, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": integerReadValueFromPointer(name, size, minRange !== 0), destructorFunction: null });
+    };
+    var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
+      var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
+      var TA = typeMapping[dataTypeIndex];
+      function decodeMemoryView(handle) {
+        var size = HEAPU32[handle >> 2];
+        var data = HEAPU32[handle + 4 >> 2];
+        return new TA(HEAP8.buffer, data, size);
+      }
+      name = readLatin1String(name);
+      registerType(rawType, { name, "fromWireType": decodeMemoryView, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": decodeMemoryView }, { ignoreDuplicateRegistrations: true });
+    };
+    function readPointer(pointer) {
+      return this["fromWireType"](HEAPU32[pointer >> 2]);
+    }
+    var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+    var __embind_register_std_string = (rawType, name) => {
+      name = readLatin1String(name);
+      var stdStringIsUTF8 = name === "std::string";
+      registerType(rawType, { name, "fromWireType"(value) {
+        var length = HEAPU32[value >> 2];
+        var payload = value + 4;
+        var str;
+        if (stdStringIsUTF8) {
+          var decodeStartPtr = payload;
+          for (var i = 0; i <= length; ++i) {
+            var currentBytePtr = payload + i;
+            if (i == length || HEAPU8[currentBytePtr] == 0) {
+              var maxRead = currentBytePtr - decodeStartPtr;
+              var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+              if (str === void 0) {
+                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(HEAPU8[payload + i]);
+          }
+          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;
+        }
+        var base = _malloc(4 + length + 1);
+        var ptr = base + 4;
+        HEAPU32[base >> 2] = 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(ptr);
+                throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
+              }
+              HEAPU8[ptr + i] = charCode;
+            }
+          } else {
+            for (var i = 0; i < length; ++i) {
+              HEAPU8[ptr + i] = 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") : void 0;
+    var UTF16ToString = (ptr, maxBytesToRead) => {
+      var endPtr = ptr;
+      var idx = endPtr >> 1;
+      var maxIdx = idx + maxBytesToRead / 2;
+      while (!(idx >= maxIdx) && HEAPU16[idx])
+        ++idx;
+      endPtr = idx << 1;
+      if (endPtr - ptr > 32 && UTF16Decoder)
+        return UTF16Decoder.decode(HEAPU8.slice(ptr, endPtr));
+      var str = "";
+      for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
+        var codeUnit = HEAP16[ptr + i * 2 >> 1];
+        if (codeUnit == 0)
+          break;
+        str += String.fromCharCode(codeUnit);
+      }
+      return str;
+    };
+    var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
+      maxBytesToWrite ??= 2147483647;
+      if (maxBytesToWrite < 2)
+        return 0;
+      maxBytesToWrite -= 2;
+      var startPtr = outPtr;
+      var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+      for (var i = 0; i < numCharsToWrite; ++i) {
+        var codeUnit = str.charCodeAt(i);
+        HEAP16[outPtr >> 1] = codeUnit;
+        outPtr += 2;
+      }
+      HEAP16[outPtr >> 1] = 0;
+      return outPtr - startPtr;
+    };
+    var lengthBytesUTF16 = (str) => str.length * 2;
+    var UTF32ToString = (ptr, maxBytesToRead) => {
+      var i = 0;
+      var str = "";
+      while (!(i >= maxBytesToRead / 4)) {
+        var utf32 = HEAP32[ptr + i * 4 >> 2];
+        if (utf32 == 0)
+          break;
+        ++i;
+        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) => {
+      maxBytesToWrite ??= 2147483647;
+      if (maxBytesToWrite < 4)
+        return 0;
+      var startPtr = outPtr;
+      var endPtr = startPtr + maxBytesToWrite - 4;
+      for (var i = 0; i < str.length; ++i) {
+        var codeUnit = str.charCodeAt(i);
+        if (codeUnit >= 55296 && codeUnit <= 57343) {
+          var trailSurrogate = str.charCodeAt(++i);
+          codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
+        }
+        HEAP32[outPtr >> 2] = codeUnit;
+        outPtr += 4;
+        if (outPtr + 4 > endPtr)
+          break;
+      }
+      HEAP32[outPtr >> 2] = 0;
+      return outPtr - startPtr;
+    };
+    var lengthBytesUTF32 = (str) => {
+      var len = 0;
+      for (var i = 0; i < str.length; ++i) {
+        var codeUnit = str.charCodeAt(i);
+        if (codeUnit >= 55296 && codeUnit <= 57343)
+          ++i;
+        len += 4;
+      }
+      return len;
+    };
+    var __embind_register_std_wstring = (rawType, charSize, name) => {
+      name = readLatin1String(name);
+      var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+      if (charSize === 2) {
+        decodeString = UTF16ToString;
+        encodeString = stringToUTF16;
+        lengthBytesUTF = lengthBytesUTF16;
+        getHeap = () => HEAPU16;
+        shift = 1;
+      } else if (charSize === 4) {
+        decodeString = UTF32ToString;
+        encodeString = stringToUTF32;
+        lengthBytesUTF = lengthBytesUTF32;
+        getHeap = () => HEAPU32;
+        shift = 2;
+      }
+      registerType(rawType, { name, "fromWireType": (value) => {
+        var length = HEAPU32[value >> 2];
+        var HEAP = getHeap();
+        var str;
+        var decodeStartPtr = value + 4;
+        for (var i = 0; i <= length; ++i) {
+          var currentBytePtr = value + 4 + i * charSize;
+          if (i == length || HEAP[currentBytePtr >> shift] == 0) {
+            var maxReadBytes = currentBytePtr - decodeStartPtr;
+            var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+            if (str === void 0) {
+              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}`);
+        }
+        var length = lengthBytesUTF(value);
+        var ptr = _malloc(4 + length + charSize);
+        HEAPU32[ptr >> 2] = length >> shift;
+        encodeString(value, ptr + 4, length + charSize);
+        if (destructors !== null) {
+          destructors.push(_free, ptr);
+        }
+        return ptr;
+      }, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction(ptr) {
+        _free(ptr);
+      } });
+    };
+    var __embind_register_void = (rawType, name) => {
+      name = readLatin1String(name);
+      registerType(rawType, { isVoid: true, name, "argPackAdvance": 0, "fromWireType": () => void 0, "toWireType": (destructors, o) => void 0 });
+    };
+    var nowIsMonotonic = 1;
+    var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;
+    var maybeExit = () => {
+      if (runtimeExited) {
+        return;
+      }
+      if (!keepRuntimeAlive()) {
+        try {
+          if (ENVIRONMENT_IS_PTHREAD)
+            __emscripten_thread_exit(EXITSTATUS);
+          else
+            _exit(EXITSTATUS);
+        } catch (e) {
+          handleException(e);
+        }
+      }
+    };
+    var callUserCallback = (func) => {
+      if (runtimeExited || ABORT) {
+        return;
+      }
+      try {
+        func();
+        maybeExit();
+      } catch (e) {
+        handleException(e);
+      }
+    };
+    var __emscripten_thread_mailbox_await = (pthread_ptr) => {
+      if (typeof Atomics.waitAsync === "function") {
+        var wait = Atomics.waitAsync(HEAP32, pthread_ptr >> 2, pthread_ptr);
+        wait.value.then(checkMailbox);
+        var waitingAsync = pthread_ptr + 128;
+        Atomics.store(HEAP32, waitingAsync >> 2, 1);
+      }
+    };
+    Module["__emscripten_thread_mailbox_await"] = __emscripten_thread_mailbox_await;
+    var checkMailbox = () => {
+      var pthread_ptr = _pthread_self();
+      if (pthread_ptr) {
+        __emscripten_thread_mailbox_await(pthread_ptr);
+        callUserCallback(__emscripten_check_mailbox);
+      }
+    };
+    Module["checkMailbox"] = checkMailbox;
+    var __emscripten_notify_mailbox_postmessage = (targetThreadId, currThreadId, mainThreadId) => {
+      if (targetThreadId == currThreadId) {
+        setTimeout(() => checkMailbox());
+      } else if (ENVIRONMENT_IS_PTHREAD) {
+        postMessage({ "targetThread": targetThreadId, "cmd": "checkMailbox" });
+      } else {
+        var worker = PThread.pthreads[targetThreadId];
+        if (!worker) {
+          return;
+        }
+        worker.postMessage({ "cmd": "checkMailbox" });
+      }
+    };
+    var proxiedJSCallArgs = [];
+    var __emscripten_receive_on_main_thread_js = (index, callingThread, numCallArgs, args) => {
+      numCallArgs /= 2;
+      proxiedJSCallArgs.length = numCallArgs;
+      var b = args >> 3;
+      for (var i = 0; i < numCallArgs; i++) {
+        if (HEAP64[b + 2 * i]) {
+          proxiedJSCallArgs[i] = HEAP64[b + 2 * i + 1];
+        } else {
+          proxiedJSCallArgs[i] = HEAPF64[b + 2 * i + 1];
+        }
+      }
+      var func = proxiedFunctionTable[index];
+      PThread.currentProxiedOperationCallerThread = callingThread;
+      var rtn = func.apply(null, proxiedJSCallArgs);
+      PThread.currentProxiedOperationCallerThread = 0;
+      return rtn;
+    };
+    var __emscripten_thread_set_strongref = (thread) => {
+    };
+    var getTypeName = (type) => {
+      var ptr = ___getTypeName(type);
+      var rv = readLatin1String(ptr);
+      _free(ptr);
+      return rv;
+    };
+    var requireRegisteredType = (rawType, humanName) => {
+      var impl = registeredTypes[rawType];
+      if (void 0 === 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) {
+        HEAPU32[destructorsRef >> 2] = Emval.toHandle(destructors);
+      }
+      return result;
+    };
+    var __emval_as = (handle, returnType, destructorsRef) => {
+      handle = Emval.toValue(handle);
+      returnType = requireRegisteredType(returnType, "emval::as");
+      return emval_returnValue(returnType, destructorsRef, 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)) {
+        let sig = original.sig;
+        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] = function() {
+            Asyncify.exportCallStack.push(x);
+            try {
+              return original.apply(null, arguments);
+            } 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: 4096, currData: null, handleSleepReturnValue: 0, exportCallStack: [], callStackNameToId: {}, callStackIdToName: {}, callStackId: 0, asyncPromiseHandlers: null, sleepCallbacks: [], getCallStackId(funcName) {
+      var id = Asyncify.callStackNameToId[funcName];
+      if (id === void 0) {
+        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) {
+        Asyncify.state = Asyncify.State.Normal;
+        runtimeKeepalivePush();
+        runAndAbortIfError(_asyncify_stop_unwind);
+        if (typeof Fibers != "undefined") {
+          Fibers.trampoline();
+        }
+      }
+    }, whenDone() {
+      return new Promise((resolve, reject) => {
+        Asyncify.asyncPromiseHandlers = { resolve, reject };
+      });
+    }, allocateData() {
+      var ptr = _malloc(12 + Asyncify.StackSize);
+      Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize);
+      Asyncify.setDataRewindFunc(ptr);
+      return ptr;
+    }, setDataHeader(ptr, stack, stackSize) {
+      HEAPU32[ptr >> 2] = stack;
+      HEAPU32[ptr + 4 >> 2] = stack + stackSize;
+    }, setDataRewindFunc(ptr) {
+      var bottomOfCallStack = Asyncify.exportCallStack[0];
+      var rewindId = Asyncify.getCallStackId(bottomOfCallStack);
+      HEAP32[ptr + 8 >> 2] = rewindId;
+    }, getDataRewindFunc(ptr) {
+      var id = HEAP32[ptr + 8 >> 2];
+      var name = Asyncify.callStackIdToName[id];
+      var func = wasmExports[name];
+      return func;
+    }, doRewind(ptr) {
+      var start = Asyncify.getDataRewindFunc(ptr);
+      runtimeKeepalivePop();
+      return start();
+    }, handleSleep(startAsync) {
+      if (ABORT)
+        return;
+      if (Asyncify.state === Asyncify.State.Normal) {
+        var reachedCallback = false;
+        var reachedAfterCallback = false;
+        startAsync((handleSleepReturnValue = 0) => {
+          if (ABORT)
+            return;
+          Asyncify.handleSleepReturnValue = handleSleepReturnValue;
+          reachedCallback = true;
+          if (!reachedAfterCallback) {
+            return;
+          }
+          Asyncify.state = Asyncify.State.Rewinding;
+          runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData));
+          if (typeof Browser != "undefined" && Browser.mainLoop.func) {
+            Browser.mainLoop.resume();
+          }
+          var asyncWasmReturnValue, isError = false;
+          try {
+            asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData);
+          } catch (err2) {
+            asyncWasmReturnValue = err2;
+            isError = true;
+          }
+          var handled = false;
+          if (!Asyncify.currData) {
+            var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers;
+            if (asyncPromiseHandlers) {
+              Asyncify.asyncPromiseHandlers = null;
+              (isError ? asyncPromiseHandlers.reject : asyncPromiseHandlers.resolve)(asyncWasmReturnValue);
+              handled = true;
+            }
+          }
+          if (isError && !handled) {
+            throw asyncWasmReturnValue;
+          }
+        });
+        reachedAfterCallback = true;
+        if (!reachedCallback) {
+          Asyncify.state = Asyncify.State.Unwinding;
+          Asyncify.currData = Asyncify.allocateData();
+          if (typeof Browser != "undefined" && Browser.mainLoop.func) {
+            Browser.mainLoop.pause();
+          }
+          runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData));
+        }
+      } else if (Asyncify.state === Asyncify.State.Rewinding) {
+        Asyncify.state = Asyncify.State.Normal;
+        runAndAbortIfError(_asyncify_stop_rewind);
+        _free(Asyncify.currData);
+        Asyncify.currData = null;
+        Asyncify.sleepCallbacks.forEach((func) => callUserCallback(func));
+      } else {
+        abort(`invalid state: ${Asyncify.state}`);
+      }
+      return Asyncify.handleSleepReturnValue;
+    }, handleAsync(startAsync) {
+      return Asyncify.handleSleep((wakeUp) => {
+        startAsync().then(wakeUp);
+      });
+    } };
+    var __emval_await = (promise) => Asyncify.handleAsync(() => {
+      promise = Emval.toValue(promise);
+      return promise.then(Emval.toHandle);
+    });
+    __emval_await.isAsync = true;
+    var emval_methodCallers = [];
+    var __emval_call = (caller, handle, destructorsRef, args) => {
+      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 === void 0) {
+        return readLatin1String(address);
+      }
+      return symbol;
+    };
+    var __emval_call_method = (caller, objHandle, methodName, destructorsRef, args) => {
+      caller = emval_methodCallers[caller];
+      objHandle = Emval.toValue(objHandle);
+      methodName = getStringOrSymbol(methodName);
+      return caller(objHandle, objHandle[methodName], destructorsRef, args);
+    };
+    var __emval_coro_make_promise = (resolveHandlePtr, rejectHandlePtr) => Emval.toHandle(new Promise((resolve, reject) => {
+      const rejectWithCurrentException = () => {
+        try {
+          ___cxa_rethrow();
+        } catch (e) {
+          reject(e);
+        }
+      };
+      HEAPU32[resolveHandlePtr >> 2] = Emval.toHandle(resolve);
+      HEAPU32[rejectHandlePtr >> 2] = Emval.toHandle(rejectWithCurrentException);
+    }));
+    var __emval_coro_suspend = (promiseHandle, awaiterPtr) => {
+      Emval.toValue(promiseHandle).then((result) => {
+        __emval_coro_resume(awaiterPtr, Emval.toHandle(result));
+      });
+    };
+    var emval_get_global = () => {
+      if (typeof globalThis == "object") {
+        return globalThis;
+      }
+      return (/* @__PURE__ */ function() {
+        return Function;
+      }())("return this")();
+    };
+    var __emval_get_global = (name) => {
+      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(HEAPU32[argTypes + i * 4 >> 2], "parameter " + i);
+      }
+      return a;
+    };
+    var createNamedFunction = (name, body) => Object.defineProperty(body, "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`);
+      }
+      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;
+    }
+    var __emval_get_method_caller = (argCount, argTypes, kind) => {
+      var types = emval_lookupTypes(argCount, argTypes);
+      var retType = types.shift();
+      argCount--;
+      var functionBody = `return function (obj, func, destructorsRef, args) {
+`;
+      var offset = 0;
+      var argsList = [];
+      if (kind === 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 : ""});
+`;
+        offset += types[i]["argPackAdvance"];
+      }
+      var invoker = kind === 1 ? "new func" : "func.call";
+      functionBody += `  var rv = ${invoker}(${argsList.join(", ")});
+`;
+      for (var i = 0; i < argCount; ++i) {
+        if (types[i]["deleteObject"]) {
+          functionBody += `  argType${i}.deleteObject(arg${i});
+`;
+        }
+      }
+      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).apply(null, args);
+      var functionName = `methodCaller<(${types.map((t) => t.name).join(", ")}) => ${retType.name}>`;
+      return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+    };
+    var __emval_get_property = (handle, key) => {
+      handle = Emval.toValue(handle);
+      key = Emval.toValue(key);
+      return Emval.toHandle(handle[key]);
+    };
+    var __emval_incref = (handle) => {
+      if (handle > 4) {
+        emval_handles.get(handle).refcount += 1;
+      }
+    };
+    var __emval_iter_begin = (iterable) => {
+      iterable = Emval.toValue(iterable);
+      return Emval.toHandle(iterable[Symbol.iterator]());
+    };
+    var __emval_iter_next = (iterator) => {
+      iterator = Emval.toValue(iterator);
+      var result = iterator.next();
+      return result.done ? 0 : Emval.toHandle(result.value);
+    };
+    var __emval_new_cstring = (v) => Emval.toHandle(getStringOrSymbol(v));
+    var __emval_new_object = () => Emval.toHandle({});
+    var runDestructors = (destructors) => {
+      while (destructors.length) {
+        var ptr = destructors.pop();
+        var del = destructors.pop();
+        del(ptr);
+      }
+    };
+    var __emval_run_destructors = (handle) => {
+      var destructors = Emval.toValue(handle);
+      runDestructors(destructors);
+      __emval_decref(handle);
+    };
+    var __emval_set_property = (handle, key, value) => {
+      handle = Emval.toValue(handle);
+      key = Emval.toValue(key);
+      value = Emval.toValue(value);
+      handle[key] = value;
+    };
+    var __emval_take_value = (type, arg) => {
+      type = requireRegisteredType(type, "_emval_take_value");
+      var v = type["readValueFromPointer"](arg);
+      return Emval.toHandle(v);
+    };
+    var _abort = () => {
+      abort("");
+    };
+    var warnOnce = (text) => {
+      warnOnce.shown ||= {};
+      if (!warnOnce.shown[text]) {
+        warnOnce.shown[text] = 1;
+        err(text);
+      }
+    };
+    var _emscripten_check_blocking_allowed = () => {
+    };
+    var _emscripten_date_now = () => Date.now();
+    var _emscripten_exit_with_live_runtime = () => {
+      runtimeKeepalivePush();
+      throw "unwind";
+    };
+    var _emscripten_get_now;
+    _emscripten_get_now = () => performance.timeOrigin + performance.now();
+    var abortOnCannotGrowMemory = (requestedSize) => {
+      abort("OOM");
+    };
+    var _emscripten_resize_heap = (requestedSize) => {
+      var oldSize = HEAPU8.length;
+      requestedSize >>>= 0;
+      abortOnCannotGrowMemory(requestedSize);
+    };
+    var ENV = {};
+    var getExecutableName = () => thisProgram || "./this.program";
+    var getEnvStrings = () => {
+      if (!getEnvStrings.strings) {
+        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() };
+        for (var x in ENV) {
+          if (ENV[x] === void 0)
+            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) {
+        HEAP8[buffer++ >> 0] = str.charCodeAt(i);
+      }
+      HEAP8[buffer >> 0] = 0;
+    };
+    var _environ_get = function(__environ, environ_buf) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(8, 1, __environ, environ_buf);
+      var bufSize = 0;
+      getEnvStrings().forEach((string, i) => {
+        var ptr = environ_buf + bufSize;
+        HEAPU32[__environ + i * 4 >> 2] = 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(9, 1, penviron_count, penviron_buf_size);
+      var strings = getEnvStrings();
+      HEAPU32[penviron_count >> 2] = strings.length;
+      var bufSize = 0;
+      strings.forEach((string) => bufSize += string.length + 1);
+      HEAPU32[penviron_buf_size >> 2] = bufSize;
+      return 0;
+    };
+    function _fd_close(fd) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(10, 1, fd);
+      try {
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        FS.close(stream);
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return e.errno;
+      }
+    }
+    function _fd_fdstat_get(fd, pbuf) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(11, 1, fd, pbuf);
+      try {
+        var rightsBase = 0;
+        var rightsInheriting = 0;
+        var flags = 0;
+        {
+          var stream = SYSCALLS.getStreamFromFD(fd);
+          var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
+        }
+        HEAP8[pbuf >> 0] = type;
+        HEAP16[pbuf + 2 >> 1] = flags;
+        HEAP64[pbuf + 8 >> 3] = BigInt(rightsBase);
+        HEAP64[pbuf + 16 >> 3] = BigInt(rightsInheriting);
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return e.errno;
+      }
+    }
+    var doReadv = (stream, iov, iovcnt, offset) => {
+      var ret = 0;
+      for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[iov + 4 >> 2];
+        iov += 8;
+        var curr = FS.read(stream, HEAP8, ptr, len, offset);
+        if (curr < 0)
+          return -1;
+        ret += curr;
+        if (curr < len)
+          break;
+        if (typeof offset !== "undefined") {
+          offset += curr;
+        }
+      }
+      return ret;
+    };
+    function _fd_read(fd, iov, iovcnt, pnum) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(12, 1, fd, iov, iovcnt, pnum);
+      try {
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        var num = doReadv(stream, iov, iovcnt);
+        HEAPU32[pnum >> 2] = num;
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return e.errno;
+      }
+    }
+    function _fd_seek(fd, offset, whence, newOffset) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(13, 1, fd, offset, whence, newOffset);
+      offset = bigintToI53Checked(offset);
+      try {
+        if (isNaN(offset))
+          return 61;
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        FS.llseek(stream, offset, whence);
+        HEAP64[newOffset >> 3] = BigInt(stream.position);
+        if (stream.getdents && offset === 0 && whence === 0)
+          stream.getdents = null;
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return e.errno;
+      }
+    }
+    var doWritev = (stream, iov, iovcnt, offset) => {
+      var ret = 0;
+      for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[iov + 4 >> 2];
+        iov += 8;
+        var curr = FS.write(stream, HEAP8, ptr, len, offset);
+        if (curr < 0)
+          return -1;
+        ret += curr;
+        if (typeof offset !== "undefined") {
+          offset += curr;
+        }
+      }
+      return ret;
+    };
+    function _fd_write(fd, iov, iovcnt, pnum) {
+      if (ENVIRONMENT_IS_PTHREAD)
+        return proxyToMainThread(14, 1, fd, iov, iovcnt, pnum);
+      try {
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        var num = doWritev(stream, iov, iovcnt);
+        HEAPU32[pnum >> 2] = num;
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return e.errno;
+      }
+    }
+    var _llvm_eh_typeid_for = (type) => type;
+    var isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    var arraySum = (array, index) => {
+      var sum = 0;
+      for (var i = 0; i <= index; sum += array[i++]) {
+      }
+      return sum;
+    };
+    var MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    var MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    var addDays = (date, days) => {
+      var newDate = new Date(date.getTime());
+      while (days > 0) {
+        var leap = isLeapYear(newDate.getFullYear());
+        var currentMonth = newDate.getMonth();
+        var daysInCurrentMonth = (leap ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR)[currentMonth];
+        if (days > daysInCurrentMonth - newDate.getDate()) {
+          days -= daysInCurrentMonth - newDate.getDate() + 1;
+          newDate.setDate(1);
+          if (currentMonth < 11) {
+            newDate.setMonth(currentMonth + 1);
+          } else {
+            newDate.setMonth(0);
+            newDate.setFullYear(newDate.getFullYear() + 1);
+          }
+        } else {
+          newDate.setDate(newDate.getDate() + days);
+          return newDate;
+        }
+      }
+      return newDate;
+    };
+    var writeArrayToMemory = (array, buffer) => {
+      HEAP8.set(array, buffer);
+    };
+    var _strftime = (s, maxsize, format, tm) => {
+      var tm_zone = HEAPU32[tm + 40 >> 2];
+      var date = { tm_sec: HEAP32[tm >> 2], tm_min: HEAP32[tm + 4 >> 2], tm_hour: HEAP32[tm + 8 >> 2], tm_mday: HEAP32[tm + 12 >> 2], tm_mon: HEAP32[tm + 16 >> 2], tm_year: HEAP32[tm + 20 >> 2], tm_wday: HEAP32[tm + 24 >> 2], tm_yday: HEAP32[tm + 28 >> 2], tm_isdst: HEAP32[tm + 32 >> 2], tm_gmtoff: HEAP32[tm + 36 >> 2], tm_zone: tm_zone ? UTF8ToString(tm_zone) : "" };
+      var pattern = UTF8ToString(format);
+      var EXPANSION_RULES_1 = { "%c": "%a %b %d %H:%M:%S %Y", "%D": "%m/%d/%y", "%F": "%Y-%m-%d", "%h": "%b", "%r": "%I:%M:%S %p", "%R": "%H:%M", "%T": "%H:%M:%S", "%x": "%m/%d/%y", "%X": "%H:%M:%S", "%Ec": "%c", "%EC": "%C", "%Ex": "%m/%d/%y", "%EX": "%H:%M:%S", "%Ey": "%y", "%EY": "%Y", "%Od": "%d", "%Oe": "%e", "%OH": "%H", "%OI": "%I", "%Om": "%m", "%OM": "%M", "%OS": "%S", "%Ou": "%u", "%OU": "%U", "%OV": "%V", "%Ow": "%w", "%OW": "%W", "%Oy": "%y" };
+      for (var rule in EXPANSION_RULES_1) {
+        pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
+      }
+      var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+      var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+      function leadingSomething(value, digits, character) {
+        var str = typeof value == "number" ? value.toString() : value || "";
+        while (str.length < digits) {
+          str = character[0] + str;
+        }
+        return str;
+      }
+      function leadingNulls(value, digits) {
+        return leadingSomething(value, digits, "0");
+      }
+      function compareByDay(date1, date2) {
+        function sgn(value) {
+          return value < 0 ? -1 : value > 0 ? 1 : 0;
+        }
+        var compare;
+        if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
+          if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
+            compare = sgn(date1.getDate() - date2.getDate());
+          }
+        }
+        return compare;
+      }
+      function getFirstWeekStartDate(janFourth) {
+        switch (janFourth.getDay()) {
+          case 0:
+            return new Date(janFourth.getFullYear() - 1, 11, 29);
+          case 1:
+            return janFourth;
+          case 2:
+            return new Date(janFourth.getFullYear(), 0, 3);
+          case 3:
+            return new Date(janFourth.getFullYear(), 0, 2);
+          case 4:
+            return new Date(janFourth.getFullYear(), 0, 1);
+          case 5:
+            return new Date(janFourth.getFullYear() - 1, 11, 31);
+          case 6:
+            return new Date(janFourth.getFullYear() - 1, 11, 30);
+        }
+      }
+      function getWeekBasedYear(date2) {
+        var thisDate = addDays(new Date(date2.tm_year + 1900, 0, 1), date2.tm_yday);
+        var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
+        var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
+        var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+        var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+        if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
+          if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
+            return thisDate.getFullYear() + 1;
+          }
+          return thisDate.getFullYear();
+        }
+        return thisDate.getFullYear() - 1;
+      }
+      var EXPANSION_RULES_2 = { "%a": (date2) => WEEKDAYS[date2.tm_wday].substring(0, 3), "%A": (date2) => WEEKDAYS[date2.tm_wday], "%b": (date2) => MONTHS[date2.tm_mon].substring(0, 3), "%B": (date2) => MONTHS[date2.tm_mon], "%C": (date2) => {
+        var year = date2.tm_year + 1900;
+        return leadingNulls(year / 100 | 0, 2);
+      }, "%d": (date2) => leadingNulls(date2.tm_mday, 2), "%e": (date2) => leadingSomething(date2.tm_mday, 2, " "), "%g": (date2) => getWeekBasedYear(date2).toString().substring(2), "%G": (date2) => getWeekBasedYear(date2), "%H": (date2) => leadingNulls(date2.tm_hour, 2), "%I": (date2) => {
+        var twelveHour = date2.tm_hour;
+        if (twelveHour == 0)
+          twelveHour = 12;
+        else if (twelveHour > 12)
+          twelveHour -= 12;
+        return leadingNulls(twelveHour, 2);
+      }, "%j": (date2) => leadingNulls(date2.tm_mday + arraySum(isLeapYear(date2.tm_year + 1900) ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR, date2.tm_mon - 1), 3), "%m": (date2) => leadingNulls(date2.tm_mon + 1, 2), "%M": (date2) => leadingNulls(date2.tm_min, 2), "%n": () => "\n", "%p": (date2) => {
+        if (date2.tm_hour >= 0 && date2.tm_hour < 12) {
+          return "AM";
+        }
+        return "PM";
+      }, "%S": (date2) => leadingNulls(date2.tm_sec, 2), "%t": () => "	", "%u": (date2) => date2.tm_wday || 7, "%U": (date2) => {
+        var days = date2.tm_yday + 7 - date2.tm_wday;
+        return leadingNulls(Math.floor(days / 7), 2);
+      }, "%V": (date2) => {
+        var val = Math.floor((date2.tm_yday + 7 - (date2.tm_wday + 6) % 7) / 7);
+        if ((date2.tm_wday + 371 - date2.tm_yday - 2) % 7 <= 2) {
+          val++;
+        }
+        if (!val) {
+          val = 52;
+          var dec31 = (date2.tm_wday + 7 - date2.tm_yday - 1) % 7;
+          if (dec31 == 4 || dec31 == 5 && isLeapYear(date2.tm_year % 400 - 1)) {
+            val++;
+          }
+        } else if (val == 53) {
+          var jan1 = (date2.tm_wday + 371 - date2.tm_yday) % 7;
+          if (jan1 != 4 && (jan1 != 3 || !isLeapYear(date2.tm_year)))
+            val = 1;
+        }
+        return leadingNulls(val, 2);
+      }, "%w": (date2) => date2.tm_wday, "%W": (date2) => {
+        var days = date2.tm_yday + 7 - (date2.tm_wday + 6) % 7;
+        return leadingNulls(Math.floor(days / 7), 2);
+      }, "%y": (date2) => (date2.tm_year + 1900).toString().substring(2), "%Y": (date2) => date2.tm_year + 1900, "%z": (date2) => {
+        var off = date2.tm_gmtoff;
+        var ahead = off >= 0;
+        off = Math.abs(off) / 60;
+        off = off / 60 * 100 + off % 60;
+        return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
+      }, "%Z": (date2) => date2.tm_zone, "%%": () => "%" };
+      pattern = pattern.replace(/%%/g, "\0\0");
+      for (var rule in EXPANSION_RULES_2) {
+        if (pattern.includes(rule)) {
+          pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date));
+        }
+      }
+      pattern = pattern.replace(/\0\0/g, "%");
+      var bytes = intArrayFromString(pattern, false);
+      if (bytes.length > maxsize) {
+        return 0;
+      }
+      writeArrayToMemory(bytes, s);
+      return bytes.length - 1;
+    };
+    var _strftime_l = (s, maxsize, format, tm, loc) => _strftime(s, maxsize, format, tm);
+    var stringToUTF8OnStack = (str) => {
+      var size = lengthBytesUTF8(str) + 1;
+      var ret = stackAlloc(size);
+      stringToUTF8(str, ret, size);
+      return ret;
+    };
+    var wasmTable;
+    var getCFunc = (ident) => {
+      var func = Module["_" + ident];
+      return func;
+    };
+    var ccall = (ident, returnType, argTypes, args, opts) => {
+      var toC = { "string": (str) => {
+        var ret2 = 0;
+        if (str !== null && str !== void 0 && str !== 0) {
+          ret2 = stringToUTF8OnStack(str);
+        }
+        return ret2;
+      }, "array": (arr) => {
+        var ret2 = stackAlloc(arr.length);
+        writeArrayToMemory(arr, ret2);
+        return ret2;
+      } };
+      function convertReturnValue(ret2) {
+        if (returnType === "string") {
+          return UTF8ToString(ret2);
+        }
+        if (returnType === "boolean")
+          return Boolean(ret2);
+        return ret2;
+      }
+      var func = getCFunc(ident);
+      var cArgs = [];
+      var stack = 0;
+      if (args) {
+        for (var i = 0; i < args.length; i++) {
+          var converter = toC[argTypes[i]];
+          if (converter) {
+            if (stack === 0)
+              stack = stackSave();
+            cArgs[i] = converter(args[i]);
+          } else {
+            cArgs[i] = args[i];
+          }
+        }
+      }
+      var previousAsync = Asyncify.currData;
+      var ret = func.apply(null, cArgs);
+      function onDone(ret2) {
+        runtimeKeepalivePop();
+        if (stack !== 0)
+          stackRestore(stack);
+        return convertReturnValue(ret2);
+      }
+      var asyncMode = opts?.async;
+      runtimeKeepalivePush();
+      if (Asyncify.currData != previousAsync) {
+        return Asyncify.whenDone().then(onDone);
+      }
+      ret = onDone(ret);
+      if (asyncMode)
+        return Promise.resolve(ret);
+      return ret;
+    };
+    PThread.init();
+    var FSNode = function(parent, name, mode, rdev) {
+      if (!parent) {
+        parent = this;
+      }
+      this.parent = parent;
+      this.mount = parent.mount;
+      this.mounted = null;
+      this.id = FS.nextInode++;
+      this.name = name;
+      this.mode = mode;
+      this.node_ops = {};
+      this.stream_ops = {};
+      this.rdev = rdev;
+    };
+    var readMode = 292 | 73;
+    var writeMode = 146;
+    Object.defineProperties(FSNode.prototype, { read: { get: function() {
+      return (this.mode & readMode) === readMode;
+    }, set: function(val) {
+      val ? this.mode |= readMode : this.mode &= ~readMode;
+    } }, write: { get: function() {
+      return (this.mode & writeMode) === writeMode;
+    }, set: function(val) {
+      val ? this.mode |= writeMode : this.mode &= ~writeMode;
+    } }, isFolder: { get: function() {
+      return FS.isDir(this.mode);
+    } }, isDevice: { get: function() {
+      return FS.isChrdev(this.mode);
+    } } });
+    FS.FSNode = FSNode;
+    FS.createPreloadedFile = FS_createPreloadedFile;
+    FS.staticInit();
+    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";
+      }
+    };
+    handleAllocatorInit();
+    init_emval();
+    var proxiedFunctionTable = [_proc_exit, exitOnMainThread, pthreadCreateProxied, ___syscall_fcntl64, ___syscall_ioctl, ___syscall_openat, ___syscall_pipe, ___syscall_poll, _environ_get, _environ_sizes_get, _fd_close, _fd_fdstat_get, _fd_read, _fd_seek, _fd_write];
+    var wasmImports = { l: ___assert_fail, Sa: __asyncjs__em_libusb_wait_async, r: ___cxa_begin_catch, v: ___cxa_end_catch, b: ___cxa_find_matching_catch_2, g: ___cxa_find_matching_catch_3, ia: ___cxa_find_matching_catch_4, la: ___cxa_rethrow, q: ___cxa_throw, na: ___cxa_uncaught_exceptions, za: ___emscripten_init_main_thread_js, aa: ___emscripten_thread_cleanup, ta: ___pthread_create_js, h: ___resumeException, F: ___syscall_fcntl64, Da: ___syscall_ioctl, Ea: ___syscall_openat, wa: ___syscall_pipe, va: ___syscall_poll, fa: __embind_register_bigint, Ka: __embind_register_bool, Ja: __embind_register_emval, ea: __embind_register_float, I: __embind_register_integer, B: __embind_register_memory_view, da: __embind_register_std_string, Y: __embind_register_std_wstring, La: __embind_register_void, Ha: __emscripten_get_now_is_monotonic, ra: __emscripten_notify_mailbox_postmessage, ua: __emscripten_receive_on_main_thread_js, ya: __emscripten_thread_mailbox_await, Ga: __emscripten_thread_set_strongref, G: __emval_as, L: __emval_await, T: __emval_call, J: __emval_call_method, Ra: __emval_coro_make_promise, Qa: __emval_coro_suspend, n: __emval_decref, ha: __emval_get_global, D: __emval_get_method_caller, ga: __emval_get_property, w: __emval_incref, Ma: __emval_iter_begin, Pa: __emval_iter_next, M: __emval_new_cstring, Na: __emval_new_object, z: __emval_run_destructors, R: __emval_set_property, S: __emval_take_value, W: _abort, ba: _emscripten_check_blocking_allowed, Ia: _emscripten_date_now, Fa: _emscripten_exit_with_live_runtime, H: _emscripten_get_now, qa: _emscripten_resize_heap, Ba: _environ_get, Ca: _environ_sizes_get, sa: _exit, Q: _fd_close, Aa: _fd_fdstat_get, ca: _fd_read, xa: _fd_seek, X: _fd_write, Va: invoke_dii, _: invoke_diii, $: invoke_fiii, x: invoke_i, i: invoke_ii, Ta: invoke_iid, c: invoke_iii, d: invoke_iiii, m: invoke_iiiii, ma: invoke_iiiiid, j: invoke_iiiiii, y: invoke_iiiiiii, u: invoke_iiiiiiii, U: invoke_iiiiiiiiii, ja: invoke_iiiiiiiiiii, N: invoke_iiiiiiiiiiii, Xa: invoke_iiiiiiiiiiiii, Wa: invoke_iiiiiiiiiiiiiiii, ka: invoke_iiji, pa: invoke_j, C: invoke_ji, P: invoke_jiiii, o: invoke_v, k: invoke_vi, f: invoke_vii, e: invoke_viii, s: invoke_viiii, A: invoke_viiiii, p: invoke_viiiiii, E: invoke_viiiiiii, O: invoke_viiiiiiiiii, V: invoke_viiiiiiiiiiiiiii, oa: invoke_viijii, Ua: invoke_vij, t: _llvm_eh_typeid_for, a: wasmMemory || Module["wasmMemory"], Ya: _strftime_l, Z: usbi_em_copy_from_dataview, Oa: usbi_em_device_safe_open_close, K: usbi_em_promise_catch };
+    var wasmExports = createWasm();
+    var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["Za"])();
+    var ___cxa_free_exception = (a0) => (___cxa_free_exception = wasmExports["__cxa_free_exception"])(a0);
+    var _free = (a0) => (_free = wasmExports["$a"])(a0);
+    var _malloc = (a0) => (_malloc = wasmExports["ab"])(a0);
+    var _main = Module["_main"] = (a0, a1) => (_main = Module["_main"] = wasmExports["bb"])(a0, a1);
+    var ___errno_location = () => (___errno_location = wasmExports["cb"])();
+    var _pthread_self = Module["_pthread_self"] = () => (_pthread_self = Module["_pthread_self"] = wasmExports["db"])();
+    var _emscripten_main_runtime_thread_id = () => (_emscripten_main_runtime_thread_id = wasmExports["emscripten_main_runtime_thread_id"])();
+    var __emscripten_tls_init = Module["__emscripten_tls_init"] = () => (__emscripten_tls_init = Module["__emscripten_tls_init"] = wasmExports["eb"])();
+    var ___getTypeName = (a0) => (___getTypeName = wasmExports["fb"])(a0);
+    var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = () => (__embind_initialize_bindings = Module["__embind_initialize_bindings"] = wasmExports["gb"])();
+    var __emval_coro_resume = (a0, a1) => (__emval_coro_resume = wasmExports["hb"])(a0, a1);
+    var ___funcs_on_exit = () => (___funcs_on_exit = wasmExports["ib"])();
+    var __emscripten_thread_init = Module["__emscripten_thread_init"] = (a0, a1, a2, a3, a4, a5) => (__emscripten_thread_init = Module["__emscripten_thread_init"] = wasmExports["jb"])(a0, a1, a2, a3, a4, a5);
+    var __emscripten_thread_crashed = Module["__emscripten_thread_crashed"] = () => (__emscripten_thread_crashed = Module["__emscripten_thread_crashed"] = wasmExports["kb"])();
+    var _emscripten_main_thread_process_queued_calls = () => (_emscripten_main_thread_process_queued_calls = wasmExports["emscripten_main_thread_process_queued_calls"])();
+    var _fflush = Module["_fflush"] = (a0) => (_fflush = Module["_fflush"] = wasmExports["lb"])(a0);
+    var __emscripten_run_on_main_thread_js = (a0, a1, a2, a3) => (__emscripten_run_on_main_thread_js = wasmExports["mb"])(a0, a1, a2, a3);
+    var __emscripten_thread_free_data = (a0) => (__emscripten_thread_free_data = wasmExports["nb"])(a0);
+    var __emscripten_thread_exit = Module["__emscripten_thread_exit"] = (a0) => (__emscripten_thread_exit = Module["__emscripten_thread_exit"] = wasmExports["ob"])(a0);
+    var __emscripten_check_mailbox = () => (__emscripten_check_mailbox = wasmExports["pb"])();
+    var _setThrew = (a0, a1) => (_setThrew = wasmExports["qb"])(a0, a1);
+    var setTempRet0 = (a0) => (setTempRet0 = wasmExports["rb"])(a0);
+    var _emscripten_stack_set_limits = (a0, a1) => (_emscripten_stack_set_limits = wasmExports["sb"])(a0, a1);
+    var stackSave = () => (stackSave = wasmExports["tb"])();
+    var stackRestore = (a0) => (stackRestore = wasmExports["ub"])(a0);
+    var stackAlloc = (a0) => (stackAlloc = wasmExports["vb"])(a0);
+    var ___cxa_decrement_exception_refcount = (a0) => (___cxa_decrement_exception_refcount = wasmExports["wb"])(a0);
+    var ___cxa_increment_exception_refcount = (a0) => (___cxa_increment_exception_refcount = wasmExports["xb"])(a0);
+    var ___cxa_can_catch = (a0, a1, a2) => (___cxa_can_catch = wasmExports["yb"])(a0, a1, a2);
+    var ___cxa_is_pointer_type = (a0) => (___cxa_is_pointer_type = wasmExports["zb"])(a0);
+    var dynCall_viiiii = Module["dynCall_viiiii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_viiiii = Module["dynCall_viiiii"] = wasmExports["Ab"])(a0, a1, a2, a3, a4, a5);
+    var dynCall_iii = Module["dynCall_iii"] = (a0, a1, a2) => (dynCall_iii = Module["dynCall_iii"] = wasmExports["Bb"])(a0, a1, a2);
+    var dynCall_iiii = Module["dynCall_iiii"] = (a0, a1, a2, a3) => (dynCall_iiii = Module["dynCall_iiii"] = wasmExports["Cb"])(a0, a1, a2, a3);
+    var dynCall_vi = Module["dynCall_vi"] = (a0, a1) => (dynCall_vi = Module["dynCall_vi"] = wasmExports["Db"])(a0, a1);
+    var dynCall_viii = Module["dynCall_viii"] = (a0, a1, a2, a3) => (dynCall_viii = Module["dynCall_viii"] = wasmExports["Eb"])(a0, a1, a2, a3);
+    var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = wasmExports["Fb"])(a0, a1, a2, a3, a4, a5, a6);
+    var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = wasmExports["Gb"])(a0, a1, a2, a3, a4, a5, a6, a7);
+    var dynCall_ii = Module["dynCall_ii"] = (a0, a1) => (dynCall_ii = Module["dynCall_ii"] = wasmExports["Hb"])(a0, a1);
+    var dynCall_vii = Module["dynCall_vii"] = (a0, a1, a2) => (dynCall_vii = Module["dynCall_vii"] = wasmExports["Ib"])(a0, a1, a2);
+    var dynCall_iiiiii = Module["dynCall_iiiiii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiiiii = Module["dynCall_iiiiii"] = wasmExports["Jb"])(a0, a1, a2, a3, a4, a5);
+    var dynCall_iiiii = Module["dynCall_iiiii"] = (a0, a1, a2, a3, a4) => (dynCall_iiiii = Module["dynCall_iiiii"] = wasmExports["Kb"])(a0, a1, a2, a3, a4);
+    var dynCall_v = Module["dynCall_v"] = (a0) => (dynCall_v = Module["dynCall_v"] = wasmExports["Lb"])(a0);
+    var dynCall_viiiiii = Module["dynCall_viiiiii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viiiiii = Module["dynCall_viiiiii"] = wasmExports["Mb"])(a0, a1, a2, a3, a4, a5, a6);
+    var dynCall_viiii = Module["dynCall_viiii"] = (a0, a1, a2, a3, a4) => (dynCall_viiii = Module["dynCall_viiii"] = wasmExports["Nb"])(a0, a1, a2, a3, a4);
+    var dynCall_iiji = Module["dynCall_iiji"] = (a0, a1, a2, a3) => (dynCall_iiji = Module["dynCall_iiji"] = wasmExports["Ob"])(a0, a1, a2, a3);
+    var dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = wasmExports["Pb"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    var dynCall_iiiiiiiiiiii = Module["dynCall_iiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) => (dynCall_iiiiiiiiiiii = Module["dynCall_iiiiiiiiiiii"] = wasmExports["Qb"])(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["Rb"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
+    var dynCall_iiiiiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) => (dynCall_iiiiiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiiiiii"] = wasmExports["Sb"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
+    var dynCall_iiiiiiiiiii = Module["dynCall_iiiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_iiiiiiiiiii = Module["dynCall_iiiiiiiiiii"] = wasmExports["Tb"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+    var dynCall_dii = Module["dynCall_dii"] = (a0, a1, a2) => (dynCall_dii = Module["dynCall_dii"] = wasmExports["Ub"])(a0, a1, a2);
+    var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = wasmExports["Vb"])(a0, a1, a2, a3, a4, a5, a6, a7);
+    var dynCall_ji = Module["dynCall_ji"] = (a0, a1) => (dynCall_ji = Module["dynCall_ji"] = wasmExports["Wb"])(a0, a1);
+    var dynCall_vij = Module["dynCall_vij"] = (a0, a1, a2) => (dynCall_vij = Module["dynCall_vij"] = wasmExports["Xb"])(a0, a1, a2);
+    var dynCall_iid = Module["dynCall_iid"] = (a0, a1, a2) => (dynCall_iid = Module["dynCall_iid"] = wasmExports["Yb"])(a0, a1, a2);
+    var dynCall_i = Module["dynCall_i"] = (a0) => (dynCall_i = Module["dynCall_i"] = wasmExports["Zb"])(a0);
+    var dynCall_j = Module["dynCall_j"] = (a0) => (dynCall_j = Module["dynCall_j"] = wasmExports["_b"])(a0);
+    var dynCall_viijii = Module["dynCall_viijii"] = (a0, a1, a2, a3, a4, a5) => (dynCall_viijii = Module["dynCall_viijii"] = wasmExports["$b"])(a0, a1, a2, a3, a4, a5);
+    var dynCall_iiiiid = Module["dynCall_iiiiid"] = (a0, a1, a2, a3, a4, a5) => (dynCall_iiiiid = Module["dynCall_iiiiid"] = wasmExports["ac"])(a0, a1, a2, a3, a4, a5);
+    var dynCall_jiiii = Module["dynCall_jiiii"] = (a0, a1, a2, a3, a4) => (dynCall_jiiii = Module["dynCall_jiiii"] = wasmExports["bc"])(a0, a1, a2, a3, a4);
+    var dynCall_fiii = Module["dynCall_fiii"] = (a0, a1, a2, a3) => (dynCall_fiii = Module["dynCall_fiii"] = wasmExports["cc"])(a0, a1, a2, a3);
+    var dynCall_diii = Module["dynCall_diii"] = (a0, a1, a2, a3) => (dynCall_diii = Module["dynCall_diii"] = wasmExports["dc"])(a0, a1, a2, a3);
+    var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = wasmExports["ec"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+    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["fc"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
+    var _asyncify_start_unwind = (a0) => (_asyncify_start_unwind = wasmExports["gc"])(a0);
+    var _asyncify_stop_unwind = () => (_asyncify_stop_unwind = wasmExports["hc"])();
+    var _asyncify_start_rewind = (a0) => (_asyncify_start_rewind = wasmExports["ic"])(a0);
+    var _asyncify_stop_rewind = () => (_asyncify_stop_rewind = wasmExports["jc"])();
+    var ___start_em_js = Module["___start_em_js"] = 241208;
+    var ___stop_em_js = Module["___stop_em_js"] = 242610;
+    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_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_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_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_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_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_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_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_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_v(index) {
+      var sp = stackSave();
+      try {
+        dynCall_v(index);
+      } 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_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_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_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_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_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_iiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {
+      var sp = stackSave();
+      try {
+        return dynCall_iiiiiiiiiiiiiiii(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_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_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_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_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_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_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_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_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_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_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);
+      }
+    }
+    function invoke_jiiii(index, a1, a2, a3, a4) {
+      var sp = stackSave();
+      try {
+        return dynCall_jiiii(index, a1, a2, a3, a4);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0)
+          throw e;
+        _setThrew(1, 0);
+        return 0n;
+      }
+    }
+    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_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_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_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);
+      }
+    }
+    Module["wasmMemory"] = wasmMemory;
+    Module["stackAlloc"] = stackAlloc;
+    Module["keepRuntimeAlive"] = keepRuntimeAlive;
+    Module["ccall"] = ccall;
+    Module["stringToUTF8OnStack"] = stringToUTF8OnStack;
+    Module["ExitStatus"] = ExitStatus;
+    Module["FS"] = FS;
+    Module["PThread"] = PThread;
+    var calledRun;
+    dependenciesFulfilled = function runCaller() {
+      if (!calledRun)
+        run();
+      if (!calledRun)
+        dependenciesFulfilled = runCaller;
+    };
+    function callMain(args = []) {
+      var entryFunction = _main;
+      args.unshift(thisProgram);
+      var argc = args.length;
+      var argv = stackAlloc((argc + 1) * 4);
+      var argv_ptr = argv;
+      args.forEach((arg) => {
+        HEAPU32[argv_ptr >> 2] = stringToUTF8OnStack(arg);
+        argv_ptr += 4;
+      });
+      HEAPU32[argv_ptr >> 2] = 0;
+      try {
+        var ret = entryFunction(argc, argv);
+        exitJS(ret, true);
+        return ret;
+      } catch (e) {
+        return handleException(e);
+      }
+    }
+    function run(args = arguments_) {
+      if (runDependencies > 0) {
+        return;
+      }
+      if (ENVIRONMENT_IS_PTHREAD) {
+        readyPromiseResolve(Module);
+        initRuntime();
+        startWorker(Module);
+        return;
+      }
+      preRun();
+      if (runDependencies > 0) {
+        return;
+      }
+      function doRun() {
+        if (calledRun)
+          return;
+        calledRun = true;
+        Module["calledRun"] = true;
+        if (ABORT)
+          return;
+        initRuntime();
+        preMain();
+        readyPromiseResolve(Module);
+        if (shouldRunNow)
+          callMain(args);
+        postRun();
+      }
+      {
+        doRun();
+      }
+    }
+    var shouldRunNow = false;
+    run();
+    return moduleArg.ready;
+  };
+})();
+var openFPGALoader_default = instantiate;
+
+// lib/api.js
+var Exit = class extends Error {
+  constructor(code, files) {
+    super(`Exited with status ${code}`);
+    this.code = code;
+    this.files = files;
+  }
+};
+function makeTerminalWrite({ print = null, printLine = null }) {
+  let terminalBuffer = [];
+  return function(charCode) {
+    if (print !== null) {
+      if (charCode !== null)
+        terminalBuffer.push(charCode);
+      if (charCode === null || charCode === 10 || charCode == 13)
+        print(new TextDecoder().decode(new Uint8Array(terminalBuffer.splice(0))));
+    } else if (printLine !== null) {
+      if (charCode === null) {
+      } else if (charCode === 10) {
+        printLine(new TextDecoder().decode(new Uint8Array(terminalBuffer.splice(0))));
+      } else {
+        terminalBuffer.push(charCode);
+      }
+    }
+  };
+}
+function writeTreeToMEMFS(FS, tree, path = "/") {
+  for (const [filename, data] of Object.entries(tree)) {
+    const filepath = `${path}${filename}`;
+    if (typeof data === "string" || data instanceof Uint8Array) {
+      FS.writeFile(filepath, data);
+    } else {
+      FS.mkdir(filepath);
+      writeTreeToMEMFS(FS, data, `${filepath}/`);
+    }
+  }
+}
+function readTreeFromMEMFS(FS, path = "/") {
+  const tree = {};
+  for (const filename of FS.readdir(path)) {
+    const filepath = `${path}${filename}`;
+    if (filename === "." || filename === "..")
+      continue;
+    if (["/tmp", "/dev", "/proc"].includes(filepath))
+      continue;
+    const stat = FS.stat(filepath);
+    if (FS.isFile(stat.mode)) {
+      tree[filename] = FS.readFile(filepath, { encoding: "binary" });
+    } else if (FS.isDir(stat.mode)) {
+      tree[filename] = readTreeFromMEMFS(FS, `${filepath}/`);
+    }
+  }
+  return tree;
+}
+async function runOpenFPGALoader(args = null, filesIn = {}, options = { printLine: console.log }) {
+  if (args === null)
+    return;
+  const terminalWrite = makeTerminalWrite(options);
+  const inst = await openFPGALoader_default({
+    stdin: () => null,
+    stdout: terminalWrite,
+    stderr: terminalWrite
+  });
+  inst.FS.rmdir("/home/web_user");
+  inst.FS.rmdir("/home");
+  writeTreeToMEMFS(inst.FS, filesIn);
+  const argv = ["openFPGALoader", ...args, null];
+  const argvPtr = inst.stackAlloc(argv.length * 4);
+  argv.forEach((arg, off) => inst.HEAPU32[(argvPtr >> 2) + off] = arg === null ? 0 : inst.stringToUTF8OnStack(arg));
+  const exitCode = await inst.ccall(
+    "main",
+    "number",
+    ["number", "number"],
+    [argv.length - 1, argvPtr],
+    { async: true }
+  );
+  inst._fflush(0);
+  const filesOut = readTreeFromMEMFS(inst.FS);
+  if (exitCode == 0) {
+    return filesOut;
+  } else {
+    throw new Exit(exitCode, filesOut);
+  }
+}
+runOpenFPGALoader.requiresUSBDevice = [];
+var commands = {
+  openFPGALoader: runOpenFPGALoader
+};
+export {
+  Exit,
+  commands,
+  runOpenFPGALoader
+};