@prisma-next/sql-runtime 0.1.0-dev.2 → 0.1.0-dev.20

package/dist/pg_dump-SG4KYBUB.js

@@ -0,0 +1,2492 @@
+import "./chunk-7D4SUZUM.js";
+
+// ../../../node_modules/.pnpm/@electric-sql+pglite-tools@0.2.19_@electric-sql+pglite@0.3.14/node_modules/@electric-sql/pglite-tools/dist/chunk-WKZSYPH3.js
+var x = Object.defineProperty;
+var B = (e, r, t) => r in e ? x(e, r, { enumerable: true, configurable: true, writable: true, value: t }) : e[r] = t;
+var b = (e, r, t) => B(e, typeof r != "symbol" ? r + "" : r, t);
+var j = (() => {
+  var _scriptName = import.meta.url;
+  return async function(moduleArg = {}) {
+    var moduleRtn, Module = moduleArg, readyPromiseResolve, readyPromiseReject, readyPromise = new Promise((e, r) => {
+      readyPromiseResolve = e, readyPromiseReject = r;
+    }), ENVIRONMENT_IS_WEB = typeof window == "object", ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope < "u", ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
+    if (ENVIRONMENT_IS_NODE) {
+      let { createRequire: e } = await import("module"), r = import.meta.url;
+      r.startsWith("data:") && (r = "/");
+      var require = e(r);
+    }
+    var moduleOverrides = Object.assign({}, Module), arguments_ = [], thisProgram = "./this.program", quit_ = (e, r) => {
+      throw r;
+    }, scriptDirectory = "";
+    function locateFile(e) {
+      return Module.locateFile ? Module.locateFile(e, scriptDirectory) : scriptDirectory + e;
+    }
+    var readAsync, readBinary;
+    if (ENVIRONMENT_IS_NODE) {
+      var fs = require("fs"), nodePath = require("path");
+      import.meta.url.startsWith("data:") || (scriptDirectory = nodePath.dirname(require("url").fileURLToPath(import.meta.url)) + "/"), readBinary = (e) => {
+        e = isFileURI(e) ? new URL(e) : e;
+        var r = fs.readFileSync(e);
+        return r;
+      }, readAsync = async (e, r = true) => {
+        e = isFileURI(e) ? new URL(e) : e;
+        var t = fs.readFileSync(e, r ? void 0 : "utf8");
+        return t;
+      }, !Module.thisProgram && process.argv.length > 1 && (thisProgram = process.argv[1].replace(/\\/g, "/")), arguments_ = process.argv.slice(2), quit_ = (e, r) => {
+        throw process.exitCode = e, r;
+      };
+    } else (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && (ENVIRONMENT_IS_WORKER ? scriptDirectory = self.location.href : typeof document < "u" && document.currentScript && (scriptDirectory = document.currentScript.src), _scriptName && (scriptDirectory = _scriptName), scriptDirectory.startsWith("blob:") ? scriptDirectory = "" : scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1), ENVIRONMENT_IS_WORKER && (readBinary = (e) => {
+      var r = new XMLHttpRequest();
+      return r.open("GET", e, false), r.responseType = "arraybuffer", r.send(null), new Uint8Array(r.response);
+    }), readAsync = async (e) => {
+      var r = await fetch(e, { credentials: "same-origin" });
+      if (r.ok) return r.arrayBuffer();
+      throw new Error(r.status + " : " + r.url);
+    });
+    var out = Module.print || console.log.bind(console), err = Module.printErr || console.error.bind(console);
+    Object.assign(Module, moduleOverrides), moduleOverrides = null, Module.arguments && (arguments_ = Module.arguments), Module.thisProgram && (thisProgram = Module.thisProgram);
+    var dynamicLibraries = Module.dynamicLibraries || [], wasmBinary = Module.wasmBinary;
+    function intArrayFromBase64(e) {
+      if (typeof ENVIRONMENT_IS_NODE < "u" && ENVIRONMENT_IS_NODE) {
+        var r = Buffer.from(e, "base64");
+        return new Uint8Array(r.buffer, r.byteOffset, r.length);
+      }
+      for (var t = atob(e), n = new Uint8Array(t.length), a = 0; a < t.length; ++a) n[a] = t.charCodeAt(a);
+      return n;
+    }
+    var wasmMemory, ABORT = false, EXITSTATUS;
+    function assert(e, r) {
+      e || abort(r);
+    }
+    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
+    function updateMemoryViews() {
+      var e = wasmMemory.buffer;
+      Module.HEAP8 = HEAP8 = new Int8Array(e), Module.HEAP16 = HEAP16 = new Int16Array(e), Module.HEAPU8 = HEAPU8 = new Uint8Array(e), Module.HEAPU16 = HEAPU16 = new Uint16Array(e), Module.HEAP32 = HEAP32 = new Int32Array(e), Module.HEAPU32 = HEAPU32 = new Uint32Array(e), Module.HEAPF32 = HEAPF32 = new Float32Array(e), Module.HEAPF64 = HEAPF64 = new Float64Array(e), Module.HEAP64 = HEAP64 = new BigInt64Array(e), Module.HEAPU64 = HEAPU64 = new BigUint64Array(e);
+    }
+    if (Module.wasmMemory) wasmMemory = Module.wasmMemory;
+    else {
+      var INITIAL_MEMORY = Module.INITIAL_MEMORY || 33554432;
+      wasmMemory = new WebAssembly.Memory({ initial: INITIAL_MEMORY / 65536, maximum: 32768 });
+    }
+    updateMemoryViews();
+    var __ATPRERUN__ = [], __ATINIT__ = [], __ATMAIN__ = [], __ATEXIT__ = [], __ATPOSTRUN__ = [], __RELOC_FUNCS__ = [], runtimeInitialized = false, runtimeExited = false;
+    function preRun() {
+      if (Module.preRun) for (typeof Module.preRun == "function" && (Module.preRun = [Module.preRun]); Module.preRun.length; ) addOnPreRun(Module.preRun.shift());
+      callRuntimeCallbacks(__ATPRERUN__);
+    }
+    function initRuntime() {
+      runtimeInitialized = true, callRuntimeCallbacks(__RELOC_FUNCS__), !Module.noFSInit && !FS.initialized && FS.init(), FS.ignorePermissions = false, TTY.init(), PIPEFS.root = FS.mount(PIPEFS, {}, null), SOCKFS.root = FS.mount(SOCKFS, {}, null), callRuntimeCallbacks(__ATINIT__);
+    }
+    function preMain() {
+      callRuntimeCallbacks(__ATMAIN__);
+    }
+    function exitRuntime() {
+      ___funcs_on_exit(), callRuntimeCallbacks(__ATEXIT__), FS.quit(), TTY.shutdown(), runtimeExited = true;
+    }
+    function postRun() {
+      if (Module.postRun) for (typeof Module.postRun == "function" && (Module.postRun = [Module.postRun]); Module.postRun.length; ) addOnPostRun(Module.postRun.shift());
+      callRuntimeCallbacks(__ATPOSTRUN__);
+    }
+    function addOnPreRun(e) {
+      __ATPRERUN__.unshift(e);
+    }
+    function addOnInit(e) {
+      __ATINIT__.unshift(e);
+    }
+    function addOnPostRun(e) {
+      __ATPOSTRUN__.unshift(e);
+    }
+    var runDependencies = 0, dependenciesFulfilled = null;
+    function getUniqueRunDependency(e) {
+      return e;
+    }
+    function addRunDependency(e) {
+      runDependencies++, Module.monitorRunDependencies?.(runDependencies);
+    }
+    function removeRunDependency(e) {
+      if (runDependencies--, Module.monitorRunDependencies?.(runDependencies), runDependencies == 0 && dependenciesFulfilled) {
+        var r = dependenciesFulfilled;
+        dependenciesFulfilled = null, r();
+      }
+    }
+    function abort(e) {
+      Module.onAbort?.(e), e = "Aborted(" + e + ")", err(e), ABORT = true, e += ". Build with -sASSERTIONS for more info.";
+      var r = new WebAssembly.RuntimeError(e);
+      throw readyPromiseReject(r), r;
+    }
+    var dataURIPrefix = "data:application/octet-stream;base64,", isDataURI = (e) => e.startsWith(dataURIPrefix), isFileURI = (e) => e.startsWith("file://");
+    function findWasmBinary() {
+      if (Module.locateFile) {
+        var e = "pg_dump.wasm";
+        return isDataURI(e) ? e : locateFile(e);
+      }
+      return new URL("pg_dump.wasm", import.meta.url).href;
+    }
+    var wasmBinaryFile;
+    function getBinarySync(e) {
+      if (e == wasmBinaryFile && wasmBinary) return new Uint8Array(wasmBinary);
+      if (readBinary) return readBinary(e);
+      throw "both async and sync fetching of the wasm failed";
+    }
+    async function getWasmBinary(e) {
+      if (!wasmBinary) try {
+        var r = await readAsync(e);
+        return new Uint8Array(r);
+      } catch {
+      }
+      return getBinarySync(e);
+    }
+    async function instantiateArrayBuffer(e, r) {
+      try {
+        var t = await getWasmBinary(e), n = await WebAssembly.instantiate(t, r);
+        return n;
+      } catch (a) {
+        err(`failed to asynchronously prepare wasm: ${a}`), abort(a);
+      }
+    }
+    async function instantiateAsync(e, r, t) {
+      if (!e && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(r) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") try {
+        var n = fetch(r, { credentials: "same-origin" }), a = await WebAssembly.instantiateStreaming(n, t);
+        return a;
+      } catch (o) {
+        err(`wasm streaming compile failed: ${o}`), err("falling back to ArrayBuffer instantiation");
+      }
+      return instantiateArrayBuffer(r, t);
+    }
+    function getWasmImports() {
+      return { env: wasmImports, wasi_snapshot_preview1: wasmImports, "GOT.mem": new Proxy(wasmImports, GOTHandler), "GOT.func": new Proxy(wasmImports, GOTHandler) };
+    }
+    async function createWasm() {
+      function e(a, o) {
+        wasmExports = a.exports, wasmExports = relocateExports(wasmExports, 1024);
+        var s = getDylinkMetadata(o);
+        return s.neededDynlibs && (dynamicLibraries = s.neededDynlibs.concat(dynamicLibraries)), mergeLibSymbols(wasmExports, "main"), LDSO.init(), loadDylibs(), addOnInit(wasmExports.__wasm_call_ctors), __RELOC_FUNCS__.push(wasmExports.__wasm_apply_data_relocs), removeRunDependency("wasm-instantiate"), wasmExports;
+      }
+      addRunDependency("wasm-instantiate");
+      function r(a) {
+        e(a.instance, a.module);
+      }
+      var t = getWasmImports();
+      if (Module.instantiateWasm) try {
+        return Module.instantiateWasm(t, e);
+      } catch (a) {
+        err(`Module.instantiateWasm callback failed with error: ${a}`), readyPromiseReject(a);
+      }
+      wasmBinaryFile ?? (wasmBinaryFile = findWasmBinary());
+      try {
+        var n = await instantiateAsync(wasmBinary, wasmBinaryFile, t);
+        return r(n), n;
+      } catch (a) {
+        readyPromiseReject(a);
+        return;
+      }
+    }
+    var ASM_CONSTS = {};
+    class ExitStatus {
+      constructor(r) {
+        b(this, "name", "ExitStatus");
+        this.message = `Program terminated with exit(${r})`, this.status = r;
+      }
+    }
+    var GOT = {}, currentModuleWeakSymbols = /* @__PURE__ */ new Set([]), GOTHandler = { get(e, r) {
+      var t = GOT[r];
+      return t || (t = GOT[r] = new WebAssembly.Global({ value: "i32", mutable: true })), currentModuleWeakSymbols.has(r) || (t.required = true), t;
+    } }, callRuntimeCallbacks = (e) => {
+      for (; e.length > 0; ) e.shift()(Module);
+    }, UTF8Decoder = typeof TextDecoder < "u" ? new TextDecoder() : void 0, UTF8ArrayToString = (e, r = 0, t = NaN) => {
+      for (var n = r + t, a = r; e[a] && !(a >= n); ) ++a;
+      if (a - r > 16 && e.buffer && UTF8Decoder) return UTF8Decoder.decode(e.subarray(r, a));
+      for (var o = ""; r < a; ) {
+        var s = e[r++];
+        if (!(s & 128)) {
+          o += String.fromCharCode(s);
+          continue;
+        }
+        var l = e[r++] & 63;
+        if ((s & 224) == 192) {
+          o += String.fromCharCode((s & 31) << 6 | l);
+          continue;
+        }
+        var u = e[r++] & 63;
+        if ((s & 240) == 224 ? s = (s & 15) << 12 | l << 6 | u : s = (s & 7) << 18 | l << 12 | u << 6 | e[r++] & 63, s < 65536) o += String.fromCharCode(s);
+        else {
+          var d = s - 65536;
+          o += String.fromCharCode(55296 | d >> 10, 56320 | d & 1023);
+        }
+      }
+      return o;
+    }, getDylinkMetadata = (e) => {
+      var r = 0, t = 0;
+      function n() {
+        return e[r++];
+      }
+      function a() {
+        for (var P = 0, H = 1; ; ) {
+          var I = e[r++];
+          if (P += (I & 127) * H, H *= 128, !(I & 128)) break;
+        }
+        return P;
+      }
+      function o() {
+        var P = a();
+        return r += P, UTF8ArrayToString(e, r - P, P);
+      }
+      function s(P, H) {
+        if (P) throw new Error(H);
+      }
+      var l = "dylink.0";
+      if (e instanceof WebAssembly.Module) {
+        var u = WebAssembly.Module.customSections(e, l);
+        u.length === 0 && (l = "dylink", u = WebAssembly.Module.customSections(e, l)), s(u.length === 0, "need dylink section"), e = new Uint8Array(u[0]), t = e.length;
+      } else {
+        var d = new Uint32Array(new Uint8Array(e.subarray(0, 24)).buffer), c = d[0] == 1836278016;
+        s(!c, "need to see wasm magic number"), s(e[8] !== 0, "need the dylink section to be first"), r = 9;
+        var m = a();
+        t = r + m, l = o();
+      }
+      var _ = { neededDynlibs: [], tlsExports: /* @__PURE__ */ new Set(), weakImports: /* @__PURE__ */ new Set() };
+      if (l == "dylink") {
+        _.memorySize = a(), _.memoryAlign = a(), _.tableSize = a(), _.tableAlign = a();
+        for (var f = a(), S = 0; S < f; ++S) {
+          var v = o();
+          _.neededDynlibs.push(v);
+        }
+      } else {
+        s(l !== "dylink.0");
+        for (var F = 1, g = 2, w = 3, A = 4, y = 256, p = 3, h = 1; r < t; ) {
+          var E = n(), M = a();
+          if (E === F) _.memorySize = a(), _.memoryAlign = a(), _.tableSize = a(), _.tableAlign = a();
+          else if (E === g) for (var f = a(), S = 0; S < f; ++S) v = o(), _.neededDynlibs.push(v);
+          else if (E === w) for (var T = a(); T--; ) {
+            var D = o(), R = a();
+            R & y && _.tlsExports.add(D);
+          }
+          else if (E === A) for (var T = a(); T--; ) {
+            var k = o(), D = o(), R = a();
+            (R & p) == h && _.weakImports.add(D);
+          }
+          else r += M;
+        }
+      }
+      return _;
+    }, newDSO = (e, r, t) => {
+      var n = { refcount: 1 / 0, name: e, exports: t, global: true };
+      return LDSO.loadedLibsByName[e] = n, r != null && (LDSO.loadedLibsByHandle[r] = n), n;
+    }, LDSO = { loadedLibsByName: {}, loadedLibsByHandle: {}, init() {
+      newDSO("__main__", 0, wasmImports);
+    } }, ___heap_base = 289952, alignMemory = (e, r) => Math.ceil(e / r) * r, getMemory = (e) => {
+      if (runtimeInitialized) return _calloc(e, 1);
+      var r = ___heap_base, t = r + alignMemory(e, 16);
+      return ___heap_base = t, GOT.__heap_base.value = t, r;
+    }, isInternalSym = (e) => ["__cpp_exception", "__c_longjmp", "__wasm_apply_data_relocs", "__dso_handle", "__tls_size", "__tls_align", "__set_stack_limits", "_emscripten_tls_init", "__wasm_init_tls", "__wasm_call_ctors", "__start_em_asm", "__stop_em_asm", "__start_em_js", "__stop_em_js"].includes(e) || e.startsWith("__em_js__"), uleb128Encode = (e, r) => {
+      e < 128 ? r.push(e) : r.push(e % 128 | 128, e >> 7);
+    }, sigToWasmTypes = (e) => {
+      for (var r = { i: "i32", j: "i64", f: "f32", d: "f64", e: "externref", p: "i32" }, t = { parameters: [], results: e[0] == "v" ? [] : [r[e[0]]] }, n = 1; n < e.length; ++n) t.parameters.push(r[e[n]]);
+      return t;
+    }, generateFuncType = (e, r) => {
+      var t = e.slice(0, 1), n = e.slice(1), a = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+      r.push(96), uleb128Encode(n.length, r);
+      for (var o = 0; o < n.length; ++o) r.push(a[n[o]]);
+      t == "v" ? r.push(0) : r.push(1, a[t]);
+    }, convertJsFunctionToWasm = (e, r) => {
+      if (typeof WebAssembly.Function == "function") return new WebAssembly.Function(sigToWasmTypes(r), e);
+      var t = [1];
+      generateFuncType(r, t);
+      var n = [0, 97, 115, 109, 1, 0, 0, 0, 1];
+      uleb128Encode(t.length, n), n.push(...t), n.push(2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+      var a = new WebAssembly.Module(new Uint8Array(n)), o = new WebAssembly.Instance(a, { e: { f: e } }), s = o.exports.f;
+      return s;
+    }, wasmTableMirror = [], wasmTable = new WebAssembly.Table({ initial: 215, element: "anyfunc" }), getWasmTableEntry = (e) => {
+      var r = wasmTableMirror[e];
+      return r || (e >= wasmTableMirror.length && (wasmTableMirror.length = e + 1), wasmTableMirror[e] = r = wasmTable.get(e)), r;
+    }, updateTableMap = (e, r) => {
+      if (functionsInTableMap) for (var t = e; t < e + r; t++) {
+        var n = getWasmTableEntry(t);
+        n && functionsInTableMap.set(n, t);
+      }
+    }, functionsInTableMap, getFunctionAddress = (e) => (functionsInTableMap || (functionsInTableMap = /* @__PURE__ */ new WeakMap(), updateTableMap(0, wasmTable.length)), functionsInTableMap.get(e) || 0), freeTableIndexes = [], getEmptyTableSlot = () => {
+      if (freeTableIndexes.length) return freeTableIndexes.pop();
+      try {
+        wasmTable.grow(1);
+      } catch (e) {
+        throw e instanceof RangeError ? "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH." : e;
+      }
+      return wasmTable.length - 1;
+    }, setWasmTableEntry = (e, r) => {
+      wasmTable.set(e, r), wasmTableMirror[e] = wasmTable.get(e);
+    }, addFunction = (e, r) => {
+      var t = getFunctionAddress(e);
+      if (t) return t;
+      var n = getEmptyTableSlot();
+      try {
+        setWasmTableEntry(n, e);
+      } catch (o) {
+        if (!(o instanceof TypeError)) throw o;
+        var a = convertJsFunctionToWasm(e, r);
+        setWasmTableEntry(n, a);
+      }
+      return functionsInTableMap.set(e, n), n;
+    }, updateGOT = (e, r) => {
+      for (var t in e) if (!isInternalSym(t)) {
+        var n = e[t];
+        GOT[t] || (GOT[t] = new WebAssembly.Global({ value: "i32", mutable: true })), (r || GOT[t].value == 0) && (typeof n == "function" ? GOT[t].value = addFunction(n) : typeof n == "number" ? GOT[t].value = n : err(`unhandled export type for '${t}': ${typeof n}`));
+      }
+    }, relocateExports = (e, r, t) => {
+      var n = {};
+      for (var a in e) {
+        var o = e[a];
+        typeof o == "object" && (o = o.value), typeof o == "number" && (o += r), n[a] = o;
+      }
+      return updateGOT(n, t), n;
+    }, isSymbolDefined = (e) => {
+      var r = wasmImports[e];
+      return !(!r || r.stub);
+    }, dynCall = (e, r, t = []) => {
+      var n = getWasmTableEntry(r)(...t);
+      return n;
+    }, stackSave = () => _emscripten_stack_get_current(), stackRestore = (e) => __emscripten_stack_restore(e), createInvokeFunction = (e) => (r, ...t) => {
+      var n = stackSave();
+      try {
+        return dynCall(e, r, t);
+      } catch (a) {
+        if (stackRestore(n), a !== a + 0) throw a;
+        if (_setThrew(1, 0), e[0] == "j") return 0n;
+      }
+    }, resolveGlobalSymbol = (e, r = false) => {
+      var t;
+      return isSymbolDefined(e) ? t = wasmImports[e] : e.startsWith("invoke_") && (t = wasmImports[e] = createInvokeFunction(e.split("_")[1])), { sym: t, name: e };
+    }, UTF8ToString = (e, r) => e ? UTF8ArrayToString(HEAPU8, e, r) : "", loadWebAssemblyModule = (binary, flags, libName, localScope, handle) => {
+      var metadata = getDylinkMetadata(binary);
+      currentModuleWeakSymbols = metadata.weakImports;
+      function loadModule() {
+        var firstLoad = !handle || !HEAP8[handle + 8];
+        if (firstLoad) {
+          var memAlign = Math.pow(2, metadata.memoryAlign), memoryBase = metadata.memorySize ? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign) : 0, tableBase = metadata.tableSize ? wasmTable.length : 0;
+          handle && (HEAP8[handle + 8] = 1, HEAPU32[handle + 12 >> 2] = memoryBase, HEAP32[handle + 16 >> 2] = metadata.memorySize, HEAPU32[handle + 20 >> 2] = tableBase, HEAP32[handle + 24 >> 2] = metadata.tableSize);
+        } else memoryBase = HEAPU32[handle + 12 >> 2], tableBase = HEAPU32[handle + 20 >> 2];
+        var tableGrowthNeeded = tableBase + metadata.tableSize - wasmTable.length;
+        tableGrowthNeeded > 0 && wasmTable.grow(tableGrowthNeeded);
+        var moduleExports;
+        function resolveSymbol(e) {
+          var r = resolveGlobalSymbol(e).sym;
+          return !r && localScope && (r = localScope[e]), r || (r = moduleExports[e]), r;
+        }
+        var proxyHandler = { get(e, r) {
+          switch (r) {
+            case "__memory_base":
+              return memoryBase;
+            case "__table_base":
+              return tableBase;
+          }
+          if (r in wasmImports && !wasmImports[r].stub) return wasmImports[r];
+          if (!(r in e)) {
+            var t;
+            e[r] = (...n) => (t || (t = resolveSymbol(r)), t(...n));
+          }
+          return e[r];
+        } }, proxy = new Proxy({}, proxyHandler), info = { "GOT.mem": new Proxy({}, GOTHandler), "GOT.func": new Proxy({}, GOTHandler), env: proxy, wasi_snapshot_preview1: proxy };
+        function postInstantiation(module, instance) {
+          updateTableMap(tableBase, metadata.tableSize), moduleExports = relocateExports(instance.exports, memoryBase), flags.allowUndefined || reportUndefinedSymbols();
+          function addEmAsm(addr, body) {
+            for (var args = [], arity = 0; arity < 16 && body.indexOf("$" + arity) != -1; arity++) args.push("$" + arity);
+            args = args.join(",");
+            var func = `(${args}) => { ${body} };`;
+            ASM_CONSTS[start] = eval(func);
+          }
+          if ("__start_em_asm" in moduleExports) for (var start = moduleExports.__start_em_asm, stop = moduleExports.__stop_em_asm; start < stop; ) {
+            var jsString = UTF8ToString(start);
+            addEmAsm(start, jsString), start = HEAPU8.indexOf(0, start) + 1;
+          }
+          function addEmJs(name, cSig, body) {
+            var jsArgs = [];
+            if (cSig = cSig.slice(1, -1), cSig != "void") {
+              cSig = cSig.split(",");
+              for (var i in cSig) {
+                var jsArg = cSig[i].split(" ").pop();
+                jsArgs.push(jsArg.replace("*", ""));
+              }
+            }
+            var func = `(${jsArgs}) => ${body};`;
+            moduleExports[name] = eval(func);
+          }
+          for (var name in moduleExports) if (name.startsWith("__em_js__")) {
+            var start = moduleExports[name], jsString = UTF8ToString(start), parts = jsString.split("<::>");
+            addEmJs(name.replace("__em_js__", ""), parts[0], parts[1]), delete moduleExports[name];
+          }
+          var applyRelocs = moduleExports.__wasm_apply_data_relocs;
+          applyRelocs && (runtimeInitialized ? applyRelocs() : __RELOC_FUNCS__.push(applyRelocs));
+          var init = moduleExports.__wasm_call_ctors;
+          return init && (runtimeInitialized ? init() : __ATINIT__.push(init)), moduleExports;
+        }
+        if (flags.loadAsync) {
+          if (binary instanceof WebAssembly.Module) {
+            var instance = new WebAssembly.Instance(binary, info);
+            return Promise.resolve(postInstantiation(binary, instance));
+          }
+          return WebAssembly.instantiate(binary, info).then((e) => postInstantiation(e.module, e.instance));
+        }
+        var module = binary instanceof WebAssembly.Module ? binary : new WebAssembly.Module(binary), instance = new WebAssembly.Instance(module, info);
+        return postInstantiation(module, instance);
+      }
+      return flags.loadAsync ? metadata.neededDynlibs.reduce((e, r) => e.then(() => loadDynamicLibrary(r, flags, localScope)), Promise.resolve()).then(loadModule) : (metadata.neededDynlibs.forEach((e) => loadDynamicLibrary(e, flags, localScope)), loadModule());
+    }, mergeLibSymbols = (e, r) => {
+      for (var [t, n] of Object.entries(e)) {
+        let a = (s) => {
+          isSymbolDefined(s) || (wasmImports[s] = n);
+        };
+        a(t);
+        let o = "__main_argc_argv";
+        t == "main" && a(o), t == o && a("main");
+      }
+    }, asyncLoad = async (e) => {
+      var r = await readAsync(e);
+      return new Uint8Array(r);
+    }, preloadPlugins = Module.preloadPlugins || [], registerWasmPlugin = () => {
+      var e = { promiseChainEnd: Promise.resolve(), canHandle: (r) => !Module.noWasmDecoding && r.endsWith(".so"), handle: (r, t, n, a) => {
+        e.promiseChainEnd = e.promiseChainEnd.then(() => loadWebAssemblyModule(r, { loadAsync: true, nodelete: true }, t, {})).then((o) => {
+          preloadedWasm[t] = o, n(r);
+        }, (o) => {
+          err(`failed to instantiate wasm: ${t}: ${o}`), a();
+        });
+      } };
+      preloadPlugins.push(e);
+    }, preloadedWasm = {};
+    function loadDynamicLibrary(e, r = { global: true, nodelete: true }, t, n) {
+      var a = LDSO.loadedLibsByName[e];
+      if (a) return r.global ? a.global || (a.global = true, mergeLibSymbols(a.exports, e)) : t && Object.assign(t, a.exports), r.nodelete && a.refcount !== 1 / 0 && (a.refcount = 1 / 0), a.refcount++, n && (LDSO.loadedLibsByHandle[n] = a), r.loadAsync ? Promise.resolve(true) : true;
+      a = newDSO(e, n, "loading"), a.refcount = r.nodelete ? 1 / 0 : 1, a.global = r.global;
+      function o() {
+        if (n) {
+          var u = HEAPU32[n + 28 >> 2], d = HEAPU32[n + 32 >> 2];
+          if (u && d) {
+            var c = HEAP8.slice(u, u + d);
+            return r.loadAsync ? Promise.resolve(c) : c;
+          }
+        }
+        var m = locateFile(e);
+        if (r.loadAsync) return asyncLoad(m);
+        if (!readBinary) throw new Error(`${m}: file not found, and synchronous loading of external files is not available`);
+        return readBinary(m);
+      }
+      function s() {
+        var u = preloadedWasm[e];
+        return u ? r.loadAsync ? Promise.resolve(u) : u : r.loadAsync ? o().then((d) => loadWebAssemblyModule(d, r, e, t, n)) : loadWebAssemblyModule(o(), r, e, t, n);
+      }
+      function l(u) {
+        a.global ? mergeLibSymbols(u, e) : t && Object.assign(t, u), a.exports = u;
+      }
+      return r.loadAsync ? s().then((u) => (l(u), true)) : (l(s()), true);
+    }
+    var reportUndefinedSymbols = () => {
+      for (var [e, r] of Object.entries(GOT)) if (r.value == 0) {
+        var t = resolveGlobalSymbol(e, true).sym;
+        if (!t && !r.required) continue;
+        if (typeof t == "function") r.value = addFunction(t, t.sig);
+        else if (typeof t == "number") r.value = t;
+        else throw new Error(`bad export type for '${e}': ${typeof t}`);
+      }
+    }, loadDylibs = () => {
+      if (!dynamicLibraries.length) {
+        reportUndefinedSymbols();
+        return;
+      }
+      addRunDependency("loadDylibs"), dynamicLibraries.reduce((e, r) => e.then(() => loadDynamicLibrary(r, { loadAsync: true, global: true, nodelete: true, allowUndefined: true })), Promise.resolve()).then(() => {
+        reportUndefinedSymbols(), removeRunDependency("loadDylibs");
+      });
+    }, noExitRuntime = Module.noExitRuntime || false, ___call_sighandler = (e, r) => getWasmTableEntry(e)(r);
+    ___call_sighandler.sig = "vpi";
+    var ___memory_base = new WebAssembly.Global({ value: "i32", mutable: false }, 1024), ___stack_pointer = new WebAssembly.Global({ value: "i32", mutable: true }, 289952), PATH = { isAbs: (e) => e.charAt(0) === "/", splitPath: (e) => {
+      var r = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+      return r.exec(e).slice(1);
+    }, normalizeArray: (e, r) => {
+      for (var t = 0, n = e.length - 1; n >= 0; n--) {
+        var a = e[n];
+        a === "." ? e.splice(n, 1) : a === ".." ? (e.splice(n, 1), t++) : t && (e.splice(n, 1), t--);
+      }
+      if (r) for (; t; t--) e.unshift("..");
+      return e;
+    }, normalize: (e) => {
+      var r = PATH.isAbs(e), t = e.substr(-1) === "/";
+      return e = PATH.normalizeArray(e.split("/").filter((n) => !!n), !r).join("/"), !e && !r && (e = "."), e && t && (e += "/"), (r ? "/" : "") + e;
+    }, dirname: (e) => {
+      var r = PATH.splitPath(e), t = r[0], n = r[1];
+      return !t && !n ? "." : (n && (n = n.substr(0, n.length - 1)), t + n);
+    }, basename: (e) => {
+      if (e === "/") return "/";
+      e = PATH.normalize(e), e = e.replace(/\/$/, "");
+      var r = e.lastIndexOf("/");
+      return r === -1 ? e : e.substr(r + 1);
+    }, join: (...e) => PATH.normalize(e.join("/")), join2: (e, r) => PATH.normalize(e + "/" + r) }, initRandomFill = () => {
+      if (typeof crypto == "object" && typeof crypto.getRandomValues == "function") return (n) => crypto.getRandomValues(n);
+      if (ENVIRONMENT_IS_NODE) try {
+        var e = require("crypto"), r = e.randomFillSync;
+        if (r) return (n) => e.randomFillSync(n);
+        var t = e.randomBytes;
+        return (n) => (n.set(t(n.byteLength)), n);
+      } catch {
+      }
+      abort("initRandomDevice");
+    }, randomFill = (e) => (randomFill = initRandomFill())(e), PATH_FS = { resolve: (...e) => {
+      for (var r = "", t = false, n = e.length - 1; n >= -1 && !t; n--) {
+        var a = n >= 0 ? e[n] : FS.cwd();
+        if (typeof a != "string") throw new TypeError("Arguments to path.resolve must be strings");
+        if (!a) return "";
+        r = a + "/" + r, t = PATH.isAbs(a);
+      }
+      return r = PATH.normalizeArray(r.split("/").filter((o) => !!o), !t).join("/"), (t ? "/" : "") + r || ".";
+    }, relative: (e, r) => {
+      e = PATH_FS.resolve(e).substr(1), r = PATH_FS.resolve(r).substr(1);
+      function t(d) {
+        for (var c = 0; c < d.length && d[c] === ""; c++) ;
+        for (var m = d.length - 1; m >= 0 && d[m] === ""; m--) ;
+        return c > m ? [] : d.slice(c, m - c + 1);
+      }
+      for (var n = t(e.split("/")), a = t(r.split("/")), o = Math.min(n.length, a.length), s = o, l = 0; l < o; l++) if (n[l] !== a[l]) {
+        s = l;
+        break;
+      }
+      for (var u = [], l = s; l < n.length; l++) u.push("..");
+      return u = u.concat(a.slice(s)), u.join("/");
+    } }, FS_stdin_getChar_buffer = [], lengthBytesUTF8 = (e) => {
+      for (var r = 0, t = 0; t < e.length; ++t) {
+        var n = e.charCodeAt(t);
+        n <= 127 ? r++ : n <= 2047 ? r += 2 : n >= 55296 && n <= 57343 ? (r += 4, ++t) : r += 3;
+      }
+      return r;
+    }, stringToUTF8Array = (e, r, t, n) => {
+      if (!(n > 0)) return 0;
+      for (var a = t, o = t + n - 1, s = 0; s < e.length; ++s) {
+        var l = e.charCodeAt(s);
+        if (l >= 55296 && l <= 57343) {
+          var u = e.charCodeAt(++s);
+          l = 65536 + ((l & 1023) << 10) | u & 1023;
+        }
+        if (l <= 127) {
+          if (t >= o) break;
+          r[t++] = l;
+        } else if (l <= 2047) {
+          if (t + 1 >= o) break;
+          r[t++] = 192 | l >> 6, r[t++] = 128 | l & 63;
+        } else if (l <= 65535) {
+          if (t + 2 >= o) break;
+          r[t++] = 224 | l >> 12, r[t++] = 128 | l >> 6 & 63, r[t++] = 128 | l & 63;
+        } else {
+          if (t + 3 >= o) break;
+          r[t++] = 240 | l >> 18, r[t++] = 128 | l >> 12 & 63, r[t++] = 128 | l >> 6 & 63, r[t++] = 128 | l & 63;
+        }
+      }
+      return r[t] = 0, t - a;
+    };
+    function intArrayFromString(e, r, t) {
+      var n = t > 0 ? t : lengthBytesUTF8(e) + 1, a = new Array(n), o = stringToUTF8Array(e, a, 0, a.length);
+      return r && (a.length = o), a;
+    }
+    var FS_stdin_getChar = () => {
+      if (!FS_stdin_getChar_buffer.length) {
+        var e = null;
+        if (ENVIRONMENT_IS_NODE) {
+          var r = 256, t = Buffer.alloc(r), n = 0, a = process.stdin.fd;
+          try {
+            n = fs.readSync(a, t, 0, r);
+          } catch (o) {
+            if (o.toString().includes("EOF")) n = 0;
+            else throw o;
+          }
+          n > 0 && (e = t.slice(0, n).toString("utf-8"));
+        } else typeof window < "u" && typeof window.prompt == "function" && (e = window.prompt("Input: "), e !== null && (e += `
+`));
+        if (!e) return null;
+        FS_stdin_getChar_buffer = intArrayFromString(e, true);
+      }
+      return FS_stdin_getChar_buffer.shift();
+    }, TTY = { ttys: [], init() {
+    }, shutdown() {
+    }, register(e, r) {
+      TTY.ttys[e] = { input: [], output: [], ops: r }, FS.registerDevice(e, TTY.stream_ops);
+    }, stream_ops: { open(e) {
+      var r = TTY.ttys[e.node.rdev];
+      if (!r) throw new FS.ErrnoError(43);
+      e.tty = r, e.seekable = false;
+    }, close(e) {
+      e.tty.ops.fsync(e.tty);
+    }, fsync(e) {
+      e.tty.ops.fsync(e.tty);
+    }, read(e, r, t, n, a) {
+      if (!e.tty || !e.tty.ops.get_char) throw new FS.ErrnoError(60);
+      for (var o = 0, s = 0; s < n; s++) {
+        var l;
+        try {
+          l = e.tty.ops.get_char(e.tty);
+        } catch {
+          throw new FS.ErrnoError(29);
+        }
+        if (l === void 0 && o === 0) throw new FS.ErrnoError(6);
+        if (l == null) break;
+        o++, r[t + s] = l;
+      }
+      return o && (e.node.atime = Date.now()), o;
+    }, write(e, r, t, n, a) {
+      if (!e.tty || !e.tty.ops.put_char) throw new FS.ErrnoError(60);
+      try {
+        for (var o = 0; o < n; o++) e.tty.ops.put_char(e.tty, r[t + o]);
+      } catch {
+        throw new FS.ErrnoError(29);
+      }
+      return n && (e.node.mtime = e.node.ctime = Date.now()), o;
+    } }, default_tty_ops: { get_char(e) {
+      return FS_stdin_getChar();
+    }, put_char(e, r) {
+      r === null || r === 10 ? (out(UTF8ArrayToString(e.output)), e.output = []) : r != 0 && e.output.push(r);
+    }, fsync(e) {
+      e.output && e.output.length > 0 && (out(UTF8ArrayToString(e.output)), e.output = []);
+    }, ioctl_tcgets(e) {
+      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(e, r, t) {
+      return 0;
+    }, ioctl_tiocgwinsz(e) {
+      return [24, 80];
+    } }, default_tty1_ops: { put_char(e, r) {
+      r === null || r === 10 ? (err(UTF8ArrayToString(e.output)), e.output = []) : r != 0 && e.output.push(r);
+    }, fsync(e) {
+      e.output && e.output.length > 0 && (err(UTF8ArrayToString(e.output)), e.output = []);
+    } } }, zeroMemory = (e, r) => {
+      HEAPU8.fill(0, e, e + r);
+    }, mmapAlloc = (e) => {
+      abort();
+    }, MEMFS = { ops_table: null, mount(e) {
+      return MEMFS.createNode(null, "/", 16895, 0);
+    }, createNode(e, r, t, n) {
+      if (FS.isBlkdev(t) || FS.isFIFO(t)) throw new FS.ErrnoError(63);
+      MEMFS.ops_table || (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 a = FS.createNode(e, r, t, n);
+      return FS.isDir(a.mode) ? (a.node_ops = MEMFS.ops_table.dir.node, a.stream_ops = MEMFS.ops_table.dir.stream, a.contents = {}) : FS.isFile(a.mode) ? (a.node_ops = MEMFS.ops_table.file.node, a.stream_ops = MEMFS.ops_table.file.stream, a.usedBytes = 0, a.contents = null) : FS.isLink(a.mode) ? (a.node_ops = MEMFS.ops_table.link.node, a.stream_ops = MEMFS.ops_table.link.stream) : FS.isChrdev(a.mode) && (a.node_ops = MEMFS.ops_table.chrdev.node, a.stream_ops = MEMFS.ops_table.chrdev.stream), a.atime = a.mtime = a.ctime = Date.now(), e && (e.contents[r] = a, e.atime = e.mtime = e.ctime = a.atime), a;
+    }, getFileDataAsTypedArray(e) {
+      return e.contents ? e.contents.subarray ? e.contents.subarray(0, e.usedBytes) : new Uint8Array(e.contents) : new Uint8Array(0);
+    }, expandFileStorage(e, r) {
+      var t = e.contents ? e.contents.length : 0;
+      if (!(t >= r)) {
+        var n = 1024 * 1024;
+        r = Math.max(r, t * (t < n ? 2 : 1.125) >>> 0), t != 0 && (r = Math.max(r, 256));
+        var a = e.contents;
+        e.contents = new Uint8Array(r), e.usedBytes > 0 && e.contents.set(a.subarray(0, e.usedBytes), 0);
+      }
+    }, resizeFileStorage(e, r) {
+      if (e.usedBytes != r) if (r == 0) e.contents = null, e.usedBytes = 0;
+      else {
+        var t = e.contents;
+        e.contents = new Uint8Array(r), t && e.contents.set(t.subarray(0, Math.min(r, e.usedBytes))), e.usedBytes = r;
+      }
+    }, node_ops: { getattr(e) {
+      var r = {};
+      return r.dev = FS.isChrdev(e.mode) ? e.id : 1, r.ino = e.id, r.mode = e.mode, r.nlink = 1, r.uid = 0, r.gid = 0, r.rdev = e.rdev, FS.isDir(e.mode) ? r.size = 4096 : FS.isFile(e.mode) ? r.size = e.usedBytes : FS.isLink(e.mode) ? r.size = e.link.length : r.size = 0, r.atime = new Date(e.atime), r.mtime = new Date(e.mtime), r.ctime = new Date(e.ctime), r.blksize = 4096, r.blocks = Math.ceil(r.size / r.blksize), r;
+    }, setattr(e, r) {
+      for (let t of ["mode", "atime", "mtime", "ctime"]) r[t] && (e[t] = r[t]);
+      r.size !== void 0 && MEMFS.resizeFileStorage(e, r.size);
+    }, lookup(e, r) {
+      throw MEMFS.doesNotExistError;
+    }, mknod(e, r, t, n) {
+      return MEMFS.createNode(e, r, t, n);
+    }, rename(e, r, t) {
+      var n;
+      try {
+        n = FS.lookupNode(r, t);
+      } catch {
+      }
+      if (n) {
+        if (FS.isDir(e.mode)) for (var a in n.contents) throw new FS.ErrnoError(55);
+        FS.hashRemoveNode(n);
+      }
+      delete e.parent.contents[e.name], r.contents[t] = e, e.name = t, r.ctime = r.mtime = e.parent.ctime = e.parent.mtime = Date.now();
+    }, unlink(e, r) {
+      delete e.contents[r], e.ctime = e.mtime = Date.now();
+    }, rmdir(e, r) {
+      var t = FS.lookupNode(e, r);
+      for (var n in t.contents) throw new FS.ErrnoError(55);
+      delete e.contents[r], e.ctime = e.mtime = Date.now();
+    }, readdir(e) {
+      return [".", "..", ...Object.keys(e.contents)];
+    }, symlink(e, r, t) {
+      var n = MEMFS.createNode(e, r, 41471, 0);
+      return n.link = t, n;
+    }, readlink(e) {
+      if (!FS.isLink(e.mode)) throw new FS.ErrnoError(28);
+      return e.link;
+    } }, stream_ops: { read(e, r, t, n, a) {
+      var o = e.node.contents;
+      if (a >= e.node.usedBytes) return 0;
+      var s = Math.min(e.node.usedBytes - a, n);
+      if (s > 8 && o.subarray) r.set(o.subarray(a, a + s), t);
+      else for (var l = 0; l < s; l++) r[t + l] = o[a + l];
+      return s;
+    }, write(e, r, t, n, a, o) {
+      if (r.buffer === HEAP8.buffer && (o = false), !n) return 0;
+      var s = e.node;
+      if (s.mtime = s.ctime = Date.now(), r.subarray && (!s.contents || s.contents.subarray)) {
+        if (o) return s.contents = r.subarray(t, t + n), s.usedBytes = n, n;
+        if (s.usedBytes === 0 && a === 0) return s.contents = r.slice(t, t + n), s.usedBytes = n, n;
+        if (a + n <= s.usedBytes) return s.contents.set(r.subarray(t, t + n), a), n;
+      }
+      if (MEMFS.expandFileStorage(s, a + n), s.contents.subarray && r.subarray) s.contents.set(r.subarray(t, t + n), a);
+      else for (var l = 0; l < n; l++) s.contents[a + l] = r[t + l];
+      return s.usedBytes = Math.max(s.usedBytes, a + n), n;
+    }, llseek(e, r, t) {
+      var n = r;
+      if (t === 1 ? n += e.position : t === 2 && FS.isFile(e.node.mode) && (n += e.node.usedBytes), n < 0) throw new FS.ErrnoError(28);
+      return n;
+    }, allocate(e, r, t) {
+      MEMFS.expandFileStorage(e.node, r + t), e.node.usedBytes = Math.max(e.node.usedBytes, r + t);
+    }, mmap(e, r, t, n, a) {
+      if (!FS.isFile(e.node.mode)) throw new FS.ErrnoError(43);
+      var o, s, l = e.node.contents;
+      if (!(a & 2) && l && l.buffer === HEAP8.buffer) s = false, o = l.byteOffset;
+      else {
+        if (s = true, o = mmapAlloc(r), !o) throw new FS.ErrnoError(48);
+        l && ((t > 0 || t + r < l.length) && (l.subarray ? l = l.subarray(t, t + r) : l = Array.prototype.slice.call(l, t, t + r)), HEAP8.set(l, o));
+      }
+      return { ptr: o, allocated: s };
+    }, msync(e, r, t, n, a) {
+      return MEMFS.stream_ops.write(e, r, 0, n, t, false), 0;
+    } } }, FS_createDataFile = (e, r, t, n, a, o) => {
+      FS.createDataFile(e, r, t, n, a, o);
+    }, FS_handledByPreloadPlugin = (e, r, t, n) => {
+      typeof Browser < "u" && Browser.init();
+      var a = false;
+      return preloadPlugins.forEach((o) => {
+        a || o.canHandle(r) && (o.handle(e, r, t, n), a = true);
+      }), a;
+    }, FS_createPreloadedFile = (e, r, t, n, a, o, s, l, u, d) => {
+      var c = r ? PATH_FS.resolve(PATH.join2(e, r)) : e, m = `cp ${c}`;
+      function _(f) {
+        function S(v) {
+          d?.(), l || FS_createDataFile(e, r, v, n, a, u), o?.(), removeRunDependency(m);
+        }
+        FS_handledByPreloadPlugin(f, c, S, () => {
+          s?.(), removeRunDependency(m);
+        }) || S(f);
+      }
+      addRunDependency(m), typeof t == "string" ? asyncLoad(t).then(_, s) : _(t);
+    }, FS_modeStringToFlags = (e) => {
+      var r = { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }, t = r[e];
+      if (typeof t > "u") throw new Error(`Unknown file open mode: ${e}`);
+      return t;
+    }, FS_getMode = (e, r) => {
+      var t = 0;
+      return e && (t |= 365), r && (t |= 146), t;
+    }, FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, ErrnoError: class {
+      constructor(e) {
+        b(this, "name", "ErrnoError");
+        this.errno = e;
+      }
+    }, filesystems: null, syncFSRequests: 0, readFiles: {}, FSStream: class {
+      constructor() {
+        b(this, "shared", {});
+      }
+      get object() {
+        return this.node;
+      }
+      set object(e) {
+        this.node = e;
+      }
+      get isRead() {
+        return (this.flags & 2097155) !== 1;
+      }
+      get isWrite() {
+        return (this.flags & 2097155) !== 0;
+      }
+      get isAppend() {
+        return this.flags & 1024;
+      }
+      get flags() {
+        return this.shared.flags;
+      }
+      set flags(e) {
+        this.shared.flags = e;
+      }
+      get position() {
+        return this.shared.position;
+      }
+      set position(e) {
+        this.shared.position = e;
+      }
+    }, FSNode: class {
+      constructor(e, r, t, n) {
+        b(this, "node_ops", {});
+        b(this, "stream_ops", {});
+        b(this, "readMode", 365);
+        b(this, "writeMode", 146);
+        b(this, "mounted", null);
+        e || (e = this), this.parent = e, this.mount = e.mount, this.id = FS.nextInode++, this.name = r, this.mode = t, this.rdev = n, this.atime = this.mtime = this.ctime = Date.now();
+      }
+      get read() {
+        return (this.mode & this.readMode) === this.readMode;
+      }
+      set read(e) {
+        e ? this.mode |= this.readMode : this.mode &= ~this.readMode;
+      }
+      get write() {
+        return (this.mode & this.writeMode) === this.writeMode;
+      }
+      set write(e) {
+        e ? this.mode |= this.writeMode : this.mode &= ~this.writeMode;
+      }
+      get isFolder() {
+        return FS.isDir(this.mode);
+      }
+      get isDevice() {
+        return FS.isChrdev(this.mode);
+      }
+    }, lookupPath(e, r = {}) {
+      if (!e) return { path: "", node: null };
+      r.follow_mount ?? (r.follow_mount = true), PATH.isAbs(e) || (e = FS.cwd() + "/" + e);
+      e: for (var t = 0; t < 40; t++) {
+        for (var n = e.split("/").filter((d) => !!d && d !== "."), a = FS.root, o = "/", s = 0; s < n.length; s++) {
+          var l = s === n.length - 1;
+          if (l && r.parent) break;
+          if (n[s] === "..") {
+            o = PATH.dirname(o), a = a.parent;
+            continue;
+          }
+          o = PATH.join2(o, n[s]);
+          try {
+            a = FS.lookupNode(a, n[s]);
+          } catch (d) {
+            if (d?.errno === 44 && l && r.noent_okay) return { path: o };
+            throw d;
+          }
+          if (FS.isMountpoint(a) && (!l || r.follow_mount) && (a = a.mounted.root), FS.isLink(a.mode) && (!l || r.follow)) {
+            if (!a.node_ops.readlink) throw new FS.ErrnoError(52);
+            var u = a.node_ops.readlink(a);
+            PATH.isAbs(u) || (u = PATH.dirname(o) + "/" + u), e = u + "/" + n.slice(s + 1).join("/");
+            continue e;
+          }
+        }
+        return { path: o, node: a };
+      }
+      throw new FS.ErrnoError(32);
+    }, getPath(e) {
+      for (var r; ; ) {
+        if (FS.isRoot(e)) {
+          var t = e.mount.mountpoint;
+          return r ? t[t.length - 1] !== "/" ? `${t}/${r}` : t + r : t;
+        }
+        r = r ? `${e.name}/${r}` : e.name, e = e.parent;
+      }
+    }, hashName(e, r) {
+      for (var t = 0, n = 0; n < r.length; n++) t = (t << 5) - t + r.charCodeAt(n) | 0;
+      return (e + t >>> 0) % FS.nameTable.length;
+    }, hashAddNode(e) {
+      var r = FS.hashName(e.parent.id, e.name);
+      e.name_next = FS.nameTable[r], FS.nameTable[r] = e;
+    }, hashRemoveNode(e) {
+      var r = FS.hashName(e.parent.id, e.name);
+      if (FS.nameTable[r] === e) FS.nameTable[r] = e.name_next;
+      else for (var t = FS.nameTable[r]; t; ) {
+        if (t.name_next === e) {
+          t.name_next = e.name_next;
+          break;
+        }
+        t = t.name_next;
+      }
+    }, lookupNode(e, r) {
+      var t = FS.mayLookup(e);
+      if (t) throw new FS.ErrnoError(t);
+      for (var n = FS.hashName(e.id, r), a = FS.nameTable[n]; a; a = a.name_next) {
+        var o = a.name;
+        if (a.parent.id === e.id && o === r) return a;
+      }
+      return FS.lookup(e, r);
+    }, createNode(e, r, t, n) {
+      var a = new FS.FSNode(e, r, t, n);
+      return FS.hashAddNode(a), a;
+    }, destroyNode(e) {
+      FS.hashRemoveNode(e);
+    }, isRoot(e) {
+      return e === e.parent;
+    }, isMountpoint(e) {
+      return !!e.mounted;
+    }, isFile(e) {
+      return (e & 61440) === 32768;
+    }, isDir(e) {
+      return (e & 61440) === 16384;
+    }, isLink(e) {
+      return (e & 61440) === 40960;
+    }, isChrdev(e) {
+      return (e & 61440) === 8192;
+    }, isBlkdev(e) {
+      return (e & 61440) === 24576;
+    }, isFIFO(e) {
+      return (e & 61440) === 4096;
+    }, isSocket(e) {
+      return (e & 49152) === 49152;
+    }, flagsToPermissionString(e) {
+      var r = ["r", "w", "rw"][e & 3];
+      return e & 512 && (r += "w"), r;
+    }, nodePermissions(e, r) {
+      return FS.ignorePermissions ? 0 : r.includes("r") && !(e.mode & 292) || r.includes("w") && !(e.mode & 146) || r.includes("x") && !(e.mode & 73) ? 2 : 0;
+    }, mayLookup(e) {
+      if (!FS.isDir(e.mode)) return 54;
+      var r = FS.nodePermissions(e, "x");
+      return r || (e.node_ops.lookup ? 0 : 2);
+    }, mayCreate(e, r) {
+      if (!FS.isDir(e.mode)) return 54;
+      try {
+        var t = FS.lookupNode(e, r);
+        return 20;
+      } catch {
+      }
+      return FS.nodePermissions(e, "wx");
+    }, mayDelete(e, r, t) {
+      var n;
+      try {
+        n = FS.lookupNode(e, r);
+      } catch (o) {
+        return o.errno;
+      }
+      var a = FS.nodePermissions(e, "wx");
+      if (a) return a;
+      if (t) {
+        if (!FS.isDir(n.mode)) return 54;
+        if (FS.isRoot(n) || FS.getPath(n) === FS.cwd()) return 10;
+      } else if (FS.isDir(n.mode)) return 31;
+      return 0;
+    }, mayOpen(e, r) {
+      return e ? FS.isLink(e.mode) ? 32 : FS.isDir(e.mode) && (FS.flagsToPermissionString(r) !== "r" || r & 512) ? 31 : FS.nodePermissions(e, FS.flagsToPermissionString(r)) : 44;
+    }, MAX_OPEN_FDS: 4096, nextfd() {
+      for (var e = 0; e <= FS.MAX_OPEN_FDS; e++) if (!FS.streams[e]) return e;
+      throw new FS.ErrnoError(33);
+    }, getStreamChecked(e) {
+      var r = FS.getStream(e);
+      if (!r) throw new FS.ErrnoError(8);
+      return r;
+    }, getStream: (e) => FS.streams[e], createStream(e, r = -1) {
+      return e = Object.assign(new FS.FSStream(), e), r == -1 && (r = FS.nextfd()), e.fd = r, FS.streams[r] = e, e;
+    }, closeStream(e) {
+      FS.streams[e] = null;
+    }, dupStream(e, r = -1) {
+      var t = FS.createStream(e, r);
+      return t.stream_ops?.dup?.(t), t;
+    }, chrdev_stream_ops: { open(e) {
+      var r = FS.getDevice(e.node.rdev);
+      e.stream_ops = r.stream_ops, e.stream_ops.open?.(e);
+    }, llseek() {
+      throw new FS.ErrnoError(70);
+    } }, major: (e) => e >> 8, minor: (e) => e & 255, makedev: (e, r) => e << 8 | r, registerDevice(e, r) {
+      FS.devices[e] = { stream_ops: r };
+    }, getDevice: (e) => FS.devices[e], getMounts(e) {
+      for (var r = [], t = [e]; t.length; ) {
+        var n = t.pop();
+        r.push(n), t.push(...n.mounts);
+      }
+      return r;
+    }, syncfs(e, r) {
+      typeof e == "function" && (r = e, e = false), FS.syncFSRequests++, FS.syncFSRequests > 1 && err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
+      var t = FS.getMounts(FS.root.mount), n = 0;
+      function a(s) {
+        return FS.syncFSRequests--, r(s);
+      }
+      function o(s) {
+        if (s) return o.errored ? void 0 : (o.errored = true, a(s));
+        ++n >= t.length && a(null);
+      }
+      t.forEach((s) => {
+        if (!s.type.syncfs) return o(null);
+        s.type.syncfs(s, e, o);
+      });
+    }, mount(e, r, t) {
+      var n = t === "/", a = !t, o;
+      if (n && FS.root) throw new FS.ErrnoError(10);
+      if (!n && !a) {
+        var s = FS.lookupPath(t, { follow_mount: false });
+        if (t = s.path, o = s.node, FS.isMountpoint(o)) throw new FS.ErrnoError(10);
+        if (!FS.isDir(o.mode)) throw new FS.ErrnoError(54);
+      }
+      var l = { type: e, opts: r, mountpoint: t, mounts: [] }, u = e.mount(l);
+      return u.mount = l, l.root = u, n ? FS.root = u : o && (o.mounted = l, o.mount && o.mount.mounts.push(l)), u;
+    }, unmount(e) {
+      var r = FS.lookupPath(e, { follow_mount: false });
+      if (!FS.isMountpoint(r.node)) throw new FS.ErrnoError(28);
+      var t = r.node, n = t.mounted, a = FS.getMounts(n);
+      Object.keys(FS.nameTable).forEach((s) => {
+        for (var l = FS.nameTable[s]; l; ) {
+          var u = l.name_next;
+          a.includes(l.mount) && FS.destroyNode(l), l = u;
+        }
+      }), t.mounted = null;
+      var o = t.mount.mounts.indexOf(n);
+      t.mount.mounts.splice(o, 1);
+    }, lookup(e, r) {
+      return e.node_ops.lookup(e, r);
+    }, mknod(e, r, t) {
+      var n = FS.lookupPath(e, { parent: true }), a = n.node, o = PATH.basename(e);
+      if (!o || o === "." || o === "..") throw new FS.ErrnoError(28);
+      var s = FS.mayCreate(a, o);
+      if (s) throw new FS.ErrnoError(s);
+      if (!a.node_ops.mknod) throw new FS.ErrnoError(63);
+      return a.node_ops.mknod(a, o, r, t);
+    }, statfs(e) {
+      var r = { bsize: 4096, frsize: 4096, blocks: 1e6, bfree: 5e5, bavail: 5e5, files: FS.nextInode, ffree: FS.nextInode - 1, fsid: 42, flags: 2, namelen: 255 }, t = FS.lookupPath(e, { follow: true }).node;
+      return t?.node_ops.statfs && Object.assign(r, t.node_ops.statfs(t.mount.opts.root)), r;
+    }, create(e, r = 438) {
+      return r &= 4095, r |= 32768, FS.mknod(e, r, 0);
+    }, mkdir(e, r = 511) {
+      return r &= 1023, r |= 16384, FS.mknod(e, r, 0);
+    }, mkdirTree(e, r) {
+      for (var t = e.split("/"), n = "", a = 0; a < t.length; ++a) if (t[a]) {
+        n += "/" + t[a];
+        try {
+          FS.mkdir(n, r);
+        } catch (o) {
+          if (o.errno != 20) throw o;
+        }
+      }
+    }, mkdev(e, r, t) {
+      return typeof t > "u" && (t = r, r = 438), r |= 8192, FS.mknod(e, r, t);
+    }, symlink(e, r) {
+      if (!PATH_FS.resolve(e)) throw new FS.ErrnoError(44);
+      var t = FS.lookupPath(r, { parent: true }), n = t.node;
+      if (!n) throw new FS.ErrnoError(44);
+      var a = PATH.basename(r), o = FS.mayCreate(n, a);
+      if (o) throw new FS.ErrnoError(o);
+      if (!n.node_ops.symlink) throw new FS.ErrnoError(63);
+      return n.node_ops.symlink(n, a, e);
+    }, rename(e, r) {
+      var t = PATH.dirname(e), n = PATH.dirname(r), a = PATH.basename(e), o = PATH.basename(r), s, l, u;
+      if (s = FS.lookupPath(e, { parent: true }), l = s.node, s = FS.lookupPath(r, { parent: true }), u = s.node, !l || !u) throw new FS.ErrnoError(44);
+      if (l.mount !== u.mount) throw new FS.ErrnoError(75);
+      var d = FS.lookupNode(l, a), c = PATH_FS.relative(e, n);
+      if (c.charAt(0) !== ".") throw new FS.ErrnoError(28);
+      if (c = PATH_FS.relative(r, t), c.charAt(0) !== ".") throw new FS.ErrnoError(55);
+      var m;
+      try {
+        m = FS.lookupNode(u, o);
+      } catch {
+      }
+      if (d !== m) {
+        var _ = FS.isDir(d.mode), f = FS.mayDelete(l, a, _);
+        if (f) throw new FS.ErrnoError(f);
+        if (f = m ? FS.mayDelete(u, o, _) : FS.mayCreate(u, o), f) throw new FS.ErrnoError(f);
+        if (!l.node_ops.rename) throw new FS.ErrnoError(63);
+        if (FS.isMountpoint(d) || m && FS.isMountpoint(m)) throw new FS.ErrnoError(10);
+        if (u !== l && (f = FS.nodePermissions(l, "w"), f)) throw new FS.ErrnoError(f);
+        FS.hashRemoveNode(d);
+        try {
+          l.node_ops.rename(d, u, o), d.parent = u;
+        } catch (S) {
+          throw S;
+        } finally {
+          FS.hashAddNode(d);
+        }
+      }
+    }, rmdir(e) {
+      var r = FS.lookupPath(e, { parent: true }), t = r.node, n = PATH.basename(e), a = FS.lookupNode(t, n), o = FS.mayDelete(t, n, true);
+      if (o) throw new FS.ErrnoError(o);
+      if (!t.node_ops.rmdir) throw new FS.ErrnoError(63);
+      if (FS.isMountpoint(a)) throw new FS.ErrnoError(10);
+      t.node_ops.rmdir(t, n), FS.destroyNode(a);
+    }, readdir(e) {
+      var r = FS.lookupPath(e, { follow: true }), t = r.node;
+      if (!t.node_ops.readdir) throw new FS.ErrnoError(54);
+      return t.node_ops.readdir(t);
+    }, unlink(e) {
+      var r = FS.lookupPath(e, { parent: true }), t = r.node;
+      if (!t) throw new FS.ErrnoError(44);
+      var n = PATH.basename(e), a = FS.lookupNode(t, n), o = FS.mayDelete(t, n, false);
+      if (o) throw new FS.ErrnoError(o);
+      if (!t.node_ops.unlink) throw new FS.ErrnoError(63);
+      if (FS.isMountpoint(a)) throw new FS.ErrnoError(10);
+      t.node_ops.unlink(t, n), FS.destroyNode(a);
+    }, readlink(e) {
+      var r = FS.lookupPath(e), t = r.node;
+      if (!t) throw new FS.ErrnoError(44);
+      if (!t.node_ops.readlink) throw new FS.ErrnoError(28);
+      return t.node_ops.readlink(t);
+    }, stat(e, r) {
+      var t = FS.lookupPath(e, { follow: !r }), n = t.node;
+      if (!n) throw new FS.ErrnoError(44);
+      if (!n.node_ops.getattr) throw new FS.ErrnoError(63);
+      return n.node_ops.getattr(n);
+    }, lstat(e) {
+      return FS.stat(e, true);
+    }, chmod(e, r, t) {
+      var n;
+      if (typeof e == "string") {
+        var a = FS.lookupPath(e, { follow: !t });
+        n = a.node;
+      } else n = e;
+      if (!n.node_ops.setattr) throw new FS.ErrnoError(63);
+      n.node_ops.setattr(n, { mode: r & 4095 | n.mode & -4096, ctime: Date.now() });
+    }, lchmod(e, r) {
+      FS.chmod(e, r, true);
+    }, fchmod(e, r) {
+      var t = FS.getStreamChecked(e);
+      FS.chmod(t.node, r);
+    }, chown(e, r, t, n) {
+      var a;
+      if (typeof e == "string") {
+        var o = FS.lookupPath(e, { follow: !n });
+        a = o.node;
+      } else a = e;
+      if (!a.node_ops.setattr) throw new FS.ErrnoError(63);
+      a.node_ops.setattr(a, { timestamp: Date.now() });
+    }, lchown(e, r, t) {
+      FS.chown(e, r, t, true);
+    }, fchown(e, r, t) {
+      var n = FS.getStreamChecked(e);
+      FS.chown(n.node, r, t);
+    }, truncate(e, r) {
+      if (r < 0) throw new FS.ErrnoError(28);
+      var t;
+      if (typeof e == "string") {
+        var n = FS.lookupPath(e, { follow: true });
+        t = n.node;
+      } else t = e;
+      if (!t.node_ops.setattr) throw new FS.ErrnoError(63);
+      if (FS.isDir(t.mode)) throw new FS.ErrnoError(31);
+      if (!FS.isFile(t.mode)) throw new FS.ErrnoError(28);
+      var a = FS.nodePermissions(t, "w");
+      if (a) throw new FS.ErrnoError(a);
+      t.node_ops.setattr(t, { size: r, timestamp: Date.now() });
+    }, ftruncate(e, r) {
+      var t = FS.getStreamChecked(e);
+      if (!(t.flags & 2097155)) throw new FS.ErrnoError(28);
+      FS.truncate(t.node, r);
+    }, utime(e, r, t) {
+      var n = FS.lookupPath(e, { follow: true }), a = n.node;
+      a.node_ops.setattr(a, { atime: r, mtime: t });
+    }, open(e, r, t = 438) {
+      if (e === "") throw new FS.ErrnoError(44);
+      r = typeof r == "string" ? FS_modeStringToFlags(r) : r, r & 64 ? t = t & 4095 | 32768 : t = 0;
+      var n;
+      if (typeof e == "object") n = e;
+      else {
+        var a = FS.lookupPath(e, { follow: !(r & 131072), noent_okay: true });
+        n = a.node, e = a.path;
+      }
+      var o = false;
+      if (r & 64) if (n) {
+        if (r & 128) throw new FS.ErrnoError(20);
+      } else n = FS.mknod(e, t, 0), o = true;
+      if (!n) throw new FS.ErrnoError(44);
+      if (FS.isChrdev(n.mode) && (r &= -513), r & 65536 && !FS.isDir(n.mode)) throw new FS.ErrnoError(54);
+      if (!o) {
+        var s = FS.mayOpen(n, r);
+        if (s) throw new FS.ErrnoError(s);
+      }
+      r & 512 && !o && FS.truncate(n, 0), r &= -131713;
+      var l = FS.createStream({ node: n, path: FS.getPath(n), flags: r, seekable: true, position: 0, stream_ops: n.stream_ops, ungotten: [], error: false });
+      return l.stream_ops.open && l.stream_ops.open(l), Module.logReadFiles && !(r & 1) && (e in FS.readFiles || (FS.readFiles[e] = 1)), l;
+    }, close(e) {
+      if (FS.isClosed(e)) throw new FS.ErrnoError(8);
+      e.getdents && (e.getdents = null);
+      try {
+        e.stream_ops.close && e.stream_ops.close(e);
+      } catch (r) {
+        throw r;
+      } finally {
+        FS.closeStream(e.fd);
+      }
+      e.fd = null;
+    }, isClosed(e) {
+      return e.fd === null;
+    }, llseek(e, r, t) {
+      if (FS.isClosed(e)) throw new FS.ErrnoError(8);
+      if (!e.seekable || !e.stream_ops.llseek) throw new FS.ErrnoError(70);
+      if (t != 0 && t != 1 && t != 2) throw new FS.ErrnoError(28);
+      return e.position = e.stream_ops.llseek(e, r, t), e.ungotten = [], e.position;
+    }, read(e, r, t, n, a) {
+      if (n < 0 || a < 0) throw new FS.ErrnoError(28);
+      if (FS.isClosed(e)) throw new FS.ErrnoError(8);
+      if ((e.flags & 2097155) === 1) throw new FS.ErrnoError(8);
+      if (FS.isDir(e.node.mode)) throw new FS.ErrnoError(31);
+      if (!e.stream_ops.read) throw new FS.ErrnoError(28);
+      var o = typeof a < "u";
+      if (!o) a = e.position;
+      else if (!e.seekable) throw new FS.ErrnoError(70);
+      var s = e.stream_ops.read(e, r, t, n, a);
+      return o || (e.position += s), s;
+    }, write(e, r, t, n, a, o) {
+      if (n < 0 || a < 0) throw new FS.ErrnoError(28);
+      if (FS.isClosed(e)) throw new FS.ErrnoError(8);
+      if (!(e.flags & 2097155)) throw new FS.ErrnoError(8);
+      if (FS.isDir(e.node.mode)) throw new FS.ErrnoError(31);
+      if (!e.stream_ops.write) throw new FS.ErrnoError(28);
+      e.seekable && e.flags & 1024 && FS.llseek(e, 0, 2);
+      var s = typeof a < "u";
+      if (!s) a = e.position;
+      else if (!e.seekable) throw new FS.ErrnoError(70);
+      var l = e.stream_ops.write(e, r, t, n, a, o);
+      return s || (e.position += l), l;
+    }, allocate(e, r, t) {
+      if (FS.isClosed(e)) throw new FS.ErrnoError(8);
+      if (r < 0 || t <= 0) throw new FS.ErrnoError(28);
+      if (!(e.flags & 2097155)) throw new FS.ErrnoError(8);
+      if (!FS.isFile(e.node.mode) && !FS.isDir(e.node.mode)) throw new FS.ErrnoError(43);
+      if (!e.stream_ops.allocate) throw new FS.ErrnoError(138);
+      e.stream_ops.allocate(e, r, t);
+    }, mmap(e, r, t, n, a) {
+      if (n & 2 && !(a & 2) && (e.flags & 2097155) !== 2) throw new FS.ErrnoError(2);
+      if ((e.flags & 2097155) === 1) throw new FS.ErrnoError(2);
+      if (!e.stream_ops.mmap) throw new FS.ErrnoError(43);
+      if (!r) throw new FS.ErrnoError(28);
+      return e.stream_ops.mmap(e, r, t, n, a);
+    }, msync(e, r, t, n, a) {
+      return e.stream_ops.msync ? e.stream_ops.msync(e, r, t, n, a) : 0;
+    }, ioctl(e, r, t) {
+      if (!e.stream_ops.ioctl) throw new FS.ErrnoError(59);
+      return e.stream_ops.ioctl(e, r, t);
+    }, readFile(e, r = {}) {
+      if (r.flags = r.flags || 0, r.encoding = r.encoding || "binary", r.encoding !== "utf8" && r.encoding !== "binary") throw new Error(`Invalid encoding type "${r.encoding}"`);
+      var t, n = FS.open(e, r.flags), a = FS.stat(e), o = a.size, s = new Uint8Array(o);
+      return FS.read(n, s, 0, o, 0), r.encoding === "utf8" ? t = UTF8ArrayToString(s) : r.encoding === "binary" && (t = s), FS.close(n), t;
+    }, writeFile(e, r, t = {}) {
+      t.flags = t.flags || 577;
+      var n = FS.open(e, t.flags, t.mode);
+      if (typeof r == "string") {
+        var a = new Uint8Array(lengthBytesUTF8(r) + 1), o = stringToUTF8Array(r, a, 0, a.length);
+        FS.write(n, a, 0, o, void 0, t.canOwn);
+      } else if (ArrayBuffer.isView(r)) FS.write(n, r, 0, r.byteLength, void 0, t.canOwn);
+      else throw new Error("Unsupported data type");
+      FS.close(n);
+    }, cwd: () => FS.currentPath, chdir(e) {
+      var r = FS.lookupPath(e, { follow: true });
+      if (r.node === null) throw new FS.ErrnoError(44);
+      if (!FS.isDir(r.node.mode)) throw new FS.ErrnoError(54);
+      var t = FS.nodePermissions(r.node, "x");
+      if (t) throw new FS.ErrnoError(t);
+      FS.currentPath = r.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: (n, a, o, s, l) => s, llseek: () => 0 }), 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 e = new Uint8Array(1024), r = 0, t = () => (r === 0 && (r = randomFill(e).byteLength), e[--r]);
+      FS.createDevice("/dev", "random", t), FS.createDevice("/dev", "urandom", t), FS.mkdir("/dev/shm"), FS.mkdir("/dev/shm/tmp");
+    }, createSpecialDirectories() {
+      FS.mkdir("/proc");
+      var e = FS.mkdir("/proc/self");
+      FS.mkdir("/proc/self/fd"), FS.mount({ mount() {
+        var r = FS.createNode(e, "fd", 16895, 73);
+        return r.stream_ops = { llseek: MEMFS.stream_ops.llseek }, r.node_ops = { lookup(t, n) {
+          var a = +n, o = FS.getStreamChecked(a), s = { parent: null, mount: { mountpoint: "fake" }, node_ops: { readlink: () => o.path }, id: a + 1 };
+          return s.parent = s, s;
+        }, readdir() {
+          return Array.from(FS.streams.entries()).filter(([t, n]) => n).map(([t, n]) => t.toString());
+        } }, r;
+      } }, {}, "/proc/self/fd");
+    }, createStandardStreams(e, r, t) {
+      e ? FS.createDevice("/dev", "stdin", e) : FS.symlink("/dev/tty", "/dev/stdin"), r ? FS.createDevice("/dev", "stdout", null, r) : FS.symlink("/dev/tty", "/dev/stdout"), t ? FS.createDevice("/dev", "stderr", null, t) : FS.symlink("/dev/tty1", "/dev/stderr");
+      var n = FS.open("/dev/stdin", 0), a = FS.open("/dev/stdout", 1), o = FS.open("/dev/stderr", 1);
+    }, staticInit() {
+      FS.nameTable = new Array(4096), FS.mount(MEMFS, {}, "/"), FS.createDefaultDirectories(), FS.createDefaultDevices(), FS.createSpecialDirectories(), FS.filesystems = { MEMFS };
+    }, init(e, r, t) {
+      FS.initialized = true, e ?? (e = Module.stdin), r ?? (r = Module.stdout), t ?? (t = Module.stderr), FS.createStandardStreams(e, r, t);
+    }, quit() {
+      FS.initialized = false, _fflush(0);
+      for (var e = 0; e < FS.streams.length; e++) {
+        var r = FS.streams[e];
+        r && FS.close(r);
+      }
+    }, findObject(e, r) {
+      var t = FS.analyzePath(e, r);
+      return t.exists ? t.object : null;
+    }, analyzePath(e, r) {
+      try {
+        var t = FS.lookupPath(e, { follow: !r });
+        e = t.path;
+      } catch {
+      }
+      var n = { isRoot: false, exists: false, error: 0, name: null, path: null, object: null, parentExists: false, parentPath: null, parentObject: null };
+      try {
+        var t = FS.lookupPath(e, { parent: true });
+        n.parentExists = true, n.parentPath = t.path, n.parentObject = t.node, n.name = PATH.basename(e), t = FS.lookupPath(e, { follow: !r }), n.exists = true, n.path = t.path, n.object = t.node, n.name = t.node.name, n.isRoot = t.path === "/";
+      } catch (a) {
+        n.error = a.errno;
+      }
+      return n;
+    }, createPath(e, r, t, n) {
+      e = typeof e == "string" ? e : FS.getPath(e);
+      for (var a = r.split("/").reverse(); a.length; ) {
+        var o = a.pop();
+        if (o) {
+          var s = PATH.join2(e, o);
+          try {
+            FS.mkdir(s);
+          } catch {
+          }
+          e = s;
+        }
+      }
+      return s;
+    }, createFile(e, r, t, n, a) {
+      var o = PATH.join2(typeof e == "string" ? e : FS.getPath(e), r), s = FS_getMode(n, a);
+      return FS.create(o, s);
+    }, createDataFile(e, r, t, n, a, o) {
+      var s = r;
+      e && (e = typeof e == "string" ? e : FS.getPath(e), s = r ? PATH.join2(e, r) : e);
+      var l = FS_getMode(n, a), u = FS.create(s, l);
+      if (t) {
+        if (typeof t == "string") {
+          for (var d = new Array(t.length), c = 0, m = t.length; c < m; ++c) d[c] = t.charCodeAt(c);
+          t = d;
+        }
+        FS.chmod(u, l | 146);
+        var _ = FS.open(u, 577);
+        FS.write(_, t, 0, t.length, 0, o), FS.close(_), FS.chmod(u, l);
+      }
+    }, createDevice(e, r, t, n) {
+      var l;
+      var a = PATH.join2(typeof e == "string" ? e : FS.getPath(e), r), o = FS_getMode(!!t, !!n);
+      (l = FS.createDevice).major ?? (l.major = 64);
+      var s = FS.makedev(FS.createDevice.major++, 0);
+      return FS.registerDevice(s, { open(u) {
+        u.seekable = false;
+      }, close(u) {
+        n?.buffer?.length && n(10);
+      }, read(u, d, c, m, _) {
+        for (var f = 0, S = 0; S < m; S++) {
+          var v;
+          try {
+            v = t();
+          } catch {
+            throw new FS.ErrnoError(29);
+          }
+          if (v === void 0 && f === 0) throw new FS.ErrnoError(6);
+          if (v == null) break;
+          f++, d[c + S] = v;
+        }
+        return f && (u.node.atime = Date.now()), f;
+      }, write(u, d, c, m, _) {
+        for (var f = 0; f < m; f++) try {
+          n(d[c + f]);
+        } catch {
+          throw new FS.ErrnoError(29);
+        }
+        return m && (u.node.mtime = u.node.ctime = Date.now()), f;
+      } }), FS.mkdev(a, o, s);
+    }, forceLoadFile(e) {
+      if (e.isDevice || e.isFolder || e.link || e.contents) return true;
+      if (typeof XMLHttpRequest < "u") 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.");
+      try {
+        e.contents = readBinary(e.url), e.usedBytes = e.contents.length;
+      } catch {
+        throw new FS.ErrnoError(29);
+      }
+    }, createLazyFile(e, r, t, n, a) {
+      class o {
+        constructor() {
+          b(this, "lengthKnown", false);
+          b(this, "chunks", []);
+        }
+        get(f) {
+          if (!(f > this.length - 1 || f < 0)) {
+            var S = f % this.chunkSize, v = f / this.chunkSize | 0;
+            return this.getter(v)[S];
+          }
+        }
+        setDataGetter(f) {
+          this.getter = f;
+        }
+        cacheLength() {
+          var f = new XMLHttpRequest();
+          if (f.open("HEAD", t, false), f.send(null), !(f.status >= 200 && f.status < 300 || f.status === 304)) throw new Error("Couldn't load " + t + ". Status: " + f.status);
+          var S = Number(f.getResponseHeader("Content-length")), v, F = (v = f.getResponseHeader("Accept-Ranges")) && v === "bytes", g = (v = f.getResponseHeader("Content-Encoding")) && v === "gzip", w = 1024 * 1024;
+          F || (w = S);
+          var A = (p, h) => {
+            if (p > h) throw new Error("invalid range (" + p + ", " + h + ") or no bytes requested!");
+            if (h > S - 1) throw new Error("only " + S + " bytes available! programmer error!");
+            var E = new XMLHttpRequest();
+            if (E.open("GET", t, false), S !== w && E.setRequestHeader("Range", "bytes=" + p + "-" + h), E.responseType = "arraybuffer", E.overrideMimeType && E.overrideMimeType("text/plain; charset=x-user-defined"), E.send(null), !(E.status >= 200 && E.status < 300 || E.status === 304)) throw new Error("Couldn't load " + t + ". Status: " + E.status);
+            return E.response !== void 0 ? new Uint8Array(E.response || []) : intArrayFromString(E.responseText || "", true);
+          }, y = this;
+          y.setDataGetter((p) => {
+            var h = p * w, E = (p + 1) * w - 1;
+            if (E = Math.min(E, S - 1), typeof y.chunks[p] > "u" && (y.chunks[p] = A(h, E)), typeof y.chunks[p] > "u") throw new Error("doXHR failed!");
+            return y.chunks[p];
+          }), (g || !S) && (w = S = 1, S = this.getter(0).length, w = S, out("LazyFiles on gzip forces download of the whole file when length is accessed")), this._length = S, this._chunkSize = w, this.lengthKnown = true;
+        }
+        get length() {
+          return this.lengthKnown || this.cacheLength(), this._length;
+        }
+        get chunkSize() {
+          return this.lengthKnown || this.cacheLength(), this._chunkSize;
+        }
+      }
+      if (typeof XMLHttpRequest < "u") {
+        if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
+        var s = new o(), l = { isDevice: false, contents: s };
+      } else var l = { isDevice: false, url: t };
+      var u = FS.createFile(e, r, l, n, a);
+      l.contents ? u.contents = l.contents : l.url && (u.contents = null, u.url = l.url), Object.defineProperties(u, { usedBytes: { get: function() {
+        return this.contents.length;
+      } } });
+      var d = {}, c = Object.keys(u.stream_ops);
+      c.forEach((_) => {
+        var f = u.stream_ops[_];
+        d[_] = (...S) => (FS.forceLoadFile(u), f(...S));
+      });
+      function m(_, f, S, v, F) {
+        var g = _.node.contents;
+        if (F >= g.length) return 0;
+        var w = Math.min(g.length - F, v);
+        if (g.slice) for (var A = 0; A < w; A++) f[S + A] = g[F + A];
+        else for (var A = 0; A < w; A++) f[S + A] = g.get(F + A);
+        return w;
+      }
+      return d.read = (_, f, S, v, F) => (FS.forceLoadFile(u), m(_, f, S, v, F)), d.mmap = (_, f, S, v, F) => {
+        FS.forceLoadFile(u);
+        var g = mmapAlloc(f);
+        if (!g) throw new FS.ErrnoError(48);
+        return m(_, HEAP8, g, f, S), { ptr: g, allocated: true };
+      }, u.stream_ops = d, u;
+    } }, SYSCALLS = { DEFAULT_POLLMASK: 5, calculateAt(e, r, t) {
+      if (PATH.isAbs(r)) return r;
+      var n;
+      if (e === -100) n = FS.cwd();
+      else {
+        var a = SYSCALLS.getStreamFromFD(e);
+        n = a.path;
+      }
+      if (r.length == 0) {
+        if (!t) throw new FS.ErrnoError(44);
+        return n;
+      }
+      return n + "/" + r;
+    }, doStat(e, r, t) {
+      var n = e(r);
+      HEAP32[t >> 2] = n.dev, HEAP32[t + 4 >> 2] = n.mode, HEAPU32[t + 8 >> 2] = n.nlink, HEAP32[t + 12 >> 2] = n.uid, HEAP32[t + 16 >> 2] = n.gid, HEAP32[t + 20 >> 2] = n.rdev, HEAP64[t + 24 >> 3] = BigInt(n.size), HEAP32[t + 32 >> 2] = 4096, HEAP32[t + 36 >> 2] = n.blocks;
+      var a = n.atime.getTime(), o = n.mtime.getTime(), s = n.ctime.getTime();
+      return HEAP64[t + 40 >> 3] = BigInt(Math.floor(a / 1e3)), HEAPU32[t + 48 >> 2] = a % 1e3 * 1e3 * 1e3, HEAP64[t + 56 >> 3] = BigInt(Math.floor(o / 1e3)), HEAPU32[t + 64 >> 2] = o % 1e3 * 1e3 * 1e3, HEAP64[t + 72 >> 3] = BigInt(Math.floor(s / 1e3)), HEAPU32[t + 80 >> 2] = s % 1e3 * 1e3 * 1e3, HEAP64[t + 88 >> 3] = BigInt(n.ino), 0;
+    }, doMsync(e, r, t, n, a) {
+      if (!FS.isFile(r.node.mode)) throw new FS.ErrnoError(43);
+      if (n & 2) return 0;
+      var o = HEAPU8.slice(e, e + t);
+      FS.msync(r, o, a, t, n);
+    }, getStreamFromFD(e) {
+      var r = FS.getStreamChecked(e);
+      return r;
+    }, varargs: void 0, getStr(e) {
+      var r = UTF8ToString(e);
+      return r;
+    } }, ___syscall__newselect = function(e, r, t, n, a) {
+      try {
+        for (var o = 0, s = r ? HEAP32[r >> 2] : 0, l = r ? HEAP32[r + 4 >> 2] : 0, u = t ? HEAP32[t >> 2] : 0, d = t ? HEAP32[t + 4 >> 2] : 0, c = n ? HEAP32[n >> 2] : 0, m = n ? HEAP32[n + 4 >> 2] : 0, _ = 0, f = 0, S = 0, v = 0, F = 0, g = 0, w = (r ? HEAP32[r >> 2] : 0) | (t ? HEAP32[t >> 2] : 0) | (n ? HEAP32[n >> 2] : 0), A = (r ? HEAP32[r + 4 >> 2] : 0) | (t ? HEAP32[t + 4 >> 2] : 0) | (n ? HEAP32[n + 4 >> 2] : 0), y = (k, P, H, I) => k < 32 ? P & I : H & I, p = 0; p < e; p++) {
+          var h = 1 << p % 32;
+          if (y(p, w, A, h)) {
+            var E = SYSCALLS.getStreamFromFD(p), M = SYSCALLS.DEFAULT_POLLMASK;
+            if (E.stream_ops.poll) {
+              var T = -1;
+              if (a) {
+                var D = r ? HEAP32[a >> 2] : 0, R = r ? HEAP32[a + 4 >> 2] : 0;
+                T = (D + R / 1e6) * 1e3;
+              }
+              M = E.stream_ops.poll(E, T);
+            }
+            M & 1 && y(p, s, l, h) && (p < 32 ? _ = _ | h : f = f | h, o++), M & 4 && y(p, u, d, h) && (p < 32 ? S = S | h : v = v | h, o++), M & 2 && y(p, c, m, h) && (p < 32 ? F = F | h : g = g | h, o++);
+          }
+        }
+        return r && (HEAP32[r >> 2] = _, HEAP32[r + 4 >> 2] = f), t && (HEAP32[t >> 2] = S, HEAP32[t + 4 >> 2] = v), n && (HEAP32[n >> 2] = F, HEAP32[n + 4 >> 2] = g), o;
+      } catch (k) {
+        if (typeof FS > "u" || k.name !== "ErrnoError") throw k;
+        return -k.errno;
+      }
+    };
+    ___syscall__newselect.sig = "iipppp";
+    function ___syscall_dup(e) {
+      try {
+        var r = SYSCALLS.getStreamFromFD(e);
+        return FS.dupStream(r).fd;
+      } catch (t) {
+        if (typeof FS > "u" || t.name !== "ErrnoError") throw t;
+        return -t.errno;
+      }
+    }
+    ___syscall_dup.sig = "ii";
+    function ___syscall_faccessat(e, r, t, n) {
+      try {
+        if (r = SYSCALLS.getStr(r), r = SYSCALLS.calculateAt(e, r), t & -8) return -28;
+        var a = FS.lookupPath(r, { follow: true }), o = a.node;
+        if (!o) return -44;
+        var s = "";
+        return t & 4 && (s += "r"), t & 2 && (s += "w"), t & 1 && (s += "x"), s && FS.nodePermissions(o, s) ? -2 : 0;
+      } catch (l) {
+        if (typeof FS > "u" || l.name !== "ErrnoError") throw l;
+        return -l.errno;
+      }
+    }
+    ___syscall_faccessat.sig = "iipii";
+    var ___syscall_fadvise64 = (e, r, t, n) => 0;
+    ___syscall_fadvise64.sig = "iijji";
+    var syscallGetVarargI = () => {
+      var e = HEAP32[+SYSCALLS.varargs >> 2];
+      return SYSCALLS.varargs += 4, e;
+    }, syscallGetVarargP = syscallGetVarargI;
+    function ___syscall_fcntl64(e, r, t) {
+      SYSCALLS.varargs = t;
+      try {
+        var n = SYSCALLS.getStreamFromFD(e);
+        switch (r) {
+          case 0: {
+            var a = syscallGetVarargI();
+            if (a < 0) return -28;
+            for (; FS.streams[a]; ) a++;
+            var o;
+            return o = FS.dupStream(n, a), o.fd;
+          }
+          case 1:
+          case 2:
+            return 0;
+          case 3:
+            return n.flags;
+          case 4: {
+            var a = syscallGetVarargI();
+            return n.flags |= a, 0;
+          }
+          case 12: {
+            var a = syscallGetVarargP(), s = 0;
+            return HEAP16[a + s >> 1] = 2, 0;
+          }
+          case 13:
+          case 14:
+            return 0;
+        }
+        return -28;
+      } catch (l) {
+        if (typeof FS > "u" || l.name !== "ErrnoError") throw l;
+        return -l.errno;
+      }
+    }
+    ___syscall_fcntl64.sig = "iiip";
+    function ___syscall_fstat64(e, r) {
+      try {
+        var t = SYSCALLS.getStreamFromFD(e);
+        return SYSCALLS.doStat(FS.stat, t.path, r);
+      } catch (n) {
+        if (typeof FS > "u" || n.name !== "ErrnoError") throw n;
+        return -n.errno;
+      }
+    }
+    ___syscall_fstat64.sig = "iip";
+    var stringToUTF8 = (e, r, t) => stringToUTF8Array(e, HEAPU8, r, t);
+    function ___syscall_getcwd(e, r) {
+      try {
+        if (r === 0) return -28;
+        var t = FS.cwd(), n = lengthBytesUTF8(t) + 1;
+        return r < n ? -68 : (stringToUTF8(t, e, r), n);
+      } catch (a) {
+        if (typeof FS > "u" || a.name !== "ErrnoError") throw a;
+        return -a.errno;
+      }
+    }
+    ___syscall_getcwd.sig = "ipp";
+    function ___syscall_getdents64(e, r, t) {
+      try {
+        var n = SYSCALLS.getStreamFromFD(e);
+        n.getdents || (n.getdents = FS.readdir(n.path));
+        for (var a = 280, o = 0, s = FS.llseek(n, 0, 1), l = Math.floor(s / a), u = Math.min(n.getdents.length, l + Math.floor(t / a)), d = l; d < u; d++) {
+          var c, m, _ = n.getdents[d];
+          if (_ === ".") c = n.node.id, m = 4;
+          else if (_ === "..") {
+            var f = FS.lookupPath(n.path, { parent: true });
+            c = f.node.id, m = 4;
+          } else {
+            var S;
+            try {
+              S = FS.lookupNode(n.node, _);
+            } catch (v) {
+              if (v?.errno === 28) continue;
+              throw v;
+            }
+            c = S.id, m = FS.isChrdev(S.mode) ? 2 : FS.isDir(S.mode) ? 4 : FS.isLink(S.mode) ? 10 : 8;
+          }
+          HEAP64[r + o >> 3] = BigInt(c), HEAP64[r + o + 8 >> 3] = BigInt((d + 1) * a), HEAP16[r + o + 16 >> 1] = 280, HEAP8[r + o + 18] = m, stringToUTF8(_, r + o + 19, 256), o += a;
+        }
+        return FS.llseek(n, d * a, 0), o;
+      } catch (v) {
+        if (typeof FS > "u" || v.name !== "ErrnoError") throw v;
+        return -v.errno;
+      }
+    }
+    ___syscall_getdents64.sig = "iipp";
+    function ___syscall_ioctl(e, r, t) {
+      SYSCALLS.varargs = t;
+      try {
+        var n = SYSCALLS.getStreamFromFD(e);
+        switch (r) {
+          case 21509:
+            return n.tty ? 0 : -59;
+          case 21505: {
+            if (!n.tty) return -59;
+            if (n.tty.ops.ioctl_tcgets) {
+              var a = n.tty.ops.ioctl_tcgets(n), o = syscallGetVarargP();
+              HEAP32[o >> 2] = a.c_iflag || 0, HEAP32[o + 4 >> 2] = a.c_oflag || 0, HEAP32[o + 8 >> 2] = a.c_cflag || 0, HEAP32[o + 12 >> 2] = a.c_lflag || 0;
+              for (var s = 0; s < 32; s++) HEAP8[o + s + 17] = a.c_cc[s] || 0;
+              return 0;
+            }
+            return 0;
+          }
+          case 21510:
+          case 21511:
+          case 21512:
+            return n.tty ? 0 : -59;
+          case 21506:
+          case 21507:
+          case 21508: {
+            if (!n.tty) return -59;
+            if (n.tty.ops.ioctl_tcsets) {
+              for (var o = syscallGetVarargP(), l = HEAP32[o >> 2], u = HEAP32[o + 4 >> 2], d = HEAP32[o + 8 >> 2], c = HEAP32[o + 12 >> 2], m = [], s = 0; s < 32; s++) m.push(HEAP8[o + s + 17]);
+              return n.tty.ops.ioctl_tcsets(n.tty, r, { c_iflag: l, c_oflag: u, c_cflag: d, c_lflag: c, c_cc: m });
+            }
+            return 0;
+          }
+          case 21519: {
+            if (!n.tty) return -59;
+            var o = syscallGetVarargP();
+            return HEAP32[o >> 2] = 0, 0;
+          }
+          case 21520:
+            return n.tty ? -28 : -59;
+          case 21531: {
+            var o = syscallGetVarargP();
+            return FS.ioctl(n, r, o);
+          }
+          case 21523: {
+            if (!n.tty) return -59;
+            if (n.tty.ops.ioctl_tiocgwinsz) {
+              var _ = n.tty.ops.ioctl_tiocgwinsz(n.tty), o = syscallGetVarargP();
+              HEAP16[o >> 1] = _[0], HEAP16[o + 2 >> 1] = _[1];
+            }
+            return 0;
+          }
+          case 21524:
+            return n.tty ? 0 : -59;
+          case 21515:
+            return n.tty ? 0 : -59;
+          default:
+            return -28;
+        }
+      } catch (f) {
+        if (typeof FS > "u" || f.name !== "ErrnoError") throw f;
+        return -f.errno;
+      }
+    }
+    ___syscall_ioctl.sig = "iiip";
+    function ___syscall_lstat64(e, r) {
+      try {
+        return e = SYSCALLS.getStr(e), SYSCALLS.doStat(FS.lstat, e, r);
+      } catch (t) {
+        if (typeof FS > "u" || t.name !== "ErrnoError") throw t;
+        return -t.errno;
+      }
+    }
+    ___syscall_lstat64.sig = "ipp";
+    function ___syscall_mkdirat(e, r, t) {
+      try {
+        return r = SYSCALLS.getStr(r), r = SYSCALLS.calculateAt(e, r), FS.mkdir(r, t, 0), 0;
+      } catch (n) {
+        if (typeof FS > "u" || n.name !== "ErrnoError") throw n;
+        return -n.errno;
+      }
+    }
+    ___syscall_mkdirat.sig = "iipi";
+    function ___syscall_newfstatat(e, r, t, n) {
+      try {
+        r = SYSCALLS.getStr(r);
+        var a = n & 256, o = n & 4096;
+        return n = n & -6401, r = SYSCALLS.calculateAt(e, r, o), SYSCALLS.doStat(a ? FS.lstat : FS.stat, r, t);
+      } catch (s) {
+        if (typeof FS > "u" || s.name !== "ErrnoError") throw s;
+        return -s.errno;
+      }
+    }
+    ___syscall_newfstatat.sig = "iippi";
+    function ___syscall_openat(e, r, t, n) {
+      SYSCALLS.varargs = n;
+      try {
+        r = SYSCALLS.getStr(r), r = SYSCALLS.calculateAt(e, r);
+        var a = n ? syscallGetVarargI() : 0;
+        return FS.open(r, t, a).fd;
+      } catch (o) {
+        if (typeof FS > "u" || o.name !== "ErrnoError") throw o;
+        return -o.errno;
+      }
+    }
+    ___syscall_openat.sig = "iipip";
+    var PIPEFS = { BUCKET_BUFFER_SIZE: 8192, mount(e) {
+      return FS.createNode(null, "/", 16895, 0);
+    }, createPipe() {
+      var e = { buckets: [], refcnt: 2 };
+      e.buckets.push({ buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: 0, roffset: 0 });
+      var r = PIPEFS.nextname(), t = PIPEFS.nextname(), n = FS.createNode(PIPEFS.root, r, 4096, 0), a = FS.createNode(PIPEFS.root, t, 4096, 0);
+      n.pipe = e, a.pipe = e;
+      var o = FS.createStream({ path: r, node: n, flags: 0, seekable: false, stream_ops: PIPEFS.stream_ops });
+      n.stream = o;
+      var s = FS.createStream({ path: t, node: a, flags: 1, seekable: false, stream_ops: PIPEFS.stream_ops });
+      return a.stream = s, { readable_fd: o.fd, writable_fd: s.fd };
+    }, stream_ops: { poll(e) {
+      var r = e.node.pipe;
+      if ((e.flags & 2097155) === 1) return 260;
+      if (r.buckets.length > 0) for (var t = 0; t < r.buckets.length; t++) {
+        var n = r.buckets[t];
+        if (n.offset - n.roffset > 0) return 65;
+      }
+      return 0;
+    }, ioctl(e, r, t) {
+      return 28;
+    }, fsync(e) {
+      return 28;
+    }, read(e, r, t, n, a) {
+      for (var o = e.node.pipe, s = 0, l = 0; l < o.buckets.length; l++) {
+        var u = o.buckets[l];
+        s += u.offset - u.roffset;
+      }
+      var d = r.subarray(t, t + n);
+      if (n <= 0) return 0;
+      if (s == 0) throw new FS.ErrnoError(6);
+      for (var c = Math.min(s, n), m = c, _ = 0, l = 0; l < o.buckets.length; l++) {
+        var f = o.buckets[l], S = f.offset - f.roffset;
+        if (c <= S) {
+          var v = f.buffer.subarray(f.roffset, f.offset);
+          c < S ? (v = v.subarray(0, c), f.roffset += c) : _++, d.set(v);
+          break;
+        } else {
+          var v = f.buffer.subarray(f.roffset, f.offset);
+          d.set(v), d = d.subarray(v.byteLength), c -= v.byteLength, _++;
+        }
+      }
+      return _ && _ == o.buckets.length && (_--, o.buckets[_].offset = 0, o.buckets[_].roffset = 0), o.buckets.splice(0, _), m;
+    }, write(e, r, t, n, a) {
+      var o = e.node.pipe, s = r.subarray(t, t + n), l = s.byteLength;
+      if (l <= 0) return 0;
+      var u = null;
+      o.buckets.length == 0 ? (u = { buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: 0, roffset: 0 }, o.buckets.push(u)) : u = o.buckets[o.buckets.length - 1], assert(u.offset <= PIPEFS.BUCKET_BUFFER_SIZE);
+      var d = PIPEFS.BUCKET_BUFFER_SIZE - u.offset;
+      if (d >= l) return u.buffer.set(s, u.offset), u.offset += l, l;
+      d > 0 && (u.buffer.set(s.subarray(0, d), u.offset), u.offset += d, s = s.subarray(d, s.byteLength));
+      for (var c = s.byteLength / PIPEFS.BUCKET_BUFFER_SIZE | 0, m = s.byteLength % PIPEFS.BUCKET_BUFFER_SIZE, _ = 0; _ < c; _++) {
+        var f = { buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: PIPEFS.BUCKET_BUFFER_SIZE, roffset: 0 };
+        o.buckets.push(f), f.buffer.set(s.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE)), s = s.subarray(PIPEFS.BUCKET_BUFFER_SIZE, s.byteLength);
+      }
+      if (m > 0) {
+        var f = { buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), offset: s.byteLength, roffset: 0 };
+        o.buckets.push(f), f.buffer.set(s);
+      }
+      return l;
+    }, close(e) {
+      var r = e.node.pipe;
+      r.refcnt--, r.refcnt === 0 && (r.buckets = null);
+    } }, nextname() {
+      return PIPEFS.nextname.current || (PIPEFS.nextname.current = 0), "pipe[" + PIPEFS.nextname.current++ + "]";
+    } };
+    function ___syscall_pipe(e) {
+      try {
+        if (e == 0) throw new FS.ErrnoError(21);
+        var r = PIPEFS.createPipe();
+        return HEAP32[e >> 2] = r.readable_fd, HEAP32[e + 4 >> 2] = r.writable_fd, 0;
+      } catch (t) {
+        if (typeof FS > "u" || t.name !== "ErrnoError") throw t;
+        return -t.errno;
+      }
+    }
+    ___syscall_pipe.sig = "ip";
+    function ___syscall_readlinkat(e, r, t, n) {
+      try {
+        if (r = SYSCALLS.getStr(r), r = SYSCALLS.calculateAt(e, r), n <= 0) return -28;
+        var a = FS.readlink(r), o = Math.min(n, lengthBytesUTF8(a)), s = HEAP8[t + o];
+        return stringToUTF8(a, t, n + 1), HEAP8[t + o] = s, o;
+      } catch (l) {
+        if (typeof FS > "u" || l.name !== "ErrnoError") throw l;
+        return -l.errno;
+      }
+    }
+    ___syscall_readlinkat.sig = "iippp";
+    var SOCKFS = { websocketArgs: {}, callbacks: {}, on(e, r) {
+      SOCKFS.callbacks[e] = r;
+    }, emit(e, r) {
+      SOCKFS.callbacks[e]?.(r);
+    }, mount(e) {
+      return SOCKFS.websocketArgs = Module.websocket || {}, (Module.websocket ?? (Module.websocket = {})).on = SOCKFS.on, FS.createNode(null, "/", 16895, 0);
+    }, createSocket(e, r, t) {
+      r &= -526337;
+      var n = r == 1;
+      if (n && t && t != 6) throw new FS.ErrnoError(66);
+      var a = { family: e, type: r, protocol: t, server: null, error: null, peers: {}, pending: [], recv_queue: [], sock_ops: SOCKFS.websocket_sock_ops }, o = SOCKFS.nextname(), s = FS.createNode(SOCKFS.root, o, 49152, 0);
+      s.sock = a;
+      var l = FS.createStream({ path: o, node: s, flags: 2, seekable: false, stream_ops: SOCKFS.stream_ops });
+      return a.stream = l, a;
+    }, getSocket(e) {
+      var r = FS.getStream(e);
+      return !r || !FS.isSocket(r.node.mode) ? null : r.node.sock;
+    }, stream_ops: { poll(e) {
+      var r = e.node.sock;
+      return r.sock_ops.poll(r);
+    }, ioctl(e, r, t) {
+      var n = e.node.sock;
+      return n.sock_ops.ioctl(n, r, t);
+    }, read(e, r, t, n, a) {
+      var o = e.node.sock, s = o.sock_ops.recvmsg(o, n);
+      return s ? (r.set(s.buffer, t), s.buffer.length) : 0;
+    }, write(e, r, t, n, a) {
+      var o = e.node.sock;
+      return o.sock_ops.sendmsg(o, r, t, n);
+    }, close(e) {
+      var r = e.node.sock;
+      r.sock_ops.close(r);
+    } }, nextname() {
+      return SOCKFS.nextname.current || (SOCKFS.nextname.current = 0), `socket[${SOCKFS.nextname.current++}]`;
+    }, websocket_sock_ops: { createPeer(e, r, t) {
+      var n;
+      if (typeof r == "object" && (n = r, r = null, t = null), n) if (n._socket) r = n._socket.remoteAddress, t = n._socket.remotePort;
+      else {
+        var a = /ws[s]?:\/\/([^:]+):(\d+)/.exec(n.url);
+        if (!a) throw new Error("WebSocket URL must be in the format ws(s)://address:port");
+        r = a[1], t = parseInt(a[2], 10);
+      }
+      else try {
+        var o = "ws:#".replace("#", "//"), s = "binary", l = void 0;
+        if (SOCKFS.websocketArgs.url && (o = SOCKFS.websocketArgs.url), SOCKFS.websocketArgs.subprotocol ? s = SOCKFS.websocketArgs.subprotocol : SOCKFS.websocketArgs.subprotocol === null && (s = "null"), o === "ws://" || o === "wss://") {
+          var u = r.split("/");
+          o = o + u[0] + ":" + t + "/" + u.slice(1).join("/");
+        }
+        s !== "null" && (s = s.replace(/^ +| +$/g, "").split(/ *, */), l = s);
+        var d;
+        ENVIRONMENT_IS_NODE ? d = require("ws") : d = WebSocket, n = new d(o, l), n.binaryType = "arraybuffer";
+      } catch {
+        throw new FS.ErrnoError(23);
+      }
+      var c = { addr: r, port: t, socket: n, msg_send_queue: [] };
+      return SOCKFS.websocket_sock_ops.addPeer(e, c), SOCKFS.websocket_sock_ops.handlePeerEvents(e, c), e.type === 2 && typeof e.sport < "u" && c.msg_send_queue.push(new Uint8Array([255, 255, 255, 255, 112, 111, 114, 116, (e.sport & 65280) >> 8, e.sport & 255])), c;
+    }, getPeer(e, r, t) {
+      return e.peers[r + ":" + t];
+    }, addPeer(e, r) {
+      e.peers[r.addr + ":" + r.port] = r;
+    }, removePeer(e, r) {
+      delete e.peers[r.addr + ":" + r.port];
+    }, handlePeerEvents(e, r) {
+      var t = true, n = function() {
+        e.connecting = false, SOCKFS.emit("open", e.stream.fd);
+        try {
+          for (var o = r.msg_send_queue.shift(); o; ) r.socket.send(o), o = r.msg_send_queue.shift();
+        } catch {
+          r.socket.close();
+        }
+      };
+      function a(o) {
+        if (typeof o == "string") {
+          var s = new TextEncoder();
+          o = s.encode(o);
+        } else {
+          if (assert(o.byteLength !== void 0), o.byteLength == 0) return;
+          o = new Uint8Array(o);
+        }
+        var l = t;
+        if (t = false, l && o.length === 10 && o[0] === 255 && o[1] === 255 && o[2] === 255 && o[3] === 255 && o[4] === 112 && o[5] === 111 && o[6] === 114 && o[7] === 116) {
+          var u = o[8] << 8 | o[9];
+          SOCKFS.websocket_sock_ops.removePeer(e, r), r.port = u, SOCKFS.websocket_sock_ops.addPeer(e, r);
+          return;
+        }
+        e.recv_queue.push({ addr: r.addr, port: r.port, data: o }), SOCKFS.emit("message", e.stream.fd);
+      }
+      ENVIRONMENT_IS_NODE ? (r.socket.on("open", n), r.socket.on("message", function(o, s) {
+        s && a(new Uint8Array(o).buffer);
+      }), r.socket.on("close", function() {
+        SOCKFS.emit("close", e.stream.fd);
+      }), r.socket.on("error", function(o) {
+        e.error = 14, SOCKFS.emit("error", [e.stream.fd, e.error, "ECONNREFUSED: Connection refused"]);
+      })) : (r.socket.onopen = n, r.socket.onclose = function() {
+        SOCKFS.emit("close", e.stream.fd);
+      }, r.socket.onmessage = function(s) {
+        a(s.data);
+      }, r.socket.onerror = function(o) {
+        e.error = 14, SOCKFS.emit("error", [e.stream.fd, e.error, "ECONNREFUSED: Connection refused"]);
+      });
+    }, poll(e) {
+      if (e.type === 1 && e.server) return e.pending.length ? 65 : 0;
+      var r = 0, t = e.type === 1 ? SOCKFS.websocket_sock_ops.getPeer(e, e.daddr, e.dport) : null;
+      return (e.recv_queue.length || !t || t && t.socket.readyState === t.socket.CLOSING || t && t.socket.readyState === t.socket.CLOSED) && (r |= 65), (!t || t && t.socket.readyState === t.socket.OPEN) && (r |= 4), (t && t.socket.readyState === t.socket.CLOSING || t && t.socket.readyState === t.socket.CLOSED) && (e.connecting ? r |= 4 : r |= 16), r;
+    }, ioctl(e, r, t) {
+      switch (r) {
+        case 21531:
+          var n = 0;
+          return e.recv_queue.length && (n = e.recv_queue[0].data.length), HEAP32[t >> 2] = n, 0;
+        default:
+          return 28;
+      }
+    }, close(e) {
+      if (e.server) {
+        try {
+          e.server.close();
+        } catch {
+        }
+        e.server = null;
+      }
+      for (var r = Object.keys(e.peers), t = 0; t < r.length; t++) {
+        var n = e.peers[r[t]];
+        try {
+          n.socket.close();
+        } catch {
+        }
+        SOCKFS.websocket_sock_ops.removePeer(e, n);
+      }
+      return 0;
+    }, bind(e, r, t) {
+      if (typeof e.saddr < "u" || typeof e.sport < "u") throw new FS.ErrnoError(28);
+      if (e.saddr = r, e.sport = t, e.type === 2) {
+        e.server && (e.server.close(), e.server = null);
+        try {
+          e.sock_ops.listen(e, 0);
+        } catch (n) {
+          if (n.name !== "ErrnoError" || n.errno !== 138) throw n;
+        }
+      }
+    }, connect(e, r, t) {
+      if (e.server) throw new FS.ErrnoError(138);
+      if (typeof e.daddr < "u" && typeof e.dport < "u") {
+        var n = SOCKFS.websocket_sock_ops.getPeer(e, e.daddr, e.dport);
+        if (n) throw n.socket.readyState === n.socket.CONNECTING ? new FS.ErrnoError(7) : new FS.ErrnoError(30);
+      }
+      var a = SOCKFS.websocket_sock_ops.createPeer(e, r, t);
+      e.daddr = a.addr, e.dport = a.port, e.connecting = true;
+    }, listen(e, r) {
+      if (!ENVIRONMENT_IS_NODE) throw new FS.ErrnoError(138);
+      if (e.server) throw new FS.ErrnoError(28);
+      var t = require("ws").Server, n = e.saddr;
+      e.server = new t({ host: n, port: e.sport }), SOCKFS.emit("listen", e.stream.fd), e.server.on("connection", function(a) {
+        if (e.type === 1) {
+          var o = SOCKFS.createSocket(e.family, e.type, e.protocol), s = SOCKFS.websocket_sock_ops.createPeer(o, a);
+          o.daddr = s.addr, o.dport = s.port, e.pending.push(o), SOCKFS.emit("connection", o.stream.fd);
+        } else SOCKFS.websocket_sock_ops.createPeer(e, a), SOCKFS.emit("connection", e.stream.fd);
+      }), e.server.on("close", function() {
+        SOCKFS.emit("close", e.stream.fd), e.server = null;
+      }), e.server.on("error", function(a) {
+        e.error = 23, SOCKFS.emit("error", [e.stream.fd, e.error, "EHOSTUNREACH: Host is unreachable"]);
+      });
+    }, accept(e) {
+      if (!e.server || !e.pending.length) throw new FS.ErrnoError(28);
+      var r = e.pending.shift();
+      return r.stream.flags = e.stream.flags, r;
+    }, getname(e, r) {
+      var t, n;
+      if (r) {
+        if (e.daddr === void 0 || e.dport === void 0) throw new FS.ErrnoError(53);
+        t = e.daddr, n = e.dport;
+      } else t = e.saddr || 0, n = e.sport || 0;
+      return { addr: t, port: n };
+    }, sendmsg(e, r, t, n, a, o) {
+      if (e.type === 2) {
+        if ((a === void 0 || o === void 0) && (a = e.daddr, o = e.dport), a === void 0 || o === void 0) throw new FS.ErrnoError(17);
+      } else a = e.daddr, o = e.dport;
+      var s = SOCKFS.websocket_sock_ops.getPeer(e, a, o);
+      if (e.type === 1 && (!s || s.socket.readyState === s.socket.CLOSING || s.socket.readyState === s.socket.CLOSED)) throw new FS.ErrnoError(53);
+      ArrayBuffer.isView(r) && (t += r.byteOffset, r = r.buffer);
+      var l = r.slice(t, t + n);
+      if (!s || s.socket.readyState !== s.socket.OPEN) return e.type === 2 && (!s || s.socket.readyState === s.socket.CLOSING || s.socket.readyState === s.socket.CLOSED) && (s = SOCKFS.websocket_sock_ops.createPeer(e, a, o)), s.msg_send_queue.push(l), n;
+      try {
+        return s.socket.send(l), n;
+      } catch {
+        throw new FS.ErrnoError(28);
+      }
+    }, recvmsg(e, r) {
+      if (e.type === 1 && e.server) throw new FS.ErrnoError(53);
+      var t = e.recv_queue.shift();
+      if (!t) {
+        if (e.type === 1) {
+          var n = SOCKFS.websocket_sock_ops.getPeer(e, e.daddr, e.dport);
+          if (!n) throw new FS.ErrnoError(53);
+          if (n.socket.readyState === n.socket.CLOSING || n.socket.readyState === n.socket.CLOSED) return null;
+          throw new FS.ErrnoError(6);
+        }
+        throw new FS.ErrnoError(6);
+      }
+      var a = t.data.byteLength || t.data.length, o = t.data.byteOffset || 0, s = t.data.buffer || t.data, l = Math.min(r, a), u = { buffer: new Uint8Array(s, o, l), addr: t.addr, port: t.port };
+      if (e.type === 1 && l < a) {
+        var d = a - l;
+        t.data = new Uint8Array(s, o + l, d), e.recv_queue.unshift(t);
+      }
+      return u;
+    } } };
+    function ___syscall_socket(e, r, t) {
+      try {
+        var n = SOCKFS.createSocket(e, r, t);
+        return n.stream.fd;
+      } catch (a) {
+        if (typeof FS > "u" || a.name !== "ErrnoError") throw a;
+        return -a.errno;
+      }
+    }
+    ___syscall_socket.sig = "iiiiiii";
+    function ___syscall_stat64(e, r) {
+      try {
+        return e = SYSCALLS.getStr(e), SYSCALLS.doStat(FS.stat, e, r);
+      } catch (t) {
+        if (typeof FS > "u" || t.name !== "ErrnoError") throw t;
+        return -t.errno;
+      }
+    }
+    ___syscall_stat64.sig = "ipp";
+    function ___syscall_unlinkat(e, r, t) {
+      try {
+        return r = SYSCALLS.getStr(r), r = SYSCALLS.calculateAt(e, r), t === 0 ? FS.unlink(r) : t === 512 ? FS.rmdir(r) : abort("Invalid flags passed to unlinkat"), 0;
+      } catch (n) {
+        if (typeof FS > "u" || n.name !== "ErrnoError") throw n;
+        return -n.errno;
+      }
+    }
+    ___syscall_unlinkat.sig = "iipi";
+    var ___table_base = new WebAssembly.Global({ value: "i32", mutable: false }, 1), __abort_js = () => abort("");
+    __abort_js.sig = "v";
+    var __emscripten_fs_load_embedded_files = (e) => {
+      do {
+        var r = HEAPU32[e >> 2];
+        e += 4;
+        var t = HEAPU32[e >> 2];
+        e += 4;
+        var n = HEAPU32[e >> 2];
+        e += 4;
+        var a = UTF8ToString(r);
+        FS.createPath("/", PATH.dirname(a), true, true), FS.createDataFile(a, null, HEAP8.subarray(n, n + t), true, true, true);
+      } while (HEAPU32[e >> 2]);
+    };
+    __emscripten_fs_load_embedded_files.sig = "vp";
+    var runtimeKeepaliveCounter = 0, __emscripten_runtime_keepalive_clear = () => {
+      noExitRuntime = false, runtimeKeepaliveCounter = 0;
+    };
+    __emscripten_runtime_keepalive_clear.sig = "v";
+    var __emscripten_throw_longjmp = () => {
+      throw 1 / 0;
+    };
+    __emscripten_throw_longjmp.sig = "v";
+    var isLeapYear = (e) => e % 4 === 0 && (e % 100 !== 0 || e % 400 === 0), MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], ydayFromDate = (e) => {
+      var r = isLeapYear(e.getFullYear()), t = r ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE, n = t[e.getMonth()] + e.getDate() - 1;
+      return n;
+    }, INT53_MAX = 9007199254740992, INT53_MIN = -9007199254740992, bigintToI53Checked = (e) => e < INT53_MIN || e > INT53_MAX ? NaN : Number(e);
+    function __localtime_js(e, r) {
+      e = bigintToI53Checked(e);
+      var t = new Date(e * 1e3);
+      HEAP32[r >> 2] = t.getSeconds(), HEAP32[r + 4 >> 2] = t.getMinutes(), HEAP32[r + 8 >> 2] = t.getHours(), HEAP32[r + 12 >> 2] = t.getDate(), HEAP32[r + 16 >> 2] = t.getMonth(), HEAP32[r + 20 >> 2] = t.getFullYear() - 1900, HEAP32[r + 24 >> 2] = t.getDay();
+      var n = ydayFromDate(t) | 0;
+      HEAP32[r + 28 >> 2] = n, HEAP32[r + 36 >> 2] = -(t.getTimezoneOffset() * 60);
+      var a = new Date(t.getFullYear(), 0, 1), o = new Date(t.getFullYear(), 6, 1).getTimezoneOffset(), s = a.getTimezoneOffset(), l = (o != s && t.getTimezoneOffset() == Math.min(s, o)) | 0;
+      HEAP32[r + 32 >> 2] = l;
+    }
+    __localtime_js.sig = "vjp";
+    var __mktime_js = function(e) {
+      var r = (() => {
+        var t = new Date(HEAP32[e + 20 >> 2] + 1900, HEAP32[e + 16 >> 2], HEAP32[e + 12 >> 2], HEAP32[e + 8 >> 2], HEAP32[e + 4 >> 2], HEAP32[e >> 2], 0), n = HEAP32[e + 32 >> 2], a = t.getTimezoneOffset(), o = new Date(t.getFullYear(), 0, 1), s = new Date(t.getFullYear(), 6, 1).getTimezoneOffset(), l = o.getTimezoneOffset(), u = Math.min(l, s);
+        if (n < 0) HEAP32[e + 32 >> 2] = +(s != l && u == a);
+        else if (n > 0 != (u == a)) {
+          var d = Math.max(l, s), c = n > 0 ? u : d;
+          t.setTime(t.getTime() + (c - a) * 6e4);
+        }
+        HEAP32[e + 24 >> 2] = t.getDay();
+        var m = ydayFromDate(t) | 0;
+        HEAP32[e + 28 >> 2] = m, HEAP32[e >> 2] = t.getSeconds(), HEAP32[e + 4 >> 2] = t.getMinutes(), HEAP32[e + 8 >> 2] = t.getHours(), HEAP32[e + 12 >> 2] = t.getDate(), HEAP32[e + 16 >> 2] = t.getMonth(), HEAP32[e + 20 >> 2] = t.getYear();
+        var _ = t.getTime();
+        return isNaN(_) ? -1 : _ / 1e3;
+      })();
+      return BigInt(r);
+    };
+    __mktime_js.sig = "jp";
+    var __tzset_js = (e, r, t, n) => {
+      var a = (/* @__PURE__ */ new Date()).getFullYear(), o = new Date(a, 0, 1), s = new Date(a, 6, 1), l = o.getTimezoneOffset(), u = s.getTimezoneOffset(), d = Math.max(l, u);
+      HEAPU32[e >> 2] = d * 60, HEAP32[r >> 2] = +(l != u);
+      var c = (f) => {
+        var S = f >= 0 ? "-" : "+", v = Math.abs(f), F = String(Math.floor(v / 60)).padStart(2, "0"), g = String(v % 60).padStart(2, "0");
+        return `UTC${S}${F}${g}`;
+      }, m = c(l), _ = c(u);
+      u < l ? (stringToUTF8(m, t, 17), stringToUTF8(_, n, 17)) : (stringToUTF8(m, n, 17), stringToUTF8(_, t, 17));
+    };
+    __tzset_js.sig = "vpppp";
+    var _emscripten_get_now = () => performance.now();
+    _emscripten_get_now.sig = "d";
+    var _emscripten_date_now = () => Date.now();
+    _emscripten_date_now.sig = "d";
+    var nowIsMonotonic = 1, checkWasiClock = (e) => e >= 0 && e <= 3;
+    function _clock_time_get(e, r, t) {
+      if (r = bigintToI53Checked(r), !checkWasiClock(e)) return 28;
+      var n;
+      if (e === 0) n = _emscripten_date_now();
+      else if (nowIsMonotonic) n = _emscripten_get_now();
+      else return 52;
+      var a = Math.round(n * 1e3 * 1e3);
+      return HEAP64[t >> 3] = BigInt(a), 0;
+    }
+    _clock_time_get.sig = "iijp";
+    var getHeapMax = () => 2147483648, growMemory = (e) => {
+      var r = wasmMemory.buffer, t = (e - r.byteLength + 65535) / 65536 | 0;
+      try {
+        return wasmMemory.grow(t), updateMemoryViews(), 1;
+      } catch {
+      }
+    }, _emscripten_resize_heap = (e) => {
+      var r = HEAPU8.length;
+      e >>>= 0;
+      var t = getHeapMax();
+      if (e > t) return false;
+      for (var n = 1; n <= 4; n *= 2) {
+        var a = r * (1 + 0.2 / n);
+        a = Math.min(a, e + 100663296);
+        var o = Math.min(t, alignMemory(Math.max(e, a), 65536)), s = growMemory(o);
+        if (s) return true;
+      }
+      return false;
+    };
+    _emscripten_resize_heap.sig = "ip";
+    var ENV = {}, getExecutableName = () => thisProgram || "./this.program", getEnvStrings = () => {
+      if (!getEnvStrings.strings) {
+        var e = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", r = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: e, _: getExecutableName() };
+        for (var t in ENV) ENV[t] === void 0 ? delete r[t] : r[t] = ENV[t];
+        var n = [];
+        for (var t in r) n.push(`${t}=${r[t]}`);
+        getEnvStrings.strings = n;
+      }
+      return getEnvStrings.strings;
+    }, stringToAscii = (e, r) => {
+      for (var t = 0; t < e.length; ++t) HEAP8[r++] = e.charCodeAt(t);
+      HEAP8[r] = 0;
+    }, _environ_get = (e, r) => {
+      var t = 0;
+      return getEnvStrings().forEach((n, a) => {
+        var o = r + t;
+        HEAPU32[e + a * 4 >> 2] = o, stringToAscii(n, o), t += n.length + 1;
+      }), 0;
+    };
+    _environ_get.sig = "ipp";
+    var _environ_sizes_get = (e, r) => {
+      var t = getEnvStrings();
+      HEAPU32[e >> 2] = t.length;
+      var n = 0;
+      return t.forEach((a) => n += a.length + 1), HEAPU32[r >> 2] = n, 0;
+    };
+    _environ_sizes_get.sig = "ipp";
+    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0, _proc_exit = (e) => {
+      EXITSTATUS = e, keepRuntimeAlive() || (Module.onExit?.(e), ABORT = true), quit_(e, new ExitStatus(e));
+    };
+    _proc_exit.sig = "vi";
+    var exitJS = (e, r) => {
+      EXITSTATUS = e, keepRuntimeAlive() || exitRuntime(), _proc_exit(e);
+    }, _exit = exitJS;
+    _exit.sig = "vi";
+    function _fd_close(e) {
+      try {
+        var r = SYSCALLS.getStreamFromFD(e);
+        return FS.close(r), 0;
+      } catch (t) {
+        if (typeof FS > "u" || t.name !== "ErrnoError") throw t;
+        return t.errno;
+      }
+    }
+    _fd_close.sig = "ii";
+    function _fd_fdstat_get(e, r) {
+      try {
+        var t = 0, n = 0, a = 0, o = SYSCALLS.getStreamFromFD(e), s = o.tty ? 2 : FS.isDir(o.mode) ? 3 : FS.isLink(o.mode) ? 7 : 4;
+        return HEAP8[r] = s, HEAP16[r + 2 >> 1] = a, HEAP64[r + 8 >> 3] = BigInt(t), HEAP64[r + 16 >> 3] = BigInt(n), 0;
+      } catch (l) {
+        if (typeof FS > "u" || l.name !== "ErrnoError") throw l;
+        return l.errno;
+      }
+    }
+    _fd_fdstat_get.sig = "iip";
+    var doReadv = (e, r, t, n) => {
+      for (var a = 0, o = 0; o < t; o++) {
+        var s = HEAPU32[r >> 2], l = HEAPU32[r + 4 >> 2];
+        r += 8;
+        var u = FS.read(e, HEAP8, s, l, n);
+        if (u < 0) return -1;
+        if (a += u, u < l) break;
+        typeof n < "u" && (n += u);
+      }
+      return a;
+    };
+    function _fd_read(e, r, t, n) {
+      try {
+        var a = SYSCALLS.getStreamFromFD(e), o = doReadv(a, r, t);
+        return HEAPU32[n >> 2] = o, 0;
+      } catch (s) {
+        if (typeof FS > "u" || s.name !== "ErrnoError") throw s;
+        return s.errno;
+      }
+    }
+    _fd_read.sig = "iippp";
+    function _fd_seek(e, r, t, n) {
+      r = bigintToI53Checked(r);
+      try {
+        if (isNaN(r)) return 61;
+        var a = SYSCALLS.getStreamFromFD(e);
+        return FS.llseek(a, r, t), HEAP64[n >> 3] = BigInt(a.position), a.getdents && r === 0 && t === 0 && (a.getdents = null), 0;
+      } catch (o) {
+        if (typeof FS > "u" || o.name !== "ErrnoError") throw o;
+        return o.errno;
+      }
+    }
+    _fd_seek.sig = "iijip";
+    function _fd_sync(e) {
+      try {
+        var r = SYSCALLS.getStreamFromFD(e);
+        return r.stream_ops?.fsync ? r.stream_ops.fsync(r) : 0;
+      } catch (t) {
+        if (typeof FS > "u" || t.name !== "ErrnoError") throw t;
+        return t.errno;
+      }
+    }
+    _fd_sync.sig = "ii";
+    var doWritev = (e, r, t, n) => {
+      for (var a = 0, o = 0; o < t; o++) {
+        var s = HEAPU32[r >> 2], l = HEAPU32[r + 4 >> 2];
+        r += 8;
+        var u = FS.write(e, HEAP8, s, l, n);
+        if (u < 0) return -1;
+        if (a += u, u < l) break;
+        typeof n < "u" && (n += u);
+      }
+      return a;
+    };
+    function _fd_write(e, r, t, n) {
+      try {
+        var a = SYSCALLS.getStreamFromFD(e), o = doWritev(a, r, t);
+        return HEAPU32[n >> 2] = o, 0;
+      } catch (s) {
+        if (typeof FS > "u" || s.name !== "ErrnoError") throw s;
+        return s.errno;
+      }
+    }
+    _fd_write.sig = "iippp";
+    var inetPton4 = (e) => {
+      for (var r = e.split("."), t = 0; t < 4; t++) {
+        var n = Number(r[t]);
+        if (isNaN(n)) return null;
+        r[t] = n;
+      }
+      return (r[0] | r[1] << 8 | r[2] << 16 | r[3] << 24) >>> 0;
+    }, jstoi_q = (e) => parseInt(e), inetPton6 = (e) => {
+      var r, t, n, a, o = /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i, s = [];
+      if (!o.test(e)) return null;
+      if (e === "::") return [0, 0, 0, 0, 0, 0, 0, 0];
+      for (e.startsWith("::") ? e = e.replace("::", "Z:") : e = e.replace("::", ":Z:"), e.indexOf(".") > 0 ? (e = e.replace(new RegExp("[.]", "g"), ":"), r = e.split(":"), r[r.length - 4] = jstoi_q(r[r.length - 4]) + jstoi_q(r[r.length - 3]) * 256, r[r.length - 3] = jstoi_q(r[r.length - 2]) + jstoi_q(r[r.length - 1]) * 256, r = r.slice(0, r.length - 2)) : r = e.split(":"), n = 0, a = 0, t = 0; t < r.length; t++) if (typeof r[t] == "string") if (r[t] === "Z") {
+        for (a = 0; a < 8 - r.length + 1; a++) s[t + a] = 0;
+        n = a - 1;
+      } else s[t + n] = _htons(parseInt(r[t], 16));
+      else s[t + n] = r[t];
+      return [s[1] << 16 | s[0], s[3] << 16 | s[2], s[5] << 16 | s[4], s[7] << 16 | s[6]];
+    }, DNS = { address_map: { id: 1, addrs: {}, names: {} }, lookup_name(e) {
+      var r = inetPton4(e);
+      if (r !== null || (r = inetPton6(e), r !== null)) return e;
+      var t;
+      if (DNS.address_map.addrs[e]) t = DNS.address_map.addrs[e];
+      else {
+        var n = DNS.address_map.id++;
+        assert(n < 65535, "exceeded max address mappings of 65535"), t = "172.29." + (n & 255) + "." + (n & 65280), DNS.address_map.names[t] = e, DNS.address_map.addrs[e] = t;
+      }
+      return t;
+    }, lookup_addr(e) {
+      return DNS.address_map.names[e] ? DNS.address_map.names[e] : null;
+    } }, inetNtop4 = (e) => (e & 255) + "." + (e >> 8 & 255) + "." + (e >> 16 & 255) + "." + (e >> 24 & 255), inetNtop6 = (e) => {
+      var r = "", t = 0, n = 0, a = 0, o = 0, s = 0, l = 0, u = [e[0] & 65535, e[0] >> 16, e[1] & 65535, e[1] >> 16, e[2] & 65535, e[2] >> 16, e[3] & 65535, e[3] >> 16], d = true, c = "";
+      for (l = 0; l < 5; l++) if (u[l] !== 0) {
+        d = false;
+        break;
+      }
+      if (d) {
+        if (c = inetNtop4(u[6] | u[7] << 16), u[5] === -1) return r = "::ffff:", r += c, r;
+        if (u[5] === 0) return r = "::", c === "0.0.0.0" && (c = ""), c === "0.0.0.1" && (c = "1"), r += c, r;
+      }
+      for (t = 0; t < 8; t++) u[t] === 0 && (t - a > 1 && (s = 0), a = t, s++), s > n && (n = s, o = t - n + 1);
+      for (t = 0; t < 8; t++) {
+        if (n > 1 && u[t] === 0 && t >= o && t < o + n) {
+          t === o && (r += ":", o === 0 && (r += ":"));
+          continue;
+        }
+        r += Number(_ntohs(u[t] & 65535)).toString(16), r += t < 7 ? ":" : "";
+      }
+      return r;
+    }, writeSockaddr = (e, r, t, n, a) => {
+      switch (r) {
+        case 2:
+          t = inetPton4(t), zeroMemory(e, 16), a && (HEAP32[a >> 2] = 16), HEAP16[e >> 1] = r, HEAP32[e + 4 >> 2] = t, HEAP16[e + 2 >> 1] = _htons(n);
+          break;
+        case 10:
+          t = inetPton6(t), zeroMemory(e, 28), a && (HEAP32[a >> 2] = 28), HEAP32[e >> 2] = r, HEAP32[e + 8 >> 2] = t[0], HEAP32[e + 12 >> 2] = t[1], HEAP32[e + 16 >> 2] = t[2], HEAP32[e + 20 >> 2] = t[3], HEAP16[e + 2 >> 1] = _htons(n);
+          break;
+        default:
+          return 5;
+      }
+      return 0;
+    }, _getaddrinfo = (e, r, t, n) => {
+      var a = 0, o = 0, s = 0, l = 0, u = 0, d = 0, c;
+      function m(_, f, S, v, F, g) {
+        var w, A, y, p;
+        return A = _ === 10 ? 28 : 16, F = _ === 10 ? inetNtop6(F) : inetNtop4(F), w = _malloc(A), p = writeSockaddr(w, _, F, g), assert(!p), y = _malloc(32), HEAP32[y + 4 >> 2] = _, HEAP32[y + 8 >> 2] = f, HEAP32[y + 12 >> 2] = S, HEAPU32[y + 24 >> 2] = v, HEAPU32[y + 20 >> 2] = w, _ === 10 ? HEAP32[y + 16 >> 2] = 28 : HEAP32[y + 16 >> 2] = 16, HEAP32[y + 28 >> 2] = 0, y;
+      }
+      if (t && (s = HEAP32[t >> 2], l = HEAP32[t + 4 >> 2], u = HEAP32[t + 8 >> 2], d = HEAP32[t + 12 >> 2]), u && !d && (d = u === 2 ? 17 : 6), !u && d && (u = d === 17 ? 2 : 1), d === 0 && (d = 6), u === 0 && (u = 1), !e && !r) return -2;
+      if (s & -1088 || t !== 0 && HEAP32[t >> 2] & 2 && !e) return -1;
+      if (s & 32) return -2;
+      if (u !== 0 && u !== 1 && u !== 2) return -7;
+      if (l !== 0 && l !== 2 && l !== 10) return -6;
+      if (r && (r = UTF8ToString(r), o = parseInt(r, 10), isNaN(o))) return s & 1024 ? -2 : -8;
+      if (!e) return l === 0 && (l = 2), s & 1 || (l === 2 ? a = _htonl(2130706433) : a = [0, 0, 0, _htonl(1)]), c = m(l, u, d, null, a, o), HEAPU32[n >> 2] = c, 0;
+      if (e = UTF8ToString(e), a = inetPton4(e), a !== null) if (l === 0 || l === 2) l = 2;
+      else if (l === 10 && s & 8) a = [0, 0, _htonl(65535), a], l = 10;
+      else return -2;
+      else if (a = inetPton6(e), a !== null) if (l === 0 || l === 10) l = 10;
+      else return -2;
+      return a != null ? (c = m(l, u, d, e, a, o), HEAPU32[n >> 2] = c, 0) : s & 4 ? -2 : (e = DNS.lookup_name(e), a = inetPton4(e), l === 0 ? l = 2 : l === 10 && (a = [0, 0, _htonl(65535), a]), c = m(l, u, d, null, a, o), HEAPU32[n >> 2] = c, 0);
+    };
+    _getaddrinfo.sig = "ipppp";
+    var readSockaddr = (e, r) => {
+      var t = HEAP16[e >> 1], n = _ntohs(HEAPU16[e + 2 >> 1]), a;
+      switch (t) {
+        case 2:
+          if (r !== 16) return { errno: 28 };
+          a = HEAP32[e + 4 >> 2], a = inetNtop4(a);
+          break;
+        case 10:
+          if (r !== 28) return { errno: 28 };
+          a = [HEAP32[e + 8 >> 2], HEAP32[e + 12 >> 2], HEAP32[e + 16 >> 2], HEAP32[e + 20 >> 2]], a = inetNtop6(a);
+          break;
+        default:
+          return { errno: 5 };
+      }
+      return { family: t, addr: a, port: n };
+    }, _getnameinfo = (e, r, t, n, a, o, s) => {
+      var l = readSockaddr(e, r);
+      if (l.errno) return -6;
+      var u = l.port, d = l.addr, c = false;
+      if (t && n) {
+        var m;
+        if (s & 1 || !(m = DNS.lookup_addr(d))) {
+          if (s & 8) return -2;
+        } else d = m;
+        var _ = stringToUTF8(d, t, n);
+        _ + 1 >= n && (c = true);
+      }
+      if (a && o) {
+        u = "" + u;
+        var _ = stringToUTF8(u, a, o);
+        _ + 1 >= o && (c = true);
+      }
+      return c ? -12 : 0;
+    };
+    _getnameinfo.sig = "ipipipii";
+    var handleException = (e) => {
+      if (e instanceof ExitStatus || e == "unwind") return EXITSTATUS;
+      quit_(1, e);
+    }, stackAlloc = (e) => __emscripten_stack_alloc(e), stringToUTF8OnStack = (e) => {
+      var r = lengthBytesUTF8(e) + 1, t = stackAlloc(r);
+      return stringToUTF8(e, t, r), t;
+    }, removeFunction = (e) => {
+      functionsInTableMap.delete(getWasmTableEntry(e)), setWasmTableEntry(e, null), freeTableIndexes.push(e);
+    }, FS_createPath = FS.createPath, FS_unlink = (e) => FS.unlink(e), FS_createLazyFile = FS.createLazyFile, FS_createDevice = FS.createDevice;
+    registerWasmPlugin(), FS.createPreloadedFile = FS_createPreloadedFile, FS.staticInit(), Module.FS_createPath = FS.createPath, Module.FS_createDataFile = FS.createDataFile, Module.FS_createPreloadedFile = FS.createPreloadedFile, Module.FS_unlink = FS.unlink, Module.FS_createLazyFile = FS.createLazyFile, Module.FS_createDevice = FS.createDevice, MEMFS.doesNotExistError = new FS.ErrnoError(44), MEMFS.doesNotExistError.stack = "<generic error, no stack>";
+    var wasmImports = { __call_sighandler: ___call_sighandler, __heap_base: ___heap_base, __indirect_function_table: wasmTable, __memory_base: ___memory_base, __stack_pointer: ___stack_pointer, __syscall__newselect: ___syscall__newselect, __syscall_dup: ___syscall_dup, __syscall_faccessat: ___syscall_faccessat, __syscall_fadvise64: ___syscall_fadvise64, __syscall_fcntl64: ___syscall_fcntl64, __syscall_fstat64: ___syscall_fstat64, __syscall_getcwd: ___syscall_getcwd, __syscall_getdents64: ___syscall_getdents64, __syscall_ioctl: ___syscall_ioctl, __syscall_lstat64: ___syscall_lstat64, __syscall_mkdirat: ___syscall_mkdirat, __syscall_newfstatat: ___syscall_newfstatat, __syscall_openat: ___syscall_openat, __syscall_pipe: ___syscall_pipe, __syscall_readlinkat: ___syscall_readlinkat, __syscall_socket: ___syscall_socket, __syscall_stat64: ___syscall_stat64, __syscall_unlinkat: ___syscall_unlinkat, __table_base: ___table_base, _abort_js: __abort_js, _emscripten_fs_load_embedded_files: __emscripten_fs_load_embedded_files, _emscripten_runtime_keepalive_clear: __emscripten_runtime_keepalive_clear, _emscripten_throw_longjmp: __emscripten_throw_longjmp, _localtime_js: __localtime_js, _mktime_js: __mktime_js, _tzset_js: __tzset_js, clock_time_get: _clock_time_get, emscripten_date_now: _emscripten_date_now, emscripten_resize_heap: _emscripten_resize_heap, environ_get: _environ_get, environ_sizes_get: _environ_sizes_get, exit: _exit, fd_close: _fd_close, fd_fdstat_get: _fd_fdstat_get, fd_read: _fd_read, fd_seek: _fd_seek, fd_sync: _fd_sync, fd_write: _fd_write, getaddrinfo: _getaddrinfo, getnameinfo: _getnameinfo, invoke_ii, invoke_iiii, invoke_vii, memory: wasmMemory, proc_exit: _proc_exit }, wasmExports;
+    createWasm();
+    var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports.__wasm_call_ctors)(), _main = Module._main = (e, r) => (_main = Module._main = wasmExports.__main_argc_argv)(e, r), _fflush = (e) => (_fflush = wasmExports.fflush)(e), _malloc = (e) => (_malloc = wasmExports.malloc)(e), _calloc = (e, r) => (_calloc = wasmExports.calloc)(e, r), _setsockopt = Module._setsockopt = (e, r, t, n, a) => (_setsockopt = Module._setsockopt = wasmExports.setsockopt)(e, r, t, n, a), _connect = Module._connect = (e, r, t) => (_connect = Module._connect = wasmExports.connect)(e, r, t), _send = Module._send = (e, r, t, n) => (_send = Module._send = wasmExports.send)(e, r, t, n), _recv = Module._recv = (e, r, t, n) => (_recv = Module._recv = wasmExports.recv)(e, r, t, n), _getsockopt = Module._getsockopt = (e, r, t, n, a) => (_getsockopt = Module._getsockopt = wasmExports.getsockopt)(e, r, t, n, a), _getsockname = Module._getsockname = (e, r, t) => (_getsockname = Module._getsockname = wasmExports.getsockname)(e, r, t), _poll = Module._poll = (e, r, t) => (_poll = Module._poll = wasmExports.poll)(e, r, t), _set_read_write_cbs = Module._set_read_write_cbs = (e, r) => (_set_read_write_cbs = Module._set_read_write_cbs = wasmExports.set_read_write_cbs)(e, r), _fcntl = Module._fcntl = (e, r, t) => (_fcntl = Module._fcntl = wasmExports.fcntl)(e, r, t), ___funcs_on_exit = () => (___funcs_on_exit = wasmExports.__funcs_on_exit)(), _htonl = (e) => (_htonl = wasmExports.htonl)(e), _htons = (e) => (_htons = wasmExports.htons)(e), _ntohs = (e) => (_ntohs = wasmExports.ntohs)(e), _setThrew = (e, r) => (_setThrew = wasmExports.setThrew)(e, r), __emscripten_stack_restore = (e) => (__emscripten_stack_restore = wasmExports._emscripten_stack_restore)(e), __emscripten_stack_alloc = (e) => (__emscripten_stack_alloc = wasmExports._emscripten_stack_alloc)(e), _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports.emscripten_stack_get_current)(), ___wasm_apply_data_relocs = () => (___wasm_apply_data_relocs = wasmExports.__wasm_apply_data_relocs)(), ___emscripten_embedded_file_data = Module.___emscripten_embedded_file_data = 198860;
+    function invoke_iiii(e, r, t, n) {
+      var a = stackSave();
+      try {
+        return getWasmTableEntry(e)(r, t, n);
+      } catch (o) {
+        if (stackRestore(a), o !== o + 0) throw o;
+        _setThrew(1, 0);
+      }
+    }
+    function invoke_ii(e, r) {
+      var t = stackSave();
+      try {
+        return getWasmTableEntry(e)(r);
+      } catch (n) {
+        if (stackRestore(t), n !== n + 0) throw n;
+        _setThrew(1, 0);
+      }
+    }
+    function invoke_vii(e, r, t) {
+      var n = stackSave();
+      try {
+        getWasmTableEntry(e)(r, t);
+      } catch (a) {
+        if (stackRestore(n), a !== a + 0) throw a;
+        _setThrew(1, 0);
+      }
+    }
+    Module.addRunDependency = addRunDependency, Module.removeRunDependency = removeRunDependency, Module.addFunction = addFunction, Module.removeFunction = removeFunction, Module.FS_createPreloadedFile = FS_createPreloadedFile, Module.FS_unlink = FS_unlink, Module.FS_createPath = FS_createPath, Module.FS_createDevice = FS_createDevice, Module.FS = FS, Module.FS_createDataFile = FS_createDataFile, Module.FS_createLazyFile = FS_createLazyFile, Module.MEMFS = MEMFS;
+    var calledRun;
+    dependenciesFulfilled = function e() {
+      calledRun || run(), calledRun || (dependenciesFulfilled = e);
+    };
+    function callMain(e = []) {
+      var r = resolveGlobalSymbol("main").sym;
+      if (r) {
+        e.unshift(thisProgram);
+        var t = e.length, n = stackAlloc((t + 1) * 4), a = n;
+        e.forEach((s) => {
+          HEAPU32[a >> 2] = stringToUTF8OnStack(s), a += 4;
+        }), HEAPU32[a >> 2] = 0;
+        try {
+          var o = r(t, n);
+          return exitJS(o, true), o;
+        } catch (s) {
+          return handleException(s);
+        }
+      }
+    }
+    function run(e = arguments_) {
+      if (runDependencies > 0 || (preRun(), runDependencies > 0)) return;
+      function r() {
+        calledRun || (calledRun = true, Module.calledRun = true, !ABORT && (initRuntime(), preMain(), readyPromiseResolve(Module), Module.onRuntimeInitialized?.(), shouldRunNow && callMain(e), postRun()));
+      }
+      Module.setStatus ? (Module.setStatus("Running..."), setTimeout(() => {
+        setTimeout(() => Module.setStatus(""), 1), r();
+      }, 1)) : r();
+    }
+    if (Module.preInit) for (typeof Module.preInit == "function" && (Module.preInit = [Module.preInit]); Module.preInit.length > 0; ) Module.preInit.pop()();
+    var shouldRunNow = true;
+    return Module.noInitialRun && (shouldRunNow = false), run(), moduleRtn = readyPromise, moduleRtn;
+  };
+})();
+var U = j;
+var L = U;
+var N = "/tmp/out.sql";
+function W(e, r) {
+  let t = new Uint8Array(e.byteLength + r.byteLength);
+  return t.set(new Uint8Array(e), 0), t.set(new Uint8Array(r), e.byteLength), t;
+}
+async function z({ pg: e, args: r }) {
+  let t, n, a = 0, o = "", s = "", u = await L({ arguments: r, noExitRuntime: false, print: (c) => {
+    s += c;
+  }, printErr: (c) => {
+    o += c;
+  }, onExit: (c) => {
+    a = c;
+  }, preRun: [(c) => {
+    c.onRuntimeInitialized = () => {
+      let m = new Uint8Array();
+      t = c.addFunction((_, f) => {
+        let S;
+        try {
+          S = c.HEAPU8.subarray(_, _ + f);
+        } catch (F) {
+          throw console.error("error", F), F;
+        }
+        let v = e.execProtocolRawSync(S);
+        return m = W(m, v), f;
+      }, "iii"), n = c.addFunction((_, f) => {
+        let S = m.length;
+        S > f && (S = f);
+        try {
+          c.HEAP8.set(m.subarray(0, S), _);
+        } catch (v) {
+          console.error(v);
+        }
+        return m = m.subarray(S, m.length), S;
+      }, "iii"), c._set_read_write_cbs(n, t), c.FS.chmod("/home/web_user/.pgpass", 384);
+    };
+  }] }), d = "";
+  return a || (d = u.FS.readFile(N, { encoding: "utf8" })), { exitCode: a, fileContents: d, stderr: o, stdout: s };
+}
+async function te({ pg: e, args: r, fileName: t = "dump.sql" }) {
+  let a = (await e.query("SHOW SEARCH_PATH;")).rows[0].search_path, o = ["-U", "postgres", "--inserts", "-j", "1", "-f", N, "postgres"], s = await z({ pg: e, args: [...r ?? [], ...o] });
+  if (e.exec(`DEALLOCATE ALL; SET SEARCH_PATH = ${a}`), s.exitCode !== 0) throw new Error(`pg_dump failed with exit code ${s.exitCode}. 
+Error message: ${s.stderr}`);
+  return new File([s.fileContents], t, { type: "text/plain" });
+}
+export {
+  te as pgDump
+};
+//# sourceMappingURL=pg_dump-SG4KYBUB.js.map