var WasmModule = (() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  var render_wasm_exports = {};
  __export(render_wasm_exports, {
    default: () => render_wasm_default
  });
  const import_meta = {};
  async function createRustSkiaModule(moduleArg = {}) {
    var moduleRtn;
    (function() {
      function humanReadableVersionToPacked(str) {
        str = str.split("-")[0];
        var vers = str.split(".").slice(0, 3);
        while (vers.length < 3) vers.push("00");
        vers = vers.map((n, i2, arr) => n.padStart(2, "0"));
        return vers.join("");
      }
      var packedVersionToHumanReadable = (n) => [n / 1e4 | 0, (n / 100 | 0) % 100, n % 100].join(".");
      var TARGET_NOT_SUPPORTED = 2147483647;
      var currentNodeVersion = typeof process !== "undefined" && process.versions?.node ? humanReadableVersionToPacked(process.versions.node) : TARGET_NOT_SUPPORTED;
      if (currentNodeVersion < TARGET_NOT_SUPPORTED) {
        throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
      }
      if (currentNodeVersion < 2147483647) {
        throw new Error(`This emscripten-generated code requires node v${packedVersionToHumanReadable(2147483647)} (detected v${packedVersionToHumanReadable(currentNodeVersion)})`);
      }
      var userAgent = typeof navigator !== "undefined" && navigator.userAgent;
      if (!userAgent) {
        return;
      }
      var currentSafariVersion = userAgent.includes("Safari/") && !userAgent.includes("Chrome/") && userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/) ? humanReadableVersionToPacked(userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/)[1]) : TARGET_NOT_SUPPORTED;
      if (currentSafariVersion < 15e4) {
        throw new Error(`This emscripten-generated code requires Safari v${packedVersionToHumanReadable(15e4)} (detected v${currentSafariVersion})`);
      }
      var currentFirefoxVersion = userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/) ? parseFloat(userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
      if (currentFirefoxVersion < 79) {
        throw new Error(`This emscripten-generated code requires Firefox v79 (detected v${currentFirefoxVersion})`);
      }
      var currentChromeVersion = userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/) ? parseFloat(userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
      if (currentChromeVersion < 85) {
        throw new Error(`This emscripten-generated code requires Chrome v85 (detected v${currentChromeVersion})`);
      }
    })();
    var Module = moduleArg;
    var ENVIRONMENT_IS_WEB = !!globalThis.window;
    var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
    var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
    var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
    var arguments_ = [];
    var thisProgram = "./this.program";
    var quit_ = (status, toThrow) => {
      throw toThrow;
    };
    var _scriptName = import_meta.url;
    var scriptDirectory = "";
    function locateFile(path) {
      if (Module["locateFile"]) {
        return Module["locateFile"](path, scriptDirectory);
      }
      return scriptDirectory + path;
    }
    var readAsync, readBinary;
    if (ENVIRONMENT_IS_SHELL) {
    } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
      try {
        scriptDirectory = new URL(".", _scriptName).href;
      } catch {
      }
      if (!(globalThis.window || globalThis.WorkerGlobalScope)) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
      {
        readAsync = async (url) => {
          assert(!isFileURI(url), "readAsync does not work with file:// URLs");
          var response = await fetch(url, { credentials: "same-origin" });
          if (response.ok) {
            return response.arrayBuffer();
          }
          throw new Error(response.status + " : " + response.url);
        };
      }
    } else {
      throw new Error("environment detection error");
    }
    var out = console.log.bind(console);
    var err = console.error.bind(console);
    var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";
    var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";
    var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
    var FETCHFS = "FETCHFS is no longer included by default; build with -lfetchfs.js";
    var ICASEFS = "ICASEFS is no longer included by default; build with -licasefs.js";
    var JSFILEFS = "JSFILEFS is no longer included by default; build with -ljsfilefs.js";
    var OPFS = "OPFS is no longer included by default; build with -lopfs.js";
    var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";
    assert(!ENVIRONMENT_IS_WORKER, "worker environment detected but not enabled at build time.  Add `worker` to `-sENVIRONMENT` to enable.");
    assert(!ENVIRONMENT_IS_NODE, "node environment detected but not enabled at build time.  Add `node` to `-sENVIRONMENT` to enable.");
    assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add `shell` to `-sENVIRONMENT` to enable.");
    var wasmBinary;
    if (!globalThis.WebAssembly) {
      err("no native wasm support detected");
    }
    var ABORT = false;
    var EXITSTATUS;
    function assert(condition, text) {
      if (!condition) {
        abort("Assertion failed" + (text ? ": " + text : ""));
      }
    }
    var isFileURI = (filename) => filename.startsWith("file://");
    function writeStackCookie() {
      var max = _emscripten_stack_get_end();
      assert((max & 3) == 0);
      if (max == 0) {
        max += 4;
      }
      HEAPU32[max >> 2] = 34821223;
      HEAPU32[max + 4 >> 2] = 2310721022;
      HEAPU32[0 >> 2] = 1668509029;
    }
    function checkStackCookie() {
      if (ABORT) return;
      var max = _emscripten_stack_get_end();
      if (max == 0) {
        max += 4;
      }
      var cookie1 = HEAPU32[max >> 2];
      var cookie2 = HEAPU32[max + 4 >> 2];
      if (cookie1 != 34821223 || cookie2 != 2310721022) {
        abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
      }
      if (HEAPU32[0 >> 2] != 1668509029) {
        abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
      }
    }
    class EmscriptenEH extends Error {
    }
    class EmscriptenSjLj extends EmscriptenEH {
    }
    class CppException extends EmscriptenEH {
      constructor(excPtr) {
        super(excPtr);
        this.excPtr = excPtr;
        const excInfo = getExceptionMessage(this);
        this.name = excInfo[0];
        this.message = excInfo[1];
      }
    }
    var runtimeDebug = true;
    function dbg(...args) {
      if (!runtimeDebug && typeof runtimeDebug != "undefined") return;
      console.warn(...args);
    }
    (() => {
      var h16 = new Int16Array(1);
      var h8 = new Int8Array(h16.buffer);
      h16[0] = 25459;
      if (h8[0] !== 115 || h8[1] !== 99) abort("Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)");
    })();
    function consumedModuleProp(prop) {
      if (!Object.getOwnPropertyDescriptor(Module, prop)) {
        Object.defineProperty(Module, prop, {
          configurable: true,
          set() {
            abort(`Attempt to set \`Module.${prop}\` after it has already been processed.  This can happen, for example, when code is injected via '--post-js' rather than '--pre-js'`);
          }
        });
      }
    }
    function makeInvalidEarlyAccess(name) {
      return () => assert(false, `call to '${name}' via reference taken before Wasm module initialization`);
    }
    function ignoredModuleProp(prop) {
      if (Object.getOwnPropertyDescriptor(Module, prop)) {
        abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
      }
    }
    function isExportedByForceFilesystem(name) {
      return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_preloadFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
      name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
    }
    function missingLibrarySymbol(sym) {
      unexportedRuntimeSymbol(sym);
    }
    function unexportedRuntimeSymbol(sym) {
      if (!Object.getOwnPropertyDescriptor(Module, sym)) {
        Object.defineProperty(Module, sym, {
          configurable: true,
          get() {
            var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
            if (isExportedByForceFilesystem(sym)) {
              msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
            }
            abort(msg);
          }
        });
      }
    }
    var readyPromiseResolve, readyPromiseReject;
    var runtimeInitialized = false;
    function updateMemoryViews() {
      var b = wasmMemory.buffer;
      HEAP8 = new Int8Array(b);
      HEAP16 = new Int16Array(b);
      Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
      HEAPU16 = new Uint16Array(b);
      Module["HEAP32"] = HEAP32 = new Int32Array(b);
      Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
      Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
      HEAPF64 = new Float64Array(b);
      HEAP64 = new BigInt64Array(b);
      HEAPU64 = new BigUint64Array(b);
    }
    assert(
      globalThis.Int32Array && globalThis.Float64Array && Int32Array.prototype.subarray && Int32Array.prototype.set,
      "JS engine does not provide full typed array support"
    );
    function preRun() {
      if (Module["preRun"]) {
        if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
        while (Module["preRun"].length) {
          addOnPreRun(Module["preRun"].shift());
        }
      }
      consumedModuleProp("preRun");
      callRuntimeCallbacks(onPreRuns);
    }
    function initRuntime() {
      assert(!runtimeInitialized);
      runtimeInitialized = true;
      checkStackCookie();
      if (!Module["noFSInit"] && !FS.initialized) FS.init();
      TTY.init();
      wasmExports["__wasm_call_ctors"]();
      FS.ignorePermissions = false;
    }
    function preMain() {
      checkStackCookie();
    }
    function postRun() {
      checkStackCookie();
      if (Module["postRun"]) {
        if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
        while (Module["postRun"].length) {
          addOnPostRun(Module["postRun"].shift());
        }
      }
      consumedModuleProp("postRun");
      callRuntimeCallbacks(onPostRuns);
    }
    function abort(what) {
      Module["onAbort"]?.(what);
      what = `Aborted(${what})`;
      err(what);
      ABORT = true;
      var e = new WebAssembly.RuntimeError(what);
      readyPromiseReject?.(e);
      throw e;
    }
    function createExportWrapper(name, nargs) {
      return (...args) => {
        assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
        var f = wasmExports[name];
        assert(f, `exported native function \`${name}\` not found`);
        assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`);
        return f(...args);
      };
    }
    var wasmBinaryFile;
    function findWasmBinary() {
      if (Module["locateFile"]) {
        return locateFile("render_wasm.wasm");
      }
      return new URL("render_wasm.wasm", import_meta.url).href;
    }
    function getBinarySync(file) {
      if (file == wasmBinaryFile && wasmBinary) {
        return new Uint8Array(wasmBinary);
      }
      if (readBinary) {
        return readBinary(file);
      }
      throw "both async and sync fetching of the wasm failed";
    }
    async function getWasmBinary(binaryFile) {
      if (!wasmBinary) {
        try {
          var response = await readAsync(binaryFile);
          return new Uint8Array(response);
        } catch {
        }
      }
      return getBinarySync(binaryFile);
    }
    async function instantiateArrayBuffer(binaryFile, imports) {
      try {
        var binary = await getWasmBinary(binaryFile);
        var instance = await WebAssembly.instantiate(binary, imports);
        return instance;
      } catch (reason) {
        err(`failed to asynchronously prepare wasm: ${reason}`);
        if (isFileURI(binaryFile)) {
          err(`warning: Loading from a file URI (${binaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
        }
        abort(reason);
      }
    }
    async function instantiateAsync(binary, binaryFile, imports) {
      if (!binary) {
        try {
          var response = fetch(binaryFile, { credentials: "same-origin" });
          var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
          return instantiationResult;
        } catch (reason) {
          err(`wasm streaming compile failed: ${reason}`);
          err("falling back to ArrayBuffer instantiation");
        }
        ;
      }
      return instantiateArrayBuffer(binaryFile, imports);
    }
    function getWasmImports() {
      var imports = {
        "env": wasmImports,
        "wasi_snapshot_preview1": wasmImports
      };
      return imports;
    }
    async function createWasm() {
      function receiveInstance(instance, module) {
        wasmExports = instance.exports;
        assignWasmExports(wasmExports);
        updateMemoryViews();
        return wasmExports;
      }
      var trueModule = Module;
      function receiveInstantiationResult(result2) {
        assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
        trueModule = null;
        return receiveInstance(result2["instance"]);
      }
      var info = getWasmImports();
      if (Module["instantiateWasm"]) {
        return new Promise((resolve, reject) => {
          try {
            Module["instantiateWasm"](info, (inst, mod) => {
              resolve(receiveInstance(inst, mod));
            });
          } catch (e) {
            err(`Module.instantiateWasm callback failed with error: ${e}`);
            reject(e);
          }
        });
      }
      wasmBinaryFile ??= findWasmBinary();
      var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
      var exports = receiveInstantiationResult(result);
      return exports;
    }
    class ExitStatus {
      name = "ExitStatus";
      constructor(status) {
        this.message = `Program terminated with exit(${status})`;
        this.status = status;
      }
    }
    var HEAP16;
    var HEAP32;
    var HEAP64;
    var HEAP8;
    var HEAPF32;
    var HEAPF64;
    var HEAPU16;
    var HEAPU32;
    var HEAPU64;
    var HEAPU8;
    var callRuntimeCallbacks = (callbacks) => {
      while (callbacks.length > 0) {
        callbacks.shift()(Module);
      }
    };
    var onPostRuns = [];
    var addOnPostRun = (cb) => onPostRuns.push(cb);
    var onPreRuns = [];
    var addOnPreRun = (cb) => onPreRuns.push(cb);
    function getValue(ptr, type = "i8") {
      if (type.endsWith("*")) type = "*";
      switch (type) {
        case "i1":
          return HEAP8[ptr];
        case "i8":
          return HEAP8[ptr];
        case "i16":
          return HEAP16[ptr >> 1];
        case "i32":
          return HEAP32[ptr >> 2];
        case "i64":
          return HEAP64[ptr >> 3];
        case "float":
          return HEAPF32[ptr >> 2];
        case "double":
          return HEAPF64[ptr >> 3];
        case "*":
          return HEAPU32[ptr >> 2];
        default:
          abort(`invalid type for getValue: ${type}`);
      }
    }
    var noExitRuntime = true;
    function ptrToString(ptr) {
      assert(typeof ptr === "number", `ptrToString expects a number, got ${typeof ptr}`);
      ptr >>>= 0;
      return "0x" + ptr.toString(16).padStart(8, "0");
    }
    function setValue(ptr, value, type = "i8") {
      if (type.endsWith("*")) type = "*";
      switch (type) {
        case "i1":
          HEAP8[ptr] = value;
          break;
        case "i8":
          HEAP8[ptr] = value;
          break;
        case "i16":
          HEAP16[ptr >> 1] = value;
          break;
        case "i32":
          HEAP32[ptr >> 2] = value;
          break;
        case "i64":
          HEAP64[ptr >> 3] = BigInt(value);
          break;
        case "float":
          HEAPF32[ptr >> 2] = value;
          break;
        case "double":
          HEAPF64[ptr >> 3] = value;
          break;
        case "*":
          HEAPU32[ptr >> 2] = value;
          break;
        default:
          abort(`invalid type for setValue: ${type}`);
      }
    }
    var stackRestore = (val) => __emscripten_stack_restore(val);
    var stackSave = () => _emscripten_stack_get_current();
    var warnOnce = (text) => {
      warnOnce.shown ||= {};
      if (!warnOnce.shown[text]) {
        warnOnce.shown[text] = 1;
        err(text);
      }
    };
    var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
    var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
      var maxIdx = idx + maxBytesToRead;
      if (ignoreNul) return maxIdx;
      while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
      return idx;
    };
    var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
      var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
      }
      var str = "";
      while (idx < endPtr) {
        var u0 = heapOrArray[idx++];
        if (!(u0 & 128)) {
          str += String.fromCharCode(u0);
          continue;
        }
        var u1 = heapOrArray[idx++] & 63;
        if ((u0 & 224) == 192) {
          str += String.fromCharCode((u0 & 31) << 6 | u1);
          continue;
        }
        var u2 = heapOrArray[idx++] & 63;
        if ((u0 & 240) == 224) {
          u0 = (u0 & 15) << 12 | u1 << 6 | u2;
        } else {
          if ((u0 & 248) != 240) warnOnce(`Invalid UTF-8 leading byte ${ptrToString(u0)} encountered when deserializing a UTF-8 string in wasm memory to a JS string!`);
          u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
        }
        if (u0 < 65536) {
          str += String.fromCharCode(u0);
        } else {
          var ch = u0 - 65536;
          str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
        }
      }
      return str;
    };
    var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
      assert(typeof ptr == "number", `UTF8ToString expects a number (got ${typeof ptr})`);
      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
    };
    var ___assert_fail = (condition, filename, line, func) => abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
    var exceptionCaught = [];
    var uncaughtExceptionCount = 0;
    var ___cxa_begin_catch = (ptr) => {
      var info = new ExceptionInfo(ptr);
      if (!info.get_caught()) {
        info.set_caught(true);
        uncaughtExceptionCount--;
      }
      info.set_rethrown(false);
      exceptionCaught.push(info);
      return ___cxa_get_exception_ptr(ptr);
    };
    var exceptionLast = null;
    var ___cxa_end_catch = () => {
      _setThrew(0, 0);
      assert(exceptionCaught.length > 0);
      var info = exceptionCaught.pop();
      ___cxa_decrement_exception_refcount(info.excPtr);
      exceptionLast = null;
    };
    class ExceptionInfo {
      // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
      constructor(excPtr) {
        this.excPtr = excPtr;
        this.ptr = excPtr - 24;
      }
      set_type(type) {
        HEAPU32[this.ptr + 4 >> 2] = type;
      }
      get_type() {
        return HEAPU32[this.ptr + 4 >> 2];
      }
      set_destructor(destructor) {
        HEAPU32[this.ptr + 8 >> 2] = destructor;
      }
      get_destructor() {
        return HEAPU32[this.ptr + 8 >> 2];
      }
      set_caught(caught) {
        caught = caught ? 1 : 0;
        HEAP8[this.ptr + 12] = caught;
      }
      get_caught() {
        return HEAP8[this.ptr + 12] != 0;
      }
      set_rethrown(rethrown) {
        rethrown = rethrown ? 1 : 0;
        HEAP8[this.ptr + 13] = rethrown;
      }
      get_rethrown() {
        return HEAP8[this.ptr + 13] != 0;
      }
      // Initialize native structure fields. Should be called once after allocated.
      init(type, destructor) {
        this.set_adjusted_ptr(0);
        this.set_type(type);
        this.set_destructor(destructor);
      }
      set_adjusted_ptr(adjustedPtr) {
        HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
      }
      get_adjusted_ptr() {
        return HEAPU32[this.ptr + 16 >> 2];
      }
    }
    var setTempRet0 = (val) => __emscripten_tempret_set(val);
    var findMatchingCatch = (args) => {
      var thrown = exceptionLast?.excPtr;
      if (!thrown) {
        setTempRet0(0);
        return 0;
      }
      var info = new ExceptionInfo(thrown);
      info.set_adjusted_ptr(thrown);
      var thrownType = info.get_type();
      if (!thrownType) {
        setTempRet0(0);
        return thrown;
      }
      for (var caughtType of args) {
        if (caughtType === 0 || caughtType === thrownType) {
          break;
        }
        var adjusted_ptr_addr = info.ptr + 16;
        if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
          setTempRet0(caughtType);
          return thrown;
        }
      }
      setTempRet0(thrownType);
      return thrown;
    };
    var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
    var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch([arg0]);
    var ___cxa_find_matching_catch_4 = (arg0, arg1) => findMatchingCatch([arg0, arg1]);
    var ___cxa_rethrow = () => {
      if (!exceptionCaught.length) {
        abort("no exception to throw");
      }
      var info = exceptionCaught.at(-1);
      var ptr = info.excPtr;
      info.set_rethrown(true);
      info.set_caught(false);
      uncaughtExceptionCount++;
      ___cxa_increment_exception_refcount(ptr);
      exceptionLast = new CppException(ptr);
      throw exceptionLast;
    };
    var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
    var getExceptionMessageCommon = (ptr) => {
      var sp = stackSave();
      var type_addr_addr = stackAlloc(4);
      var message_addr_addr = stackAlloc(4);
      ___get_exception_message(ptr, type_addr_addr, message_addr_addr);
      var type_addr = HEAPU32[type_addr_addr >> 2];
      var message_addr = HEAPU32[message_addr_addr >> 2];
      var type = UTF8ToString(type_addr);
      _free(type_addr);
      var message;
      if (message_addr) {
        message = UTF8ToString(message_addr);
        _free(message_addr);
      }
      stackRestore(sp);
      return [type, message];
    };
    var getExceptionMessage = (exn) => getExceptionMessageCommon(exn.excPtr);
    var decrementExceptionRefcount = (exn) => ___cxa_decrement_exception_refcount(exn.excPtr);
    var incrementExceptionRefcount = (exn) => ___cxa_increment_exception_refcount(exn.excPtr);
    var ___cxa_throw = (ptr, type, destructor) => {
      var info = new ExceptionInfo(ptr);
      info.init(type, destructor);
      ___cxa_increment_exception_refcount(ptr);
      exceptionLast = new CppException(ptr);
      uncaughtExceptionCount++;
      throw exceptionLast;
    };
    var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
    var ___resumeException = (ptr) => {
      if (!exceptionLast) {
        exceptionLast = new CppException(ptr);
      }
      throw exceptionLast;
    };
    var syscallGetVarargI = () => {
      assert(SYSCALLS.varargs != void 0);
      var ret = HEAP32[+SYSCALLS.varargs >> 2];
      SYSCALLS.varargs += 4;
      return ret;
    };
    var syscallGetVarargP = syscallGetVarargI;
    var PATH = {
      isAbs: (path) => path.charAt(0) === "/",
      splitPath: (filename) => {
        var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
        return splitPathRe.exec(filename).slice(1);
      },
      normalizeArray: (parts, allowAboveRoot) => {
        var up = 0;
        for (var i2 = parts.length - 1; i2 >= 0; i2--) {
          var last = parts[i2];
          if (last === ".") {
            parts.splice(i2, 1);
          } else if (last === "..") {
            parts.splice(i2, 1);
            up++;
          } else if (up) {
            parts.splice(i2, 1);
            up--;
          }
        }
        if (allowAboveRoot) {
          for (; up; up--) {
            parts.unshift("..");
          }
        }
        return parts;
      },
      normalize: (path) => {
        var isAbsolute = PATH.isAbs(path), trailingSlash = path.slice(-1) === "/";
        path = PATH.normalizeArray(path.split("/").filter((p) => !!p), !isAbsolute).join("/");
        if (!path && !isAbsolute) {
          path = ".";
        }
        if (path && trailingSlash) {
          path += "/";
        }
        return (isAbsolute ? "/" : "") + path;
      },
      dirname: (path) => {
        var result = PATH.splitPath(path), root = result[0], dir = result[1];
        if (!root && !dir) {
          return ".";
        }
        if (dir) {
          dir = dir.slice(0, -1);
        }
        return root + dir;
      },
      basename: (path) => path && path.match(/([^\/]+|\/)\/*$/)[1],
      join: (...paths) => PATH.normalize(paths.join("/")),
      join2: (l, r) => PATH.normalize(l + "/" + r)
    };
    var initRandomFill = () => {
      return (view) => (crypto.getRandomValues(view), 0);
    };
    var randomFill = (view) => (randomFill = initRandomFill())(view);
    var PATH_FS = {
      resolve: (...args) => {
        var resolvedPath = "", resolvedAbsolute = false;
        for (var i2 = args.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
          var path = i2 >= 0 ? args[i2] : FS.cwd();
          if (typeof path != "string") {
            throw new TypeError("Arguments to path.resolve must be strings");
          } else if (!path) {
            return "";
          }
          resolvedPath = path + "/" + resolvedPath;
          resolvedAbsolute = PATH.isAbs(path);
        }
        resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
        return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
      },
      relative: (from, to) => {
        from = PATH_FS.resolve(from).slice(1);
        to = PATH_FS.resolve(to).slice(1);
        function trim(arr) {
          var start = 0;
          for (; start < arr.length; start++) {
            if (arr[start] !== "") break;
          }
          var end = arr.length - 1;
          for (; end >= 0; end--) {
            if (arr[end] !== "") break;
          }
          if (start > end) return [];
          return arr.slice(start, end - start + 1);
        }
        var fromParts = trim(from.split("/"));
        var toParts = trim(to.split("/"));
        var length = Math.min(fromParts.length, toParts.length);
        var samePartsLength = length;
        for (var i2 = 0; i2 < length; i2++) {
          if (fromParts[i2] !== toParts[i2]) {
            samePartsLength = i2;
            break;
          }
        }
        var outputParts = [];
        for (var i2 = samePartsLength; i2 < fromParts.length; i2++) {
          outputParts.push("..");
        }
        outputParts = outputParts.concat(toParts.slice(samePartsLength));
        return outputParts.join("/");
      }
    };
    var FS_stdin_getChar_buffer = [];
    var lengthBytesUTF8 = (str) => {
      var len = 0;
      for (var i2 = 0; i2 < str.length; ++i2) {
        var c = str.charCodeAt(i2);
        if (c <= 127) {
          len++;
        } else if (c <= 2047) {
          len += 2;
        } else if (c >= 55296 && c <= 57343) {
          len += 4;
          ++i2;
        } else {
          len += 3;
        }
      }
      return len;
    };
    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
      assert(typeof str === "string", `stringToUTF8Array expects a string (got ${typeof str})`);
      if (!(maxBytesToWrite > 0))
        return 0;
      var startIdx = outIdx;
      var endIdx = outIdx + maxBytesToWrite - 1;
      for (var i2 = 0; i2 < str.length; ++i2) {
        var u = str.codePointAt(i2);
        if (u <= 127) {
          if (outIdx >= endIdx) break;
          heap[outIdx++] = u;
        } else if (u <= 2047) {
          if (outIdx + 1 >= endIdx) break;
          heap[outIdx++] = 192 | u >> 6;
          heap[outIdx++] = 128 | u & 63;
        } else if (u <= 65535) {
          if (outIdx + 2 >= endIdx) break;
          heap[outIdx++] = 224 | u >> 12;
          heap[outIdx++] = 128 | u >> 6 & 63;
          heap[outIdx++] = 128 | u & 63;
        } else {
          if (outIdx + 3 >= endIdx) break;
          if (u > 1114111) warnOnce(`Invalid Unicode code point ${ptrToString(u)} encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).`);
          heap[outIdx++] = 240 | u >> 18;
          heap[outIdx++] = 128 | u >> 12 & 63;
          heap[outIdx++] = 128 | u >> 6 & 63;
          heap[outIdx++] = 128 | u & 63;
          i2++;
        }
      }
      heap[outIdx] = 0;
      return outIdx - startIdx;
    };
    var intArrayFromString = (stringy, dontAddNull, length) => {
      var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
      var u8array = new Array(len);
      var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
      if (dontAddNull) u8array.length = numBytesWritten;
      return u8array;
    };
    var FS_stdin_getChar = () => {
      if (!FS_stdin_getChar_buffer.length) {
        var result = null;
        if (globalThis.window?.prompt) {
          result = window.prompt("Input: ");
          if (result !== null) {
            result += "\n";
          }
        } else {
        }
        if (!result) {
          return null;
        }
        FS_stdin_getChar_buffer = intArrayFromString(result, true);
      }
      return FS_stdin_getChar_buffer.shift();
    };
    var TTY = {
      ttys: [],
      init() {
      },
      shutdown() {
      },
      register(dev, ops) {
        TTY.ttys[dev] = { input: [], output: [], ops };
        FS.registerDevice(dev, TTY.stream_ops);
      },
      stream_ops: {
        open(stream) {
          var tty = TTY.ttys[stream.node.rdev];
          if (!tty) {
            throw new FS.ErrnoError(43);
          }
          stream.tty = tty;
          stream.seekable = false;
        },
        close(stream) {
          stream.tty.ops.fsync(stream.tty);
        },
        fsync(stream) {
          stream.tty.ops.fsync(stream.tty);
        },
        read(stream, buffer, offset, length, pos) {
          if (!stream.tty || !stream.tty.ops.get_char) {
            throw new FS.ErrnoError(60);
          }
          var bytesRead = 0;
          for (var i2 = 0; i2 < length; i2++) {
            var result;
            try {
              result = stream.tty.ops.get_char(stream.tty);
            } catch (e) {
              throw new FS.ErrnoError(29);
            }
            if (result === void 0 && bytesRead === 0) {
              throw new FS.ErrnoError(6);
            }
            if (result === null || result === void 0) break;
            bytesRead++;
            buffer[offset + i2] = result;
          }
          if (bytesRead) {
            stream.node.atime = Date.now();
          }
          return bytesRead;
        },
        write(stream, buffer, offset, length, pos) {
          if (!stream.tty || !stream.tty.ops.put_char) {
            throw new FS.ErrnoError(60);
          }
          try {
            for (var i2 = 0; i2 < length; i2++) {
              stream.tty.ops.put_char(stream.tty, buffer[offset + i2]);
            }
          } catch (e) {
            throw new FS.ErrnoError(29);
          }
          if (length) {
            stream.node.mtime = stream.node.ctime = Date.now();
          }
          return i2;
        }
      },
      default_tty_ops: {
        get_char(tty) {
          return FS_stdin_getChar();
        },
        put_char(tty, val) {
          if (val === null || val === 10) {
            out(UTF8ArrayToString(tty.output));
            tty.output = [];
          } else {
            if (val != 0) tty.output.push(val);
          }
        },
        fsync(tty) {
          if (tty.output?.length > 0) {
            out(UTF8ArrayToString(tty.output));
            tty.output = [];
          }
        },
        ioctl_tcgets(tty) {
          return {
            c_iflag: 25856,
            c_oflag: 5,
            c_cflag: 191,
            c_lflag: 35387,
            c_cc: [
              3,
              28,
              127,
              21,
              4,
              0,
              1,
              0,
              17,
              19,
              26,
              0,
              18,
              15,
              23,
              22,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0
            ]
          };
        },
        ioctl_tcsets(tty, optional_actions, data) {
          return 0;
        },
        ioctl_tiocgwinsz(tty) {
          return [24, 80];
        }
      },
      default_tty1_ops: {
        put_char(tty, val) {
          if (val === null || val === 10) {
            err(UTF8ArrayToString(tty.output));
            tty.output = [];
          } else {
            if (val != 0) tty.output.push(val);
          }
        },
        fsync(tty) {
          if (tty.output?.length > 0) {
            err(UTF8ArrayToString(tty.output));
            tty.output = [];
          }
        }
      }
    };
    var zeroMemory = (ptr, size) => HEAPU8.fill(0, ptr, ptr + size);
    var alignMemory = (size, alignment) => {
      assert(alignment, "alignment argument is required");
      return Math.ceil(size / alignment) * alignment;
    };
    var mmapAlloc = (size) => {
      size = alignMemory(size, 65536);
      var ptr = _emscripten_builtin_memalign(65536, size);
      if (ptr) zeroMemory(ptr, size);
      return ptr;
    };
    var MEMFS = {
      ops_table: null,
      mount(mount) {
        return MEMFS.createNode(null, "/", 16895, 0);
      },
      createNode(parent, name, mode, dev) {
        if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
          throw new FS.ErrnoError(63);
        }
        MEMFS.ops_table ||= {
          dir: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr,
              lookup: MEMFS.node_ops.lookup,
              mknod: MEMFS.node_ops.mknod,
              rename: MEMFS.node_ops.rename,
              unlink: MEMFS.node_ops.unlink,
              rmdir: MEMFS.node_ops.rmdir,
              readdir: MEMFS.node_ops.readdir,
              symlink: MEMFS.node_ops.symlink
            },
            stream: {
              llseek: MEMFS.stream_ops.llseek
            }
          },
          file: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr
            },
            stream: {
              llseek: MEMFS.stream_ops.llseek,
              read: MEMFS.stream_ops.read,
              write: MEMFS.stream_ops.write,
              mmap: MEMFS.stream_ops.mmap,
              msync: MEMFS.stream_ops.msync
            }
          },
          link: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr,
              readlink: MEMFS.node_ops.readlink
            },
            stream: {}
          },
          chrdev: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr
            },
            stream: FS.chrdev_stream_ops
          }
        };
        var node = FS.createNode(parent, name, mode, dev);
        if (FS.isDir(node.mode)) {
          node.node_ops = MEMFS.ops_table.dir.node;
          node.stream_ops = MEMFS.ops_table.dir.stream;
          node.contents = {};
        } else if (FS.isFile(node.mode)) {
          node.node_ops = MEMFS.ops_table.file.node;
          node.stream_ops = MEMFS.ops_table.file.stream;
          node.usedBytes = 0;
          node.contents = MEMFS.emptyFileContents ??= new Uint8Array(0);
        } else if (FS.isLink(node.mode)) {
          node.node_ops = MEMFS.ops_table.link.node;
          node.stream_ops = MEMFS.ops_table.link.stream;
        } else if (FS.isChrdev(node.mode)) {
          node.node_ops = MEMFS.ops_table.chrdev.node;
          node.stream_ops = MEMFS.ops_table.chrdev.stream;
        }
        node.atime = node.mtime = node.ctime = Date.now();
        if (parent) {
          parent.contents[name] = node;
          parent.atime = parent.mtime = parent.ctime = node.atime;
        }
        return node;
      },
      getFileDataAsTypedArray(node) {
        assert(FS.isFile(node.mode), "getFileDataAsTypedArray called on non-file");
        return node.contents.subarray(0, node.usedBytes);
      },
      expandFileStorage(node, newCapacity) {
        var prevCapacity = node.contents.length;
        if (prevCapacity >= newCapacity) return;
        var CAPACITY_DOUBLING_MAX = 1024 * 1024;
        newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
        if (prevCapacity) newCapacity = Math.max(newCapacity, 256);
        var oldContents = MEMFS.getFileDataAsTypedArray(node);
        node.contents = new Uint8Array(newCapacity);
        node.contents.set(oldContents);
      },
      resizeFileStorage(node, newSize) {
        if (node.usedBytes == newSize) return;
        var oldContents = node.contents;
        node.contents = new Uint8Array(newSize);
        node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
        node.usedBytes = newSize;
      },
      node_ops: {
        getattr(node) {
          var attr = {};
          attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
          attr.ino = node.id;
          attr.mode = node.mode;
          attr.nlink = 1;
          attr.uid = 0;
          attr.gid = 0;
          attr.rdev = node.rdev;
          if (FS.isDir(node.mode)) {
            attr.size = 4096;
          } else if (FS.isFile(node.mode)) {
            attr.size = node.usedBytes;
          } else if (FS.isLink(node.mode)) {
            attr.size = node.link.length;
          } else {
            attr.size = 0;
          }
          attr.atime = new Date(node.atime);
          attr.mtime = new Date(node.mtime);
          attr.ctime = new Date(node.ctime);
          attr.blksize = 4096;
          attr.blocks = Math.ceil(attr.size / attr.blksize);
          return attr;
        },
        setattr(node, attr) {
          for (const key of ["mode", "atime", "mtime", "ctime"]) {
            if (attr[key] != null) {
              node[key] = attr[key];
            }
          }
          if (attr.size !== void 0) {
            MEMFS.resizeFileStorage(node, attr.size);
          }
        },
        lookup(parent, name) {
          throw new FS.ErrnoError(44);
        },
        mknod(parent, name, mode, dev) {
          return MEMFS.createNode(parent, name, mode, dev);
        },
        rename(old_node, new_dir, new_name) {
          var new_node;
          try {
            new_node = FS.lookupNode(new_dir, new_name);
          } catch (e) {
          }
          if (new_node) {
            if (FS.isDir(old_node.mode)) {
              for (var i2 in new_node.contents) {
                throw new FS.ErrnoError(55);
              }
            }
            FS.hashRemoveNode(new_node);
          }
          delete old_node.parent.contents[old_node.name];
          new_dir.contents[new_name] = old_node;
          old_node.name = new_name;
          new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now();
        },
        unlink(parent, name) {
          delete parent.contents[name];
          parent.ctime = parent.mtime = Date.now();
        },
        rmdir(parent, name) {
          var node = FS.lookupNode(parent, name);
          for (var i2 in node.contents) {
            throw new FS.ErrnoError(55);
          }
          delete parent.contents[name];
          parent.ctime = parent.mtime = Date.now();
        },
        readdir(node) {
          return [".", "..", ...Object.keys(node.contents)];
        },
        symlink(parent, newname, oldpath) {
          var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
          node.link = oldpath;
          return node;
        },
        readlink(node) {
          if (!FS.isLink(node.mode)) {
            throw new FS.ErrnoError(28);
          }
          return node.link;
        }
      },
      stream_ops: {
        read(stream, buffer, offset, length, position) {
          var contents = stream.node.contents;
          if (position >= stream.node.usedBytes) return 0;
          var size = Math.min(stream.node.usedBytes - position, length);
          assert(size >= 0);
          buffer.set(contents.subarray(position, position + size), offset);
          return size;
        },
        write(stream, buffer, offset, length, position, canOwn) {
          assert(buffer.subarray, "FS.write expects a TypedArray");
          if (buffer.buffer === HEAP8.buffer) {
            canOwn = false;
          }
          if (!length) return 0;
          var node = stream.node;
          node.mtime = node.ctime = Date.now();
          if (canOwn) {
            assert(position === 0, "canOwn must imply no weird position inside the file");
            node.contents = buffer.subarray(offset, offset + length);
            node.usedBytes = length;
          } else if (node.usedBytes === 0 && position === 0) {
            node.contents = buffer.slice(offset, offset + length);
            node.usedBytes = length;
          } else {
            MEMFS.expandFileStorage(node, position + length);
            node.contents.set(buffer.subarray(offset, offset + length), position);
            node.usedBytes = Math.max(node.usedBytes, position + length);
          }
          return length;
        },
        llseek(stream, offset, whence) {
          var position = offset;
          if (whence === 1) {
            position += stream.position;
          } else if (whence === 2) {
            if (FS.isFile(stream.node.mode)) {
              position += stream.node.usedBytes;
            }
          }
          if (position < 0) {
            throw new FS.ErrnoError(28);
          }
          return position;
        },
        mmap(stream, length, position, prot, flags) {
          if (!FS.isFile(stream.node.mode)) {
            throw new FS.ErrnoError(43);
          }
          var ptr;
          var allocated;
          var contents = stream.node.contents;
          if (!(flags & 2) && contents.buffer === HEAP8.buffer) {
            allocated = false;
            ptr = contents.byteOffset;
          } else {
            allocated = true;
            ptr = mmapAlloc(length);
            if (!ptr) {
              throw new FS.ErrnoError(48);
            }
            if (contents) {
              if (position > 0 || position + length < contents.length) {
                if (contents.subarray) {
                  contents = contents.subarray(position, position + length);
                } else {
                  contents = Array.prototype.slice.call(contents, position, position + length);
                }
              }
              HEAP8.set(contents, ptr);
            }
          }
          return { ptr, allocated };
        },
        msync(stream, buffer, offset, length, mmapFlags) {
          MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
          return 0;
        }
      }
    };
    var FS_modeStringToFlags = (str) => {
      if (typeof str != "string") return str;
      var flagModes = {
        "r": 0,
        "r+": 2,
        "w": 512 | 64 | 1,
        "w+": 512 | 64 | 2,
        "a": 1024 | 64 | 1,
        "a+": 1024 | 64 | 2
      };
      var flags = flagModes[str];
      if (typeof flags == "undefined") {
        throw new Error(`Unknown file open mode: ${str}`);
      }
      return flags;
    };
    var FS_fileDataToTypedArray = (data) => {
      if (typeof data == "string") {
        data = intArrayFromString(data, true);
      }
      if (!data.subarray) {
        data = new Uint8Array(data);
      }
      return data;
    };
    var FS_getMode = (canRead, canWrite) => {
      var mode = 0;
      if (canRead) mode |= 292 | 73;
      if (canWrite) mode |= 146;
      return mode;
    };
    var strError = (errno) => UTF8ToString(_strerror(errno));
    var ERRNO_CODES = {
      "EPERM": 63,
      "ENOENT": 44,
      "ESRCH": 71,
      "EINTR": 27,
      "EIO": 29,
      "ENXIO": 60,
      "E2BIG": 1,
      "ENOEXEC": 45,
      "EBADF": 8,
      "ECHILD": 12,
      "EAGAIN": 6,
      "EWOULDBLOCK": 6,
      "ENOMEM": 48,
      "EACCES": 2,
      "EFAULT": 21,
      "ENOTBLK": 105,
      "EBUSY": 10,
      "EEXIST": 20,
      "EXDEV": 75,
      "ENODEV": 43,
      "ENOTDIR": 54,
      "EISDIR": 31,
      "EINVAL": 28,
      "ENFILE": 41,
      "EMFILE": 33,
      "ENOTTY": 59,
      "ETXTBSY": 74,
      "EFBIG": 22,
      "ENOSPC": 51,
      "ESPIPE": 70,
      "EROFS": 69,
      "EMLINK": 34,
      "EPIPE": 64,
      "EDOM": 18,
      "ERANGE": 68,
      "ENOMSG": 49,
      "EIDRM": 24,
      "ECHRNG": 106,
      "EL2NSYNC": 156,
      "EL3HLT": 107,
      "EL3RST": 108,
      "ELNRNG": 109,
      "EUNATCH": 110,
      "ENOCSI": 111,
      "EL2HLT": 112,
      "EDEADLK": 16,
      "ENOLCK": 46,
      "EBADE": 113,
      "EBADR": 114,
      "EXFULL": 115,
      "ENOANO": 104,
      "EBADRQC": 103,
      "EBADSLT": 102,
      "EDEADLOCK": 16,
      "EBFONT": 101,
      "ENOSTR": 100,
      "ENODATA": 116,
      "ETIME": 117,
      "ENOSR": 118,
      "ENONET": 119,
      "ENOPKG": 120,
      "EREMOTE": 121,
      "ENOLINK": 47,
      "EADV": 122,
      "ESRMNT": 123,
      "ECOMM": 124,
      "EPROTO": 65,
      "EMULTIHOP": 36,
      "EDOTDOT": 125,
      "EBADMSG": 9,
      "ENOTUNIQ": 126,
      "EBADFD": 127,
      "EREMCHG": 128,
      "ELIBACC": 129,
      "ELIBBAD": 130,
      "ELIBSCN": 131,
      "ELIBMAX": 132,
      "ELIBEXEC": 133,
      "ENOSYS": 52,
      "ENOTEMPTY": 55,
      "ENAMETOOLONG": 37,
      "ELOOP": 32,
      "EOPNOTSUPP": 138,
      "EPFNOSUPPORT": 139,
      "ECONNRESET": 15,
      "ENOBUFS": 42,
      "EAFNOSUPPORT": 5,
      "EPROTOTYPE": 67,
      "ENOTSOCK": 57,
      "ENOPROTOOPT": 50,
      "ESHUTDOWN": 140,
      "ECONNREFUSED": 14,
      "EADDRINUSE": 3,
      "ECONNABORTED": 13,
      "ENETUNREACH": 40,
      "ENETDOWN": 38,
      "ETIMEDOUT": 73,
      "EHOSTDOWN": 142,
      "EHOSTUNREACH": 23,
      "EINPROGRESS": 26,
      "EALREADY": 7,
      "EDESTADDRREQ": 17,
      "EMSGSIZE": 35,
      "EPROTONOSUPPORT": 66,
      "ESOCKTNOSUPPORT": 137,
      "EADDRNOTAVAIL": 4,
      "ENETRESET": 39,
      "EISCONN": 30,
      "ENOTCONN": 53,
      "ETOOMANYREFS": 141,
      "EUSERS": 136,
      "EDQUOT": 19,
      "ESTALE": 72,
      "ENOTSUP": 138,
      "ENOMEDIUM": 148,
      "EILSEQ": 25,
      "EOVERFLOW": 61,
      "ECANCELED": 11,
      "ENOTRECOVERABLE": 56,
      "EOWNERDEAD": 62,
      "ESTRPIPE": 135
    };
    var asyncLoad = async (url) => {
      var arrayBuffer = await readAsync(url);
      assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
      return new Uint8Array(arrayBuffer);
    };
    var FS_createDataFile = (...args) => FS.createDataFile(...args);
    var getUniqueRunDependency = (id) => {
      var orig = id;
      while (1) {
        if (!runDependencyTracking[id]) return id;
        id = orig + Math.random();
      }
    };
    var runDependencies = 0;
    var dependenciesFulfilled = null;
    var runDependencyTracking = {};
    var runDependencyWatcher = null;
    var removeRunDependency = (id) => {
      runDependencies--;
      Module["monitorRunDependencies"]?.(runDependencies);
      assert(id, "removeRunDependency requires an ID");
      assert(runDependencyTracking[id]);
      delete runDependencyTracking[id];
      if (runDependencies == 0) {
        if (runDependencyWatcher !== null) {
          clearInterval(runDependencyWatcher);
          runDependencyWatcher = null;
        }
        if (dependenciesFulfilled) {
          var callback = dependenciesFulfilled;
          dependenciesFulfilled = null;
          callback();
        }
      }
    };
    var addRunDependency = (id) => {
      runDependencies++;
      Module["monitorRunDependencies"]?.(runDependencies);
      assert(id, "addRunDependency requires an ID");
      assert(!runDependencyTracking[id]);
      runDependencyTracking[id] = 1;
      if (runDependencyWatcher === null && globalThis.setInterval) {
        runDependencyWatcher = setInterval(() => {
          if (ABORT) {
            clearInterval(runDependencyWatcher);
            runDependencyWatcher = null;
            return;
          }
          var shown = false;
          for (var dep in runDependencyTracking) {
            if (!shown) {
              shown = true;
              err("still waiting on run dependencies:");
            }
            err(`dependency: ${dep}`);
          }
          if (shown) {
            err("(end of list)");
          }
        }, 1e4);
      }
    };
    var preloadPlugins = [];
    var FS_handledByPreloadPlugin = async (byteArray, fullname) => {
      if (typeof Browser != "undefined") Browser.init();
      for (var plugin of preloadPlugins) {
        if (plugin["canHandle"](fullname)) {
          assert(plugin["handle"].constructor.name === "AsyncFunction", "Filesystem plugin handlers must be async functions (See #24914)");
          return plugin["handle"](byteArray, fullname);
        }
      }
      return byteArray;
    };
    var FS_preloadFile = async (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => {
      var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
      var dep = getUniqueRunDependency(`cp ${fullname}`);
      addRunDependency(dep);
      try {
        var byteArray = url;
        if (typeof url == "string") {
          byteArray = await asyncLoad(url);
        }
        byteArray = await FS_handledByPreloadPlugin(byteArray, fullname);
        preFinish?.();
        if (!dontCreateFile) {
          FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
        }
      } finally {
        removeRunDependency(dep);
      }
    };
    var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
      FS_preloadFile(parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish).then(onload).catch(onerror);
    };
    var FS = {
      root: null,
      mounts: [],
      devices: {},
      streams: [],
      nextInode: 1,
      nameTable: null,
      currentPath: "/",
      initialized: false,
      ignorePermissions: true,
      filesystems: null,
      syncFSRequests: 0,
      ErrnoError: class extends Error {
        name = "ErrnoError";
        // We set the `name` property to be able to identify `FS.ErrnoError`
        // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway.
        // - when using PROXYFS, an error can come from an underlying FS
        // as different FS objects have their own FS.ErrnoError each,
        // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs.
        // we'll use the reliable test `err.name == "ErrnoError"` instead
        constructor(errno) {
          super(runtimeInitialized ? strError(errno) : "");
          this.errno = errno;
          for (var key in ERRNO_CODES) {
            if (ERRNO_CODES[key] === errno) {
              this.code = key;
              break;
            }
          }
        }
      },
      FSStream: class {
        shared = {};
        get object() {
          return this.node;
        }
        set object(val) {
          this.node = val;
        }
        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(val) {
          this.shared.flags = val;
        }
        get position() {
          return this.shared.position;
        }
        set position(val) {
          this.shared.position = val;
        }
      },
      FSNode: class {
        node_ops = {};
        stream_ops = {};
        readMode = 292 | 73;
        writeMode = 146;
        mounted = null;
        constructor(parent, name, mode, rdev) {
          if (!parent) {
            parent = this;
          }
          this.parent = parent;
          this.mount = parent.mount;
          this.id = FS.nextInode++;
          this.name = name;
          this.mode = mode;
          this.rdev = rdev;
          this.atime = this.mtime = this.ctime = Date.now();
        }
        get read() {
          return (this.mode & this.readMode) === this.readMode;
        }
        set read(val) {
          val ? this.mode |= this.readMode : this.mode &= ~this.readMode;
        }
        get write() {
          return (this.mode & this.writeMode) === this.writeMode;
        }
        set write(val) {
          val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode;
        }
        get isFolder() {
          return FS.isDir(this.mode);
        }
        get isDevice() {
          return FS.isChrdev(this.mode);
        }
      },
      lookupPath(path, opts = {}) {
        if (!path) {
          throw new FS.ErrnoError(44);
        }
        opts.follow_mount ??= true;
        if (!PATH.isAbs(path)) {
          path = FS.cwd() + "/" + path;
        }
        linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
          var parts = path.split("/").filter((p) => !!p);
          var current = FS.root;
          var current_path = "/";
          for (var i2 = 0; i2 < parts.length; i2++) {
            var islast = i2 === parts.length - 1;
            if (islast && opts.parent) {
              break;
            }
            if (parts[i2] === ".") {
              continue;
            }
            if (parts[i2] === "..") {
              current_path = PATH.dirname(current_path);
              if (FS.isRoot(current)) {
                path = current_path + "/" + parts.slice(i2 + 1).join("/");
                nlinks--;
                continue linkloop;
              } else {
                current = current.parent;
              }
              continue;
            }
            current_path = PATH.join2(current_path, parts[i2]);
            try {
              current = FS.lookupNode(current, parts[i2]);
            } catch (e) {
              if (e?.errno === 44 && islast && opts.noent_okay) {
                return { path: current_path };
              }
              throw e;
            }
            if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
              current = current.mounted.root;
            }
            if (FS.isLink(current.mode) && (!islast || opts.follow)) {
              if (!current.node_ops.readlink) {
                throw new FS.ErrnoError(52);
              }
              var link = current.node_ops.readlink(current);
              if (!PATH.isAbs(link)) {
                link = PATH.dirname(current_path) + "/" + link;
              }
              path = link + "/" + parts.slice(i2 + 1).join("/");
              continue linkloop;
            }
          }
          return { path: current_path, node: current };
        }
        throw new FS.ErrnoError(32);
      },
      getPath(node) {
        var path;
        while (true) {
          if (FS.isRoot(node)) {
            var mount = node.mount.mountpoint;
            if (!path) return mount;
            return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
          }
          path = path ? `${node.name}/${path}` : node.name;
          node = node.parent;
        }
      },
      hashName(parentid, name) {
        var hash = 0;
        for (var i2 = 0; i2 < name.length; i2++) {
          hash = (hash << 5) - hash + name.charCodeAt(i2) | 0;
        }
        return (parentid + hash >>> 0) % FS.nameTable.length;
      },
      hashAddNode(node) {
        var hash = FS.hashName(node.parent.id, node.name);
        node.name_next = FS.nameTable[hash];
        FS.nameTable[hash] = node;
      },
      hashRemoveNode(node) {
        var hash = FS.hashName(node.parent.id, node.name);
        if (FS.nameTable[hash] === node) {
          FS.nameTable[hash] = node.name_next;
        } else {
          var current = FS.nameTable[hash];
          while (current) {
            if (current.name_next === node) {
              current.name_next = node.name_next;
              break;
            }
            current = current.name_next;
          }
        }
      },
      lookupNode(parent, name) {
        var errCode = FS.mayLookup(parent);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        var hash = FS.hashName(parent.id, name);
        for (var node = FS.nameTable[hash]; node; node = node.name_next) {
          var nodeName = node.name;
          if (node.parent.id === parent.id && nodeName === name) {
            return node;
          }
        }
        return FS.lookup(parent, name);
      },
      createNode(parent, name, mode, rdev) {
        assert(typeof parent == "object");
        var node = new FS.FSNode(parent, name, mode, rdev);
        FS.hashAddNode(node);
        return node;
      },
      destroyNode(node) {
        FS.hashRemoveNode(node);
      },
      isRoot(node) {
        return node === node.parent;
      },
      isMountpoint(node) {
        return !!node.mounted;
      },
      isFile(mode) {
        return (mode & 61440) === 32768;
      },
      isDir(mode) {
        return (mode & 61440) === 16384;
      },
      isLink(mode) {
        return (mode & 61440) === 40960;
      },
      isChrdev(mode) {
        return (mode & 61440) === 8192;
      },
      isBlkdev(mode) {
        return (mode & 61440) === 24576;
      },
      isFIFO(mode) {
        return (mode & 61440) === 4096;
      },
      isSocket(mode) {
        return (mode & 49152) === 49152;
      },
      flagsToPermissionString(flag) {
        var perms = ["r", "w", "rw"][flag & 3];
        if (flag & 512) {
          perms += "w";
        }
        return perms;
      },
      nodePermissions(node, perms) {
        if (FS.ignorePermissions) {
          return 0;
        }
        if (perms.includes("r") && !(node.mode & 292)) {
          return 2;
        }
        if (perms.includes("w") && !(node.mode & 146)) {
          return 2;
        }
        if (perms.includes("x") && !(node.mode & 73)) {
          return 2;
        }
        return 0;
      },
      mayLookup(dir) {
        if (!FS.isDir(dir.mode)) return 54;
        var errCode = FS.nodePermissions(dir, "x");
        if (errCode) return errCode;
        if (!dir.node_ops.lookup) return 2;
        return 0;
      },
      mayCreate(dir, name) {
        if (!FS.isDir(dir.mode)) {
          return 54;
        }
        try {
          var node = FS.lookupNode(dir, name);
          return 20;
        } catch (e) {
        }
        return FS.nodePermissions(dir, "wx");
      },
      mayDelete(dir, name, isdir) {
        var node;
        try {
          node = FS.lookupNode(dir, name);
        } catch (e) {
          return e.errno;
        }
        var errCode = FS.nodePermissions(dir, "wx");
        if (errCode) {
          return errCode;
        }
        if (isdir) {
          if (!FS.isDir(node.mode)) {
            return 54;
          }
          if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
            return 10;
          }
        } else if (FS.isDir(node.mode)) {
          return 31;
        }
        return 0;
      },
      mayOpen(node, flags) {
        if (!node) {
          return 44;
        }
        if (FS.isLink(node.mode)) {
          return 32;
        }
        var mode = FS.flagsToPermissionString(flags);
        if (FS.isDir(node.mode)) {
          if (mode !== "r" || flags & (512 | 64)) {
            return 31;
          }
        }
        return FS.nodePermissions(node, mode);
      },
      checkOpExists(op, err2) {
        if (!op) {
          throw new FS.ErrnoError(err2);
        }
        return op;
      },
      MAX_OPEN_FDS: 4096,
      nextfd() {
        for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
          if (!FS.streams[fd]) {
            return fd;
          }
        }
        throw new FS.ErrnoError(33);
      },
      getStreamChecked(fd) {
        var stream = FS.getStream(fd);
        if (!stream) {
          throw new FS.ErrnoError(8);
        }
        return stream;
      },
      getStream: (fd) => FS.streams[fd],
      createStream(stream, fd = -1) {
        assert(fd >= -1);
        stream = Object.assign(new FS.FSStream(), stream);
        if (fd == -1) {
          fd = FS.nextfd();
        }
        stream.fd = fd;
        FS.streams[fd] = stream;
        return stream;
      },
      closeStream(fd) {
        FS.streams[fd] = null;
      },
      dupStream(origStream, fd = -1) {
        var stream = FS.createStream(origStream, fd);
        stream.stream_ops?.dup?.(stream);
        return stream;
      },
      doSetAttr(stream, node, attr) {
        var setattr = stream?.stream_ops.setattr;
        var arg = setattr ? stream : node;
        setattr ??= node.node_ops.setattr;
        FS.checkOpExists(setattr, 63);
        setattr(arg, attr);
      },
      chrdev_stream_ops: {
        open(stream) {
          var device = FS.getDevice(stream.node.rdev);
          stream.stream_ops = device.stream_ops;
          stream.stream_ops.open?.(stream);
        },
        llseek() {
          throw new FS.ErrnoError(70);
        }
      },
      major: (dev) => dev >> 8,
      minor: (dev) => dev & 255,
      makedev: (ma, mi) => ma << 8 | mi,
      registerDevice(dev, ops) {
        FS.devices[dev] = { stream_ops: ops };
      },
      getDevice: (dev) => FS.devices[dev],
      getMounts(mount) {
        var mounts = [];
        var check = [mount];
        while (check.length) {
          var m = check.pop();
          mounts.push(m);
          check.push(...m.mounts);
        }
        return mounts;
      },
      syncfs(populate, callback) {
        if (typeof populate == "function") {
          callback = populate;
          populate = false;
        }
        FS.syncFSRequests++;
        if (FS.syncFSRequests > 1) {
          err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
        }
        var mounts = FS.getMounts(FS.root.mount);
        var completed = 0;
        function doCallback(errCode) {
          assert(FS.syncFSRequests > 0);
          FS.syncFSRequests--;
          return callback(errCode);
        }
        function done(errCode) {
          if (errCode) {
            if (!done.errored) {
              done.errored = true;
              return doCallback(errCode);
            }
            return;
          }
          if (++completed >= mounts.length) {
            doCallback(null);
          }
        }
        ;
        for (var mount of mounts) {
          if (mount.type.syncfs) {
            mount.type.syncfs(mount, populate, done);
          } else {
            done(null);
          }
        }
      },
      mount(type, opts, mountpoint) {
        if (typeof type == "string") {
          throw type;
        }
        var root = mountpoint === "/";
        var pseudo = !mountpoint;
        var node;
        if (root && FS.root) {
          throw new FS.ErrnoError(10);
        } else if (!root && !pseudo) {
          var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
          mountpoint = lookup.path;
          node = lookup.node;
          if (FS.isMountpoint(node)) {
            throw new FS.ErrnoError(10);
          }
          if (!FS.isDir(node.mode)) {
            throw new FS.ErrnoError(54);
          }
        }
        var mount = {
          type,
          opts,
          mountpoint,
          mounts: []
        };
        var mountRoot = type.mount(mount);
        mountRoot.mount = mount;
        mount.root = mountRoot;
        if (root) {
          FS.root = mountRoot;
        } else if (node) {
          node.mounted = mount;
          if (node.mount) {
            node.mount.mounts.push(mount);
          }
        }
        return mountRoot;
      },
      unmount(mountpoint) {
        var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
        if (!FS.isMountpoint(lookup.node)) {
          throw new FS.ErrnoError(28);
        }
        var node = lookup.node;
        var mount = node.mounted;
        var mounts = FS.getMounts(mount);
        for (var [hash, current] of Object.entries(FS.nameTable)) {
          while (current) {
            var next = current.name_next;
            if (mounts.includes(current.mount)) {
              FS.destroyNode(current);
            }
            current = next;
          }
        }
        node.mounted = null;
        var idx = node.mount.mounts.indexOf(mount);
        assert(idx !== -1);
        node.mount.mounts.splice(idx, 1);
      },
      lookup(parent, name) {
        return parent.node_ops.lookup(parent, name);
      },
      mknod(path, mode, dev) {
        var lookup = FS.lookupPath(path, { parent: true });
        var parent = lookup.node;
        var name = PATH.basename(path);
        if (!name) {
          throw new FS.ErrnoError(28);
        }
        if (name === "." || name === "..") {
          throw new FS.ErrnoError(20);
        }
        var errCode = FS.mayCreate(parent, name);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        if (!parent.node_ops.mknod) {
          throw new FS.ErrnoError(63);
        }
        return parent.node_ops.mknod(parent, name, mode, dev);
      },
      statfs(path) {
        return FS.statfsNode(FS.lookupPath(path, { follow: true }).node);
      },
      statfsStream(stream) {
        return FS.statfsNode(stream.node);
      },
      statfsNode(node) {
        var rtn = {
          bsize: 4096,
          frsize: 4096,
          blocks: 1e6,
          bfree: 5e5,
          bavail: 5e5,
          files: FS.nextInode,
          ffree: FS.nextInode - 1,
          fsid: 42,
          flags: 2,
          namelen: 255
        };
        if (node.node_ops.statfs) {
          Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root));
        }
        return rtn;
      },
      create(path, mode = 438) {
        mode &= 4095;
        mode |= 32768;
        return FS.mknod(path, mode, 0);
      },
      mkdir(path, mode = 511) {
        mode &= 511 | 512;
        mode |= 16384;
        return FS.mknod(path, mode, 0);
      },
      mkdirTree(path, mode) {
        var dirs = path.split("/");
        var d = "";
        for (var dir of dirs) {
          if (!dir) continue;
          if (d || PATH.isAbs(path)) d += "/";
          d += dir;
          try {
            FS.mkdir(d, mode);
          } catch (e) {
            if (e.errno != 20) throw e;
          }
        }
      },
      mkdev(path, mode, dev) {
        if (typeof dev == "undefined") {
          dev = mode;
          mode = 438;
        }
        mode |= 8192;
        return FS.mknod(path, mode, dev);
      },
      symlink(oldpath, newpath) {
        if (!PATH_FS.resolve(oldpath)) {
          throw new FS.ErrnoError(44);
        }
        var lookup = FS.lookupPath(newpath, { parent: true });
        var parent = lookup.node;
        if (!parent) {
          throw new FS.ErrnoError(44);
        }
        var newname = PATH.basename(newpath);
        var errCode = FS.mayCreate(parent, newname);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        if (!parent.node_ops.symlink) {
          throw new FS.ErrnoError(63);
        }
        return parent.node_ops.symlink(parent, newname, oldpath);
      },
      rename(old_path, new_path) {
        var old_dirname = PATH.dirname(old_path);
        var new_dirname = PATH.dirname(new_path);
        var old_name = PATH.basename(old_path);
        var new_name = PATH.basename(new_path);
        var lookup, old_dir, new_dir;
        lookup = FS.lookupPath(old_path, { parent: true });
        old_dir = lookup.node;
        lookup = FS.lookupPath(new_path, { parent: true });
        new_dir = lookup.node;
        if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
        if (old_dir.mount !== new_dir.mount) {
          throw new FS.ErrnoError(75);
        }
        var old_node = FS.lookupNode(old_dir, old_name);
        var relative = PATH_FS.relative(old_path, new_dirname);
        if (relative.charAt(0) !== ".") {
          throw new FS.ErrnoError(28);
        }
        relative = PATH_FS.relative(new_path, old_dirname);
        if (relative.charAt(0) !== ".") {
          throw new FS.ErrnoError(55);
        }
        var new_node;
        try {
          new_node = FS.lookupNode(new_dir, new_name);
        } catch (e) {
        }
        if (old_node === new_node) {
          return;
        }
        var isdir = FS.isDir(old_node.mode);
        var errCode = FS.mayDelete(old_dir, old_name, isdir);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        if (!old_dir.node_ops.rename) {
          throw new FS.ErrnoError(63);
        }
        if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
          throw new FS.ErrnoError(10);
        }
        if (new_dir !== old_dir) {
          errCode = FS.nodePermissions(old_dir, "w");
          if (errCode) {
            throw new FS.ErrnoError(errCode);
          }
        }
        FS.hashRemoveNode(old_node);
        try {
          old_dir.node_ops.rename(old_node, new_dir, new_name);
          old_node.parent = new_dir;
        } catch (e) {
          throw e;
        } finally {
          FS.hashAddNode(old_node);
        }
      },
      rmdir(path) {
        var lookup = FS.lookupPath(path, { parent: true });
        var parent = lookup.node;
        var name = PATH.basename(path);
        var node = FS.lookupNode(parent, name);
        var errCode = FS.mayDelete(parent, name, true);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        if (!parent.node_ops.rmdir) {
          throw new FS.ErrnoError(63);
        }
        if (FS.isMountpoint(node)) {
          throw new FS.ErrnoError(10);
        }
        parent.node_ops.rmdir(parent, name);
        FS.destroyNode(node);
      },
      readdir(path) {
        var lookup = FS.lookupPath(path, { follow: true });
        var node = lookup.node;
        var readdir = FS.checkOpExists(node.node_ops.readdir, 54);
        return readdir(node);
      },
      unlink(path) {
        var lookup = FS.lookupPath(path, { parent: true });
        var parent = lookup.node;
        if (!parent) {
          throw new FS.ErrnoError(44);
        }
        var name = PATH.basename(path);
        var node = FS.lookupNode(parent, name);
        var errCode = FS.mayDelete(parent, name, false);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        if (!parent.node_ops.unlink) {
          throw new FS.ErrnoError(63);
        }
        if (FS.isMountpoint(node)) {
          throw new FS.ErrnoError(10);
        }
        parent.node_ops.unlink(parent, name);
        FS.destroyNode(node);
      },
      readlink(path) {
        var lookup = FS.lookupPath(path);
        var link = lookup.node;
        if (!link) {
          throw new FS.ErrnoError(44);
        }
        if (!link.node_ops.readlink) {
          throw new FS.ErrnoError(28);
        }
        return link.node_ops.readlink(link);
      },
      stat(path, dontFollow) {
        var lookup = FS.lookupPath(path, { follow: !dontFollow });
        var node = lookup.node;
        var getattr = FS.checkOpExists(node.node_ops.getattr, 63);
        return getattr(node);
      },
      fstat(fd) {
        var stream = FS.getStreamChecked(fd);
        var node = stream.node;
        var getattr = stream.stream_ops.getattr;
        var arg = getattr ? stream : node;
        getattr ??= node.node_ops.getattr;
        FS.checkOpExists(getattr, 63);
        return getattr(arg);
      },
      lstat(path) {
        return FS.stat(path, true);
      },
      doChmod(stream, node, mode, dontFollow) {
        FS.doSetAttr(stream, node, {
          mode: mode & 4095 | node.mode & ~4095,
          ctime: Date.now(),
          dontFollow
        });
      },
      chmod(path, mode, dontFollow) {
        var node;
        if (typeof path == "string") {
          var lookup = FS.lookupPath(path, { follow: !dontFollow });
          node = lookup.node;
        } else {
          node = path;
        }
        FS.doChmod(null, node, mode, dontFollow);
      },
      lchmod(path, mode) {
        FS.chmod(path, mode, true);
      },
      fchmod(fd, mode) {
        var stream = FS.getStreamChecked(fd);
        FS.doChmod(stream, stream.node, mode, false);
      },
      doChown(stream, node, dontFollow) {
        FS.doSetAttr(stream, node, {
          timestamp: Date.now(),
          dontFollow
          // we ignore the uid / gid for now
        });
      },
      chown(path, uid, gid, dontFollow) {
        var node;
        if (typeof path == "string") {
          var lookup = FS.lookupPath(path, { follow: !dontFollow });
          node = lookup.node;
        } else {
          node = path;
        }
        FS.doChown(null, node, dontFollow);
      },
      lchown(path, uid, gid) {
        FS.chown(path, uid, gid, true);
      },
      fchown(fd, uid, gid) {
        var stream = FS.getStreamChecked(fd);
        FS.doChown(stream, stream.node, false);
      },
      doTruncate(stream, node, len) {
        if (FS.isDir(node.mode)) {
          throw new FS.ErrnoError(31);
        }
        if (!FS.isFile(node.mode)) {
          throw new FS.ErrnoError(28);
        }
        var errCode = FS.nodePermissions(node, "w");
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        FS.doSetAttr(stream, node, {
          size: len,
          timestamp: Date.now()
        });
      },
      truncate(path, len) {
        if (len < 0) {
          throw new FS.ErrnoError(28);
        }
        var node;
        if (typeof path == "string") {
          var lookup = FS.lookupPath(path, { follow: true });
          node = lookup.node;
        } else {
          node = path;
        }
        FS.doTruncate(null, node, len);
      },
      ftruncate(fd, len) {
        var stream = FS.getStreamChecked(fd);
        if (len < 0 || (stream.flags & 2097155) === 0) {
          throw new FS.ErrnoError(28);
        }
        FS.doTruncate(stream, stream.node, len);
      },
      utime(path, atime, mtime) {
        var lookup = FS.lookupPath(path, { follow: true });
        var node = lookup.node;
        var setattr = FS.checkOpExists(node.node_ops.setattr, 63);
        setattr(node, {
          atime,
          mtime
        });
      },
      open(path, flags, mode = 438) {
        if (path === "") {
          throw new FS.ErrnoError(44);
        }
        flags = FS_modeStringToFlags(flags);
        if (flags & 64) {
          mode = mode & 4095 | 32768;
        } else {
          mode = 0;
        }
        var node;
        var isDirPath;
        if (typeof path == "object") {
          node = path;
        } else {
          isDirPath = path.endsWith("/");
          var lookup = FS.lookupPath(path, {
            follow: !(flags & 131072),
            noent_okay: true
          });
          node = lookup.node;
          path = lookup.path;
        }
        var created = false;
        if (flags & 64) {
          if (node) {
            if (flags & 128) {
              throw new FS.ErrnoError(20);
            }
          } else if (isDirPath) {
            throw new FS.ErrnoError(31);
          } else {
            node = FS.mknod(path, mode | 511, 0);
            created = true;
          }
        }
        if (!node) {
          throw new FS.ErrnoError(44);
        }
        if (FS.isChrdev(node.mode)) {
          flags &= ~512;
        }
        if (flags & 65536 && !FS.isDir(node.mode)) {
          throw new FS.ErrnoError(54);
        }
        if (!created) {
          var errCode = FS.mayOpen(node, flags);
          if (errCode) {
            throw new FS.ErrnoError(errCode);
          }
        }
        if (flags & 512 && !created) {
          FS.truncate(node, 0);
        }
        flags &= ~(128 | 512 | 131072);
        var stream = FS.createStream({
          node,
          path: FS.getPath(node),
          // we want the absolute path to the node
          flags,
          seekable: true,
          position: 0,
          stream_ops: node.stream_ops,
          // used by the file family libc calls (fopen, fwrite, ferror, etc.)
          ungotten: [],
          error: false
        });
        if (stream.stream_ops.open) {
          stream.stream_ops.open(stream);
        }
        if (created) {
          FS.chmod(node, mode & 511);
        }
        return stream;
      },
      close(stream) {
        if (FS.isClosed(stream)) {
          throw new FS.ErrnoError(8);
        }
        if (stream.getdents) stream.getdents = null;
        try {
          if (stream.stream_ops.close) {
            stream.stream_ops.close(stream);
          }
        } catch (e) {
          throw e;
        } finally {
          FS.closeStream(stream.fd);
        }
        stream.fd = null;
      },
      isClosed(stream) {
        return stream.fd === null;
      },
      llseek(stream, offset, whence) {
        if (FS.isClosed(stream)) {
          throw new FS.ErrnoError(8);
        }
        if (!stream.seekable || !stream.stream_ops.llseek) {
          throw new FS.ErrnoError(70);
        }
        if (whence != 0 && whence != 1 && whence != 2) {
          throw new FS.ErrnoError(28);
        }
        stream.position = stream.stream_ops.llseek(stream, offset, whence);
        stream.ungotten = [];
        return stream.position;
      },
      read(stream, buffer, offset, length, position) {
        assert(offset >= 0);
        if (length < 0 || position < 0) {
          throw new FS.ErrnoError(28);
        }
        if (FS.isClosed(stream)) {
          throw new FS.ErrnoError(8);
        }
        if ((stream.flags & 2097155) === 1) {
          throw new FS.ErrnoError(8);
        }
        if (FS.isDir(stream.node.mode)) {
          throw new FS.ErrnoError(31);
        }
        if (!stream.stream_ops.read) {
          throw new FS.ErrnoError(28);
        }
        var seeking = typeof position != "undefined";
        if (!seeking) {
          position = stream.position;
        } else if (!stream.seekable) {
          throw new FS.ErrnoError(70);
        }
        var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
        if (!seeking) stream.position += bytesRead;
        return bytesRead;
      },
      write(stream, buffer, offset, length, position, canOwn) {
        assert(offset >= 0);
        assert(buffer.subarray, "FS.write expects a TypedArray");
        if (length < 0 || position < 0) {
          throw new FS.ErrnoError(28);
        }
        if (FS.isClosed(stream)) {
          throw new FS.ErrnoError(8);
        }
        if ((stream.flags & 2097155) === 0) {
          throw new FS.ErrnoError(8);
        }
        if (FS.isDir(stream.node.mode)) {
          throw new FS.ErrnoError(31);
        }
        if (!stream.stream_ops.write) {
          throw new FS.ErrnoError(28);
        }
        if (stream.seekable && stream.flags & 1024) {
          FS.llseek(stream, 0, 2);
        }
        var seeking = typeof position != "undefined";
        if (!seeking) {
          position = stream.position;
        } else if (!stream.seekable) {
          throw new FS.ErrnoError(70);
        }
        var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
        if (!seeking) stream.position += bytesWritten;
        return bytesWritten;
      },
      mmap(stream, length, position, prot, flags) {
        if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
          throw new FS.ErrnoError(2);
        }
        if ((stream.flags & 2097155) === 1) {
          throw new FS.ErrnoError(2);
        }
        if (!stream.stream_ops.mmap) {
          throw new FS.ErrnoError(43);
        }
        if (!length) {
          throw new FS.ErrnoError(28);
        }
        return stream.stream_ops.mmap(stream, length, position, prot, flags);
      },
      msync(stream, buffer, offset, length, mmapFlags) {
        assert(offset >= 0);
        if (!stream.stream_ops.msync) {
          return 0;
        }
        return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
      },
      ioctl(stream, cmd, arg) {
        if (!stream.stream_ops.ioctl) {
          throw new FS.ErrnoError(59);
        }
        return stream.stream_ops.ioctl(stream, cmd, arg);
      },
      readFile(path, opts = {}) {
        opts.flags = opts.flags || 0;
        opts.encoding = opts.encoding || "binary";
        if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
          abort(`Invalid encoding type "${opts.encoding}"`);
        }
        var stream = FS.open(path, opts.flags);
        var stat = FS.stat(path);
        var length = stat.size;
        var buf = new Uint8Array(length);
        FS.read(stream, buf, 0, length, 0);
        if (opts.encoding === "utf8") {
          buf = UTF8ArrayToString(buf);
        }
        FS.close(stream);
        return buf;
      },
      writeFile(path, data, opts = {}) {
        opts.flags = opts.flags || 577;
        var stream = FS.open(path, opts.flags, opts.mode);
        data = FS_fileDataToTypedArray(data);
        FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
        FS.close(stream);
      },
      cwd: () => FS.currentPath,
      chdir(path) {
        var lookup = FS.lookupPath(path, { follow: true });
        if (lookup.node === null) {
          throw new FS.ErrnoError(44);
        }
        if (!FS.isDir(lookup.node.mode)) {
          throw new FS.ErrnoError(54);
        }
        var errCode = FS.nodePermissions(lookup.node, "x");
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
        FS.currentPath = lookup.path;
      },
      createDefaultDirectories() {
        FS.mkdir("/tmp");
        FS.mkdir("/home");
        FS.mkdir("/home/web_user");
      },
      createDefaultDevices() {
        FS.mkdir("/dev");
        FS.registerDevice(FS.makedev(1, 3), {
          read: () => 0,
          write: (stream, buffer, offset, length, pos) => length,
          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 randomBuffer = new Uint8Array(1024), randomLeft = 0;
        var randomByte = () => {
          if (randomLeft === 0) {
            randomFill(randomBuffer);
            randomLeft = randomBuffer.byteLength;
          }
          return randomBuffer[--randomLeft];
        };
        FS.createDevice("/dev", "random", randomByte);
        FS.createDevice("/dev", "urandom", randomByte);
        FS.mkdir("/dev/shm");
        FS.mkdir("/dev/shm/tmp");
      },
      createSpecialDirectories() {
        FS.mkdir("/proc");
        var proc_self = FS.mkdir("/proc/self");
        FS.mkdir("/proc/self/fd");
        FS.mount({
          mount() {
            var node = FS.createNode(proc_self, "fd", 16895, 73);
            node.stream_ops = {
              llseek: MEMFS.stream_ops.llseek
            };
            node.node_ops = {
              lookup(parent, name) {
                var fd = +name;
                var stream = FS.getStreamChecked(fd);
                var ret = {
                  parent: null,
                  mount: { mountpoint: "fake" },
                  node_ops: { readlink: () => stream.path },
                  id: fd + 1
                };
                ret.parent = ret;
                return ret;
              },
              readdir() {
                return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString());
              }
            };
            return node;
          }
        }, {}, "/proc/self/fd");
      },
      createStandardStreams(input, output, error) {
        if (input) {
          FS.createDevice("/dev", "stdin", input);
        } else {
          FS.symlink("/dev/tty", "/dev/stdin");
        }
        if (output) {
          FS.createDevice("/dev", "stdout", null, output);
        } else {
          FS.symlink("/dev/tty", "/dev/stdout");
        }
        if (error) {
          FS.createDevice("/dev", "stderr", null, error);
        } else {
          FS.symlink("/dev/tty1", "/dev/stderr");
        }
        var stdin = FS.open("/dev/stdin", 0);
        var stdout = FS.open("/dev/stdout", 1);
        var stderr = FS.open("/dev/stderr", 1);
        assert(stdin.fd === 0, `invalid handle for stdin (${stdin.fd})`);
        assert(stdout.fd === 1, `invalid handle for stdout (${stdout.fd})`);
        assert(stderr.fd === 2, `invalid handle for stderr (${stderr.fd})`);
      },
      staticInit() {
        FS.nameTable = new Array(4096);
        FS.mount(MEMFS, {}, "/");
        FS.createDefaultDirectories();
        FS.createDefaultDevices();
        FS.createSpecialDirectories();
        FS.filesystems = {
          "MEMFS": MEMFS
        };
      },
      init(input, output, error) {
        assert(!FS.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");
        FS.initialized = true;
        input ??= Module["stdin"];
        output ??= Module["stdout"];
        error ??= Module["stderr"];
        FS.createStandardStreams(input, output, error);
      },
      quit() {
        FS.initialized = false;
        _fflush(0);
        for (var stream of FS.streams) {
          if (stream) {
            FS.close(stream);
          }
        }
      },
      findObject(path, dontResolveLastLink) {
        var ret = FS.analyzePath(path, dontResolveLastLink);
        if (!ret.exists) {
          return null;
        }
        return ret.object;
      },
      analyzePath(path, dontResolveLastLink) {
        try {
          var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
          path = lookup.path;
        } catch (e) {
        }
        var ret = {
          isRoot: false,
          exists: false,
          error: 0,
          name: null,
          path: null,
          object: null,
          parentExists: false,
          parentPath: null,
          parentObject: null
        };
        try {
          var lookup = FS.lookupPath(path, { parent: true });
          ret.parentExists = true;
          ret.parentPath = lookup.path;
          ret.parentObject = lookup.node;
          ret.name = PATH.basename(path);
          lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
          ret.exists = true;
          ret.path = lookup.path;
          ret.object = lookup.node;
          ret.name = lookup.node.name;
          ret.isRoot = lookup.path === "/";
        } catch (e) {
          ret.error = e.errno;
        }
        ;
        return ret;
      },
      createPath(parent, path, canRead, canWrite) {
        parent = typeof parent == "string" ? parent : FS.getPath(parent);
        var parts = path.split("/").reverse();
        while (parts.length) {
          var part = parts.pop();
          if (!part) continue;
          var current = PATH.join2(parent, part);
          try {
            FS.mkdir(current);
          } catch (e) {
            if (e.errno != 20) throw e;
          }
          parent = current;
        }
        return current;
      },
      createFile(parent, name, properties, canRead, canWrite) {
        var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
        var mode = FS_getMode(canRead, canWrite);
        return FS.create(path, mode);
      },
      createDataFile(parent, name, data, canRead, canWrite, canOwn) {
        var path = name;
        if (parent) {
          parent = typeof parent == "string" ? parent : FS.getPath(parent);
          path = name ? PATH.join2(parent, name) : parent;
        }
        var mode = FS_getMode(canRead, canWrite);
        var node = FS.create(path, mode);
        if (data) {
          data = FS_fileDataToTypedArray(data);
          FS.chmod(node, mode | 146);
          var stream = FS.open(node, 577);
          FS.write(stream, data, 0, data.length, 0, canOwn);
          FS.close(stream);
          FS.chmod(node, mode);
        }
      },
      createDevice(parent, name, input, output) {
        var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
        var mode = FS_getMode(!!input, !!output);
        FS.createDevice.major ??= 64;
        var dev = FS.makedev(FS.createDevice.major++, 0);
        FS.registerDevice(dev, {
          open(stream) {
            stream.seekable = false;
          },
          close(stream) {
            if (output?.buffer?.length) {
              output(10);
            }
          },
          read(stream, buffer, offset, length, pos) {
            var bytesRead = 0;
            for (var i2 = 0; i2 < length; i2++) {
              var result;
              try {
                result = input();
              } catch (e) {
                throw new FS.ErrnoError(29);
              }
              if (result === void 0 && bytesRead === 0) {
                throw new FS.ErrnoError(6);
              }
              if (result === null || result === void 0) break;
              bytesRead++;
              buffer[offset + i2] = result;
            }
            if (bytesRead) {
              stream.node.atime = Date.now();
            }
            return bytesRead;
          },
          write(stream, buffer, offset, length, pos) {
            for (var i2 = 0; i2 < length; i2++) {
              try {
                output(buffer[offset + i2]);
              } catch (e) {
                throw new FS.ErrnoError(29);
              }
            }
            if (length) {
              stream.node.mtime = stream.node.ctime = Date.now();
            }
            return i2;
          }
        });
        return FS.mkdev(path, mode, dev);
      },
      forceLoadFile(obj) {
        if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
        if (globalThis.XMLHttpRequest) {
          abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
        } else {
          try {
            obj.contents = readBinary(obj.url);
          } catch (e) {
            throw new FS.ErrnoError(29);
          }
        }
      },
      createLazyFile(parent, name, url, canRead, canWrite) {
        class LazyUint8Array {
          lengthKnown = false;
          chunks = [];
          // Loaded chunks. Index is the chunk number
          get(idx) {
            if (idx > this.length - 1 || idx < 0) {
              return void 0;
            }
            var chunkOffset = idx % this.chunkSize;
            var chunkNum = idx / this.chunkSize | 0;
            return this.getter(chunkNum)[chunkOffset];
          }
          setDataGetter(getter) {
            this.getter = getter;
          }
          cacheLength() {
            var xhr = new XMLHttpRequest();
            xhr.open("HEAD", url, false);
            xhr.send(null);
            if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) abort("Couldn't load " + url + ". Status: " + xhr.status);
            var datalength = Number(xhr.getResponseHeader("Content-length"));
            var header;
            var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
            var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
            var chunkSize = 1024 * 1024;
            if (!hasByteServing) chunkSize = datalength;
            var doXHR = (from, to) => {
              if (from > to) abort("invalid range (" + from + ", " + to + ") or no bytes requested!");
              if (to > datalength - 1) abort("only " + datalength + " bytes available! programmer error!");
              var xhr2 = new XMLHttpRequest();
              xhr2.open("GET", url, false);
              if (datalength !== chunkSize) xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to);
              xhr2.responseType = "arraybuffer";
              if (xhr2.overrideMimeType) {
                xhr2.overrideMimeType("text/plain; charset=x-user-defined");
              }
              xhr2.send(null);
              if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304)) abort("Couldn't load " + url + ". Status: " + xhr2.status);
              if (xhr2.response !== void 0) {
                return new Uint8Array(
                  /** @type{Array<number>} */
                  xhr2.response || []
                );
              }
              return intArrayFromString(xhr2.responseText || "", true);
            };
            var lazyArray2 = this;
            lazyArray2.setDataGetter((chunkNum) => {
              var start = chunkNum * chunkSize;
              var end = (chunkNum + 1) * chunkSize - 1;
              end = Math.min(end, datalength - 1);
              if (typeof lazyArray2.chunks[chunkNum] == "undefined") {
                lazyArray2.chunks[chunkNum] = doXHR(start, end);
              }
              if (typeof lazyArray2.chunks[chunkNum] == "undefined") abort("doXHR failed!");
              return lazyArray2.chunks[chunkNum];
            });
            if (usesGzip || !datalength) {
              chunkSize = datalength = 1;
              datalength = this.getter(0).length;
              chunkSize = datalength;
              out("LazyFiles on gzip forces download of the whole file when length is accessed");
            }
            this._length = datalength;
            this._chunkSize = chunkSize;
            this.lengthKnown = true;
          }
          get length() {
            if (!this.lengthKnown) {
              this.cacheLength();
            }
            return this._length;
          }
          get chunkSize() {
            if (!this.lengthKnown) {
              this.cacheLength();
            }
            return this._chunkSize;
          }
        }
        if (globalThis.XMLHttpRequest) {
          if (!ENVIRONMENT_IS_WORKER) abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");
          var lazyArray = new LazyUint8Array();
          var properties = { isDevice: false, contents: lazyArray };
        } else {
          var properties = { isDevice: false, url };
        }
        var node = FS.createFile(parent, name, properties, canRead, canWrite);
        if (properties.contents) {
          node.contents = properties.contents;
        } else if (properties.url) {
          node.contents = null;
          node.url = properties.url;
        }
        Object.defineProperties(node, {
          usedBytes: {
            get: function() {
              return this.contents.length;
            }
          }
        });
        var stream_ops = {};
        for (const [key, fn] of Object.entries(node.stream_ops)) {
          stream_ops[key] = (...args) => {
            FS.forceLoadFile(node);
            return fn(...args);
          };
        }
        function writeChunks(stream, buffer, offset, length, position) {
          var contents = stream.node.contents;
          if (position >= contents.length)
            return 0;
          var size = Math.min(contents.length - position, length);
          assert(size >= 0);
          if (contents.slice) {
            for (var i2 = 0; i2 < size; i2++) {
              buffer[offset + i2] = contents[position + i2];
            }
          } else {
            for (var i2 = 0; i2 < size; i2++) {
              buffer[offset + i2] = contents.get(position + i2);
            }
          }
          return size;
        }
        stream_ops.read = (stream, buffer, offset, length, position) => {
          FS.forceLoadFile(node);
          return writeChunks(stream, buffer, offset, length, position);
        };
        stream_ops.mmap = (stream, length, position, prot, flags) => {
          FS.forceLoadFile(node);
          var ptr = mmapAlloc(length);
          if (!ptr) {
            throw new FS.ErrnoError(48);
          }
          writeChunks(stream, HEAP8, ptr, length, position);
          return { ptr, allocated: true };
        };
        node.stream_ops = stream_ops;
        return node;
      }
    };
    var SYSCALLS = {
      calculateAt(dirfd, path, allowEmpty) {
        if (PATH.isAbs(path)) {
          return path;
        }
        var dir;
        if (dirfd === -100) {
          dir = FS.cwd();
        } else {
          var dirstream = SYSCALLS.getStreamFromFD(dirfd);
          dir = dirstream.path;
        }
        if (path.length == 0) {
          if (!allowEmpty) {
            throw new FS.ErrnoError(44);
            ;
          }
          return dir;
        }
        return dir + "/" + path;
      },
      writeStat(buf, stat) {
        HEAPU32[buf >> 2] = stat.dev;
        HEAPU32[buf + 4 >> 2] = stat.mode;
        HEAPU32[buf + 8 >> 2] = stat.nlink;
        HEAPU32[buf + 12 >> 2] = stat.uid;
        HEAPU32[buf + 16 >> 2] = stat.gid;
        HEAPU32[buf + 20 >> 2] = stat.rdev;
        HEAP64[buf + 24 >> 3] = BigInt(stat.size);
        HEAP32[buf + 32 >> 2] = 4096;
        HEAP32[buf + 36 >> 2] = stat.blocks;
        var atime = stat.atime.getTime();
        var mtime = stat.mtime.getTime();
        var ctime = stat.ctime.getTime();
        HEAP64[buf + 40 >> 3] = BigInt(Math.floor(atime / 1e3));
        HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3 * 1e3;
        HEAP64[buf + 56 >> 3] = BigInt(Math.floor(mtime / 1e3));
        HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3 * 1e3;
        HEAP64[buf + 72 >> 3] = BigInt(Math.floor(ctime / 1e3));
        HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3 * 1e3;
        HEAP64[buf + 88 >> 3] = BigInt(stat.ino);
        return 0;
      },
      writeStatFs(buf, stats) {
        HEAPU32[buf + 4 >> 2] = stats.bsize;
        HEAPU32[buf + 60 >> 2] = stats.bsize;
        HEAP64[buf + 8 >> 3] = BigInt(stats.blocks);
        HEAP64[buf + 16 >> 3] = BigInt(stats.bfree);
        HEAP64[buf + 24 >> 3] = BigInt(stats.bavail);
        HEAP64[buf + 32 >> 3] = BigInt(stats.files);
        HEAP64[buf + 40 >> 3] = BigInt(stats.ffree);
        HEAPU32[buf + 48 >> 2] = stats.fsid;
        HEAPU32[buf + 64 >> 2] = stats.flags;
        HEAPU32[buf + 56 >> 2] = stats.namelen;
      },
      doMsync(addr, stream, len, flags, offset) {
        if (!FS.isFile(stream.node.mode)) {
          throw new FS.ErrnoError(43);
        }
        if (flags & 2) {
          return 0;
        }
        var buffer = HEAPU8.slice(addr, addr + len);
        FS.msync(stream, buffer, offset, len, flags);
      },
      getStreamFromFD(fd) {
        var stream = FS.getStreamChecked(fd);
        return stream;
      },
      varargs: void 0,
      getStr(ptr) {
        var ret = UTF8ToString(ptr);
        return ret;
      }
    };
    function ___syscall_fcntl64(fd, cmd, varargs) {
      SYSCALLS.varargs = varargs;
      try {
        var stream = SYSCALLS.getStreamFromFD(fd);
        switch (cmd) {
          case 0: {
            var arg = syscallGetVarargI();
            if (arg < 0) {
              return -28;
            }
            while (FS.streams[arg]) {
              arg++;
            }
            var newStream;
            newStream = FS.dupStream(stream, arg);
            return newStream.fd;
          }
          case 1:
          case 2:
            return 0;
          // FD_CLOEXEC makes no sense for a single process.
          case 3:
            return stream.flags;
          case 4: {
            var arg = syscallGetVarargI();
            stream.flags |= arg;
            return 0;
          }
          case 12: {
            var arg = syscallGetVarargP();
            var offset = 0;
            HEAP16[arg + offset >> 1] = 2;
            return 0;
          }
          case 13:
          case 14:
            return 0;
        }
        return -28;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    function ___syscall_fstat64(fd, buf) {
      try {
        return SYSCALLS.writeStat(buf, FS.fstat(fd));
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
      assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
    };
    function ___syscall_getcwd(buf, size) {
      try {
        if (size === 0) return -28;
        var cwd = FS.cwd();
        var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
        if (size < cwdLengthInBytes) return -68;
        stringToUTF8(cwd, buf, size);
        return cwdLengthInBytes;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    function ___syscall_ioctl(fd, op, varargs) {
      SYSCALLS.varargs = varargs;
      try {
        var stream = SYSCALLS.getStreamFromFD(fd);
        switch (op) {
          case 21509: {
            if (!stream.tty) return -59;
            return 0;
          }
          case 21505: {
            if (!stream.tty) return -59;
            if (stream.tty.ops.ioctl_tcgets) {
              var termios = stream.tty.ops.ioctl_tcgets(stream);
              var argp = syscallGetVarargP();
              HEAP32[argp >> 2] = termios.c_iflag || 0;
              HEAP32[argp + 4 >> 2] = termios.c_oflag || 0;
              HEAP32[argp + 8 >> 2] = termios.c_cflag || 0;
              HEAP32[argp + 12 >> 2] = termios.c_lflag || 0;
              for (var i2 = 0; i2 < 32; i2++) {
                HEAP8[argp + i2 + 17] = termios.c_cc[i2] || 0;
              }
              return 0;
            }
            return 0;
          }
          case 21510:
          case 21511:
          case 21512: {
            if (!stream.tty) return -59;
            return 0;
          }
          case 21506:
          case 21507:
          case 21508: {
            if (!stream.tty) return -59;
            if (stream.tty.ops.ioctl_tcsets) {
              var argp = syscallGetVarargP();
              var c_iflag = HEAP32[argp >> 2];
              var c_oflag = HEAP32[argp + 4 >> 2];
              var c_cflag = HEAP32[argp + 8 >> 2];
              var c_lflag = HEAP32[argp + 12 >> 2];
              var c_cc = [];
              for (var i2 = 0; i2 < 32; i2++) {
                c_cc.push(HEAP8[argp + i2 + 17]);
              }
              return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc });
            }
            return 0;
          }
          case 21519: {
            if (!stream.tty) return -59;
            var argp = syscallGetVarargP();
            HEAP32[argp >> 2] = 0;
            return 0;
          }
          case 21520: {
            if (!stream.tty) return -59;
            return -28;
          }
          case 21537:
          case 21531: {
            var argp = syscallGetVarargP();
            return FS.ioctl(stream, op, argp);
          }
          case 21523: {
            if (!stream.tty) return -59;
            if (stream.tty.ops.ioctl_tiocgwinsz) {
              var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
              var argp = syscallGetVarargP();
              HEAP16[argp >> 1] = winsize[0];
              HEAP16[argp + 2 >> 1] = winsize[1];
            }
            return 0;
          }
          case 21524: {
            if (!stream.tty) return -59;
            return 0;
          }
          case 21515: {
            if (!stream.tty) return -59;
            return 0;
          }
          default:
            return -28;
        }
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    function ___syscall_lstat64(path, buf) {
      try {
        path = SYSCALLS.getStr(path);
        return SYSCALLS.writeStat(buf, FS.lstat(path));
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    function ___syscall_newfstatat(dirfd, path, buf, flags) {
      try {
        path = SYSCALLS.getStr(path);
        var nofollow = flags & 256;
        var allowEmpty = flags & 4096;
        flags = flags & ~6400;
        assert(!flags, `unknown flags in __syscall_newfstatat: ${flags}`);
        path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
        return SYSCALLS.writeStat(buf, nofollow ? FS.lstat(path) : FS.stat(path));
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    function ___syscall_openat(dirfd, path, flags, varargs) {
      SYSCALLS.varargs = varargs;
      try {
        path = SYSCALLS.getStr(path);
        path = SYSCALLS.calculateAt(dirfd, path);
        var mode = varargs ? syscallGetVarargI() : 0;
        return FS.open(path, flags, mode).fd;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    function ___syscall_stat64(path, buf) {
      try {
        path = SYSCALLS.getStr(path);
        return SYSCALLS.writeStat(buf, FS.stat(path));
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
    }
    var __abort_js = () => abort("native code called abort()");
    var __emscripten_throw_longjmp = () => {
      throw new EmscriptenSjLj();
    };
    var INT53_MAX = 9007199254740992;
    var INT53_MIN = -9007199254740992;
    var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
    function __mmap_js(len, prot, flags, fd, offset, allocated, addr) {
      offset = bigintToI53Checked(offset);
      try {
        assert(!isNaN(offset));
        var stream = SYSCALLS.getStreamFromFD(fd);
        var res = FS.mmap(stream, len, offset, prot, flags);
        var ptr = res.ptr;
        HEAP32[allocated >> 2] = res.allocated;
        HEAPU32[addr >> 2] = ptr;
        return 0;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
      ;
    }
    function __munmap_js(addr, len, prot, flags, fd, offset) {
      offset = bigintToI53Checked(offset);
      try {
        var stream = SYSCALLS.getStreamFromFD(fd);
        if (prot & 2) {
          SYSCALLS.doMsync(addr, stream, len, flags, offset);
        }
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return -e.errno;
      }
      ;
    }
    var __tzset_js = (timezone, daylight, std_name, dst_name) => {
      var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
      var winter = new Date(currentYear, 0, 1);
      var summer = new Date(currentYear, 6, 1);
      var winterOffset = winter.getTimezoneOffset();
      var summerOffset = summer.getTimezoneOffset();
      var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
      HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
      HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
      var extractZone = (timezoneOffset) => {
        var sign = timezoneOffset >= 0 ? "-" : "+";
        var absOffset = Math.abs(timezoneOffset);
        var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
        var minutes = String(absOffset % 60).padStart(2, "0");
        return `UTC${sign}${hours}${minutes}`;
      };
      var winterName = extractZone(winterOffset);
      var summerName = extractZone(summerOffset);
      assert(winterName);
      assert(summerName);
      assert(lengthBytesUTF8(winterName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${winterName})`);
      assert(lengthBytesUTF8(summerName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${summerName})`);
      if (summerOffset < winterOffset) {
        stringToUTF8(winterName, std_name, 17);
        stringToUTF8(summerName, dst_name, 17);
      } else {
        stringToUTF8(winterName, dst_name, 17);
        stringToUTF8(summerName, std_name, 17);
      }
    };
    var _emscripten_get_now = () => performance.now();
    var _emscripten_date_now = () => Date.now();
    var nowIsMonotonic = 1;
    var checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
    function _clock_time_get(clk_id, ignored_precision, ptime) {
      ignored_precision = bigintToI53Checked(ignored_precision);
      if (!checkWasiClock(clk_id)) {
        return 28;
      }
      var now;
      if (clk_id === 0) {
        now = _emscripten_date_now();
      } else if (nowIsMonotonic) {
        now = _emscripten_get_now();
      } else {
        return 52;
      }
      var nsec = Math.round(now * 1e3 * 1e3);
      HEAP64[ptime >> 3] = BigInt(nsec);
      return 0;
      ;
    }
    var GLctx;
    var webgl_enable_ANGLE_instanced_arrays = (ctx) => {
      var ext = ctx.getExtension("ANGLE_instanced_arrays");
      if (ext) {
        ctx["vertexAttribDivisor"] = (index, divisor) => ext["vertexAttribDivisorANGLE"](index, divisor);
        ctx["drawArraysInstanced"] = (mode, first, count, primcount) => ext["drawArraysInstancedANGLE"](mode, first, count, primcount);
        ctx["drawElementsInstanced"] = (mode, count, type, indices, primcount) => ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount);
        return 1;
      }
    };
    var webgl_enable_OES_vertex_array_object = (ctx) => {
      var ext = ctx.getExtension("OES_vertex_array_object");
      if (ext) {
        ctx["createVertexArray"] = () => ext["createVertexArrayOES"]();
        ctx["deleteVertexArray"] = (vao) => ext["deleteVertexArrayOES"](vao);
        ctx["bindVertexArray"] = (vao) => ext["bindVertexArrayOES"](vao);
        ctx["isVertexArray"] = (vao) => ext["isVertexArrayOES"](vao);
        return 1;
      }
    };
    var webgl_enable_WEBGL_draw_buffers = (ctx) => {
      var ext = ctx.getExtension("WEBGL_draw_buffers");
      if (ext) {
        ctx["drawBuffers"] = (n, bufs) => ext["drawBuffersWEBGL"](n, bufs);
        return 1;
      }
    };
    var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance = (ctx) => (
      // Closure is expected to be allowed to minify the '.dibvbi' property, so not accessing it quoted.
      !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"))
    );
    var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance = (ctx) => {
      return !!(ctx.mdibvbi = ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));
    };
    var webgl_enable_EXT_polygon_offset_clamp = (ctx) => !!(ctx.extPolygonOffsetClamp = ctx.getExtension("EXT_polygon_offset_clamp"));
    var webgl_enable_EXT_clip_control = (ctx) => !!(ctx.extClipControl = ctx.getExtension("EXT_clip_control"));
    var webgl_enable_WEBGL_polygon_mode = (ctx) => !!(ctx.webglPolygonMode = ctx.getExtension("WEBGL_polygon_mode"));
    var webgl_enable_WEBGL_multi_draw = (ctx) => (
      // Closure is expected to be allowed to minify the '.multiDrawWebgl' property, so not accessing it quoted.
      !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw"))
    );
    var getEmscriptenSupportedExtensions = (ctx) => {
      var supportedExtensions = [
        // WebGL 1 extensions
        "ANGLE_instanced_arrays",
        "EXT_blend_minmax",
        "EXT_disjoint_timer_query",
        "EXT_frag_depth",
        "EXT_shader_texture_lod",
        "EXT_sRGB",
        "OES_element_index_uint",
        "OES_fbo_render_mipmap",
        "OES_standard_derivatives",
        "OES_texture_float",
        "OES_texture_half_float",
        "OES_texture_half_float_linear",
        "OES_vertex_array_object",
        "WEBGL_color_buffer_float",
        "WEBGL_depth_texture",
        "WEBGL_draw_buffers",
        // WebGL 2 extensions
        "EXT_color_buffer_float",
        "EXT_conservative_depth",
        "EXT_disjoint_timer_query_webgl2",
        "EXT_texture_norm16",
        "NV_shader_noperspective_interpolation",
        "WEBGL_clip_cull_distance",
        // WebGL 1 and WebGL 2 extensions
        "EXT_clip_control",
        "EXT_color_buffer_half_float",
        "EXT_depth_clamp",
        "EXT_float_blend",
        "EXT_polygon_offset_clamp",
        "EXT_texture_compression_bptc",
        "EXT_texture_compression_rgtc",
        "EXT_texture_filter_anisotropic",
        "KHR_parallel_shader_compile",
        "OES_texture_float_linear",
        "WEBGL_blend_func_extended",
        "WEBGL_compressed_texture_astc",
        "WEBGL_compressed_texture_etc",
        "WEBGL_compressed_texture_etc1",
        "WEBGL_compressed_texture_s3tc",
        "WEBGL_compressed_texture_s3tc_srgb",
        "WEBGL_debug_renderer_info",
        "WEBGL_debug_shaders",
        "WEBGL_lose_context",
        "WEBGL_multi_draw",
        "WEBGL_polygon_mode"
      ];
      return (ctx.getSupportedExtensions() || []).filter((ext) => supportedExtensions.includes(ext));
    };
    var GL = {
      counter: 1,
      buffers: [],
      programs: [],
      framebuffers: [],
      renderbuffers: [],
      textures: [],
      shaders: [],
      vaos: [],
      contexts: [],
      offscreenCanvases: {},
      queries: [],
      samplers: [],
      transformFeedbacks: [],
      syncs: [],
      stringCache: {},
      stringiCache: {},
      unpackAlignment: 4,
      unpackRowLength: 0,
      recordError: (errorCode) => {
        if (!GL.lastError) {
          GL.lastError = errorCode;
        }
      },
      getNewId: (table) => {
        var ret = GL.counter++;
        for (var i2 = table.length; i2 < ret; i2++) {
          table[i2] = null;
        }
        return ret;
      },
      genObject: (n, buffers, createFunction, objectTable) => {
        for (var i2 = 0; i2 < n; i2++) {
          var buffer = GLctx[createFunction]();
          var id = buffer && GL.getNewId(objectTable);
          if (buffer) {
            buffer.name = id;
            objectTable[id] = buffer;
          } else {
            GL.recordError(
              1282
              /* GL_INVALID_OPERATION */
            );
          }
          HEAP32[buffers + i2 * 4 >> 2] = id;
        }
      },
      getSource: (shader, count, string, length) => {
        var source = "";
        for (var i2 = 0; i2 < count; ++i2) {
          var len = length ? HEAPU32[length + i2 * 4 >> 2] : void 0;
          source += UTF8ToString(HEAPU32[string + i2 * 4 >> 2], len);
        }
        return source;
      },
      createContext: (canvas, webGLContextAttributes) => {
        if (!canvas.getContextSafariWebGL2Fixed) {
          let fixedGetContext = function(ver, attrs) {
            var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
            return ver == "webgl" == gl instanceof WebGLRenderingContext ? gl : null;
          };
          canvas.getContextSafariWebGL2Fixed = canvas.getContext;
          canvas.getContext = fixedGetContext;
        }
        var ctx = webGLContextAttributes.majorVersion > 1 ? canvas.getContext("webgl2", webGLContextAttributes) : canvas.getContext("webgl", webGLContextAttributes);
        if (!ctx) return 0;
        var handle = GL.registerContext(ctx, webGLContextAttributes);
        return handle;
      },
      registerContext: (ctx, webGLContextAttributes) => {
        var handle = GL.getNewId(GL.contexts);
        var context = {
          handle,
          attributes: webGLContextAttributes,
          version: webGLContextAttributes.majorVersion,
          GLctx: ctx
        };
        if (ctx.canvas) ctx.canvas.GLctxObject = context;
        GL.contexts[handle] = context;
        if (typeof webGLContextAttributes.enableExtensionsByDefault == "undefined" || webGLContextAttributes.enableExtensionsByDefault) {
          GL.initExtensions(context);
        }
        return handle;
      },
      makeContextCurrent: (contextHandle) => {
        GL.currentContext = GL.contexts[contextHandle];
        Module["ctx"] = GLctx = GL.currentContext?.GLctx;
        return !(contextHandle && !GLctx);
      },
      getContext: (contextHandle) => {
        return GL.contexts[contextHandle];
      },
      deleteContext: (contextHandle) => {
        if (GL.currentContext === GL.contexts[contextHandle]) {
          GL.currentContext = null;
        }
        if (typeof JSEvents == "object") {
          JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
        }
        if (GL.contexts[contextHandle]?.GLctx.canvas) {
          GL.contexts[contextHandle].GLctx.canvas.GLctxObject = void 0;
        }
        GL.contexts[contextHandle] = null;
      },
      initExtensions: (context) => {
        context ||= GL.currentContext;
        if (context.initExtensionsDone) return;
        context.initExtensionsDone = true;
        var GLctx2 = context.GLctx;
        webgl_enable_WEBGL_multi_draw(GLctx2);
        webgl_enable_EXT_polygon_offset_clamp(GLctx2);
        webgl_enable_EXT_clip_control(GLctx2);
        webgl_enable_WEBGL_polygon_mode(GLctx2);
        webgl_enable_ANGLE_instanced_arrays(GLctx2);
        webgl_enable_OES_vertex_array_object(GLctx2);
        webgl_enable_WEBGL_draw_buffers(GLctx2);
        webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx2);
        webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx2);
        if (context.version >= 2) {
          GLctx2.disjointTimerQueryExt = GLctx2.getExtension("EXT_disjoint_timer_query_webgl2");
        }
        if (context.version < 2 || !GLctx2.disjointTimerQueryExt) {
          GLctx2.disjointTimerQueryExt = GLctx2.getExtension("EXT_disjoint_timer_query");
        }
        for (var ext of getEmscriptenSupportedExtensions(GLctx2)) {
          if (!ext.includes("lose_context") && !ext.includes("debug")) {
            GLctx2.getExtension(ext);
          }
        }
      }
    };
    var _emscripten_glActiveTexture = (x0) => GLctx.activeTexture(x0);
    var _emscripten_glAttachShader = (program, shader) => {
      GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
    };
    var _emscripten_glBeginQuery = (target, id) => {
      GLctx.beginQuery(target, GL.queries[id]);
    };
    var _emscripten_glBeginQueryEXT = (target, id) => {
      GLctx.disjointTimerQueryExt["beginQueryEXT"](target, GL.queries[id]);
    };
    var _emscripten_glBeginTransformFeedback = (x0) => GLctx.beginTransformFeedback(x0);
    var _emscripten_glBindAttribLocation = (program, index, name) => {
      GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
    };
    var _emscripten_glBindBuffer = (target, buffer) => {
      if (target == 35051) {
        GLctx.currentPixelPackBufferBinding = buffer;
      } else if (target == 35052) {
        GLctx.currentPixelUnpackBufferBinding = buffer;
      }
      GLctx.bindBuffer(target, GL.buffers[buffer]);
    };
    var _emscripten_glBindBufferBase = (target, index, buffer) => {
      GLctx.bindBufferBase(target, index, GL.buffers[buffer]);
    };
    var _emscripten_glBindBufferRange = (target, index, buffer, offset, ptrsize) => {
      GLctx.bindBufferRange(target, index, GL.buffers[buffer], offset, ptrsize);
    };
    var _emscripten_glBindFramebuffer = (target, framebuffer) => {
      GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
    };
    var _emscripten_glBindRenderbuffer = (target, renderbuffer) => {
      GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
    };
    var _emscripten_glBindSampler = (unit, sampler) => {
      GLctx.bindSampler(unit, GL.samplers[sampler]);
    };
    var _emscripten_glBindTexture = (target, texture) => {
      GLctx.bindTexture(target, GL.textures[texture]);
    };
    var _emscripten_glBindTransformFeedback = (target, id) => {
      GLctx.bindTransformFeedback(target, GL.transformFeedbacks[id]);
    };
    var _emscripten_glBindVertexArray = (vao) => {
      GLctx.bindVertexArray(GL.vaos[vao]);
    };
    var _glBindVertexArray = _emscripten_glBindVertexArray;
    var _emscripten_glBindVertexArrayOES = _glBindVertexArray;
    var _emscripten_glBlendColor = (x0, x1, x2, x3) => GLctx.blendColor(x0, x1, x2, x3);
    var _emscripten_glBlendEquation = (x0) => GLctx.blendEquation(x0);
    var _emscripten_glBlendEquationSeparate = (x0, x1) => GLctx.blendEquationSeparate(x0, x1);
    var _emscripten_glBlendFunc = (x0, x1) => GLctx.blendFunc(x0, x1);
    var _emscripten_glBlendFuncSeparate = (x0, x1, x2, x3) => GLctx.blendFuncSeparate(x0, x1, x2, x3);
    var _emscripten_glBlitFramebuffer = (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) => GLctx.blitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
    var _emscripten_glBufferData = (target, size, data, usage) => {
      if (GL.currentContext.version >= 2) {
        if (data && size) {
          GLctx.bufferData(target, HEAPU8, usage, data, size);
        } else {
          GLctx.bufferData(target, size, usage);
        }
        return;
      }
      GLctx.bufferData(target, data ? HEAPU8.subarray(data, data + size) : size, usage);
    };
    var _emscripten_glBufferSubData = (target, offset, size, data) => {
      if (GL.currentContext.version >= 2) {
        size && GLctx.bufferSubData(target, offset, HEAPU8, data, size);
        return;
      }
      GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size));
    };
    var _emscripten_glCheckFramebufferStatus = (x0) => GLctx.checkFramebufferStatus(x0);
    var _emscripten_glClear = (x0) => GLctx.clear(x0);
    var _emscripten_glClearBufferfi = (x0, x1, x2, x3) => GLctx.clearBufferfi(x0, x1, x2, x3);
    var _emscripten_glClearBufferfv = (buffer, drawbuffer, value) => {
      GLctx.clearBufferfv(buffer, drawbuffer, HEAPF32, value >> 2);
    };
    var _emscripten_glClearBufferiv = (buffer, drawbuffer, value) => {
      GLctx.clearBufferiv(buffer, drawbuffer, HEAP32, value >> 2);
    };
    var _emscripten_glClearBufferuiv = (buffer, drawbuffer, value) => {
      GLctx.clearBufferuiv(buffer, drawbuffer, HEAPU32, value >> 2);
    };
    var _emscripten_glClearColor = (x0, x1, x2, x3) => GLctx.clearColor(x0, x1, x2, x3);
    var _emscripten_glClearDepthf = (x0) => GLctx.clearDepth(x0);
    var _emscripten_glClearStencil = (x0) => GLctx.clearStencil(x0);
    var _emscripten_glClientWaitSync = (sync, flags, timeout) => {
      timeout = Number(timeout);
      return GLctx.clientWaitSync(GL.syncs[sync], flags, timeout);
    };
    var _emscripten_glClipControlEXT = (origin, depth) => {
      GLctx.extClipControl["clipControlEXT"](origin, depth);
    };
    var _emscripten_glColorMask = (red, green, blue, alpha) => {
      GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
    };
    var _emscripten_glCompileShader = (shader) => {
      GLctx.compileShader(GL.shaders[shader]);
    };
    var _emscripten_glCompressedTexImage2D = (target, level, internalFormat, width, height, border, imageSize, data) => {
      if (GL.currentContext.version >= 2) {
        if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
          GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data);
          return;
        }
        GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, HEAPU8, data, imageSize);
        return;
      }
      GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, HEAPU8.subarray(data, data + imageSize));
    };
    var _emscripten_glCompressedTexImage3D = (target, level, internalFormat, width, height, depth, border, imageSize, data) => {
      if (GLctx.currentPixelUnpackBufferBinding) {
        GLctx.compressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data);
      } else {
        GLctx.compressedTexImage3D(target, level, internalFormat, width, height, depth, border, HEAPU8, data, imageSize);
      }
    };
    var _emscripten_glCompressedTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, imageSize, data) => {
      if (GL.currentContext.version >= 2) {
        if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
          GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
          return;
        }
        GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize);
        return;
      }
      GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8.subarray(data, data + imageSize));
    };
    var _emscripten_glCompressedTexSubImage3D = (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) => {
      if (GLctx.currentPixelUnpackBufferBinding) {
        GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
      } else {
        GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize);
      }
    };
    var _emscripten_glCopyBufferSubData = (x0, x1, x2, x3, x4) => GLctx.copyBufferSubData(x0, x1, x2, x3, x4);
    var _emscripten_glCopyTexImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7);
    var _emscripten_glCopyTexSubImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7);
    var _emscripten_glCopyTexSubImage3D = (x0, x1, x2, x3, x4, x5, x6, x7, x8) => GLctx.copyTexSubImage3D(x0, x1, x2, x3, x4, x5, x6, x7, x8);
    var _emscripten_glCreateProgram = () => {
      var id = GL.getNewId(GL.programs);
      var program = GLctx.createProgram();
      program.name = id;
      program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0;
      program.uniformIdCounter = 1;
      GL.programs[id] = program;
      return id;
    };
    var _emscripten_glCreateShader = (shaderType) => {
      var id = GL.getNewId(GL.shaders);
      GL.shaders[id] = GLctx.createShader(shaderType);
      return id;
    };
    var _emscripten_glCullFace = (x0) => GLctx.cullFace(x0);
    var _emscripten_glDeleteBuffers = (n, buffers) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[buffers + i2 * 4 >> 2];
        var buffer = GL.buffers[id];
        if (!buffer) continue;
        GLctx.deleteBuffer(buffer);
        buffer.name = 0;
        GL.buffers[id] = null;
        if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0;
        if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
      }
    };
    var _emscripten_glDeleteFramebuffers = (n, framebuffers) => {
      for (var i2 = 0; i2 < n; ++i2) {
        var id = HEAP32[framebuffers + i2 * 4 >> 2];
        var framebuffer = GL.framebuffers[id];
        if (!framebuffer) continue;
        GLctx.deleteFramebuffer(framebuffer);
        framebuffer.name = 0;
        GL.framebuffers[id] = null;
      }
    };
    var _emscripten_glDeleteProgram = (id) => {
      if (!id) return;
      var program = GL.programs[id];
      if (!program) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      GLctx.deleteProgram(program);
      program.name = 0;
      GL.programs[id] = null;
    };
    var _emscripten_glDeleteQueries = (n, ids) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[ids + i2 * 4 >> 2];
        var query = GL.queries[id];
        if (!query) continue;
        GLctx.deleteQuery(query);
        GL.queries[id] = null;
      }
    };
    var _emscripten_glDeleteQueriesEXT = (n, ids) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[ids + i2 * 4 >> 2];
        var query = GL.queries[id];
        if (!query) continue;
        GLctx.disjointTimerQueryExt["deleteQueryEXT"](query);
        GL.queries[id] = null;
      }
    };
    var _emscripten_glDeleteRenderbuffers = (n, renderbuffers) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[renderbuffers + i2 * 4 >> 2];
        var renderbuffer = GL.renderbuffers[id];
        if (!renderbuffer) continue;
        GLctx.deleteRenderbuffer(renderbuffer);
        renderbuffer.name = 0;
        GL.renderbuffers[id] = null;
      }
    };
    var _emscripten_glDeleteSamplers = (n, samplers) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[samplers + i2 * 4 >> 2];
        var sampler = GL.samplers[id];
        if (!sampler) continue;
        GLctx.deleteSampler(sampler);
        sampler.name = 0;
        GL.samplers[id] = null;
      }
    };
    var _emscripten_glDeleteShader = (id) => {
      if (!id) return;
      var shader = GL.shaders[id];
      if (!shader) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      GLctx.deleteShader(shader);
      GL.shaders[id] = null;
    };
    var _emscripten_glDeleteSync = (id) => {
      if (!id) return;
      var sync = GL.syncs[id];
      if (!sync) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      GLctx.deleteSync(sync);
      sync.name = 0;
      GL.syncs[id] = null;
    };
    var _emscripten_glDeleteTextures = (n, textures) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[textures + i2 * 4 >> 2];
        var texture = GL.textures[id];
        if (!texture) continue;
        GLctx.deleteTexture(texture);
        texture.name = 0;
        GL.textures[id] = null;
      }
    };
    var _emscripten_glDeleteTransformFeedbacks = (n, ids) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[ids + i2 * 4 >> 2];
        var transformFeedback = GL.transformFeedbacks[id];
        if (!transformFeedback) continue;
        GLctx.deleteTransformFeedback(transformFeedback);
        transformFeedback.name = 0;
        GL.transformFeedbacks[id] = null;
      }
    };
    var _emscripten_glDeleteVertexArrays = (n, vaos) => {
      for (var i2 = 0; i2 < n; i2++) {
        var id = HEAP32[vaos + i2 * 4 >> 2];
        GLctx.deleteVertexArray(GL.vaos[id]);
        GL.vaos[id] = null;
      }
    };
    var _glDeleteVertexArrays = _emscripten_glDeleteVertexArrays;
    var _emscripten_glDeleteVertexArraysOES = _glDeleteVertexArrays;
    var _emscripten_glDepthFunc = (x0) => GLctx.depthFunc(x0);
    var _emscripten_glDepthMask = (flag) => {
      GLctx.depthMask(!!flag);
    };
    var _emscripten_glDepthRangef = (x0, x1) => GLctx.depthRange(x0, x1);
    var _emscripten_glDetachShader = (program, shader) => {
      GLctx.detachShader(GL.programs[program], GL.shaders[shader]);
    };
    var _emscripten_glDisable = (x0) => GLctx.disable(x0);
    var _emscripten_glDisableVertexAttribArray = (index) => {
      GLctx.disableVertexAttribArray(index);
    };
    var _emscripten_glDrawArrays = (mode, first, count) => {
      GLctx.drawArrays(mode, first, count);
    };
    var _emscripten_glDrawArraysInstanced = (mode, first, count, primcount) => {
      GLctx.drawArraysInstanced(mode, first, count, primcount);
    };
    var _glDrawArraysInstanced = _emscripten_glDrawArraysInstanced;
    var _emscripten_glDrawArraysInstancedANGLE = _glDrawArraysInstanced;
    var _emscripten_glDrawArraysInstancedARB = _glDrawArraysInstanced;
    var _emscripten_glDrawArraysInstancedBaseInstanceWEBGL = (mode, first, count, instanceCount, baseInstance) => {
      GLctx.dibvbi["drawArraysInstancedBaseInstanceWEBGL"](mode, first, count, instanceCount, baseInstance);
    };
    var _emscripten_glDrawArraysInstancedEXT = _glDrawArraysInstanced;
    var _emscripten_glDrawArraysInstancedNV = _glDrawArraysInstanced;
    var tempFixedLengthArray = [];
    var _emscripten_glDrawBuffers = (n, bufs) => {
      var bufArray = tempFixedLengthArray[n];
      for (var i2 = 0; i2 < n; i2++) {
        bufArray[i2] = HEAP32[bufs + i2 * 4 >> 2];
      }
      GLctx.drawBuffers(bufArray);
    };
    var _glDrawBuffers = _emscripten_glDrawBuffers;
    var _emscripten_glDrawBuffersEXT = _glDrawBuffers;
    var _emscripten_glDrawBuffersWEBGL = _glDrawBuffers;
    var _emscripten_glDrawElements = (mode, count, type, indices) => {
      GLctx.drawElements(mode, count, type, indices);
    };
    var _emscripten_glDrawElementsInstanced = (mode, count, type, indices, primcount) => {
      GLctx.drawElementsInstanced(mode, count, type, indices, primcount);
    };
    var _glDrawElementsInstanced = _emscripten_glDrawElementsInstanced;
    var _emscripten_glDrawElementsInstancedANGLE = _glDrawElementsInstanced;
    var _emscripten_glDrawElementsInstancedARB = _glDrawElementsInstanced;
    var _emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL = (mode, count, type, offset, instanceCount, baseVertex, baseinstance) => {
      GLctx.dibvbi["drawElementsInstancedBaseVertexBaseInstanceWEBGL"](mode, count, type, offset, instanceCount, baseVertex, baseinstance);
    };
    var _emscripten_glDrawElementsInstancedEXT = _glDrawElementsInstanced;
    var _emscripten_glDrawElementsInstancedNV = _glDrawElementsInstanced;
    var _glDrawElements = _emscripten_glDrawElements;
    var _emscripten_glDrawRangeElements = (mode, start, end, count, type, indices) => {
      _glDrawElements(mode, count, type, indices);
    };
    var _emscripten_glEnable = (x0) => GLctx.enable(x0);
    var _emscripten_glEnableVertexAttribArray = (index) => {
      GLctx.enableVertexAttribArray(index);
    };
    var _emscripten_glEndQuery = (x0) => GLctx.endQuery(x0);
    var _emscripten_glEndQueryEXT = (target) => {
      GLctx.disjointTimerQueryExt["endQueryEXT"](target);
    };
    var _emscripten_glEndTransformFeedback = () => GLctx.endTransformFeedback();
    var _emscripten_glFenceSync = (condition, flags) => {
      var sync = GLctx.fenceSync(condition, flags);
      if (sync) {
        var id = GL.getNewId(GL.syncs);
        sync.name = id;
        GL.syncs[id] = sync;
        return id;
      }
      return 0;
    };
    var _emscripten_glFinish = () => GLctx.finish();
    var _emscripten_glFlush = () => GLctx.flush();
    var _emscripten_glFramebufferRenderbuffer = (target, attachment, renderbuffertarget, renderbuffer) => {
      GLctx.framebufferRenderbuffer(
        target,
        attachment,
        renderbuffertarget,
        GL.renderbuffers[renderbuffer]
      );
    };
    var _emscripten_glFramebufferTexture2D = (target, attachment, textarget, texture, level) => {
      GLctx.framebufferTexture2D(
        target,
        attachment,
        textarget,
        GL.textures[texture],
        level
      );
    };
    var _emscripten_glFramebufferTextureLayer = (target, attachment, texture, level, layer) => {
      GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer);
    };
    var _emscripten_glFrontFace = (x0) => GLctx.frontFace(x0);
    var _emscripten_glGenBuffers = (n, buffers) => {
      GL.genObject(
        n,
        buffers,
        "createBuffer",
        GL.buffers
      );
    };
    var _emscripten_glGenFramebuffers = (n, ids) => {
      GL.genObject(
        n,
        ids,
        "createFramebuffer",
        GL.framebuffers
      );
    };
    var _emscripten_glGenQueries = (n, ids) => {
      GL.genObject(
        n,
        ids,
        "createQuery",
        GL.queries
      );
    };
    var _emscripten_glGenQueriesEXT = (n, ids) => {
      for (var i2 = 0; i2 < n; i2++) {
        var query = GLctx.disjointTimerQueryExt["createQueryEXT"]();
        if (!query) {
          GL.recordError(
            1282
            /* GL_INVALID_OPERATION */
          );
          while (i2 < n) HEAP32[ids + i2++ * 4 >> 2] = 0;
          return;
        }
        var id = GL.getNewId(GL.queries);
        query.name = id;
        GL.queries[id] = query;
        HEAP32[ids + i2 * 4 >> 2] = id;
      }
    };
    var _emscripten_glGenRenderbuffers = (n, renderbuffers) => {
      GL.genObject(
        n,
        renderbuffers,
        "createRenderbuffer",
        GL.renderbuffers
      );
    };
    var _emscripten_glGenSamplers = (n, samplers) => {
      GL.genObject(
        n,
        samplers,
        "createSampler",
        GL.samplers
      );
    };
    var _emscripten_glGenTextures = (n, textures) => {
      GL.genObject(
        n,
        textures,
        "createTexture",
        GL.textures
      );
    };
    var _emscripten_glGenTransformFeedbacks = (n, ids) => {
      GL.genObject(
        n,
        ids,
        "createTransformFeedback",
        GL.transformFeedbacks
      );
    };
    var _emscripten_glGenVertexArrays = (n, arrays) => {
      GL.genObject(
        n,
        arrays,
        "createVertexArray",
        GL.vaos
      );
    };
    var _glGenVertexArrays = _emscripten_glGenVertexArrays;
    var _emscripten_glGenVertexArraysOES = _glGenVertexArrays;
    var _emscripten_glGenerateMipmap = (x0) => GLctx.generateMipmap(x0);
    var __glGetActiveAttribOrUniform = (funcName, program, index, bufSize, length, size, type, name) => {
      program = GL.programs[program];
      var info = GLctx[funcName](program, index);
      if (info) {
        var numBytesWrittenExclNull = name && stringToUTF8(info.name, name, bufSize);
        if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
        if (size) HEAP32[size >> 2] = info.size;
        if (type) HEAP32[type >> 2] = info.type;
      }
    };
    var _emscripten_glGetActiveAttrib = (program, index, bufSize, length, size, type, name) => __glGetActiveAttribOrUniform("getActiveAttrib", program, index, bufSize, length, size, type, name);
    var _emscripten_glGetActiveUniform = (program, index, bufSize, length, size, type, name) => __glGetActiveAttribOrUniform("getActiveUniform", program, index, bufSize, length, size, type, name);
    var _emscripten_glGetActiveUniformBlockName = (program, uniformBlockIndex, bufSize, length, uniformBlockName) => {
      program = GL.programs[program];
      var result = GLctx.getActiveUniformBlockName(program, uniformBlockIndex);
      if (!result) return;
      if (uniformBlockName && bufSize > 0) {
        var numBytesWrittenExclNull = stringToUTF8(result, uniformBlockName, bufSize);
        if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
      } else {
        if (length) HEAP32[length >> 2] = 0;
      }
    };
    var _emscripten_glGetActiveUniformBlockiv = (program, uniformBlockIndex, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      program = GL.programs[program];
      if (pname == 35393) {
        var name = GLctx.getActiveUniformBlockName(program, uniformBlockIndex);
        HEAP32[params >> 2] = name.length + 1;
        return;
      }
      var result = GLctx.getActiveUniformBlockParameter(program, uniformBlockIndex, pname);
      if (result === null) return;
      if (pname == 35395) {
        for (var i2 = 0; i2 < result.length; i2++) {
          HEAP32[params + i2 * 4 >> 2] = result[i2];
        }
      } else {
        HEAP32[params >> 2] = result;
      }
    };
    var _emscripten_glGetActiveUniformsiv = (program, uniformCount, uniformIndices, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      if (uniformCount > 0 && uniformIndices == 0) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      program = GL.programs[program];
      var ids = [];
      for (var i2 = 0; i2 < uniformCount; i2++) {
        ids.push(HEAP32[uniformIndices + i2 * 4 >> 2]);
      }
      var result = GLctx.getActiveUniforms(program, ids, pname);
      if (!result) return;
      var len = result.length;
      for (var i2 = 0; i2 < len; i2++) {
        HEAP32[params + i2 * 4 >> 2] = result[i2];
      }
    };
    var _emscripten_glGetAttachedShaders = (program, maxCount, count, shaders) => {
      var result = GLctx.getAttachedShaders(GL.programs[program]);
      var len = result.length;
      if (len > maxCount) {
        len = maxCount;
      }
      HEAP32[count >> 2] = len;
      for (var i2 = 0; i2 < len; ++i2) {
        var id = GL.shaders.indexOf(result[i2]);
        HEAP32[shaders + i2 * 4 >> 2] = id;
      }
    };
    var _emscripten_glGetAttribLocation = (program, name) => GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
    var readI53FromI64 = (ptr) => {
      return HEAPU32[ptr >> 2] + HEAP32[ptr + 4 >> 2] * 4294967296;
    };
    var readI53FromU64 = (ptr) => {
      return HEAPU32[ptr >> 2] + HEAPU32[ptr + 4 >> 2] * 4294967296;
    };
    var writeI53ToI64 = (ptr, num) => {
      HEAPU32[ptr >> 2] = num;
      var lower = HEAPU32[ptr >> 2];
      HEAPU32[ptr + 4 >> 2] = (num - lower) / 4294967296;
      var deserialized = num >= 0 ? readI53FromU64(ptr) : readI53FromI64(ptr);
      var offset = ptr >> 2;
      if (deserialized != num) warnOnce(`writeI53ToI64() out of range: serialized JS Number ${num} to Wasm heap as bytes lo=${ptrToString(HEAPU32[offset])}, hi=${ptrToString(HEAPU32[offset + 1])}, which deserializes back to ${deserialized} instead!`);
    };
    var webglGetExtensions = () => {
      var exts = getEmscriptenSupportedExtensions(GLctx);
      exts = exts.concat(exts.map((e) => "GL_" + e));
      return exts;
    };
    var emscriptenWebGLGet = (name_, p, type) => {
      if (!p) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var ret = void 0;
      switch (name_) {
        // Handle a few trivial GLES values
        case 36346:
          ret = 1;
          break;
        case 36344:
          if (type != 0 && type != 1) {
            GL.recordError(1280);
          }
          return;
        case 34814:
        // GL_NUM_PROGRAM_BINARY_FORMATS
        case 36345:
          ret = 0;
          break;
        case 34466:
          var formats = GLctx.getParameter(
            34467
            /*GL_COMPRESSED_TEXTURE_FORMATS*/
          );
          ret = formats ? formats.length : 0;
          break;
        case 33309:
          if (GL.currentContext.version < 2) {
            GL.recordError(
              1282
              /* GL_INVALID_OPERATION */
            );
            return;
          }
          ret = webglGetExtensions().length;
          break;
        case 33307:
        // GL_MAJOR_VERSION
        case 33308:
          if (GL.currentContext.version < 2) {
            GL.recordError(1280);
            return;
          }
          ret = name_ == 33307 ? 3 : 0;
          break;
      }
      if (ret === void 0) {
        var result = GLctx.getParameter(name_);
        switch (typeof result) {
          case "number":
            ret = result;
            break;
          case "boolean":
            ret = result ? 1 : 0;
            break;
          case "string":
            GL.recordError(1280);
            return;
          case "object":
            if (result === null) {
              switch (name_) {
                case 34964:
                // ARRAY_BUFFER_BINDING
                case 35725:
                // CURRENT_PROGRAM
                case 34965:
                // ELEMENT_ARRAY_BUFFER_BINDING
                case 36006:
                // FRAMEBUFFER_BINDING or DRAW_FRAMEBUFFER_BINDING
                case 36007:
                // RENDERBUFFER_BINDING
                case 32873:
                // TEXTURE_BINDING_2D
                case 34229:
                // WebGL 2 GL_VERTEX_ARRAY_BINDING, or WebGL 1 extension OES_vertex_array_object GL_VERTEX_ARRAY_BINDING_OES
                case 36662:
                // COPY_READ_BUFFER_BINDING or COPY_READ_BUFFER
                case 36663:
                // COPY_WRITE_BUFFER_BINDING or COPY_WRITE_BUFFER
                case 35053:
                // PIXEL_PACK_BUFFER_BINDING
                case 35055:
                // PIXEL_UNPACK_BUFFER_BINDING
                case 36010:
                // READ_FRAMEBUFFER_BINDING
                case 35097:
                // SAMPLER_BINDING
                case 35869:
                // TEXTURE_BINDING_2D_ARRAY
                case 32874:
                // TEXTURE_BINDING_3D
                case 36389:
                // TRANSFORM_FEEDBACK_BINDING
                case 35983:
                // TRANSFORM_FEEDBACK_BUFFER_BINDING
                case 35368:
                // UNIFORM_BUFFER_BINDING
                case 34068: {
                  ret = 0;
                  break;
                }
                default: {
                  GL.recordError(1280);
                  return;
                }
              }
            } else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) {
              for (var i2 = 0; i2 < result.length; ++i2) {
                switch (type) {
                  case 0:
                    HEAP32[p + i2 * 4 >> 2] = result[i2];
                    break;
                  case 2:
                    HEAPF32[p + i2 * 4 >> 2] = result[i2];
                    break;
                  case 4:
                    HEAP8[p + i2] = result[i2] ? 1 : 0;
                    break;
                }
              }
              return;
            } else {
              try {
                ret = result.name | 0;
              } catch (e) {
                GL.recordError(1280);
                err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`);
                return;
              }
            }
            break;
          default:
            GL.recordError(1280);
            err(`GL_INVALID_ENUM in glGet${type}v: Native code calling glGet${type}v(${name_}) and it returns ${result} of type ${typeof result}!`);
            return;
        }
      }
      switch (type) {
        case 1:
          writeI53ToI64(p, ret);
          break;
        case 0:
          HEAP32[p >> 2] = ret;
          break;
        case 2:
          HEAPF32[p >> 2] = ret;
          break;
        case 4:
          HEAP8[p] = ret ? 1 : 0;
          break;
      }
    };
    var _emscripten_glGetBooleanv = (name_, p) => emscriptenWebGLGet(name_, p, 4);
    var _emscripten_glGetBufferParameteri64v = (target, value, data) => {
      if (!data) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      writeI53ToI64(data, GLctx.getBufferParameter(target, value));
    };
    var _emscripten_glGetBufferParameteriv = (target, value, data) => {
      if (!data) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAP32[data >> 2] = GLctx.getBufferParameter(target, value);
    };
    var _emscripten_glGetError = () => {
      var error = GLctx.getError() || GL.lastError;
      GL.lastError = 0;
      return error;
    };
    var _emscripten_glGetFloatv = (name_, p) => emscriptenWebGLGet(name_, p, 2);
    var _emscripten_glGetFragDataLocation = (program, name) => {
      return GLctx.getFragDataLocation(GL.programs[program], UTF8ToString(name));
    };
    var _emscripten_glGetFramebufferAttachmentParameteriv = (target, attachment, pname, params) => {
      var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname);
      if (result instanceof WebGLRenderbuffer || result instanceof WebGLTexture) {
        result = result.name | 0;
      }
      HEAP32[params >> 2] = result;
    };
    var emscriptenWebGLGetIndexed = (target, index, data, type) => {
      if (!data) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var result = GLctx.getIndexedParameter(target, index);
      var ret;
      switch (typeof result) {
        case "boolean":
          ret = result ? 1 : 0;
          break;
        case "number":
          ret = result;
          break;
        case "object":
          if (result === null) {
            switch (target) {
              case 35983:
              // TRANSFORM_FEEDBACK_BUFFER_BINDING
              case 35368:
                ret = 0;
                break;
              default: {
                GL.recordError(1280);
                return;
              }
            }
          } else if (result instanceof WebGLBuffer) {
            ret = result.name | 0;
          } else {
            GL.recordError(1280);
            return;
          }
          break;
        default:
          GL.recordError(1280);
          return;
      }
      switch (type) {
        case 1:
          writeI53ToI64(data, ret);
          break;
        case 0:
          HEAP32[data >> 2] = ret;
          break;
        case 2:
          HEAPF32[data >> 2] = ret;
          break;
        case 4:
          HEAP8[data] = ret ? 1 : 0;
          break;
        default:
          abort("internal emscriptenWebGLGetIndexed() error, bad type: " + type);
      }
    };
    var _emscripten_glGetInteger64i_v = (target, index, data) => emscriptenWebGLGetIndexed(target, index, data, 1);
    var _emscripten_glGetInteger64v = (name_, p) => {
      emscriptenWebGLGet(name_, p, 1);
    };
    var _emscripten_glGetIntegeri_v = (target, index, data) => emscriptenWebGLGetIndexed(target, index, data, 0);
    var _emscripten_glGetIntegerv = (name_, p) => emscriptenWebGLGet(name_, p, 0);
    var _emscripten_glGetInternalformativ = (target, internalformat, pname, bufSize, params) => {
      if (bufSize < 0) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var ret = GLctx.getInternalformatParameter(target, internalformat, pname);
      if (ret === null) return;
      for (var i2 = 0; i2 < ret.length && i2 < bufSize; ++i2) {
        HEAP32[params + i2 * 4 >> 2] = ret[i2];
      }
    };
    var _emscripten_glGetProgramBinary = (program, bufSize, length, binaryFormat, binary) => {
      GL.recordError(
        1282
        /*GL_INVALID_OPERATION*/
      );
    };
    var _emscripten_glGetProgramInfoLog = (program, maxLength, length, infoLog) => {
      var log = GLctx.getProgramInfoLog(GL.programs[program]);
      if (log === null) log = "(unknown error)";
      var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
      if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
    };
    var _emscripten_glGetProgramiv = (program, pname, p) => {
      if (!p) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      if (program >= GL.counter) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      program = GL.programs[program];
      if (pname == 35716) {
        var log = GLctx.getProgramInfoLog(program);
        if (log === null) log = "(unknown error)";
        HEAP32[p >> 2] = log.length + 1;
      } else if (pname == 35719) {
        if (!program.maxUniformLength) {
          var numActiveUniforms = GLctx.getProgramParameter(
            program,
            35718
            /*GL_ACTIVE_UNIFORMS*/
          );
          for (var i2 = 0; i2 < numActiveUniforms; ++i2) {
            program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i2).name.length + 1);
          }
        }
        HEAP32[p >> 2] = program.maxUniformLength;
      } else if (pname == 35722) {
        if (!program.maxAttributeLength) {
          var numActiveAttributes = GLctx.getProgramParameter(
            program,
            35721
            /*GL_ACTIVE_ATTRIBUTES*/
          );
          for (var i2 = 0; i2 < numActiveAttributes; ++i2) {
            program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i2).name.length + 1);
          }
        }
        HEAP32[p >> 2] = program.maxAttributeLength;
      } else if (pname == 35381) {
        if (!program.maxUniformBlockNameLength) {
          var numActiveUniformBlocks = GLctx.getProgramParameter(
            program,
            35382
            /*GL_ACTIVE_UNIFORM_BLOCKS*/
          );
          for (var i2 = 0; i2 < numActiveUniformBlocks; ++i2) {
            program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i2).length + 1);
          }
        }
        HEAP32[p >> 2] = program.maxUniformBlockNameLength;
      } else {
        HEAP32[p >> 2] = GLctx.getProgramParameter(program, pname);
      }
    };
    var _emscripten_glGetQueryObjecti64vEXT = (id, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var query = GL.queries[id];
      var param;
      if (GL.currentContext.version < 2) {
        param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
      } else {
        param = GLctx.getQueryParameter(query, pname);
      }
      var ret;
      if (typeof param == "boolean") {
        ret = param ? 1 : 0;
      } else {
        ret = param;
      }
      writeI53ToI64(params, ret);
    };
    var _emscripten_glGetQueryObjectivEXT = (id, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var query = GL.queries[id];
      var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
      var ret;
      if (typeof param == "boolean") {
        ret = param ? 1 : 0;
      } else {
        ret = param;
      }
      HEAP32[params >> 2] = ret;
    };
    var _glGetQueryObjecti64vEXT = _emscripten_glGetQueryObjecti64vEXT;
    var _emscripten_glGetQueryObjectui64vEXT = _glGetQueryObjecti64vEXT;
    var _emscripten_glGetQueryObjectuiv = (id, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var query = GL.queries[id];
      var param = GLctx.getQueryParameter(query, pname);
      var ret;
      if (typeof param == "boolean") {
        ret = param ? 1 : 0;
      } else {
        ret = param;
      }
      HEAP32[params >> 2] = ret;
    };
    var _glGetQueryObjectivEXT = _emscripten_glGetQueryObjectivEXT;
    var _emscripten_glGetQueryObjectuivEXT = _glGetQueryObjectivEXT;
    var _emscripten_glGetQueryiv = (target, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAP32[params >> 2] = GLctx.getQuery(target, pname);
    };
    var _emscripten_glGetQueryivEXT = (target, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAP32[params >> 2] = GLctx.disjointTimerQueryExt["getQueryEXT"](target, pname);
    };
    var _emscripten_glGetRenderbufferParameteriv = (target, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname);
    };
    var _emscripten_glGetSamplerParameterfv = (sampler, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAPF32[params >> 2] = GLctx.getSamplerParameter(GL.samplers[sampler], pname);
    };
    var _emscripten_glGetSamplerParameteriv = (sampler, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAP32[params >> 2] = GLctx.getSamplerParameter(GL.samplers[sampler], pname);
    };
    var _emscripten_glGetShaderInfoLog = (shader, maxLength, length, infoLog) => {
      var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
      if (log === null) log = "(unknown error)";
      var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
      if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
    };
    var _emscripten_glGetShaderPrecisionFormat = (shaderType, precisionType, range, precision) => {
      var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType);
      HEAP32[range >> 2] = result.rangeMin;
      HEAP32[range + 4 >> 2] = result.rangeMax;
      HEAP32[precision >> 2] = result.precision;
    };
    var _emscripten_glGetShaderSource = (shader, bufSize, length, source) => {
      var result = GLctx.getShaderSource(GL.shaders[shader]);
      if (!result) return;
      var numBytesWrittenExclNull = bufSize > 0 && source ? stringToUTF8(result, source, bufSize) : 0;
      if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
    };
    var _emscripten_glGetShaderiv = (shader, pname, p) => {
      if (!p) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      if (pname == 35716) {
        var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
        if (log === null) log = "(unknown error)";
        var logLength = log ? log.length + 1 : 0;
        HEAP32[p >> 2] = logLength;
      } else if (pname == 35720) {
        var source = GLctx.getShaderSource(GL.shaders[shader]);
        var sourceLength = source ? source.length + 1 : 0;
        HEAP32[p >> 2] = sourceLength;
      } else {
        HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
      }
    };
    var stringToNewUTF8 = (str) => {
      var size = lengthBytesUTF8(str) + 1;
      var ret = _malloc(size);
      if (ret) stringToUTF8(str, ret, size);
      return ret;
    };
    var _emscripten_glGetString = (name_) => {
      var ret = GL.stringCache[name_];
      if (!ret) {
        switch (name_) {
          case 7939:
            ret = stringToNewUTF8(webglGetExtensions().join(" "));
            break;
          case 7936:
          case 7937:
          case 37445:
          case 37446:
            var s = GLctx.getParameter(name_);
            if (!s) {
              GL.recordError(
                1280
                /*GL_INVALID_ENUM*/
              );
            }
            ret = s ? stringToNewUTF8(s) : 0;
            break;
          case 7938:
            var webGLVersion = GLctx.getParameter(
              7938
              /*GL_VERSION*/
            );
            var glVersion = `OpenGL ES 2.0 (${webGLVersion})`;
            if (GL.currentContext.version >= 2) glVersion = `OpenGL ES 3.0 (${webGLVersion})`;
            ret = stringToNewUTF8(glVersion);
            break;
          case 35724:
            var glslVersion = GLctx.getParameter(
              35724
              /*GL_SHADING_LANGUAGE_VERSION*/
            );
            var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;
            var ver_num = glslVersion.match(ver_re);
            if (ver_num !== null) {
              if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0";
              glslVersion = `OpenGL ES GLSL ES ${ver_num[1]} (${glslVersion})`;
            }
            ret = stringToNewUTF8(glslVersion);
            break;
          default:
            GL.recordError(
              1280
              /*GL_INVALID_ENUM*/
            );
        }
        GL.stringCache[name_] = ret;
      }
      return ret;
    };
    var _emscripten_glGetStringi = (name, index) => {
      if (GL.currentContext.version < 2) {
        GL.recordError(
          1282
          /* GL_INVALID_OPERATION */
        );
        return 0;
      }
      var stringiCache = GL.stringiCache[name];
      if (stringiCache) {
        if (index < 0 || index >= stringiCache.length) {
          GL.recordError(
            1281
            /*GL_INVALID_VALUE*/
          );
          return 0;
        }
        return stringiCache[index];
      }
      switch (name) {
        case 7939:
          var exts = webglGetExtensions().map(stringToNewUTF8);
          stringiCache = GL.stringiCache[name] = exts;
          if (index < 0 || index >= stringiCache.length) {
            GL.recordError(
              1281
              /*GL_INVALID_VALUE*/
            );
            return 0;
          }
          return stringiCache[index];
        default:
          GL.recordError(
            1280
            /*GL_INVALID_ENUM*/
          );
          return 0;
      }
    };
    var _emscripten_glGetSynciv = (sync, pname, bufSize, length, values) => {
      if (bufSize < 0) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      if (!values) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var ret = GLctx.getSyncParameter(GL.syncs[sync], pname);
      if (ret !== null) {
        HEAP32[values >> 2] = ret;
        if (length) HEAP32[length >> 2] = 1;
      }
    };
    var _emscripten_glGetTexParameterfv = (target, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAPF32[params >> 2] = GLctx.getTexParameter(target, pname);
    };
    var _emscripten_glGetTexParameteriv = (target, pname, params) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAP32[params >> 2] = GLctx.getTexParameter(target, pname);
    };
    var _emscripten_glGetTransformFeedbackVarying = (program, index, bufSize, length, size, type, name) => {
      program = GL.programs[program];
      var info = GLctx.getTransformFeedbackVarying(program, index);
      if (!info) return;
      if (name && bufSize > 0) {
        var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize);
        if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
      } else {
        if (length) HEAP32[length >> 2] = 0;
      }
      if (size) HEAP32[size >> 2] = info.size;
      if (type) HEAP32[type >> 2] = info.type;
    };
    var _emscripten_glGetUniformBlockIndex = (program, uniformBlockName) => {
      return GLctx.getUniformBlockIndex(GL.programs[program], UTF8ToString(uniformBlockName));
    };
    var _emscripten_glGetUniformIndices = (program, uniformCount, uniformNames, uniformIndices) => {
      if (!uniformIndices) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      program = GL.programs[program];
      var names = [];
      for (var i2 = 0; i2 < uniformCount; i2++)
        names.push(UTF8ToString(HEAPU32[uniformNames + i2 * 4 >> 2]));
      var result = GLctx.getUniformIndices(program, names);
      if (!result) return;
      var len = result.length;
      for (var i2 = 0; i2 < len; i2++) {
        HEAP32[uniformIndices + i2 * 4 >> 2] = result[i2];
      }
    };
    var jstoi_q = (str) => parseInt(str);
    var webglGetLeftBracePos = (name) => name.slice(-1) == "]" && name.lastIndexOf("[");
    var webglPrepareUniformLocationsBeforeFirstUse = (program) => {
      var uniformLocsById = program.uniformLocsById, uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, i2, j;
      if (!uniformLocsById) {
        program.uniformLocsById = uniformLocsById = {};
        program.uniformArrayNamesById = {};
        var numActiveUniforms = GLctx.getProgramParameter(
          program,
          35718
          /*GL_ACTIVE_UNIFORMS*/
        );
        for (i2 = 0; i2 < numActiveUniforms; ++i2) {
          var u = GLctx.getActiveUniform(program, i2);
          var nm = u.name;
          var sz = u.size;
          var lb = webglGetLeftBracePos(nm);
          var arrayName = lb > 0 ? nm.slice(0, lb) : nm;
          var id = program.uniformIdCounter;
          program.uniformIdCounter += sz;
          uniformSizeAndIdsByName[arrayName] = [sz, id];
          for (j = 0; j < sz; ++j) {
            uniformLocsById[id] = j;
            program.uniformArrayNamesById[id++] = arrayName;
          }
        }
      }
    };
    var _emscripten_glGetUniformLocation = (program, name) => {
      name = UTF8ToString(name);
      if (program = GL.programs[program]) {
        webglPrepareUniformLocationsBeforeFirstUse(program);
        var uniformLocsById = program.uniformLocsById;
        var arrayIndex = 0;
        var uniformBaseName = name;
        var leftBrace = webglGetLeftBracePos(name);
        if (leftBrace > 0) {
          arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0;
          uniformBaseName = name.slice(0, leftBrace);
        }
        var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName];
        if (sizeAndId && arrayIndex < sizeAndId[0]) {
          arrayIndex += sizeAndId[1];
          if (uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) {
            return arrayIndex;
          }
        }
      } else {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
      }
      return -1;
    };
    var webglGetUniformLocation = (location) => {
      var p = GLctx.currentProgram;
      if (p) {
        var webglLoc = p.uniformLocsById[location];
        if (typeof webglLoc == "number") {
          p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? `[${webglLoc}]` : ""));
        }
        return webglLoc;
      } else {
        GL.recordError(
          1282
          /*GL_INVALID_OPERATION*/
        );
      }
    };
    var emscriptenWebGLGetUniform = (program, location, params, type) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      program = GL.programs[program];
      webglPrepareUniformLocationsBeforeFirstUse(program);
      var data = GLctx.getUniform(program, webglGetUniformLocation(location));
      if (typeof data == "number" || typeof data == "boolean") {
        switch (type) {
          case 0:
            HEAP32[params >> 2] = data;
            break;
          case 2:
            HEAPF32[params >> 2] = data;
            break;
        }
      } else {
        for (var i2 = 0; i2 < data.length; i2++) {
          switch (type) {
            case 0:
              HEAP32[params + i2 * 4 >> 2] = data[i2];
              break;
            case 2:
              HEAPF32[params + i2 * 4 >> 2] = data[i2];
              break;
          }
        }
      }
    };
    var _emscripten_glGetUniformfv = (program, location, params) => {
      emscriptenWebGLGetUniform(program, location, params, 2);
    };
    var _emscripten_glGetUniformiv = (program, location, params) => {
      emscriptenWebGLGetUniform(program, location, params, 0);
    };
    var _emscripten_glGetUniformuiv = (program, location, params) => emscriptenWebGLGetUniform(program, location, params, 0);
    var emscriptenWebGLGetVertexAttrib = (index, pname, params, type) => {
      if (!params) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      var data = GLctx.getVertexAttrib(index, pname);
      if (pname == 34975) {
        HEAP32[params >> 2] = data && data["name"];
      } else if (typeof data == "number" || typeof data == "boolean") {
        switch (type) {
          case 0:
            HEAP32[params >> 2] = data;
            break;
          case 2:
            HEAPF32[params >> 2] = data;
            break;
          case 5:
            HEAP32[params >> 2] = Math.fround(data);
            break;
        }
      } else {
        for (var i2 = 0; i2 < data.length; i2++) {
          switch (type) {
            case 0:
              HEAP32[params + i2 * 4 >> 2] = data[i2];
              break;
            case 2:
              HEAPF32[params + i2 * 4 >> 2] = data[i2];
              break;
            case 5:
              HEAP32[params + i2 * 4 >> 2] = Math.fround(data[i2]);
              break;
          }
        }
      }
    };
    var _emscripten_glGetVertexAttribIiv = (index, pname, params) => {
      emscriptenWebGLGetVertexAttrib(index, pname, params, 0);
    };
    var _glGetVertexAttribIiv = _emscripten_glGetVertexAttribIiv;
    var _emscripten_glGetVertexAttribIuiv = _glGetVertexAttribIiv;
    var _emscripten_glGetVertexAttribPointerv = (index, pname, pointer) => {
      if (!pointer) {
        GL.recordError(
          1281
          /* GL_INVALID_VALUE */
        );
        return;
      }
      HEAP32[pointer >> 2] = GLctx.getVertexAttribOffset(index, pname);
    };
    var _emscripten_glGetVertexAttribfv = (index, pname, params) => {
      emscriptenWebGLGetVertexAttrib(index, pname, params, 2);
    };
    var _emscripten_glGetVertexAttribiv = (index, pname, params) => {
      emscriptenWebGLGetVertexAttrib(index, pname, params, 5);
    };
    var _emscripten_glHint = (x0, x1) => GLctx.hint(x0, x1);
    var _emscripten_glInvalidateFramebuffer = (target, numAttachments, attachments) => {
      var list = tempFixedLengthArray[numAttachments];
      for (var i2 = 0; i2 < numAttachments; i2++) {
        list[i2] = HEAP32[attachments + i2 * 4 >> 2];
      }
      GLctx.invalidateFramebuffer(target, list);
    };
    var _emscripten_glInvalidateSubFramebuffer = (target, numAttachments, attachments, x, y, width, height) => {
      var list = tempFixedLengthArray[numAttachments];
      for (var i2 = 0; i2 < numAttachments; i2++) {
        list[i2] = HEAP32[attachments + i2 * 4 >> 2];
      }
      GLctx.invalidateSubFramebuffer(target, list, x, y, width, height);
    };
    var _emscripten_glIsBuffer = (buffer) => {
      var b = GL.buffers[buffer];
      if (!b) return 0;
      return GLctx.isBuffer(b);
    };
    var _emscripten_glIsEnabled = (x0) => GLctx.isEnabled(x0);
    var _emscripten_glIsFramebuffer = (framebuffer) => {
      var fb = GL.framebuffers[framebuffer];
      if (!fb) return 0;
      return GLctx.isFramebuffer(fb);
    };
    var _emscripten_glIsProgram = (program) => {
      program = GL.programs[program];
      if (!program) return 0;
      return GLctx.isProgram(program);
    };
    var _emscripten_glIsQuery = (id) => {
      var query = GL.queries[id];
      if (!query) return 0;
      return GLctx.isQuery(query);
    };
    var _emscripten_glIsQueryEXT = (id) => {
      var query = GL.queries[id];
      if (!query) return 0;
      return GLctx.disjointTimerQueryExt["isQueryEXT"](query);
    };
    var _emscripten_glIsRenderbuffer = (renderbuffer) => {
      var rb = GL.renderbuffers[renderbuffer];
      if (!rb) return 0;
      return GLctx.isRenderbuffer(rb);
    };
    var _emscripten_glIsSampler = (id) => {
      var sampler = GL.samplers[id];
      if (!sampler) return 0;
      return GLctx.isSampler(sampler);
    };
    var _emscripten_glIsShader = (shader) => {
      var s = GL.shaders[shader];
      if (!s) return 0;
      return GLctx.isShader(s);
    };
    var _emscripten_glIsSync = (sync) => GLctx.isSync(GL.syncs[sync]);
    var _emscripten_glIsTexture = (id) => {
      var texture = GL.textures[id];
      if (!texture) return 0;
      return GLctx.isTexture(texture);
    };
    var _emscripten_glIsTransformFeedback = (id) => GLctx.isTransformFeedback(GL.transformFeedbacks[id]);
    var _emscripten_glIsVertexArray = (array) => {
      var vao = GL.vaos[array];
      if (!vao) return 0;
      return GLctx.isVertexArray(vao);
    };
    var _glIsVertexArray = _emscripten_glIsVertexArray;
    var _emscripten_glIsVertexArrayOES = _glIsVertexArray;
    var _emscripten_glLineWidth = (x0) => GLctx.lineWidth(x0);
    var _emscripten_glLinkProgram = (program) => {
      program = GL.programs[program];
      GLctx.linkProgram(program);
      program.uniformLocsById = 0;
      program.uniformSizeAndIdsByName = {};
    };
    var _emscripten_glMultiDrawArraysInstancedBaseInstanceWEBGL = (mode, firsts, counts, instanceCounts, baseInstances, drawCount) => {
      GLctx.mdibvbi["multiDrawArraysInstancedBaseInstanceWEBGL"](
        mode,
        HEAP32,
        firsts >> 2,
        HEAP32,
        counts >> 2,
        HEAP32,
        instanceCounts >> 2,
        HEAPU32,
        baseInstances >> 2,
        drawCount
      );
    };
    var _emscripten_glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL = (mode, counts, type, offsets, instanceCounts, baseVertices, baseInstances, drawCount) => {
      GLctx.mdibvbi["multiDrawElementsInstancedBaseVertexBaseInstanceWEBGL"](
        mode,
        HEAP32,
        counts >> 2,
        type,
        HEAP32,
        offsets >> 2,
        HEAP32,
        instanceCounts >> 2,
        HEAP32,
        baseVertices >> 2,
        HEAPU32,
        baseInstances >> 2,
        drawCount
      );
    };
    var _emscripten_glPauseTransformFeedback = () => GLctx.pauseTransformFeedback();
    var _emscripten_glPixelStorei = (pname, param) => {
      if (pname == 3317) {
        GL.unpackAlignment = param;
      } else if (pname == 3314) {
        GL.unpackRowLength = param;
      }
      GLctx.pixelStorei(pname, param);
    };
    var _emscripten_glPolygonModeWEBGL = (face, mode) => {
      GLctx.webglPolygonMode["polygonModeWEBGL"](face, mode);
    };
    var _emscripten_glPolygonOffset = (x0, x1) => GLctx.polygonOffset(x0, x1);
    var _emscripten_glPolygonOffsetClampEXT = (factor, units, clamp) => {
      GLctx.extPolygonOffsetClamp["polygonOffsetClampEXT"](factor, units, clamp);
    };
    var _emscripten_glProgramBinary = (program, binaryFormat, binary, length) => {
      GL.recordError(
        1280
        /*GL_INVALID_ENUM*/
      );
    };
    var _emscripten_glProgramParameteri = (program, pname, value) => {
      GL.recordError(
        1280
        /*GL_INVALID_ENUM*/
      );
    };
    var _emscripten_glQueryCounterEXT = (id, target) => {
      GLctx.disjointTimerQueryExt["queryCounterEXT"](GL.queries[id], target);
    };
    var _emscripten_glReadBuffer = (x0) => GLctx.readBuffer(x0);
    var computeUnpackAlignedImageSize = (width, height, sizePerPixel) => {
      function roundedToNextMultipleOf(x, y) {
        return x + y - 1 & -y;
      }
      var plainRowSize = (GL.unpackRowLength || width) * sizePerPixel;
      var alignedRowSize = roundedToNextMultipleOf(plainRowSize, GL.unpackAlignment);
      return height * alignedRowSize;
    };
    var colorChannelsInGlTextureFormat = (format) => {
      var colorChannels = {
        // 0x1902 /* GL_DEPTH_COMPONENT */ - 0x1902: 1,
        // 0x1906 /* GL_ALPHA */ - 0x1902: 1,
        5: 3,
        6: 4,
        // 0x1909 /* GL_LUMINANCE */ - 0x1902: 1,
        8: 2,
        29502: 3,
        29504: 4,
        // 0x1903 /* GL_RED */ - 0x1902: 1,
        26917: 2,
        26918: 2,
        // 0x8D94 /* GL_RED_INTEGER */ - 0x1902: 1,
        29846: 3,
        29847: 4
      };
      return colorChannels[format - 6402] || 1;
    };
    var heapObjectForWebGLType = (type) => {
      type -= 5120;
      if (type == 0) return HEAP8;
      if (type == 1) return HEAPU8;
      if (type == 2) return HEAP16;
      if (type == 4) return HEAP32;
      if (type == 6) return HEAPF32;
      if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782)
        return HEAPU32;
      return HEAPU16;
    };
    var toTypedArrayIndex = (pointer, heap) => pointer >>> 31 - Math.clz32(heap.BYTES_PER_ELEMENT);
    var emscriptenWebGLGetTexPixelData = (type, format, width, height, pixels, internalFormat) => {
      var heap = heapObjectForWebGLType(type);
      var sizePerPixel = colorChannelsInGlTextureFormat(format) * heap.BYTES_PER_ELEMENT;
      var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel);
      return heap.subarray(toTypedArrayIndex(pixels, heap), toTypedArrayIndex(pixels + bytes, heap));
    };
    var _emscripten_glReadPixels = (x, y, width, height, format, type, pixels) => {
      if (GL.currentContext.version >= 2) {
        if (GLctx.currentPixelPackBufferBinding) {
          GLctx.readPixels(x, y, width, height, format, type, pixels);
          return;
        }
        var heap = heapObjectForWebGLType(type);
        var target = toTypedArrayIndex(pixels, heap);
        GLctx.readPixels(x, y, width, height, format, type, heap, target);
        return;
      }
      var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format);
      if (!pixelData) {
        GL.recordError(
          1280
          /*GL_INVALID_ENUM*/
        );
        return;
      }
      GLctx.readPixels(x, y, width, height, format, type, pixelData);
    };
    var _emscripten_glReleaseShaderCompiler = () => {
    };
    var _emscripten_glRenderbufferStorage = (x0, x1, x2, x3) => GLctx.renderbufferStorage(x0, x1, x2, x3);
    var _emscripten_glRenderbufferStorageMultisample = (x0, x1, x2, x3, x4) => GLctx.renderbufferStorageMultisample(x0, x1, x2, x3, x4);
    var _emscripten_glResumeTransformFeedback = () => GLctx.resumeTransformFeedback();
    var _emscripten_glSampleCoverage = (value, invert) => {
      GLctx.sampleCoverage(value, !!invert);
    };
    var _emscripten_glSamplerParameterf = (sampler, pname, param) => {
      GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
    };
    var _emscripten_glSamplerParameterfv = (sampler, pname, params) => {
      var param = HEAPF32[params >> 2];
      GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
    };
    var _emscripten_glSamplerParameteri = (sampler, pname, param) => {
      GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
    };
    var _emscripten_glSamplerParameteriv = (sampler, pname, params) => {
      var param = HEAP32[params >> 2];
      GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
    };
    var _emscripten_glScissor = (x0, x1, x2, x3) => GLctx.scissor(x0, x1, x2, x3);
    var _emscripten_glShaderBinary = (count, shaders, binaryformat, binary, length) => {
      GL.recordError(
        1280
        /*GL_INVALID_ENUM*/
      );
    };
    var _emscripten_glShaderSource = (shader, count, string, length) => {
      var source = GL.getSource(shader, count, string, length);
      GLctx.shaderSource(GL.shaders[shader], source);
    };
    var _emscripten_glStencilFunc = (x0, x1, x2) => GLctx.stencilFunc(x0, x1, x2);
    var _emscripten_glStencilFuncSeparate = (x0, x1, x2, x3) => GLctx.stencilFuncSeparate(x0, x1, x2, x3);
    var _emscripten_glStencilMask = (x0) => GLctx.stencilMask(x0);
    var _emscripten_glStencilMaskSeparate = (x0, x1) => GLctx.stencilMaskSeparate(x0, x1);
    var _emscripten_glStencilOp = (x0, x1, x2) => GLctx.stencilOp(x0, x1, x2);
    var _emscripten_glStencilOpSeparate = (x0, x1, x2, x3) => GLctx.stencilOpSeparate(x0, x1, x2, x3);
    var _emscripten_glTexImage2D = (target, level, internalFormat, width, height, border, format, type, pixels) => {
      if (GL.currentContext.version >= 2) {
        if (GLctx.currentPixelUnpackBufferBinding) {
          GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
          return;
        }
        if (pixels) {
          var heap = heapObjectForWebGLType(type);
          var index = toTypedArrayIndex(pixels, heap);
          GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, index);
          return;
        }
      }
      var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null;
      GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixelData);
    };
    var _emscripten_glTexImage3D = (target, level, internalFormat, width, height, depth, border, format, type, pixels) => {
      if (GLctx.currentPixelUnpackBufferBinding) {
        GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
      } else if (pixels) {
        var heap = heapObjectForWebGLType(type);
        GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, heap, toTypedArrayIndex(pixels, heap));
      } else {
        GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, null);
      }
    };
    var _emscripten_glTexParameterf = (x0, x1, x2) => GLctx.texParameterf(x0, x1, x2);
    var _emscripten_glTexParameterfv = (target, pname, params) => {
      var param = HEAPF32[params >> 2];
      GLctx.texParameterf(target, pname, param);
    };
    var _emscripten_glTexParameteri = (x0, x1, x2) => GLctx.texParameteri(x0, x1, x2);
    var _emscripten_glTexParameteriv = (target, pname, params) => {
      var param = HEAP32[params >> 2];
      GLctx.texParameteri(target, pname, param);
    };
    var _emscripten_glTexStorage2D = (x0, x1, x2, x3, x4) => GLctx.texStorage2D(x0, x1, x2, x3, x4);
    var _emscripten_glTexStorage3D = (x0, x1, x2, x3, x4, x5) => GLctx.texStorage3D(x0, x1, x2, x3, x4, x5);
    var _emscripten_glTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, type, pixels) => {
      if (GL.currentContext.version >= 2) {
        if (GLctx.currentPixelUnpackBufferBinding) {
          GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
          return;
        }
        if (pixels) {
          var heap = heapObjectForWebGLType(type);
          GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, toTypedArrayIndex(pixels, heap));
          return;
        }
      }
      var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0) : null;
      GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData);
    };
    var _emscripten_glTexSubImage3D = (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) => {
      if (GLctx.currentPixelUnpackBufferBinding) {
        GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
      } else if (pixels) {
        var heap = heapObjectForWebGLType(type);
        GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, heap, toTypedArrayIndex(pixels, heap));
      } else {
        GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null);
      }
    };
    var _emscripten_glTransformFeedbackVaryings = (program, count, varyings, bufferMode) => {
      program = GL.programs[program];
      var vars = [];
      for (var i2 = 0; i2 < count; i2++)
        vars.push(UTF8ToString(HEAPU32[varyings + i2 * 4 >> 2]));
      GLctx.transformFeedbackVaryings(program, vars, bufferMode);
    };
    var _emscripten_glUniform1f = (location, v0) => {
      GLctx.uniform1f(webglGetUniformLocation(location), v0);
    };
    var miniTempWebGLFloatBuffers = [];
    var _emscripten_glUniform1fv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count);
        return;
      }
      if (count <= 288) {
        var view = miniTempWebGLFloatBuffers[count];
        for (var i2 = 0; i2 < count; ++i2) {
          view[i2] = HEAPF32[value + 4 * i2 >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, value + count * 4 >> 2);
      }
      GLctx.uniform1fv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform1i = (location, v0) => {
      GLctx.uniform1i(webglGetUniformLocation(location), v0);
    };
    var miniTempWebGLIntBuffers = [];
    var _emscripten_glUniform1iv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, value >> 2, count);
        return;
      }
      if (count <= 288) {
        var view = miniTempWebGLIntBuffers[count];
        for (var i2 = 0; i2 < count; ++i2) {
          view[i2] = HEAP32[value + 4 * i2 >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, value + count * 4 >> 2);
      }
      GLctx.uniform1iv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform1ui = (location, v0) => {
      GLctx.uniform1ui(webglGetUniformLocation(location), v0);
    };
    var _emscripten_glUniform1uiv = (location, count, value) => {
      count && GLctx.uniform1uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count);
    };
    var _emscripten_glUniform2f = (location, v0, v1) => {
      GLctx.uniform2f(webglGetUniformLocation(location), v0, v1);
    };
    var _emscripten_glUniform2fv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2);
        return;
      }
      if (count <= 144) {
        count *= 2;
        var view = miniTempWebGLFloatBuffers[count];
        for (var i2 = 0; i2 < count; i2 += 2) {
          view[i2] = HEAPF32[value + 4 * i2 >> 2];
          view[i2 + 1] = HEAPF32[value + (4 * i2 + 4) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, value + count * 8 >> 2);
      }
      GLctx.uniform2fv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform2i = (location, v0, v1) => {
      GLctx.uniform2i(webglGetUniformLocation(location), v0, v1);
    };
    var _emscripten_glUniform2iv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 2);
        return;
      }
      if (count <= 144) {
        count *= 2;
        var view = miniTempWebGLIntBuffers[count];
        for (var i2 = 0; i2 < count; i2 += 2) {
          view[i2] = HEAP32[value + 4 * i2 >> 2];
          view[i2 + 1] = HEAP32[value + (4 * i2 + 4) >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, value + count * 8 >> 2);
      }
      GLctx.uniform2iv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform2ui = (location, v0, v1) => {
      GLctx.uniform2ui(webglGetUniformLocation(location), v0, v1);
    };
    var _emscripten_glUniform2uiv = (location, count, value) => {
      count && GLctx.uniform2uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count * 2);
    };
    var _emscripten_glUniform3f = (location, v0, v1, v2) => {
      GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2);
    };
    var _emscripten_glUniform3fv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 3);
        return;
      }
      if (count <= 96) {
        count *= 3;
        var view = miniTempWebGLFloatBuffers[count];
        for (var i2 = 0; i2 < count; i2 += 3) {
          view[i2] = HEAPF32[value + 4 * i2 >> 2];
          view[i2 + 1] = HEAPF32[value + (4 * i2 + 4) >> 2];
          view[i2 + 2] = HEAPF32[value + (4 * i2 + 8) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, value + count * 12 >> 2);
      }
      GLctx.uniform3fv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform3i = (location, v0, v1, v2) => {
      GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2);
    };
    var _emscripten_glUniform3iv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 3);
        return;
      }
      if (count <= 96) {
        count *= 3;
        var view = miniTempWebGLIntBuffers[count];
        for (var i2 = 0; i2 < count; i2 += 3) {
          view[i2] = HEAP32[value + 4 * i2 >> 2];
          view[i2 + 1] = HEAP32[value + (4 * i2 + 4) >> 2];
          view[i2 + 2] = HEAP32[value + (4 * i2 + 8) >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, value + count * 12 >> 2);
      }
      GLctx.uniform3iv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform3ui = (location, v0, v1, v2) => {
      GLctx.uniform3ui(webglGetUniformLocation(location), v0, v1, v2);
    };
    var _emscripten_glUniform3uiv = (location, count, value) => {
      count && GLctx.uniform3uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count * 3);
    };
    var _emscripten_glUniform4f = (location, v0, v1, v2, v3) => {
      GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
    };
    var _emscripten_glUniform4fv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4);
        return;
      }
      if (count <= 72) {
        var view = miniTempWebGLFloatBuffers[4 * count];
        var heap = HEAPF32;
        value = value >> 2;
        count *= 4;
        for (var i2 = 0; i2 < count; i2 += 4) {
          var dst = value + i2;
          view[i2] = heap[dst];
          view[i2 + 1] = heap[dst + 1];
          view[i2 + 2] = heap[dst + 2];
          view[i2 + 3] = heap[dst + 3];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2);
      }
      GLctx.uniform4fv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform4i = (location, v0, v1, v2, v3) => {
      GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3);
    };
    var _emscripten_glUniform4iv = (location, count, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4);
        return;
      }
      if (count <= 72) {
        count *= 4;
        var view = miniTempWebGLIntBuffers[count];
        for (var i2 = 0; i2 < count; i2 += 4) {
          view[i2] = HEAP32[value + 4 * i2 >> 2];
          view[i2 + 1] = HEAP32[value + (4 * i2 + 4) >> 2];
          view[i2 + 2] = HEAP32[value + (4 * i2 + 8) >> 2];
          view[i2 + 3] = HEAP32[value + (4 * i2 + 12) >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, value + count * 16 >> 2);
      }
      GLctx.uniform4iv(webglGetUniformLocation(location), view);
    };
    var _emscripten_glUniform4ui = (location, v0, v1, v2, v3) => {
      GLctx.uniform4ui(webglGetUniformLocation(location), v0, v1, v2, v3);
    };
    var _emscripten_glUniform4uiv = (location, count, value) => {
      count && GLctx.uniform4uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count * 4);
    };
    var _emscripten_glUniformBlockBinding = (program, uniformBlockIndex, uniformBlockBinding) => {
      program = GL.programs[program];
      GLctx.uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
    };
    var _emscripten_glUniformMatrix2fv = (location, count, transpose, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 4);
        return;
      }
      if (count <= 72) {
        count *= 4;
        var view = miniTempWebGLFloatBuffers[count];
        for (var i2 = 0; i2 < count; i2 += 4) {
          view[i2] = HEAPF32[value + 4 * i2 >> 2];
          view[i2 + 1] = HEAPF32[value + (4 * i2 + 4) >> 2];
          view[i2 + 2] = HEAPF32[value + (4 * i2 + 8) >> 2];
          view[i2 + 3] = HEAPF32[value + (4 * i2 + 12) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2);
      }
      GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view);
    };
    var _emscripten_glUniformMatrix2x3fv = (location, count, transpose, value) => {
      count && GLctx.uniformMatrix2x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 6);
    };
    var _emscripten_glUniformMatrix2x4fv = (location, count, transpose, value) => {
      count && GLctx.uniformMatrix2x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 8);
    };
    var _emscripten_glUniformMatrix3fv = (location, count, transpose, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 9);
        return;
      }
      if (count <= 32) {
        count *= 9;
        var view = miniTempWebGLFloatBuffers[count];
        for (var i2 = 0; i2 < count; i2 += 9) {
          view[i2] = HEAPF32[value + 4 * i2 >> 2];
          view[i2 + 1] = HEAPF32[value + (4 * i2 + 4) >> 2];
          view[i2 + 2] = HEAPF32[value + (4 * i2 + 8) >> 2];
          view[i2 + 3] = HEAPF32[value + (4 * i2 + 12) >> 2];
          view[i2 + 4] = HEAPF32[value + (4 * i2 + 16) >> 2];
          view[i2 + 5] = HEAPF32[value + (4 * i2 + 20) >> 2];
          view[i2 + 6] = HEAPF32[value + (4 * i2 + 24) >> 2];
          view[i2 + 7] = HEAPF32[value + (4 * i2 + 28) >> 2];
          view[i2 + 8] = HEAPF32[value + (4 * i2 + 32) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, value + count * 36 >> 2);
      }
      GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view);
    };
    var _emscripten_glUniformMatrix3x2fv = (location, count, transpose, value) => {
      count && GLctx.uniformMatrix3x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 6);
    };
    var _emscripten_glUniformMatrix3x4fv = (location, count, transpose, value) => {
      count && GLctx.uniformMatrix3x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 12);
    };
    var _emscripten_glUniformMatrix4fv = (location, count, transpose, value) => {
      if (GL.currentContext.version >= 2) {
        count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 16);
        return;
      }
      if (count <= 18) {
        var view = miniTempWebGLFloatBuffers[16 * count];
        var heap = HEAPF32;
        value = value >> 2;
        count *= 16;
        for (var i2 = 0; i2 < count; i2 += 16) {
          var dst = value + i2;
          view[i2] = heap[dst];
          view[i2 + 1] = heap[dst + 1];
          view[i2 + 2] = heap[dst + 2];
          view[i2 + 3] = heap[dst + 3];
          view[i2 + 4] = heap[dst + 4];
          view[i2 + 5] = heap[dst + 5];
          view[i2 + 6] = heap[dst + 6];
          view[i2 + 7] = heap[dst + 7];
          view[i2 + 8] = heap[dst + 8];
          view[i2 + 9] = heap[dst + 9];
          view[i2 + 10] = heap[dst + 10];
          view[i2 + 11] = heap[dst + 11];
          view[i2 + 12] = heap[dst + 12];
          view[i2 + 13] = heap[dst + 13];
          view[i2 + 14] = heap[dst + 14];
          view[i2 + 15] = heap[dst + 15];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, value + count * 64 >> 2);
      }
      GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view);
    };
    var _emscripten_glUniformMatrix4x2fv = (location, count, transpose, value) => {
      count && GLctx.uniformMatrix4x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 8);
    };
    var _emscripten_glUniformMatrix4x3fv = (location, count, transpose, value) => {
      count && GLctx.uniformMatrix4x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 12);
    };
    var _emscripten_glUseProgram = (program) => {
      program = GL.programs[program];
      GLctx.useProgram(program);
      GLctx.currentProgram = program;
    };
    var _emscripten_glValidateProgram = (program) => {
      GLctx.validateProgram(GL.programs[program]);
    };
    var _emscripten_glVertexAttrib1f = (x0, x1) => GLctx.vertexAttrib1f(x0, x1);
    var _emscripten_glVertexAttrib1fv = (index, v) => {
      GLctx.vertexAttrib1f(index, HEAPF32[v >> 2]);
    };
    var _emscripten_glVertexAttrib2f = (x0, x1, x2) => GLctx.vertexAttrib2f(x0, x1, x2);
    var _emscripten_glVertexAttrib2fv = (index, v) => {
      GLctx.vertexAttrib2f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2]);
    };
    var _emscripten_glVertexAttrib3f = (x0, x1, x2, x3) => GLctx.vertexAttrib3f(x0, x1, x2, x3);
    var _emscripten_glVertexAttrib3fv = (index, v) => {
      GLctx.vertexAttrib3f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2]);
    };
    var _emscripten_glVertexAttrib4f = (x0, x1, x2, x3, x4) => GLctx.vertexAttrib4f(x0, x1, x2, x3, x4);
    var _emscripten_glVertexAttrib4fv = (index, v) => {
      GLctx.vertexAttrib4f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2], HEAPF32[v + 12 >> 2]);
    };
    var _emscripten_glVertexAttribDivisor = (index, divisor) => {
      GLctx.vertexAttribDivisor(index, divisor);
    };
    var _glVertexAttribDivisor = _emscripten_glVertexAttribDivisor;
    var _emscripten_glVertexAttribDivisorANGLE = _glVertexAttribDivisor;
    var _emscripten_glVertexAttribDivisorARB = _glVertexAttribDivisor;
    var _emscripten_glVertexAttribDivisorEXT = _glVertexAttribDivisor;
    var _emscripten_glVertexAttribDivisorNV = _glVertexAttribDivisor;
    var _emscripten_glVertexAttribI4i = (x0, x1, x2, x3, x4) => GLctx.vertexAttribI4i(x0, x1, x2, x3, x4);
    var _emscripten_glVertexAttribI4iv = (index, v) => {
      GLctx.vertexAttribI4i(index, HEAP32[v >> 2], HEAP32[v + 4 >> 2], HEAP32[v + 8 >> 2], HEAP32[v + 12 >> 2]);
    };
    var _emscripten_glVertexAttribI4ui = (x0, x1, x2, x3, x4) => GLctx.vertexAttribI4ui(x0, x1, x2, x3, x4);
    var _emscripten_glVertexAttribI4uiv = (index, v) => {
      GLctx.vertexAttribI4ui(index, HEAPU32[v >> 2], HEAPU32[v + 4 >> 2], HEAPU32[v + 8 >> 2], HEAPU32[v + 12 >> 2]);
    };
    var _emscripten_glVertexAttribIPointer = (index, size, type, stride, ptr) => {
      GLctx.vertexAttribIPointer(index, size, type, stride, ptr);
    };
    var _emscripten_glVertexAttribPointer = (index, size, type, normalized, stride, ptr) => {
      GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
    };
    var _emscripten_glViewport = (x0, x1, x2, x3) => GLctx.viewport(x0, x1, x2, x3);
    var _emscripten_glWaitSync = (sync, flags, timeout) => {
      timeout = Number(timeout);
      GLctx.waitSync(GL.syncs[sync], flags, timeout);
    };
    var getHeapMax = () => (
      // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
      // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
      // for any code that deals with heap sizes, which would require special
      // casing all heap size related code to treat 0 specially.
      2147483648
    );
    var growMemory = (size) => {
      var oldHeapSize = wasmMemory.buffer.byteLength;
      var pages = (size - oldHeapSize + 65535) / 65536 | 0;
      try {
        wasmMemory.grow(pages);
        updateMemoryViews();
        return 1;
      } catch (e) {
        err(`growMemory: Attempted to grow heap from ${oldHeapSize} bytes to ${size} bytes, but got error: ${e}`);
      }
    };
    var _emscripten_resize_heap = (requestedSize) => {
      var oldSize = HEAPU8.length;
      requestedSize >>>= 0;
      assert(requestedSize > oldSize);
      var maxHeapSize = getHeapMax();
      if (requestedSize > maxHeapSize) {
        err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
        return false;
      }
      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
        var overGrownHeapSize = oldSize * (1 + 0.8 / cutDown);
        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
        var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
        var replacement = growMemory(newSize);
        if (replacement) {
          return true;
        }
      }
      err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
      return false;
    };
    var ENV = {};
    var getExecutableName = () => thisProgram || "./this.program";
    var getEnvStrings = () => {
      if (!getEnvStrings.strings) {
        var lang = (globalThis.navigator?.language ?? "C").replace("-", "_") + ".UTF-8";
        var env = {
          "USER": "web_user",
          "LOGNAME": "web_user",
          "PATH": "/",
          "PWD": "/",
          "HOME": "/home/web_user",
          "LANG": lang,
          "_": getExecutableName()
        };
        for (var x in ENV) {
          if (ENV[x] === void 0) delete env[x];
          else env[x] = ENV[x];
        }
        var strings = [];
        for (var x in env) {
          strings.push(`${x}=${env[x]}`);
        }
        getEnvStrings.strings = strings;
      }
      return getEnvStrings.strings;
    };
    var _environ_get = (__environ, environ_buf) => {
      var bufSize = 0;
      var envp = 0;
      for (var string of getEnvStrings()) {
        var ptr = environ_buf + bufSize;
        HEAPU32[__environ + envp >> 2] = ptr;
        bufSize += stringToUTF8(string, ptr, Infinity) + 1;
        envp += 4;
      }
      return 0;
    };
    var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
      var strings = getEnvStrings();
      HEAPU32[penviron_count >> 2] = strings.length;
      var bufSize = 0;
      for (var string of strings) {
        bufSize += lengthBytesUTF8(string) + 1;
      }
      HEAPU32[penviron_buf_size >> 2] = bufSize;
      return 0;
    };
    var runtimeKeepaliveCounter = 0;
    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
    var _proc_exit = (code) => {
      EXITSTATUS = code;
      if (!keepRuntimeAlive()) {
        Module["onExit"]?.(code);
        ABORT = true;
      }
      quit_(code, new ExitStatus(code));
    };
    var exitJS = (status, implicit) => {
      EXITSTATUS = status;
      checkUnflushedContent();
      if (keepRuntimeAlive() && !implicit) {
        var msg = `program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`;
        readyPromiseReject?.(msg);
        err(msg);
      }
      _proc_exit(status);
    };
    var _exit = exitJS;
    function _fd_close(fd) {
      try {
        var stream = SYSCALLS.getStreamFromFD(fd);
        FS.close(stream);
        return 0;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return e.errno;
      }
    }
    var doReadv = (stream, iov, iovcnt, offset) => {
      var ret = 0;
      for (var i2 = 0; i2 < iovcnt; i2++) {
        var ptr = HEAPU32[iov >> 2];
        var len = HEAPU32[iov + 4 >> 2];
        iov += 8;
        var curr = FS.read(stream, HEAP8, ptr, len, offset);
        if (curr < 0) return -1;
        ret += curr;
        if (curr < len) break;
        if (typeof offset != "undefined") {
          offset += curr;
        }
      }
      return ret;
    };
    function _fd_pread(fd, iov, iovcnt, offset, pnum) {
      offset = bigintToI53Checked(offset);
      try {
        if (isNaN(offset)) return 61;
        var stream = SYSCALLS.getStreamFromFD(fd);
        var num = doReadv(stream, iov, iovcnt, offset);
        HEAPU32[pnum >> 2] = num;
        return 0;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return e.errno;
      }
      ;
    }
    function _fd_read(fd, iov, iovcnt, pnum) {
      try {
        var stream = SYSCALLS.getStreamFromFD(fd);
        var num = doReadv(stream, iov, iovcnt);
        HEAPU32[pnum >> 2] = num;
        return 0;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return e.errno;
      }
    }
    function _fd_seek(fd, offset, whence, newOffset) {
      offset = bigintToI53Checked(offset);
      try {
        if (isNaN(offset)) return 61;
        var stream = SYSCALLS.getStreamFromFD(fd);
        FS.llseek(stream, offset, whence);
        HEAP64[newOffset >> 3] = BigInt(stream.position);
        if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
        return 0;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return e.errno;
      }
      ;
    }
    var doWritev = (stream, iov, iovcnt, offset) => {
      var ret = 0;
      for (var i2 = 0; i2 < iovcnt; i2++) {
        var ptr = HEAPU32[iov >> 2];
        var len = HEAPU32[iov + 4 >> 2];
        iov += 8;
        var curr = FS.write(stream, HEAP8, ptr, len, offset);
        if (curr < 0) return -1;
        ret += curr;
        if (curr < len) {
          break;
        }
        if (typeof offset != "undefined") {
          offset += curr;
        }
      }
      return ret;
    };
    function _fd_write(fd, iov, iovcnt, pnum) {
      try {
        var stream = SYSCALLS.getStreamFromFD(fd);
        var num = doWritev(stream, iov, iovcnt);
        HEAPU32[pnum >> 2] = num;
        return 0;
      } catch (e) {
        if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
        return e.errno;
      }
    }
    var _glGetIntegerv = _emscripten_glGetIntegerv;
    var _glGetString = _emscripten_glGetString;
    var _glGetStringi = _emscripten_glGetStringi;
    var _llvm_eh_typeid_for = (type) => type;
    var _random_get = (buffer, size) => randomFill(HEAPU8.subarray(buffer, buffer + size));
    function _wapi_cancelAnimationFrame(frameId) {
      if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
        clearTimeout(frameId);
      } else {
        return window.cancelAnimationFrame(frameId);
      }
    }
    function _wapi_requestAnimationFrame() {
      if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
        setTimeout(Module._process_animation_frame);
      } else {
        return window.requestAnimationFrame(Module._process_animation_frame);
      }
    }
    var handleException = (e) => {
      if (e instanceof ExitStatus || e == "unwind") {
        return EXITSTATUS;
      }
      checkStackCookie();
      if (e instanceof WebAssembly.RuntimeError) {
        if (_emscripten_stack_get_current() <= 0) {
          err("Stack overflow detected.  You can try increasing -sSTACK_SIZE (currently set to 65536)");
        }
      }
      quit_(1, e);
    };
    var stringToUTF8OnStack = (str) => {
      var size = lengthBytesUTF8(str) + 1;
      var ret = stackAlloc(size);
      stringToUTF8(str, ret, size);
      return ret;
    };
    var getWasmTableEntry = (funcPtr) => {
      return wasmTable.get(funcPtr);
    };
    FS.createPreloadedFile = FS_createPreloadedFile;
    FS.preloadFile = FS_preloadFile;
    FS.staticInit();
    ;
    for (let i2 = 0; i2 < 32; ++i2) tempFixedLengthArray.push(new Array(i2));
    ;
    var miniTempWebGLFloatBuffersStorage = new Float32Array(288);
    for (var i = 0; i <= 288; ++i) {
      miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i);
    }
    ;
    var miniTempWebGLIntBuffersStorage = new Int32Array(288);
    for (var i = 0; i <= 288; ++i) {
      miniTempWebGLIntBuffers[i] = miniTempWebGLIntBuffersStorage.subarray(0, i);
    }
    ;
    {
      if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
      if (Module["preloadPlugins"]) preloadPlugins = Module["preloadPlugins"];
      if (Module["print"]) out = Module["print"];
      if (Module["printErr"]) err = Module["printErr"];
      if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
      checkIncomingModuleAPI();
      if (Module["arguments"]) arguments_ = Module["arguments"];
      if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
      assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
      assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
      assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
      assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
      assert(typeof Module["read"] == "undefined", "Module.read option was removed");
      assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
      assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
      assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");
      assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
      assert(typeof Module["ENVIRONMENT"] == "undefined", "Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
      assert(typeof Module["STACK_SIZE"] == "undefined", "STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time");
      assert(typeof Module["wasmMemory"] == "undefined", "Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally");
      assert(typeof Module["INITIAL_MEMORY"] == "undefined", "Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically");
      if (Module["preInit"]) {
        if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
        while (Module["preInit"].length > 0) {
          Module["preInit"].shift()();
        }
      }
      consumedModuleProp("preInit");
    }
    Module["stringToUTF8"] = stringToUTF8;
    Module["GL"] = GL;
    var missingLibrarySymbols = [
      "writeI53ToI64Clamped",
      "writeI53ToI64Signaling",
      "writeI53ToU64Clamped",
      "writeI53ToU64Signaling",
      "convertI32PairToI53",
      "convertI32PairToI53Checked",
      "convertU32PairToI53",
      "getTempRet0",
      "createNamedFunction",
      "withStackSave",
      "inetPton4",
      "inetNtop4",
      "inetPton6",
      "inetNtop6",
      "readSockaddr",
      "writeSockaddr",
      "readEmAsmArgs",
      "autoResumeAudioContext",
      "getDynCaller",
      "dynCall",
      "setWasmTableEntry",
      "runtimeKeepalivePush",
      "runtimeKeepalivePop",
      "callUserCallback",
      "maybeExit",
      "asmjsMangle",
      "HandleAllocator",
      "addOnInit",
      "addOnPostCtor",
      "addOnPreMain",
      "addOnExit",
      "STACK_SIZE",
      "STACK_ALIGN",
      "POINTER_SIZE",
      "ASSERTIONS",
      "ccall",
      "cwrap",
      "convertJsFunctionToWasm",
      "getEmptyTableSlot",
      "updateTableMap",
      "getFunctionAddress",
      "addFunction",
      "removeFunction",
      "intArrayToString",
      "AsciiToString",
      "stringToAscii",
      "UTF16ToString",
      "stringToUTF16",
      "lengthBytesUTF16",
      "UTF32ToString",
      "stringToUTF32",
      "lengthBytesUTF32",
      "writeArrayToMemory",
      "registerKeyEventCallback",
      "maybeCStringToJsString",
      "findEventTarget",
      "getBoundingClientRect",
      "fillMouseEventData",
      "registerMouseEventCallback",
      "registerWheelEventCallback",
      "registerUiEventCallback",
      "registerFocusEventCallback",
      "fillDeviceOrientationEventData",
      "registerDeviceOrientationEventCallback",
      "fillDeviceMotionEventData",
      "registerDeviceMotionEventCallback",
      "screenOrientation",
      "fillOrientationChangeEventData",
      "registerOrientationChangeEventCallback",
      "fillFullscreenChangeEventData",
      "registerFullscreenChangeEventCallback",
      "JSEvents_requestFullscreen",
      "JSEvents_resizeCanvasForFullscreen",
      "registerRestoreOldStyle",
      "hideEverythingExceptGivenElement",
      "restoreHiddenElements",
      "setLetterbox",
      "softFullscreenResizeWebGLRenderTarget",
      "doRequestFullscreen",
      "fillPointerlockChangeEventData",
      "registerPointerlockChangeEventCallback",
      "registerPointerlockErrorEventCallback",
      "requestPointerLock",
      "fillVisibilityChangeEventData",
      "registerVisibilityChangeEventCallback",
      "registerTouchEventCallback",
      "fillGamepadEventData",
      "registerGamepadEventCallback",
      "registerBeforeUnloadEventCallback",
      "fillBatteryEventData",
      "registerBatteryEventCallback",
      "setCanvasElementSize",
      "getCanvasElementSize",
      "jsStackTrace",
      "getCallstack",
      "convertPCtoSourceLocation",
      "wasiRightsToMuslOFlags",
      "wasiOFlagsToMuslOFlags",
      "safeSetTimeout",
      "setImmediateWrapped",
      "safeRequestAnimationFrame",
      "clearImmediateWrapped",
      "registerPostMainLoop",
      "registerPreMainLoop",
      "getPromise",
      "makePromise",
      "idsToPromises",
      "makePromiseCallback",
      "incrementUncaughtExceptionCount",
      "decrementUncaughtExceptionCount",
      "Browser_asyncPrepareDataCounter",
      "isLeapYear",
      "ydayFromDate",
      "arraySum",
      "addDays",
      "getSocketFromFD",
      "getSocketAddress",
      "FS_mkdirTree",
      "_setNetworkCallback",
      "writeGLArray",
      "registerWebGlEventCallback",
      "runAndAbortIfError",
      "ALLOC_NORMAL",
      "ALLOC_STACK",
      "allocate",
      "writeStringToMemory",
      "writeAsciiToMemory",
      "allocateUTF8",
      "allocateUTF8OnStack",
      "demangle",
      "stackTrace",
      "getNativeTypeSize"
    ];
    missingLibrarySymbols.forEach(missingLibrarySymbol);
    var unexportedSymbols = [
      "run",
      "out",
      "err",
      "callMain",
      "abort",
      "wasmExports",
      "writeStackCookie",
      "checkStackCookie",
      "writeI53ToI64",
      "readI53FromI64",
      "readI53FromU64",
      "INT53_MAX",
      "INT53_MIN",
      "bigintToI53Checked",
      "HEAP8",
      "HEAP16",
      "HEAPU16",
      "HEAPF64",
      "HEAP64",
      "HEAPU64",
      "stackSave",
      "stackRestore",
      "stackAlloc",
      "setTempRet0",
      "ptrToString",
      "zeroMemory",
      "exitJS",
      "getHeapMax",
      "growMemory",
      "ENV",
      "ERRNO_CODES",
      "strError",
      "DNS",
      "Protocols",
      "Sockets",
      "timers",
      "warnOnce",
      "readEmAsmArgsArray",
      "jstoi_q",
      "getExecutableName",
      "getWasmTableEntry",
      "handleException",
      "keepRuntimeAlive",
      "asyncLoad",
      "alignMemory",
      "mmapAlloc",
      "wasmTable",
      "wasmMemory",
      "getUniqueRunDependency",
      "noExitRuntime",
      "addRunDependency",
      "removeRunDependency",
      "addOnPreRun",
      "addOnPostRun",
      "freeTableIndexes",
      "functionsInTableMap",
      "setValue",
      "getValue",
      "PATH",
      "PATH_FS",
      "UTF8Decoder",
      "UTF8ArrayToString",
      "UTF8ToString",
      "stringToUTF8Array",
      "lengthBytesUTF8",
      "intArrayFromString",
      "UTF16Decoder",
      "stringToNewUTF8",
      "stringToUTF8OnStack",
      "JSEvents",
      "specialHTMLTargets",
      "findCanvasEventTarget",
      "currentFullscreenStrategy",
      "restoreOldWindowedStyle",
      "UNWIND_CACHE",
      "ExitStatus",
      "getEnvStrings",
      "checkWasiClock",
      "doReadv",
      "doWritev",
      "initRandomFill",
      "randomFill",
      "emSetImmediate",
      "emClearImmediate_deps",
      "emClearImmediate",
      "promiseMap",
      "uncaughtExceptionCount",
      "exceptionLast",
      "exceptionCaught",
      "ExceptionInfo",
      "findMatchingCatch",
      "getExceptionMessageCommon",
      "incrementExceptionRefcount",
      "decrementExceptionRefcount",
      "getExceptionMessage",
      "Browser",
      "requestFullscreen",
      "requestFullScreen",
      "setCanvasSize",
      "getUserMedia",
      "createContext",
      "getPreloadedImageData__data",
      "wget",
      "MONTH_DAYS_REGULAR",
      "MONTH_DAYS_LEAP",
      "MONTH_DAYS_REGULAR_CUMULATIVE",
      "MONTH_DAYS_LEAP_CUMULATIVE",
      "SYSCALLS",
      "preloadPlugins",
      "FS_createPreloadedFile",
      "FS_preloadFile",
      "FS_modeStringToFlags",
      "FS_getMode",
      "FS_fileDataToTypedArray",
      "FS_stdin_getChar_buffer",
      "FS_stdin_getChar",
      "FS_unlink",
      "FS_createPath",
      "FS_createDevice",
      "FS_readFile",
      "FS",
      "FS_root",
      "FS_mounts",
      "FS_devices",
      "FS_streams",
      "FS_nextInode",
      "FS_nameTable",
      "FS_currentPath",
      "FS_initialized",
      "FS_ignorePermissions",
      "FS_filesystems",
      "FS_syncFSRequests",
      "FS_lookupPath",
      "FS_getPath",
      "FS_hashName",
      "FS_hashAddNode",
      "FS_hashRemoveNode",
      "FS_lookupNode",
      "FS_createNode",
      "FS_destroyNode",
      "FS_isRoot",
      "FS_isMountpoint",
      "FS_isFile",
      "FS_isDir",
      "FS_isLink",
      "FS_isChrdev",
      "FS_isBlkdev",
      "FS_isFIFO",
      "FS_isSocket",
      "FS_flagsToPermissionString",
      "FS_nodePermissions",
      "FS_mayLookup",
      "FS_mayCreate",
      "FS_mayDelete",
      "FS_mayOpen",
      "FS_checkOpExists",
      "FS_nextfd",
      "FS_getStreamChecked",
      "FS_getStream",
      "FS_createStream",
      "FS_closeStream",
      "FS_dupStream",
      "FS_doSetAttr",
      "FS_chrdev_stream_ops",
      "FS_major",
      "FS_minor",
      "FS_makedev",
      "FS_registerDevice",
      "FS_getDevice",
      "FS_getMounts",
      "FS_syncfs",
      "FS_mount",
      "FS_unmount",
      "FS_lookup",
      "FS_mknod",
      "FS_statfs",
      "FS_statfsStream",
      "FS_statfsNode",
      "FS_create",
      "FS_mkdir",
      "FS_mkdev",
      "FS_symlink",
      "FS_rename",
      "FS_rmdir",
      "FS_readdir",
      "FS_readlink",
      "FS_stat",
      "FS_fstat",
      "FS_lstat",
      "FS_doChmod",
      "FS_chmod",
      "FS_lchmod",
      "FS_fchmod",
      "FS_doChown",
      "FS_chown",
      "FS_lchown",
      "FS_fchown",
      "FS_doTruncate",
      "FS_truncate",
      "FS_ftruncate",
      "FS_utime",
      "FS_open",
      "FS_close",
      "FS_isClosed",
      "FS_llseek",
      "FS_read",
      "FS_write",
      "FS_mmap",
      "FS_msync",
      "FS_ioctl",
      "FS_writeFile",
      "FS_cwd",
      "FS_chdir",
      "FS_createDefaultDirectories",
      "FS_createDefaultDevices",
      "FS_createSpecialDirectories",
      "FS_createStandardStreams",
      "FS_staticInit",
      "FS_init",
      "FS_quit",
      "FS_findObject",
      "FS_analyzePath",
      "FS_createFile",
      "FS_createDataFile",
      "FS_forceLoadFile",
      "FS_createLazyFile",
      "MEMFS",
      "TTY",
      "PIPEFS",
      "SOCKFS",
      "tempFixedLengthArray",
      "miniTempWebGLFloatBuffers",
      "miniTempWebGLIntBuffers",
      "heapObjectForWebGLType",
      "toTypedArrayIndex",
      "webgl_enable_ANGLE_instanced_arrays",
      "webgl_enable_OES_vertex_array_object",
      "webgl_enable_WEBGL_draw_buffers",
      "webgl_enable_WEBGL_multi_draw",
      "webgl_enable_EXT_polygon_offset_clamp",
      "webgl_enable_EXT_clip_control",
      "webgl_enable_WEBGL_polygon_mode",
      "emscriptenWebGLGet",
      "computeUnpackAlignedImageSize",
      "colorChannelsInGlTextureFormat",
      "emscriptenWebGLGetTexPixelData",
      "emscriptenWebGLGetUniform",
      "webglGetUniformLocation",
      "webglPrepareUniformLocationsBeforeFirstUse",
      "webglGetLeftBracePos",
      "emscriptenWebGLGetVertexAttrib",
      "__glGetActiveAttribOrUniform",
      "AL",
      "GLUT",
      "EGL",
      "GLEW",
      "IDBStore",
      "SDL",
      "SDL_gfx",
      "emscriptenWebGLGetIndexed",
      "webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance",
      "webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance",
      "print",
      "printErr",
      "jstoi_s"
    ];
    unexportedSymbols.forEach(unexportedRuntimeSymbol);
    function checkIncomingModuleAPI() {
      ignoredModuleProp("fetchSettings");
      ignoredModuleProp("logReadFiles");
      ignoredModuleProp("loadSplitModule");
      ignoredModuleProp("onMalloc");
      ignoredModuleProp("onRealloc");
      ignoredModuleProp("onFree");
      ignoredModuleProp("onSbrkGrow");
    }
    var _clear_shape_layout = Module["_clear_shape_layout"] = makeInvalidEarlyAccess("_clear_shape_layout");
    var _set_layout_data = Module["_set_layout_data"] = makeInvalidEarlyAccess("_set_layout_data");
    var _set_shape_vertical_align = Module["_set_shape_vertical_align"] = makeInvalidEarlyAccess("_set_shape_vertical_align");
    var _add_shape_child = Module["_add_shape_child"] = makeInvalidEarlyAccess("_add_shape_child");
    var _add_shape_shadow = Module["_add_shape_shadow"] = makeInvalidEarlyAccess("_add_shape_shadow");
    var _calculate_bool = Module["_calculate_bool"] = makeInvalidEarlyAccess("_calculate_bool");
    var _free_bytes = Module["_free_bytes"] = makeInvalidEarlyAccess("_free_bytes");
    var _calculate_position_data = Module["_calculate_position_data"] = makeInvalidEarlyAccess("_calculate_position_data");
    var _clean_modifiers = Module["_clean_modifiers"] = makeInvalidEarlyAccess("_clean_modifiers");
    var _clean_up = Module["_clean_up"] = makeInvalidEarlyAccess("_clean_up");
    var _clear_focus_mode = Module["_clear_focus_mode"] = makeInvalidEarlyAccess("_clear_focus_mode");
    var _clear_shape_shadows = Module["_clear_shape_shadows"] = makeInvalidEarlyAccess("_clear_shape_shadows");
    var _clear_shape_text = Module["_clear_shape_text"] = makeInvalidEarlyAccess("_clear_shape_text");
    var _end_temp_objects = Module["_end_temp_objects"] = makeInvalidEarlyAccess("_end_temp_objects");
    var _get_caret_position_at = Module["_get_caret_position_at"] = makeInvalidEarlyAccess("_get_caret_position_at");
    var _get_grid_coords = Module["_get_grid_coords"] = makeInvalidEarlyAccess("_get_grid_coords");
    var _get_selection_rect = Module["_get_selection_rect"] = makeInvalidEarlyAccess("_get_selection_rect");
    var _get_text_dimensions = Module["_get_text_dimensions"] = makeInvalidEarlyAccess("_get_text_dimensions");
    var _hide_grid = Module["_hide_grid"] = makeInvalidEarlyAccess("_hide_grid");
    var _init = Module["_init"] = makeInvalidEarlyAccess("_init");
    var _init_shapes_pool = Module["_init_shapes_pool"] = makeInvalidEarlyAccess("_init_shapes_pool");
    var _intersect_position_in_shape = Module["_intersect_position_in_shape"] = makeInvalidEarlyAccess("_intersect_position_in_shape");
    var _is_image_cached = Module["_is_image_cached"] = makeInvalidEarlyAccess("_is_image_cached");
    var _process_animation_frame = Module["_process_animation_frame"] = makeInvalidEarlyAccess("_process_animation_frame");
    var _render = Module["_render"] = makeInvalidEarlyAccess("_render");
    var _render_from_cache = Module["_render_from_cache"] = makeInvalidEarlyAccess("_render_from_cache");
    var _render_preview = Module["_render_preview"] = makeInvalidEarlyAccess("_render_preview");
    var _render_sync = Module["_render_sync"] = makeInvalidEarlyAccess("_render_sync");
    var _render_sync_shape = Module["_render_sync_shape"] = makeInvalidEarlyAccess("_render_sync_shape");
    var _reset_canvas = Module["_reset_canvas"] = makeInvalidEarlyAccess("_reset_canvas");
    var _resize_viewbox = Module["_resize_viewbox"] = makeInvalidEarlyAccess("_resize_viewbox");
    var _set_browser = Module["_set_browser"] = makeInvalidEarlyAccess("_set_browser");
    var _set_canvas_background = Module["_set_canvas_background"] = makeInvalidEarlyAccess("_set_canvas_background");
    var _set_children = Module["_set_children"] = makeInvalidEarlyAccess("_set_children");
    var _set_children_0 = Module["_set_children_0"] = makeInvalidEarlyAccess("_set_children_0");
    var _set_children_1 = Module["_set_children_1"] = makeInvalidEarlyAccess("_set_children_1");
    var _set_children_2 = Module["_set_children_2"] = makeInvalidEarlyAccess("_set_children_2");
    var _set_children_3 = Module["_set_children_3"] = makeInvalidEarlyAccess("_set_children_3");
    var _set_children_4 = Module["_set_children_4"] = makeInvalidEarlyAccess("_set_children_4");
    var _set_children_5 = Module["_set_children_5"] = makeInvalidEarlyAccess("_set_children_5");
    var _set_flex_layout_data = Module["_set_flex_layout_data"] = makeInvalidEarlyAccess("_set_flex_layout_data");
    var _set_focus_mode = Module["_set_focus_mode"] = makeInvalidEarlyAccess("_set_focus_mode");
    var _set_grid_cells = Module["_set_grid_cells"] = makeInvalidEarlyAccess("_set_grid_cells");
    var _set_grid_columns = Module["_set_grid_columns"] = makeInvalidEarlyAccess("_set_grid_columns");
    var _set_grid_layout_data = Module["_set_grid_layout_data"] = makeInvalidEarlyAccess("_set_grid_layout_data");
    var _set_grid_rows = Module["_set_grid_rows"] = makeInvalidEarlyAccess("_set_grid_rows");
    var _set_modifiers = Module["_set_modifiers"] = makeInvalidEarlyAccess("_set_modifiers");
    var _set_parent = Module["_set_parent"] = makeInvalidEarlyAccess("_set_parent");
    var _set_preview_mode = Module["_set_preview_mode"] = makeInvalidEarlyAccess("_set_preview_mode");
    var _set_render_options = Module["_set_render_options"] = makeInvalidEarlyAccess("_set_render_options");
    var _set_shape_bool_type = Module["_set_shape_bool_type"] = makeInvalidEarlyAccess("_set_shape_bool_type");
    var _set_shape_clip_content = Module["_set_shape_clip_content"] = makeInvalidEarlyAccess("_set_shape_clip_content");
    var _set_shape_corners = Module["_set_shape_corners"] = makeInvalidEarlyAccess("_set_shape_corners");
    var _set_shape_grow_type = Module["_set_shape_grow_type"] = makeInvalidEarlyAccess("_set_shape_grow_type");
    var _set_shape_hidden = Module["_set_shape_hidden"] = makeInvalidEarlyAccess("_set_shape_hidden");
    var _set_shape_masked_group = Module["_set_shape_masked_group"] = makeInvalidEarlyAccess("_set_shape_masked_group");
    var _set_shape_opacity = Module["_set_shape_opacity"] = makeInvalidEarlyAccess("_set_shape_opacity");
    var _set_shape_rotation = Module["_set_shape_rotation"] = makeInvalidEarlyAccess("_set_shape_rotation");
    var _set_shape_selrect = Module["_set_shape_selrect"] = makeInvalidEarlyAccess("_set_shape_selrect");
    var _set_shape_svg_attrs = Module["_set_shape_svg_attrs"] = makeInvalidEarlyAccess("_set_shape_svg_attrs");
    var _set_shape_svg_raw_content = Module["_set_shape_svg_raw_content"] = makeInvalidEarlyAccess("_set_shape_svg_raw_content");
    var _set_shape_text_content = Module["_set_shape_text_content"] = makeInvalidEarlyAccess("_set_shape_text_content");
    var _set_shape_transform = Module["_set_shape_transform"] = makeInvalidEarlyAccess("_set_shape_transform");
    var _set_structure_modifiers = Module["_set_structure_modifiers"] = makeInvalidEarlyAccess("_set_structure_modifiers");
    var _set_view = Module["_set_view"] = makeInvalidEarlyAccess("_set_view");
    var _set_view_end = Module["_set_view_end"] = makeInvalidEarlyAccess("_set_view_end");
    var _set_view_start = Module["_set_view_start"] = makeInvalidEarlyAccess("_set_view_start");
    var _show_grid = Module["_show_grid"] = makeInvalidEarlyAccess("_show_grid");
    var _start_temp_objects = Module["_start_temp_objects"] = makeInvalidEarlyAccess("_start_temp_objects");
    var _touch_shape = Module["_touch_shape"] = makeInvalidEarlyAccess("_touch_shape");
    var _update_shape_text_layout = Module["_update_shape_text_layout"] = makeInvalidEarlyAccess("_update_shape_text_layout");
    var _update_shape_text_layout_for = Module["_update_shape_text_layout_for"] = makeInvalidEarlyAccess("_update_shape_text_layout_for");
    var _use_shape = Module["_use_shape"] = makeInvalidEarlyAccess("_use_shape");
    var _main = Module["_main"] = makeInvalidEarlyAccess("_main");
    var _add_shape_center_stroke = Module["_add_shape_center_stroke"] = makeInvalidEarlyAccess("_add_shape_center_stroke");
    var _add_shape_fill = Module["_add_shape_fill"] = makeInvalidEarlyAccess("_add_shape_fill");
    var _add_shape_inner_stroke = Module["_add_shape_inner_stroke"] = makeInvalidEarlyAccess("_add_shape_inner_stroke");
    var _add_shape_outer_stroke = Module["_add_shape_outer_stroke"] = makeInvalidEarlyAccess("_add_shape_outer_stroke");
    var _add_shape_stroke_fill = Module["_add_shape_stroke_fill"] = makeInvalidEarlyAccess("_add_shape_stroke_fill");
    var _alloc_bytes = Module["_alloc_bytes"] = makeInvalidEarlyAccess("_alloc_bytes");
    var _clear_shape_constraints = Module["_clear_shape_constraints"] = makeInvalidEarlyAccess("_clear_shape_constraints");
    var _clear_shape_fills = Module["_clear_shape_fills"] = makeInvalidEarlyAccess("_clear_shape_fills");
    var _clear_shape_strokes = Module["_clear_shape_strokes"] = makeInvalidEarlyAccess("_clear_shape_strokes");
    var _current_to_path = Module["_current_to_path"] = makeInvalidEarlyAccess("_current_to_path");
    var _propagate_modifiers = Module["_propagate_modifiers"] = makeInvalidEarlyAccess("_propagate_modifiers");
    var _set_shape_constraint_h = Module["_set_shape_constraint_h"] = makeInvalidEarlyAccess("_set_shape_constraint_h");
    var _set_shape_constraint_v = Module["_set_shape_constraint_v"] = makeInvalidEarlyAccess("_set_shape_constraint_v");
    var _set_shape_fills = Module["_set_shape_fills"] = makeInvalidEarlyAccess("_set_shape_fills");
    var _set_shape_path_buffer = Module["_set_shape_path_buffer"] = makeInvalidEarlyAccess("_set_shape_path_buffer");
    var _set_shape_path_chunk_buffer = Module["_set_shape_path_chunk_buffer"] = makeInvalidEarlyAccess("_set_shape_path_chunk_buffer");
    var _set_shape_path_content = Module["_set_shape_path_content"] = makeInvalidEarlyAccess("_set_shape_path_content");
    var _start_shape_path_buffer = Module["_start_shape_path_buffer"] = makeInvalidEarlyAccess("_start_shape_path_buffer");
    var _store_image = Module["_store_image"] = makeInvalidEarlyAccess("_store_image");
    var _store_image_from_texture = Module["_store_image_from_texture"] = makeInvalidEarlyAccess("_store_image_from_texture");
    var _clear_shape_blur = Module["_clear_shape_blur"] = makeInvalidEarlyAccess("_clear_shape_blur");
    var _is_font_uploaded = Module["_is_font_uploaded"] = makeInvalidEarlyAccess("_is_font_uploaded");
    var _set_shape_base_props = Module["_set_shape_base_props"] = makeInvalidEarlyAccess("_set_shape_base_props");
    var _set_shape_blend_mode = Module["_set_shape_blend_mode"] = makeInvalidEarlyAccess("_set_shape_blend_mode");
    var _set_shape_blur = Module["_set_shape_blur"] = makeInvalidEarlyAccess("_set_shape_blur");
    var _set_shape_type = Module["_set_shape_type"] = makeInvalidEarlyAccess("_set_shape_type");
    var _store_font = Module["_store_font"] = makeInvalidEarlyAccess("_store_font");
    var _text_editor_delete_backward = Module["_text_editor_delete_backward"] = makeInvalidEarlyAccess("_text_editor_delete_backward");
    var _text_editor_delete_forward = Module["_text_editor_delete_forward"] = makeInvalidEarlyAccess("_text_editor_delete_forward");
    var _text_editor_export_content = Module["_text_editor_export_content"] = makeInvalidEarlyAccess("_text_editor_export_content");
    var _text_editor_export_selection = Module["_text_editor_export_selection"] = makeInvalidEarlyAccess("_text_editor_export_selection");
    var _text_editor_extend_selection_to_point = Module["_text_editor_extend_selection_to_point"] = makeInvalidEarlyAccess("_text_editor_extend_selection_to_point");
    var _text_editor_get_active_shape_id = Module["_text_editor_get_active_shape_id"] = makeInvalidEarlyAccess("_text_editor_get_active_shape_id");
    var _text_editor_get_cursor_rect = Module["_text_editor_get_cursor_rect"] = makeInvalidEarlyAccess("_text_editor_get_cursor_rect");
    var _text_editor_get_selection = Module["_text_editor_get_selection"] = makeInvalidEarlyAccess("_text_editor_get_selection");
    var _text_editor_get_selection_rects = Module["_text_editor_get_selection_rects"] = makeInvalidEarlyAccess("_text_editor_get_selection_rects");
    var _text_editor_insert_paragraph = Module["_text_editor_insert_paragraph"] = makeInvalidEarlyAccess("_text_editor_insert_paragraph");
    var _text_editor_insert_text = Module["_text_editor_insert_text"] = makeInvalidEarlyAccess("_text_editor_insert_text");
    var _text_editor_is_active = Module["_text_editor_is_active"] = makeInvalidEarlyAccess("_text_editor_is_active");
    var _text_editor_move_cursor = Module["_text_editor_move_cursor"] = makeInvalidEarlyAccess("_text_editor_move_cursor");
    var _text_editor_poll_event = Module["_text_editor_poll_event"] = makeInvalidEarlyAccess("_text_editor_poll_event");
    var _text_editor_render_overlay = Module["_text_editor_render_overlay"] = makeInvalidEarlyAccess("_text_editor_render_overlay");
    var _text_editor_select_all = Module["_text_editor_select_all"] = makeInvalidEarlyAccess("_text_editor_select_all");
    var _text_editor_set_cursor_from_point = Module["_text_editor_set_cursor_from_point"] = makeInvalidEarlyAccess("_text_editor_set_cursor_from_point");
    var _text_editor_start = Module["_text_editor_start"] = makeInvalidEarlyAccess("_text_editor_start");
    var _text_editor_stop = Module["_text_editor_stop"] = makeInvalidEarlyAccess("_text_editor_stop");
    var _text_editor_update_blink = Module["_text_editor_update_blink"] = makeInvalidEarlyAccess("_text_editor_update_blink");
    var _malloc = makeInvalidEarlyAccess("_malloc");
    var _free = makeInvalidEarlyAccess("_free");
    var _fflush = makeInvalidEarlyAccess("_fflush");
    var _strerror = makeInvalidEarlyAccess("_strerror");
    var _htonl = makeInvalidEarlyAccess("_htonl");
    var _htons = makeInvalidEarlyAccess("_htons");
    var _emscripten_builtin_memalign = makeInvalidEarlyAccess("_emscripten_builtin_memalign");
    var _ntohs = makeInvalidEarlyAccess("_ntohs");
    var _emscripten_stack_get_end = makeInvalidEarlyAccess("_emscripten_stack_get_end");
    var _emscripten_stack_get_base = makeInvalidEarlyAccess("_emscripten_stack_get_base");
    var _setThrew = makeInvalidEarlyAccess("_setThrew");
    var __emscripten_tempret_set = makeInvalidEarlyAccess("__emscripten_tempret_set");
    var _emscripten_stack_init = makeInvalidEarlyAccess("_emscripten_stack_init");
    var _emscripten_stack_get_free = makeInvalidEarlyAccess("_emscripten_stack_get_free");
    var __emscripten_stack_restore = makeInvalidEarlyAccess("__emscripten_stack_restore");
    var __emscripten_stack_alloc = makeInvalidEarlyAccess("__emscripten_stack_alloc");
    var _emscripten_stack_get_current = makeInvalidEarlyAccess("_emscripten_stack_get_current");
    var ___cxa_decrement_exception_refcount = makeInvalidEarlyAccess("___cxa_decrement_exception_refcount");
    var ___cxa_increment_exception_refcount = makeInvalidEarlyAccess("___cxa_increment_exception_refcount");
    var ___get_exception_message = makeInvalidEarlyAccess("___get_exception_message");
    var ___cxa_can_catch = makeInvalidEarlyAccess("___cxa_can_catch");
    var ___cxa_get_exception_ptr = makeInvalidEarlyAccess("___cxa_get_exception_ptr");
    var memory = makeInvalidEarlyAccess("memory");
    var __indirect_function_table = makeInvalidEarlyAccess("__indirect_function_table");
    var wasmMemory = makeInvalidEarlyAccess("wasmMemory");
    var wasmTable = makeInvalidEarlyAccess("wasmTable");
    function assignWasmExports(wasmExports2) {
      assert(typeof wasmExports2["clear_shape_layout"] != "undefined", "missing Wasm export: clear_shape_layout");
      assert(typeof wasmExports2["set_layout_data"] != "undefined", "missing Wasm export: set_layout_data");
      assert(typeof wasmExports2["set_shape_vertical_align"] != "undefined", "missing Wasm export: set_shape_vertical_align");
      assert(typeof wasmExports2["add_shape_child"] != "undefined", "missing Wasm export: add_shape_child");
      assert(typeof wasmExports2["add_shape_shadow"] != "undefined", "missing Wasm export: add_shape_shadow");
      assert(typeof wasmExports2["calculate_bool"] != "undefined", "missing Wasm export: calculate_bool");
      assert(typeof wasmExports2["free_bytes"] != "undefined", "missing Wasm export: free_bytes");
      assert(typeof wasmExports2["calculate_position_data"] != "undefined", "missing Wasm export: calculate_position_data");
      assert(typeof wasmExports2["clean_modifiers"] != "undefined", "missing Wasm export: clean_modifiers");
      assert(typeof wasmExports2["clean_up"] != "undefined", "missing Wasm export: clean_up");
      assert(typeof wasmExports2["clear_focus_mode"] != "undefined", "missing Wasm export: clear_focus_mode");
      assert(typeof wasmExports2["clear_shape_shadows"] != "undefined", "missing Wasm export: clear_shape_shadows");
      assert(typeof wasmExports2["clear_shape_text"] != "undefined", "missing Wasm export: clear_shape_text");
      assert(typeof wasmExports2["end_temp_objects"] != "undefined", "missing Wasm export: end_temp_objects");
      assert(typeof wasmExports2["get_caret_position_at"] != "undefined", "missing Wasm export: get_caret_position_at");
      assert(typeof wasmExports2["get_grid_coords"] != "undefined", "missing Wasm export: get_grid_coords");
      assert(typeof wasmExports2["get_selection_rect"] != "undefined", "missing Wasm export: get_selection_rect");
      assert(typeof wasmExports2["get_text_dimensions"] != "undefined", "missing Wasm export: get_text_dimensions");
      assert(typeof wasmExports2["hide_grid"] != "undefined", "missing Wasm export: hide_grid");
      assert(typeof wasmExports2["init"] != "undefined", "missing Wasm export: init");
      assert(typeof wasmExports2["init_shapes_pool"] != "undefined", "missing Wasm export: init_shapes_pool");
      assert(typeof wasmExports2["intersect_position_in_shape"] != "undefined", "missing Wasm export: intersect_position_in_shape");
      assert(typeof wasmExports2["is_image_cached"] != "undefined", "missing Wasm export: is_image_cached");
      assert(typeof wasmExports2["process_animation_frame"] != "undefined", "missing Wasm export: process_animation_frame");
      assert(typeof wasmExports2["render"] != "undefined", "missing Wasm export: render");
      assert(typeof wasmExports2["render_from_cache"] != "undefined", "missing Wasm export: render_from_cache");
      assert(typeof wasmExports2["render_preview"] != "undefined", "missing Wasm export: render_preview");
      assert(typeof wasmExports2["render_sync"] != "undefined", "missing Wasm export: render_sync");
      assert(typeof wasmExports2["render_sync_shape"] != "undefined", "missing Wasm export: render_sync_shape");
      assert(typeof wasmExports2["reset_canvas"] != "undefined", "missing Wasm export: reset_canvas");
      assert(typeof wasmExports2["resize_viewbox"] != "undefined", "missing Wasm export: resize_viewbox");
      assert(typeof wasmExports2["set_browser"] != "undefined", "missing Wasm export: set_browser");
      assert(typeof wasmExports2["set_canvas_background"] != "undefined", "missing Wasm export: set_canvas_background");
      assert(typeof wasmExports2["set_children"] != "undefined", "missing Wasm export: set_children");
      assert(typeof wasmExports2["set_children_0"] != "undefined", "missing Wasm export: set_children_0");
      assert(typeof wasmExports2["set_children_1"] != "undefined", "missing Wasm export: set_children_1");
      assert(typeof wasmExports2["set_children_2"] != "undefined", "missing Wasm export: set_children_2");
      assert(typeof wasmExports2["set_children_3"] != "undefined", "missing Wasm export: set_children_3");
      assert(typeof wasmExports2["set_children_4"] != "undefined", "missing Wasm export: set_children_4");
      assert(typeof wasmExports2["set_children_5"] != "undefined", "missing Wasm export: set_children_5");
      assert(typeof wasmExports2["set_flex_layout_data"] != "undefined", "missing Wasm export: set_flex_layout_data");
      assert(typeof wasmExports2["set_focus_mode"] != "undefined", "missing Wasm export: set_focus_mode");
      assert(typeof wasmExports2["set_grid_cells"] != "undefined", "missing Wasm export: set_grid_cells");
      assert(typeof wasmExports2["set_grid_columns"] != "undefined", "missing Wasm export: set_grid_columns");
      assert(typeof wasmExports2["set_grid_layout_data"] != "undefined", "missing Wasm export: set_grid_layout_data");
      assert(typeof wasmExports2["set_grid_rows"] != "undefined", "missing Wasm export: set_grid_rows");
      assert(typeof wasmExports2["set_modifiers"] != "undefined", "missing Wasm export: set_modifiers");
      assert(typeof wasmExports2["set_parent"] != "undefined", "missing Wasm export: set_parent");
      assert(typeof wasmExports2["set_preview_mode"] != "undefined", "missing Wasm export: set_preview_mode");
      assert(typeof wasmExports2["set_render_options"] != "undefined", "missing Wasm export: set_render_options");
      assert(typeof wasmExports2["set_shape_bool_type"] != "undefined", "missing Wasm export: set_shape_bool_type");
      assert(typeof wasmExports2["set_shape_clip_content"] != "undefined", "missing Wasm export: set_shape_clip_content");
      assert(typeof wasmExports2["set_shape_corners"] != "undefined", "missing Wasm export: set_shape_corners");
      assert(typeof wasmExports2["set_shape_grow_type"] != "undefined", "missing Wasm export: set_shape_grow_type");
      assert(typeof wasmExports2["set_shape_hidden"] != "undefined", "missing Wasm export: set_shape_hidden");
      assert(typeof wasmExports2["set_shape_masked_group"] != "undefined", "missing Wasm export: set_shape_masked_group");
      assert(typeof wasmExports2["set_shape_opacity"] != "undefined", "missing Wasm export: set_shape_opacity");
      assert(typeof wasmExports2["set_shape_rotation"] != "undefined", "missing Wasm export: set_shape_rotation");
      assert(typeof wasmExports2["set_shape_selrect"] != "undefined", "missing Wasm export: set_shape_selrect");
      assert(typeof wasmExports2["set_shape_svg_attrs"] != "undefined", "missing Wasm export: set_shape_svg_attrs");
      assert(typeof wasmExports2["set_shape_svg_raw_content"] != "undefined", "missing Wasm export: set_shape_svg_raw_content");
      assert(typeof wasmExports2["set_shape_text_content"] != "undefined", "missing Wasm export: set_shape_text_content");
      assert(typeof wasmExports2["set_shape_transform"] != "undefined", "missing Wasm export: set_shape_transform");
      assert(typeof wasmExports2["set_structure_modifiers"] != "undefined", "missing Wasm export: set_structure_modifiers");
      assert(typeof wasmExports2["set_view"] != "undefined", "missing Wasm export: set_view");
      assert(typeof wasmExports2["set_view_end"] != "undefined", "missing Wasm export: set_view_end");
      assert(typeof wasmExports2["set_view_start"] != "undefined", "missing Wasm export: set_view_start");
      assert(typeof wasmExports2["show_grid"] != "undefined", "missing Wasm export: show_grid");
      assert(typeof wasmExports2["start_temp_objects"] != "undefined", "missing Wasm export: start_temp_objects");
      assert(typeof wasmExports2["touch_shape"] != "undefined", "missing Wasm export: touch_shape");
      assert(typeof wasmExports2["update_shape_text_layout"] != "undefined", "missing Wasm export: update_shape_text_layout");
      assert(typeof wasmExports2["update_shape_text_layout_for"] != "undefined", "missing Wasm export: update_shape_text_layout_for");
      assert(typeof wasmExports2["use_shape"] != "undefined", "missing Wasm export: use_shape");
      assert(typeof wasmExports2["main"] != "undefined", "missing Wasm export: main");
      assert(typeof wasmExports2["add_shape_center_stroke"] != "undefined", "missing Wasm export: add_shape_center_stroke");
      assert(typeof wasmExports2["add_shape_fill"] != "undefined", "missing Wasm export: add_shape_fill");
      assert(typeof wasmExports2["add_shape_inner_stroke"] != "undefined", "missing Wasm export: add_shape_inner_stroke");
      assert(typeof wasmExports2["add_shape_outer_stroke"] != "undefined", "missing Wasm export: add_shape_outer_stroke");
      assert(typeof wasmExports2["add_shape_stroke_fill"] != "undefined", "missing Wasm export: add_shape_stroke_fill");
      assert(typeof wasmExports2["alloc_bytes"] != "undefined", "missing Wasm export: alloc_bytes");
      assert(typeof wasmExports2["clear_shape_constraints"] != "undefined", "missing Wasm export: clear_shape_constraints");
      assert(typeof wasmExports2["clear_shape_fills"] != "undefined", "missing Wasm export: clear_shape_fills");
      assert(typeof wasmExports2["clear_shape_strokes"] != "undefined", "missing Wasm export: clear_shape_strokes");
      assert(typeof wasmExports2["current_to_path"] != "undefined", "missing Wasm export: current_to_path");
      assert(typeof wasmExports2["propagate_modifiers"] != "undefined", "missing Wasm export: propagate_modifiers");
      assert(typeof wasmExports2["set_shape_constraint_h"] != "undefined", "missing Wasm export: set_shape_constraint_h");
      assert(typeof wasmExports2["set_shape_constraint_v"] != "undefined", "missing Wasm export: set_shape_constraint_v");
      assert(typeof wasmExports2["set_shape_fills"] != "undefined", "missing Wasm export: set_shape_fills");
      assert(typeof wasmExports2["set_shape_path_buffer"] != "undefined", "missing Wasm export: set_shape_path_buffer");
      assert(typeof wasmExports2["set_shape_path_chunk_buffer"] != "undefined", "missing Wasm export: set_shape_path_chunk_buffer");
      assert(typeof wasmExports2["set_shape_path_content"] != "undefined", "missing Wasm export: set_shape_path_content");
      assert(typeof wasmExports2["start_shape_path_buffer"] != "undefined", "missing Wasm export: start_shape_path_buffer");
      assert(typeof wasmExports2["store_image"] != "undefined", "missing Wasm export: store_image");
      assert(typeof wasmExports2["store_image_from_texture"] != "undefined", "missing Wasm export: store_image_from_texture");
      assert(typeof wasmExports2["clear_shape_blur"] != "undefined", "missing Wasm export: clear_shape_blur");
      assert(typeof wasmExports2["is_font_uploaded"] != "undefined", "missing Wasm export: is_font_uploaded");
      assert(typeof wasmExports2["set_shape_base_props"] != "undefined", "missing Wasm export: set_shape_base_props");
      assert(typeof wasmExports2["set_shape_blend_mode"] != "undefined", "missing Wasm export: set_shape_blend_mode");
      assert(typeof wasmExports2["set_shape_blur"] != "undefined", "missing Wasm export: set_shape_blur");
      assert(typeof wasmExports2["set_shape_type"] != "undefined", "missing Wasm export: set_shape_type");
      assert(typeof wasmExports2["store_font"] != "undefined", "missing Wasm export: store_font");
      assert(typeof wasmExports2["text_editor_delete_backward"] != "undefined", "missing Wasm export: text_editor_delete_backward");
      assert(typeof wasmExports2["text_editor_delete_forward"] != "undefined", "missing Wasm export: text_editor_delete_forward");
      assert(typeof wasmExports2["text_editor_export_content"] != "undefined", "missing Wasm export: text_editor_export_content");
      assert(typeof wasmExports2["text_editor_export_selection"] != "undefined", "missing Wasm export: text_editor_export_selection");
      assert(typeof wasmExports2["text_editor_extend_selection_to_point"] != "undefined", "missing Wasm export: text_editor_extend_selection_to_point");
      assert(typeof wasmExports2["text_editor_get_active_shape_id"] != "undefined", "missing Wasm export: text_editor_get_active_shape_id");
      assert(typeof wasmExports2["text_editor_get_cursor_rect"] != "undefined", "missing Wasm export: text_editor_get_cursor_rect");
      assert(typeof wasmExports2["text_editor_get_selection"] != "undefined", "missing Wasm export: text_editor_get_selection");
      assert(typeof wasmExports2["text_editor_get_selection_rects"] != "undefined", "missing Wasm export: text_editor_get_selection_rects");
      assert(typeof wasmExports2["text_editor_insert_paragraph"] != "undefined", "missing Wasm export: text_editor_insert_paragraph");
      assert(typeof wasmExports2["text_editor_insert_text"] != "undefined", "missing Wasm export: text_editor_insert_text");
      assert(typeof wasmExports2["text_editor_is_active"] != "undefined", "missing Wasm export: text_editor_is_active");
      assert(typeof wasmExports2["text_editor_move_cursor"] != "undefined", "missing Wasm export: text_editor_move_cursor");
      assert(typeof wasmExports2["text_editor_poll_event"] != "undefined", "missing Wasm export: text_editor_poll_event");
      assert(typeof wasmExports2["text_editor_render_overlay"] != "undefined", "missing Wasm export: text_editor_render_overlay");
      assert(typeof wasmExports2["text_editor_select_all"] != "undefined", "missing Wasm export: text_editor_select_all");
      assert(typeof wasmExports2["text_editor_set_cursor_from_point"] != "undefined", "missing Wasm export: text_editor_set_cursor_from_point");
      assert(typeof wasmExports2["text_editor_start"] != "undefined", "missing Wasm export: text_editor_start");
      assert(typeof wasmExports2["text_editor_stop"] != "undefined", "missing Wasm export: text_editor_stop");
      assert(typeof wasmExports2["text_editor_update_blink"] != "undefined", "missing Wasm export: text_editor_update_blink");
      assert(typeof wasmExports2["malloc"] != "undefined", "missing Wasm export: malloc");
      assert(typeof wasmExports2["free"] != "undefined", "missing Wasm export: free");
      assert(typeof wasmExports2["fflush"] != "undefined", "missing Wasm export: fflush");
      assert(typeof wasmExports2["strerror"] != "undefined", "missing Wasm export: strerror");
      assert(typeof wasmExports2["htonl"] != "undefined", "missing Wasm export: htonl");
      assert(typeof wasmExports2["htons"] != "undefined", "missing Wasm export: htons");
      assert(typeof wasmExports2["emscripten_builtin_memalign"] != "undefined", "missing Wasm export: emscripten_builtin_memalign");
      assert(typeof wasmExports2["ntohs"] != "undefined", "missing Wasm export: ntohs");
      assert(typeof wasmExports2["emscripten_stack_get_end"] != "undefined", "missing Wasm export: emscripten_stack_get_end");
      assert(typeof wasmExports2["emscripten_stack_get_base"] != "undefined", "missing Wasm export: emscripten_stack_get_base");
      assert(typeof wasmExports2["setThrew"] != "undefined", "missing Wasm export: setThrew");
      assert(typeof wasmExports2["_emscripten_tempret_set"] != "undefined", "missing Wasm export: _emscripten_tempret_set");
      assert(typeof wasmExports2["emscripten_stack_init"] != "undefined", "missing Wasm export: emscripten_stack_init");
      assert(typeof wasmExports2["emscripten_stack_get_free"] != "undefined", "missing Wasm export: emscripten_stack_get_free");
      assert(typeof wasmExports2["_emscripten_stack_restore"] != "undefined", "missing Wasm export: _emscripten_stack_restore");
      assert(typeof wasmExports2["_emscripten_stack_alloc"] != "undefined", "missing Wasm export: _emscripten_stack_alloc");
      assert(typeof wasmExports2["emscripten_stack_get_current"] != "undefined", "missing Wasm export: emscripten_stack_get_current");
      assert(typeof wasmExports2["__cxa_decrement_exception_refcount"] != "undefined", "missing Wasm export: __cxa_decrement_exception_refcount");
      assert(typeof wasmExports2["__cxa_increment_exception_refcount"] != "undefined", "missing Wasm export: __cxa_increment_exception_refcount");
      assert(typeof wasmExports2["__get_exception_message"] != "undefined", "missing Wasm export: __get_exception_message");
      assert(typeof wasmExports2["__cxa_can_catch"] != "undefined", "missing Wasm export: __cxa_can_catch");
      assert(typeof wasmExports2["__cxa_get_exception_ptr"] != "undefined", "missing Wasm export: __cxa_get_exception_ptr");
      assert(typeof wasmExports2["memory"] != "undefined", "missing Wasm export: memory");
      assert(typeof wasmExports2["__indirect_function_table"] != "undefined", "missing Wasm export: __indirect_function_table");
      _clear_shape_layout = Module["_clear_shape_layout"] = createExportWrapper("clear_shape_layout", 0);
      _set_layout_data = Module["_set_layout_data"] = createExportWrapper("set_layout_data", 17);
      _set_shape_vertical_align = Module["_set_shape_vertical_align"] = createExportWrapper("set_shape_vertical_align", 1);
      _add_shape_child = Module["_add_shape_child"] = createExportWrapper("add_shape_child", 4);
      _add_shape_shadow = Module["_add_shape_shadow"] = createExportWrapper("add_shape_shadow", 7);
      _calculate_bool = Module["_calculate_bool"] = createExportWrapper("calculate_bool", 1);
      _free_bytes = Module["_free_bytes"] = createExportWrapper("free_bytes", 0);
      _calculate_position_data = Module["_calculate_position_data"] = createExportWrapper("calculate_position_data", 0);
      _clean_modifiers = Module["_clean_modifiers"] = createExportWrapper("clean_modifiers", 0);
      _clean_up = Module["_clean_up"] = createExportWrapper("clean_up", 0);
      _clear_focus_mode = Module["_clear_focus_mode"] = createExportWrapper("clear_focus_mode", 0);
      _clear_shape_shadows = Module["_clear_shape_shadows"] = createExportWrapper("clear_shape_shadows", 0);
      _clear_shape_text = Module["_clear_shape_text"] = createExportWrapper("clear_shape_text", 0);
      _end_temp_objects = Module["_end_temp_objects"] = createExportWrapper("end_temp_objects", 0);
      _get_caret_position_at = Module["_get_caret_position_at"] = createExportWrapper("get_caret_position_at", 2);
      _get_grid_coords = Module["_get_grid_coords"] = createExportWrapper("get_grid_coords", 2);
      _get_selection_rect = Module["_get_selection_rect"] = createExportWrapper("get_selection_rect", 0);
      _get_text_dimensions = Module["_get_text_dimensions"] = createExportWrapper("get_text_dimensions", 0);
      _hide_grid = Module["_hide_grid"] = createExportWrapper("hide_grid", 0);
      _init = Module["_init"] = createExportWrapper("init", 2);
      _init_shapes_pool = Module["_init_shapes_pool"] = createExportWrapper("init_shapes_pool", 1);
      _intersect_position_in_shape = Module["_intersect_position_in_shape"] = createExportWrapper("intersect_position_in_shape", 6);
      _is_image_cached = Module["_is_image_cached"] = createExportWrapper("is_image_cached", 5);
      _process_animation_frame = Module["_process_animation_frame"] = createExportWrapper("process_animation_frame", 1);
      _render = Module["_render"] = createExportWrapper("render", 1);
      _render_from_cache = Module["_render_from_cache"] = createExportWrapper("render_from_cache", 1);
      _render_preview = Module["_render_preview"] = createExportWrapper("render_preview", 0);
      _render_sync = Module["_render_sync"] = createExportWrapper("render_sync", 0);
      _render_sync_shape = Module["_render_sync_shape"] = createExportWrapper("render_sync_shape", 4);
      _reset_canvas = Module["_reset_canvas"] = createExportWrapper("reset_canvas", 0);
      _resize_viewbox = Module["_resize_viewbox"] = createExportWrapper("resize_viewbox", 2);
      _set_browser = Module["_set_browser"] = createExportWrapper("set_browser", 1);
      _set_canvas_background = Module["_set_canvas_background"] = createExportWrapper("set_canvas_background", 1);
      _set_children = Module["_set_children"] = createExportWrapper("set_children", 0);
      _set_children_0 = Module["_set_children_0"] = createExportWrapper("set_children_0", 0);
      _set_children_1 = Module["_set_children_1"] = createExportWrapper("set_children_1", 4);
      _set_children_2 = Module["_set_children_2"] = createExportWrapper("set_children_2", 8);
      _set_children_3 = Module["_set_children_3"] = createExportWrapper("set_children_3", 12);
      _set_children_4 = Module["_set_children_4"] = createExportWrapper("set_children_4", 16);
      _set_children_5 = Module["_set_children_5"] = createExportWrapper("set_children_5", 20);
      _set_flex_layout_data = Module["_set_flex_layout_data"] = createExportWrapper("set_flex_layout_data", 12);
      _set_focus_mode = Module["_set_focus_mode"] = createExportWrapper("set_focus_mode", 0);
      _set_grid_cells = Module["_set_grid_cells"] = createExportWrapper("set_grid_cells", 0);
      _set_grid_columns = Module["_set_grid_columns"] = createExportWrapper("set_grid_columns", 0);
      _set_grid_layout_data = Module["_set_grid_layout_data"] = createExportWrapper("set_grid_layout_data", 11);
      _set_grid_rows = Module["_set_grid_rows"] = createExportWrapper("set_grid_rows", 0);
      _set_modifiers = Module["_set_modifiers"] = createExportWrapper("set_modifiers", 0);
      _set_parent = Module["_set_parent"] = createExportWrapper("set_parent", 4);
      _set_preview_mode = Module["_set_preview_mode"] = createExportWrapper("set_preview_mode", 1);
      _set_render_options = Module["_set_render_options"] = createExportWrapper("set_render_options", 2);
      _set_shape_bool_type = Module["_set_shape_bool_type"] = createExportWrapper("set_shape_bool_type", 1);
      _set_shape_clip_content = Module["_set_shape_clip_content"] = createExportWrapper("set_shape_clip_content", 1);
      _set_shape_corners = Module["_set_shape_corners"] = createExportWrapper("set_shape_corners", 4);
      _set_shape_grow_type = Module["_set_shape_grow_type"] = createExportWrapper("set_shape_grow_type", 1);
      _set_shape_hidden = Module["_set_shape_hidden"] = createExportWrapper("set_shape_hidden", 1);
      _set_shape_masked_group = Module["_set_shape_masked_group"] = createExportWrapper("set_shape_masked_group", 1);
      _set_shape_opacity = Module["_set_shape_opacity"] = createExportWrapper("set_shape_opacity", 1);
      _set_shape_rotation = Module["_set_shape_rotation"] = createExportWrapper("set_shape_rotation", 1);
      _set_shape_selrect = Module["_set_shape_selrect"] = createExportWrapper("set_shape_selrect", 4);
      _set_shape_svg_attrs = Module["_set_shape_svg_attrs"] = createExportWrapper("set_shape_svg_attrs", 4);
      _set_shape_svg_raw_content = Module["_set_shape_svg_raw_content"] = createExportWrapper("set_shape_svg_raw_content", 0);
      _set_shape_text_content = Module["_set_shape_text_content"] = createExportWrapper("set_shape_text_content", 0);
      _set_shape_transform = Module["_set_shape_transform"] = createExportWrapper("set_shape_transform", 6);
      _set_structure_modifiers = Module["_set_structure_modifiers"] = createExportWrapper("set_structure_modifiers", 0);
      _set_view = Module["_set_view"] = createExportWrapper("set_view", 3);
      _set_view_end = Module["_set_view_end"] = createExportWrapper("set_view_end", 0);
      _set_view_start = Module["_set_view_start"] = createExportWrapper("set_view_start", 0);
      _show_grid = Module["_show_grid"] = createExportWrapper("show_grid", 4);
      _start_temp_objects = Module["_start_temp_objects"] = createExportWrapper("start_temp_objects", 0);
      _touch_shape = Module["_touch_shape"] = createExportWrapper("touch_shape", 4);
      _update_shape_text_layout = Module["_update_shape_text_layout"] = createExportWrapper("update_shape_text_layout", 0);
      _update_shape_text_layout_for = Module["_update_shape_text_layout_for"] = createExportWrapper("update_shape_text_layout_for", 4);
      _use_shape = Module["_use_shape"] = createExportWrapper("use_shape", 4);
      _main = Module["_main"] = createExportWrapper("main", 2);
      _add_shape_center_stroke = Module["_add_shape_center_stroke"] = createExportWrapper("add_shape_center_stroke", 4);
      _add_shape_fill = Module["_add_shape_fill"] = createExportWrapper("add_shape_fill", 0);
      _add_shape_inner_stroke = Module["_add_shape_inner_stroke"] = createExportWrapper("add_shape_inner_stroke", 4);
      _add_shape_outer_stroke = Module["_add_shape_outer_stroke"] = createExportWrapper("add_shape_outer_stroke", 4);
      _add_shape_stroke_fill = Module["_add_shape_stroke_fill"] = createExportWrapper("add_shape_stroke_fill", 0);
      _alloc_bytes = Module["_alloc_bytes"] = createExportWrapper("alloc_bytes", 1);
      _clear_shape_constraints = Module["_clear_shape_constraints"] = createExportWrapper("clear_shape_constraints", 0);
      _clear_shape_fills = Module["_clear_shape_fills"] = createExportWrapper("clear_shape_fills", 0);
      _clear_shape_strokes = Module["_clear_shape_strokes"] = createExportWrapper("clear_shape_strokes", 0);
      _current_to_path = Module["_current_to_path"] = createExportWrapper("current_to_path", 0);
      _propagate_modifiers = Module["_propagate_modifiers"] = createExportWrapper("propagate_modifiers", 1);
      _set_shape_constraint_h = Module["_set_shape_constraint_h"] = createExportWrapper("set_shape_constraint_h", 1);
      _set_shape_constraint_v = Module["_set_shape_constraint_v"] = createExportWrapper("set_shape_constraint_v", 1);
      _set_shape_fills = Module["_set_shape_fills"] = createExportWrapper("set_shape_fills", 0);
      _set_shape_path_buffer = Module["_set_shape_path_buffer"] = createExportWrapper("set_shape_path_buffer", 0);
      _set_shape_path_chunk_buffer = Module["_set_shape_path_chunk_buffer"] = createExportWrapper("set_shape_path_chunk_buffer", 0);
      _set_shape_path_content = Module["_set_shape_path_content"] = createExportWrapper("set_shape_path_content", 0);
      _start_shape_path_buffer = Module["_start_shape_path_buffer"] = createExportWrapper("start_shape_path_buffer", 0);
      _store_image = Module["_store_image"] = createExportWrapper("store_image", 0);
      _store_image_from_texture = Module["_store_image_from_texture"] = createExportWrapper("store_image_from_texture", 0);
      _clear_shape_blur = Module["_clear_shape_blur"] = createExportWrapper("clear_shape_blur", 0);
      _is_font_uploaded = Module["_is_font_uploaded"] = createExportWrapper("is_font_uploaded", 7);
      _set_shape_base_props = Module["_set_shape_base_props"] = createExportWrapper("set_shape_base_props", 0);
      _set_shape_blend_mode = Module["_set_shape_blend_mode"] = createExportWrapper("set_shape_blend_mode", 1);
      _set_shape_blur = Module["_set_shape_blur"] = createExportWrapper("set_shape_blur", 3);
      _set_shape_type = Module["_set_shape_type"] = createExportWrapper("set_shape_type", 1);
      _store_font = Module["_store_font"] = createExportWrapper("store_font", 8);
      _text_editor_delete_backward = Module["_text_editor_delete_backward"] = createExportWrapper("text_editor_delete_backward", 0);
      _text_editor_delete_forward = Module["_text_editor_delete_forward"] = createExportWrapper("text_editor_delete_forward", 0);
      _text_editor_export_content = Module["_text_editor_export_content"] = createExportWrapper("text_editor_export_content", 0);
      _text_editor_export_selection = Module["_text_editor_export_selection"] = createExportWrapper("text_editor_export_selection", 0);
      _text_editor_extend_selection_to_point = Module["_text_editor_extend_selection_to_point"] = createExportWrapper("text_editor_extend_selection_to_point", 2);
      _text_editor_get_active_shape_id = Module["_text_editor_get_active_shape_id"] = createExportWrapper("text_editor_get_active_shape_id", 1);
      _text_editor_get_cursor_rect = Module["_text_editor_get_cursor_rect"] = createExportWrapper("text_editor_get_cursor_rect", 0);
      _text_editor_get_selection = Module["_text_editor_get_selection"] = createExportWrapper("text_editor_get_selection", 1);
      _text_editor_get_selection_rects = Module["_text_editor_get_selection_rects"] = createExportWrapper("text_editor_get_selection_rects", 0);
      _text_editor_insert_paragraph = Module["_text_editor_insert_paragraph"] = createExportWrapper("text_editor_insert_paragraph", 0);
      _text_editor_insert_text = Module["_text_editor_insert_text"] = createExportWrapper("text_editor_insert_text", 0);
      _text_editor_is_active = Module["_text_editor_is_active"] = createExportWrapper("text_editor_is_active", 0);
      _text_editor_move_cursor = Module["_text_editor_move_cursor"] = createExportWrapper("text_editor_move_cursor", 2);
      _text_editor_poll_event = Module["_text_editor_poll_event"] = createExportWrapper("text_editor_poll_event", 0);
      _text_editor_render_overlay = Module["_text_editor_render_overlay"] = createExportWrapper("text_editor_render_overlay", 0);
      _text_editor_select_all = Module["_text_editor_select_all"] = createExportWrapper("text_editor_select_all", 0);
      _text_editor_set_cursor_from_point = Module["_text_editor_set_cursor_from_point"] = createExportWrapper("text_editor_set_cursor_from_point", 2);
      _text_editor_start = Module["_text_editor_start"] = createExportWrapper("text_editor_start", 4);
      _text_editor_stop = Module["_text_editor_stop"] = createExportWrapper("text_editor_stop", 0);
      _text_editor_update_blink = Module["_text_editor_update_blink"] = createExportWrapper("text_editor_update_blink", 1);
      _malloc = createExportWrapper("malloc", 1);
      _free = createExportWrapper("free", 1);
      _fflush = createExportWrapper("fflush", 1);
      _strerror = createExportWrapper("strerror", 1);
      _htonl = createExportWrapper("htonl", 1);
      _htons = createExportWrapper("htons", 1);
      _emscripten_builtin_memalign = createExportWrapper("emscripten_builtin_memalign", 2);
      _ntohs = createExportWrapper("ntohs", 1);
      _emscripten_stack_get_end = wasmExports2["emscripten_stack_get_end"];
      _emscripten_stack_get_base = wasmExports2["emscripten_stack_get_base"];
      _setThrew = createExportWrapper("setThrew", 2);
      __emscripten_tempret_set = createExportWrapper("_emscripten_tempret_set", 1);
      _emscripten_stack_init = wasmExports2["emscripten_stack_init"];
      _emscripten_stack_get_free = wasmExports2["emscripten_stack_get_free"];
      __emscripten_stack_restore = wasmExports2["_emscripten_stack_restore"];
      __emscripten_stack_alloc = wasmExports2["_emscripten_stack_alloc"];
      _emscripten_stack_get_current = wasmExports2["emscripten_stack_get_current"];
      ___cxa_decrement_exception_refcount = createExportWrapper("__cxa_decrement_exception_refcount", 1);
      ___cxa_increment_exception_refcount = createExportWrapper("__cxa_increment_exception_refcount", 1);
      ___get_exception_message = createExportWrapper("__get_exception_message", 3);
      ___cxa_can_catch = createExportWrapper("__cxa_can_catch", 3);
      ___cxa_get_exception_ptr = createExportWrapper("__cxa_get_exception_ptr", 1);
      memory = wasmMemory = wasmExports2["memory"];
      __indirect_function_table = wasmTable = wasmExports2["__indirect_function_table"];
    }
    var wasmImports = {
      /** @export */
      __assert_fail: ___assert_fail,
      /** @export */
      __cxa_begin_catch: ___cxa_begin_catch,
      /** @export */
      __cxa_end_catch: ___cxa_end_catch,
      /** @export */
      __cxa_find_matching_catch_2: ___cxa_find_matching_catch_2,
      /** @export */
      __cxa_find_matching_catch_3: ___cxa_find_matching_catch_3,
      /** @export */
      __cxa_find_matching_catch_4: ___cxa_find_matching_catch_4,
      /** @export */
      __cxa_rethrow: ___cxa_rethrow,
      /** @export */
      __cxa_throw: ___cxa_throw,
      /** @export */
      __cxa_uncaught_exceptions: ___cxa_uncaught_exceptions,
      /** @export */
      __resumeException: ___resumeException,
      /** @export */
      __syscall_fcntl64: ___syscall_fcntl64,
      /** @export */
      __syscall_fstat64: ___syscall_fstat64,
      /** @export */
      __syscall_getcwd: ___syscall_getcwd,
      /** @export */
      __syscall_ioctl: ___syscall_ioctl,
      /** @export */
      __syscall_lstat64: ___syscall_lstat64,
      /** @export */
      __syscall_newfstatat: ___syscall_newfstatat,
      /** @export */
      __syscall_openat: ___syscall_openat,
      /** @export */
      __syscall_stat64: ___syscall_stat64,
      /** @export */
      _abort_js: __abort_js,
      /** @export */
      _emscripten_throw_longjmp: __emscripten_throw_longjmp,
      /** @export */
      _mmap_js: __mmap_js,
      /** @export */
      _munmap_js: __munmap_js,
      /** @export */
      _tzset_js: __tzset_js,
      /** @export */
      clock_time_get: _clock_time_get,
      /** @export */
      emscripten_date_now: _emscripten_date_now,
      /** @export */
      emscripten_get_now: _emscripten_get_now,
      /** @export */
      emscripten_glActiveTexture: _emscripten_glActiveTexture,
      /** @export */
      emscripten_glAttachShader: _emscripten_glAttachShader,
      /** @export */
      emscripten_glBeginQuery: _emscripten_glBeginQuery,
      /** @export */
      emscripten_glBeginQueryEXT: _emscripten_glBeginQueryEXT,
      /** @export */
      emscripten_glBeginTransformFeedback: _emscripten_glBeginTransformFeedback,
      /** @export */
      emscripten_glBindAttribLocation: _emscripten_glBindAttribLocation,
      /** @export */
      emscripten_glBindBuffer: _emscripten_glBindBuffer,
      /** @export */
      emscripten_glBindBufferBase: _emscripten_glBindBufferBase,
      /** @export */
      emscripten_glBindBufferRange: _emscripten_glBindBufferRange,
      /** @export */
      emscripten_glBindFramebuffer: _emscripten_glBindFramebuffer,
      /** @export */
      emscripten_glBindRenderbuffer: _emscripten_glBindRenderbuffer,
      /** @export */
      emscripten_glBindSampler: _emscripten_glBindSampler,
      /** @export */
      emscripten_glBindTexture: _emscripten_glBindTexture,
      /** @export */
      emscripten_glBindTransformFeedback: _emscripten_glBindTransformFeedback,
      /** @export */
      emscripten_glBindVertexArray: _emscripten_glBindVertexArray,
      /** @export */
      emscripten_glBindVertexArrayOES: _emscripten_glBindVertexArrayOES,
      /** @export */
      emscripten_glBlendColor: _emscripten_glBlendColor,
      /** @export */
      emscripten_glBlendEquation: _emscripten_glBlendEquation,
      /** @export */
      emscripten_glBlendEquationSeparate: _emscripten_glBlendEquationSeparate,
      /** @export */
      emscripten_glBlendFunc: _emscripten_glBlendFunc,
      /** @export */
      emscripten_glBlendFuncSeparate: _emscripten_glBlendFuncSeparate,
      /** @export */
      emscripten_glBlitFramebuffer: _emscripten_glBlitFramebuffer,
      /** @export */
      emscripten_glBufferData: _emscripten_glBufferData,
      /** @export */
      emscripten_glBufferSubData: _emscripten_glBufferSubData,
      /** @export */
      emscripten_glCheckFramebufferStatus: _emscripten_glCheckFramebufferStatus,
      /** @export */
      emscripten_glClear: _emscripten_glClear,
      /** @export */
      emscripten_glClearBufferfi: _emscripten_glClearBufferfi,
      /** @export */
      emscripten_glClearBufferfv: _emscripten_glClearBufferfv,
      /** @export */
      emscripten_glClearBufferiv: _emscripten_glClearBufferiv,
      /** @export */
      emscripten_glClearBufferuiv: _emscripten_glClearBufferuiv,
      /** @export */
      emscripten_glClearColor: _emscripten_glClearColor,
      /** @export */
      emscripten_glClearDepthf: _emscripten_glClearDepthf,
      /** @export */
      emscripten_glClearStencil: _emscripten_glClearStencil,
      /** @export */
      emscripten_glClientWaitSync: _emscripten_glClientWaitSync,
      /** @export */
      emscripten_glClipControlEXT: _emscripten_glClipControlEXT,
      /** @export */
      emscripten_glColorMask: _emscripten_glColorMask,
      /** @export */
      emscripten_glCompileShader: _emscripten_glCompileShader,
      /** @export */
      emscripten_glCompressedTexImage2D: _emscripten_glCompressedTexImage2D,
      /** @export */
      emscripten_glCompressedTexImage3D: _emscripten_glCompressedTexImage3D,
      /** @export */
      emscripten_glCompressedTexSubImage2D: _emscripten_glCompressedTexSubImage2D,
      /** @export */
      emscripten_glCompressedTexSubImage3D: _emscripten_glCompressedTexSubImage3D,
      /** @export */
      emscripten_glCopyBufferSubData: _emscripten_glCopyBufferSubData,
      /** @export */
      emscripten_glCopyTexImage2D: _emscripten_glCopyTexImage2D,
      /** @export */
      emscripten_glCopyTexSubImage2D: _emscripten_glCopyTexSubImage2D,
      /** @export */
      emscripten_glCopyTexSubImage3D: _emscripten_glCopyTexSubImage3D,
      /** @export */
      emscripten_glCreateProgram: _emscripten_glCreateProgram,
      /** @export */
      emscripten_glCreateShader: _emscripten_glCreateShader,
      /** @export */
      emscripten_glCullFace: _emscripten_glCullFace,
      /** @export */
      emscripten_glDeleteBuffers: _emscripten_glDeleteBuffers,
      /** @export */
      emscripten_glDeleteFramebuffers: _emscripten_glDeleteFramebuffers,
      /** @export */
      emscripten_glDeleteProgram: _emscripten_glDeleteProgram,
      /** @export */
      emscripten_glDeleteQueries: _emscripten_glDeleteQueries,
      /** @export */
      emscripten_glDeleteQueriesEXT: _emscripten_glDeleteQueriesEXT,
      /** @export */
      emscripten_glDeleteRenderbuffers: _emscripten_glDeleteRenderbuffers,
      /** @export */
      emscripten_glDeleteSamplers: _emscripten_glDeleteSamplers,
      /** @export */
      emscripten_glDeleteShader: _emscripten_glDeleteShader,
      /** @export */
      emscripten_glDeleteSync: _emscripten_glDeleteSync,
      /** @export */
      emscripten_glDeleteTextures: _emscripten_glDeleteTextures,
      /** @export */
      emscripten_glDeleteTransformFeedbacks: _emscripten_glDeleteTransformFeedbacks,
      /** @export */
      emscripten_glDeleteVertexArrays: _emscripten_glDeleteVertexArrays,
      /** @export */
      emscripten_glDeleteVertexArraysOES: _emscripten_glDeleteVertexArraysOES,
      /** @export */
      emscripten_glDepthFunc: _emscripten_glDepthFunc,
      /** @export */
      emscripten_glDepthMask: _emscripten_glDepthMask,
      /** @export */
      emscripten_glDepthRangef: _emscripten_glDepthRangef,
      /** @export */
      emscripten_glDetachShader: _emscripten_glDetachShader,
      /** @export */
      emscripten_glDisable: _emscripten_glDisable,
      /** @export */
      emscripten_glDisableVertexAttribArray: _emscripten_glDisableVertexAttribArray,
      /** @export */
      emscripten_glDrawArrays: _emscripten_glDrawArrays,
      /** @export */
      emscripten_glDrawArraysInstanced: _emscripten_glDrawArraysInstanced,
      /** @export */
      emscripten_glDrawArraysInstancedANGLE: _emscripten_glDrawArraysInstancedANGLE,
      /** @export */
      emscripten_glDrawArraysInstancedARB: _emscripten_glDrawArraysInstancedARB,
      /** @export */
      emscripten_glDrawArraysInstancedBaseInstanceWEBGL: _emscripten_glDrawArraysInstancedBaseInstanceWEBGL,
      /** @export */
      emscripten_glDrawArraysInstancedEXT: _emscripten_glDrawArraysInstancedEXT,
      /** @export */
      emscripten_glDrawArraysInstancedNV: _emscripten_glDrawArraysInstancedNV,
      /** @export */
      emscripten_glDrawBuffers: _emscripten_glDrawBuffers,
      /** @export */
      emscripten_glDrawBuffersEXT: _emscripten_glDrawBuffersEXT,
      /** @export */
      emscripten_glDrawBuffersWEBGL: _emscripten_glDrawBuffersWEBGL,
      /** @export */
      emscripten_glDrawElements: _emscripten_glDrawElements,
      /** @export */
      emscripten_glDrawElementsInstanced: _emscripten_glDrawElementsInstanced,
      /** @export */
      emscripten_glDrawElementsInstancedANGLE: _emscripten_glDrawElementsInstancedANGLE,
      /** @export */
      emscripten_glDrawElementsInstancedARB: _emscripten_glDrawElementsInstancedARB,
      /** @export */
      emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL: _emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
      /** @export */
      emscripten_glDrawElementsInstancedEXT: _emscripten_glDrawElementsInstancedEXT,
      /** @export */
      emscripten_glDrawElementsInstancedNV: _emscripten_glDrawElementsInstancedNV,
      /** @export */
      emscripten_glDrawRangeElements: _emscripten_glDrawRangeElements,
      /** @export */
      emscripten_glEnable: _emscripten_glEnable,
      /** @export */
      emscripten_glEnableVertexAttribArray: _emscripten_glEnableVertexAttribArray,
      /** @export */
      emscripten_glEndQuery: _emscripten_glEndQuery,
      /** @export */
      emscripten_glEndQueryEXT: _emscripten_glEndQueryEXT,
      /** @export */
      emscripten_glEndTransformFeedback: _emscripten_glEndTransformFeedback,
      /** @export */
      emscripten_glFenceSync: _emscripten_glFenceSync,
      /** @export */
      emscripten_glFinish: _emscripten_glFinish,
      /** @export */
      emscripten_glFlush: _emscripten_glFlush,
      /** @export */
      emscripten_glFramebufferRenderbuffer: _emscripten_glFramebufferRenderbuffer,
      /** @export */
      emscripten_glFramebufferTexture2D: _emscripten_glFramebufferTexture2D,
      /** @export */
      emscripten_glFramebufferTextureLayer: _emscripten_glFramebufferTextureLayer,
      /** @export */
      emscripten_glFrontFace: _emscripten_glFrontFace,
      /** @export */
      emscripten_glGenBuffers: _emscripten_glGenBuffers,
      /** @export */
      emscripten_glGenFramebuffers: _emscripten_glGenFramebuffers,
      /** @export */
      emscripten_glGenQueries: _emscripten_glGenQueries,
      /** @export */
      emscripten_glGenQueriesEXT: _emscripten_glGenQueriesEXT,
      /** @export */
      emscripten_glGenRenderbuffers: _emscripten_glGenRenderbuffers,
      /** @export */
      emscripten_glGenSamplers: _emscripten_glGenSamplers,
      /** @export */
      emscripten_glGenTextures: _emscripten_glGenTextures,
      /** @export */
      emscripten_glGenTransformFeedbacks: _emscripten_glGenTransformFeedbacks,
      /** @export */
      emscripten_glGenVertexArrays: _emscripten_glGenVertexArrays,
      /** @export */
      emscripten_glGenVertexArraysOES: _emscripten_glGenVertexArraysOES,
      /** @export */
      emscripten_glGenerateMipmap: _emscripten_glGenerateMipmap,
      /** @export */
      emscripten_glGetActiveAttrib: _emscripten_glGetActiveAttrib,
      /** @export */
      emscripten_glGetActiveUniform: _emscripten_glGetActiveUniform,
      /** @export */
      emscripten_glGetActiveUniformBlockName: _emscripten_glGetActiveUniformBlockName,
      /** @export */
      emscripten_glGetActiveUniformBlockiv: _emscripten_glGetActiveUniformBlockiv,
      /** @export */
      emscripten_glGetActiveUniformsiv: _emscripten_glGetActiveUniformsiv,
      /** @export */
      emscripten_glGetAttachedShaders: _emscripten_glGetAttachedShaders,
      /** @export */
      emscripten_glGetAttribLocation: _emscripten_glGetAttribLocation,
      /** @export */
      emscripten_glGetBooleanv: _emscripten_glGetBooleanv,
      /** @export */
      emscripten_glGetBufferParameteri64v: _emscripten_glGetBufferParameteri64v,
      /** @export */
      emscripten_glGetBufferParameteriv: _emscripten_glGetBufferParameteriv,
      /** @export */
      emscripten_glGetError: _emscripten_glGetError,
      /** @export */
      emscripten_glGetFloatv: _emscripten_glGetFloatv,
      /** @export */
      emscripten_glGetFragDataLocation: _emscripten_glGetFragDataLocation,
      /** @export */
      emscripten_glGetFramebufferAttachmentParameteriv: _emscripten_glGetFramebufferAttachmentParameteriv,
      /** @export */
      emscripten_glGetInteger64i_v: _emscripten_glGetInteger64i_v,
      /** @export */
      emscripten_glGetInteger64v: _emscripten_glGetInteger64v,
      /** @export */
      emscripten_glGetIntegeri_v: _emscripten_glGetIntegeri_v,
      /** @export */
      emscripten_glGetIntegerv: _emscripten_glGetIntegerv,
      /** @export */
      emscripten_glGetInternalformativ: _emscripten_glGetInternalformativ,
      /** @export */
      emscripten_glGetProgramBinary: _emscripten_glGetProgramBinary,
      /** @export */
      emscripten_glGetProgramInfoLog: _emscripten_glGetProgramInfoLog,
      /** @export */
      emscripten_glGetProgramiv: _emscripten_glGetProgramiv,
      /** @export */
      emscripten_glGetQueryObjecti64vEXT: _emscripten_glGetQueryObjecti64vEXT,
      /** @export */
      emscripten_glGetQueryObjectivEXT: _emscripten_glGetQueryObjectivEXT,
      /** @export */
      emscripten_glGetQueryObjectui64vEXT: _emscripten_glGetQueryObjectui64vEXT,
      /** @export */
      emscripten_glGetQueryObjectuiv: _emscripten_glGetQueryObjectuiv,
      /** @export */
      emscripten_glGetQueryObjectuivEXT: _emscripten_glGetQueryObjectuivEXT,
      /** @export */
      emscripten_glGetQueryiv: _emscripten_glGetQueryiv,
      /** @export */
      emscripten_glGetQueryivEXT: _emscripten_glGetQueryivEXT,
      /** @export */
      emscripten_glGetRenderbufferParameteriv: _emscripten_glGetRenderbufferParameteriv,
      /** @export */
      emscripten_glGetSamplerParameterfv: _emscripten_glGetSamplerParameterfv,
      /** @export */
      emscripten_glGetSamplerParameteriv: _emscripten_glGetSamplerParameteriv,
      /** @export */
      emscripten_glGetShaderInfoLog: _emscripten_glGetShaderInfoLog,
      /** @export */
      emscripten_glGetShaderPrecisionFormat: _emscripten_glGetShaderPrecisionFormat,
      /** @export */
      emscripten_glGetShaderSource: _emscripten_glGetShaderSource,
      /** @export */
      emscripten_glGetShaderiv: _emscripten_glGetShaderiv,
      /** @export */
      emscripten_glGetString: _emscripten_glGetString,
      /** @export */
      emscripten_glGetStringi: _emscripten_glGetStringi,
      /** @export */
      emscripten_glGetSynciv: _emscripten_glGetSynciv,
      /** @export */
      emscripten_glGetTexParameterfv: _emscripten_glGetTexParameterfv,
      /** @export */
      emscripten_glGetTexParameteriv: _emscripten_glGetTexParameteriv,
      /** @export */
      emscripten_glGetTransformFeedbackVarying: _emscripten_glGetTransformFeedbackVarying,
      /** @export */
      emscripten_glGetUniformBlockIndex: _emscripten_glGetUniformBlockIndex,
      /** @export */
      emscripten_glGetUniformIndices: _emscripten_glGetUniformIndices,
      /** @export */
      emscripten_glGetUniformLocation: _emscripten_glGetUniformLocation,
      /** @export */
      emscripten_glGetUniformfv: _emscripten_glGetUniformfv,
      /** @export */
      emscripten_glGetUniformiv: _emscripten_glGetUniformiv,
      /** @export */
      emscripten_glGetUniformuiv: _emscripten_glGetUniformuiv,
      /** @export */
      emscripten_glGetVertexAttribIiv: _emscripten_glGetVertexAttribIiv,
      /** @export */
      emscripten_glGetVertexAttribIuiv: _emscripten_glGetVertexAttribIuiv,
      /** @export */
      emscripten_glGetVertexAttribPointerv: _emscripten_glGetVertexAttribPointerv,
      /** @export */
      emscripten_glGetVertexAttribfv: _emscripten_glGetVertexAttribfv,
      /** @export */
      emscripten_glGetVertexAttribiv: _emscripten_glGetVertexAttribiv,
      /** @export */
      emscripten_glHint: _emscripten_glHint,
      /** @export */
      emscripten_glInvalidateFramebuffer: _emscripten_glInvalidateFramebuffer,
      /** @export */
      emscripten_glInvalidateSubFramebuffer: _emscripten_glInvalidateSubFramebuffer,
      /** @export */
      emscripten_glIsBuffer: _emscripten_glIsBuffer,
      /** @export */
      emscripten_glIsEnabled: _emscripten_glIsEnabled,
      /** @export */
      emscripten_glIsFramebuffer: _emscripten_glIsFramebuffer,
      /** @export */
      emscripten_glIsProgram: _emscripten_glIsProgram,
      /** @export */
      emscripten_glIsQuery: _emscripten_glIsQuery,
      /** @export */
      emscripten_glIsQueryEXT: _emscripten_glIsQueryEXT,
      /** @export */
      emscripten_glIsRenderbuffer: _emscripten_glIsRenderbuffer,
      /** @export */
      emscripten_glIsSampler: _emscripten_glIsSampler,
      /** @export */
      emscripten_glIsShader: _emscripten_glIsShader,
      /** @export */
      emscripten_glIsSync: _emscripten_glIsSync,
      /** @export */
      emscripten_glIsTexture: _emscripten_glIsTexture,
      /** @export */
      emscripten_glIsTransformFeedback: _emscripten_glIsTransformFeedback,
      /** @export */
      emscripten_glIsVertexArray: _emscripten_glIsVertexArray,
      /** @export */
      emscripten_glIsVertexArrayOES: _emscripten_glIsVertexArrayOES,
      /** @export */
      emscripten_glLineWidth: _emscripten_glLineWidth,
      /** @export */
      emscripten_glLinkProgram: _emscripten_glLinkProgram,
      /** @export */
      emscripten_glMultiDrawArraysInstancedBaseInstanceWEBGL: _emscripten_glMultiDrawArraysInstancedBaseInstanceWEBGL,
      /** @export */
      emscripten_glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL: _emscripten_glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
      /** @export */
      emscripten_glPauseTransformFeedback: _emscripten_glPauseTransformFeedback,
      /** @export */
      emscripten_glPixelStorei: _emscripten_glPixelStorei,
      /** @export */
      emscripten_glPolygonModeWEBGL: _emscripten_glPolygonModeWEBGL,
      /** @export */
      emscripten_glPolygonOffset: _emscripten_glPolygonOffset,
      /** @export */
      emscripten_glPolygonOffsetClampEXT: _emscripten_glPolygonOffsetClampEXT,
      /** @export */
      emscripten_glProgramBinary: _emscripten_glProgramBinary,
      /** @export */
      emscripten_glProgramParameteri: _emscripten_glProgramParameteri,
      /** @export */
      emscripten_glQueryCounterEXT: _emscripten_glQueryCounterEXT,
      /** @export */
      emscripten_glReadBuffer: _emscripten_glReadBuffer,
      /** @export */
      emscripten_glReadPixels: _emscripten_glReadPixels,
      /** @export */
      emscripten_glReleaseShaderCompiler: _emscripten_glReleaseShaderCompiler,
      /** @export */
      emscripten_glRenderbufferStorage: _emscripten_glRenderbufferStorage,
      /** @export */
      emscripten_glRenderbufferStorageMultisample: _emscripten_glRenderbufferStorageMultisample,
      /** @export */
      emscripten_glResumeTransformFeedback: _emscripten_glResumeTransformFeedback,
      /** @export */
      emscripten_glSampleCoverage: _emscripten_glSampleCoverage,
      /** @export */
      emscripten_glSamplerParameterf: _emscripten_glSamplerParameterf,
      /** @export */
      emscripten_glSamplerParameterfv: _emscripten_glSamplerParameterfv,
      /** @export */
      emscripten_glSamplerParameteri: _emscripten_glSamplerParameteri,
      /** @export */
      emscripten_glSamplerParameteriv: _emscripten_glSamplerParameteriv,
      /** @export */
      emscripten_glScissor: _emscripten_glScissor,
      /** @export */
      emscripten_glShaderBinary: _emscripten_glShaderBinary,
      /** @export */
      emscripten_glShaderSource: _emscripten_glShaderSource,
      /** @export */
      emscripten_glStencilFunc: _emscripten_glStencilFunc,
      /** @export */
      emscripten_glStencilFuncSeparate: _emscripten_glStencilFuncSeparate,
      /** @export */
      emscripten_glStencilMask: _emscripten_glStencilMask,
      /** @export */
      emscripten_glStencilMaskSeparate: _emscripten_glStencilMaskSeparate,
      /** @export */
      emscripten_glStencilOp: _emscripten_glStencilOp,
      /** @export */
      emscripten_glStencilOpSeparate: _emscripten_glStencilOpSeparate,
      /** @export */
      emscripten_glTexImage2D: _emscripten_glTexImage2D,
      /** @export */
      emscripten_glTexImage3D: _emscripten_glTexImage3D,
      /** @export */
      emscripten_glTexParameterf: _emscripten_glTexParameterf,
      /** @export */
      emscripten_glTexParameterfv: _emscripten_glTexParameterfv,
      /** @export */
      emscripten_glTexParameteri: _emscripten_glTexParameteri,
      /** @export */
      emscripten_glTexParameteriv: _emscripten_glTexParameteriv,
      /** @export */
      emscripten_glTexStorage2D: _emscripten_glTexStorage2D,
      /** @export */
      emscripten_glTexStorage3D: _emscripten_glTexStorage3D,
      /** @export */
      emscripten_glTexSubImage2D: _emscripten_glTexSubImage2D,
      /** @export */
      emscripten_glTexSubImage3D: _emscripten_glTexSubImage3D,
      /** @export */
      emscripten_glTransformFeedbackVaryings: _emscripten_glTransformFeedbackVaryings,
      /** @export */
      emscripten_glUniform1f: _emscripten_glUniform1f,
      /** @export */
      emscripten_glUniform1fv: _emscripten_glUniform1fv,
      /** @export */
      emscripten_glUniform1i: _emscripten_glUniform1i,
      /** @export */
      emscripten_glUniform1iv: _emscripten_glUniform1iv,
      /** @export */
      emscripten_glUniform1ui: _emscripten_glUniform1ui,
      /** @export */
      emscripten_glUniform1uiv: _emscripten_glUniform1uiv,
      /** @export */
      emscripten_glUniform2f: _emscripten_glUniform2f,
      /** @export */
      emscripten_glUniform2fv: _emscripten_glUniform2fv,
      /** @export */
      emscripten_glUniform2i: _emscripten_glUniform2i,
      /** @export */
      emscripten_glUniform2iv: _emscripten_glUniform2iv,
      /** @export */
      emscripten_glUniform2ui: _emscripten_glUniform2ui,
      /** @export */
      emscripten_glUniform2uiv: _emscripten_glUniform2uiv,
      /** @export */
      emscripten_glUniform3f: _emscripten_glUniform3f,
      /** @export */
      emscripten_glUniform3fv: _emscripten_glUniform3fv,
      /** @export */
      emscripten_glUniform3i: _emscripten_glUniform3i,
      /** @export */
      emscripten_glUniform3iv: _emscripten_glUniform3iv,
      /** @export */
      emscripten_glUniform3ui: _emscripten_glUniform3ui,
      /** @export */
      emscripten_glUniform3uiv: _emscripten_glUniform3uiv,
      /** @export */
      emscripten_glUniform4f: _emscripten_glUniform4f,
      /** @export */
      emscripten_glUniform4fv: _emscripten_glUniform4fv,
      /** @export */
      emscripten_glUniform4i: _emscripten_glUniform4i,
      /** @export */
      emscripten_glUniform4iv: _emscripten_glUniform4iv,
      /** @export */
      emscripten_glUniform4ui: _emscripten_glUniform4ui,
      /** @export */
      emscripten_glUniform4uiv: _emscripten_glUniform4uiv,
      /** @export */
      emscripten_glUniformBlockBinding: _emscripten_glUniformBlockBinding,
      /** @export */
      emscripten_glUniformMatrix2fv: _emscripten_glUniformMatrix2fv,
      /** @export */
      emscripten_glUniformMatrix2x3fv: _emscripten_glUniformMatrix2x3fv,
      /** @export */
      emscripten_glUniformMatrix2x4fv: _emscripten_glUniformMatrix2x4fv,
      /** @export */
      emscripten_glUniformMatrix3fv: _emscripten_glUniformMatrix3fv,
      /** @export */
      emscripten_glUniformMatrix3x2fv: _emscripten_glUniformMatrix3x2fv,
      /** @export */
      emscripten_glUniformMatrix3x4fv: _emscripten_glUniformMatrix3x4fv,
      /** @export */
      emscripten_glUniformMatrix4fv: _emscripten_glUniformMatrix4fv,
      /** @export */
      emscripten_glUniformMatrix4x2fv: _emscripten_glUniformMatrix4x2fv,
      /** @export */
      emscripten_glUniformMatrix4x3fv: _emscripten_glUniformMatrix4x3fv,
      /** @export */
      emscripten_glUseProgram: _emscripten_glUseProgram,
      /** @export */
      emscripten_glValidateProgram: _emscripten_glValidateProgram,
      /** @export */
      emscripten_glVertexAttrib1f: _emscripten_glVertexAttrib1f,
      /** @export */
      emscripten_glVertexAttrib1fv: _emscripten_glVertexAttrib1fv,
      /** @export */
      emscripten_glVertexAttrib2f: _emscripten_glVertexAttrib2f,
      /** @export */
      emscripten_glVertexAttrib2fv: _emscripten_glVertexAttrib2fv,
      /** @export */
      emscripten_glVertexAttrib3f: _emscripten_glVertexAttrib3f,
      /** @export */
      emscripten_glVertexAttrib3fv: _emscripten_glVertexAttrib3fv,
      /** @export */
      emscripten_glVertexAttrib4f: _emscripten_glVertexAttrib4f,
      /** @export */
      emscripten_glVertexAttrib4fv: _emscripten_glVertexAttrib4fv,
      /** @export */
      emscripten_glVertexAttribDivisor: _emscripten_glVertexAttribDivisor,
      /** @export */
      emscripten_glVertexAttribDivisorANGLE: _emscripten_glVertexAttribDivisorANGLE,
      /** @export */
      emscripten_glVertexAttribDivisorARB: _emscripten_glVertexAttribDivisorARB,
      /** @export */
      emscripten_glVertexAttribDivisorEXT: _emscripten_glVertexAttribDivisorEXT,
      /** @export */
      emscripten_glVertexAttribDivisorNV: _emscripten_glVertexAttribDivisorNV,
      /** @export */
      emscripten_glVertexAttribI4i: _emscripten_glVertexAttribI4i,
      /** @export */
      emscripten_glVertexAttribI4iv: _emscripten_glVertexAttribI4iv,
      /** @export */
      emscripten_glVertexAttribI4ui: _emscripten_glVertexAttribI4ui,
      /** @export */
      emscripten_glVertexAttribI4uiv: _emscripten_glVertexAttribI4uiv,
      /** @export */
      emscripten_glVertexAttribIPointer: _emscripten_glVertexAttribIPointer,
      /** @export */
      emscripten_glVertexAttribPointer: _emscripten_glVertexAttribPointer,
      /** @export */
      emscripten_glViewport: _emscripten_glViewport,
      /** @export */
      emscripten_glWaitSync: _emscripten_glWaitSync,
      /** @export */
      emscripten_resize_heap: _emscripten_resize_heap,
      /** @export */
      environ_get: _environ_get,
      /** @export */
      environ_sizes_get: _environ_sizes_get,
      /** @export */
      exit: _exit,
      /** @export */
      fd_close: _fd_close,
      /** @export */
      fd_pread: _fd_pread,
      /** @export */
      fd_read: _fd_read,
      /** @export */
      fd_seek: _fd_seek,
      /** @export */
      fd_write: _fd_write,
      /** @export */
      glGetIntegerv: _glGetIntegerv,
      /** @export */
      glGetString: _glGetString,
      /** @export */
      glGetStringi: _glGetStringi,
      /** @export */
      invoke_dd,
      /** @export */
      invoke_dddd,
      /** @export */
      invoke_did,
      /** @export */
      invoke_diddi,
      /** @export */
      invoke_dii,
      /** @export */
      invoke_diii,
      /** @export */
      invoke_fffff,
      /** @export */
      invoke_fi,
      /** @export */
      invoke_fif,
      /** @export */
      invoke_fii,
      /** @export */
      invoke_fiif,
      /** @export */
      invoke_fiii,
      /** @export */
      invoke_i,
      /** @export */
      invoke_iffffffff,
      /** @export */
      invoke_iffii,
      /** @export */
      invoke_iffiii,
      /** @export */
      invoke_ii,
      /** @export */
      invoke_iif,
      /** @export */
      invoke_iiff,
      /** @export */
      invoke_iiffffff,
      /** @export */
      invoke_iiffi,
      /** @export */
      invoke_iifi,
      /** @export */
      invoke_iii,
      /** @export */
      invoke_iiif,
      /** @export */
      invoke_iiiff,
      /** @export */
      invoke_iiiffii,
      /** @export */
      invoke_iiii,
      /** @export */
      invoke_iiiii,
      /** @export */
      invoke_iiiiid,
      /** @export */
      invoke_iiiiii,
      /** @export */
      invoke_iiiiiii,
      /** @export */
      invoke_iiiiiiii,
      /** @export */
      invoke_iiiiiiiii,
      /** @export */
      invoke_iiiiiiiiii,
      /** @export */
      invoke_iiiiiiiiiii,
      /** @export */
      invoke_iiiiiiiiiiii,
      /** @export */
      invoke_iiiiiiiiiiiii,
      /** @export */
      invoke_jii,
      /** @export */
      invoke_jiii,
      /** @export */
      invoke_jiiii,
      /** @export */
      invoke_v,
      /** @export */
      invoke_vffi,
      /** @export */
      invoke_vi,
      /** @export */
      invoke_vif,
      /** @export */
      invoke_viff,
      /** @export */
      invoke_vifff,
      /** @export */
      invoke_viffff,
      /** @export */
      invoke_viffffff,
      /** @export */
      invoke_vii,
      /** @export */
      invoke_viiddiddd,
      /** @export */
      invoke_viif,
      /** @export */
      invoke_viiff,
      /** @export */
      invoke_viiffi,
      /** @export */
      invoke_viiffii,
      /** @export */
      invoke_viiffiiiiffff,
      /** @export */
      invoke_viiffiiiiiffff,
      /** @export */
      invoke_viifiii,
      /** @export */
      invoke_viii,
      /** @export */
      invoke_viiidd,
      /** @export */
      invoke_viiif,
      /** @export */
      invoke_viiiff,
      /** @export */
      invoke_viiii,
      /** @export */
      invoke_viiiifiii,
      /** @export */
      invoke_viiiii,
      /** @export */
      invoke_viiiiif,
      /** @export */
      invoke_viiiiiffffi,
      /** @export */
      invoke_viiiiifffi,
      /** @export */
      invoke_viiiiifiii,
      /** @export */
      invoke_viiiiii,
      /** @export */
      invoke_viiiiiii,
      /** @export */
      invoke_viiiiiiii,
      /** @export */
      invoke_viiiiiiiii,
      /** @export */
      invoke_viiiiiiiiii,
      /** @export */
      invoke_viiiiiiiiiiiiiii,
      /** @export */
      invoke_viiijdjd,
      /** @export */
      invoke_viiji,
      /** @export */
      invoke_vijj,
      /** @export */
      invoke_vijjjj,
      /** @export */
      llvm_eh_typeid_for: _llvm_eh_typeid_for,
      /** @export */
      random_get: _random_get,
      /** @export */
      wapi_cancelAnimationFrame: _wapi_cancelAnimationFrame,
      /** @export */
      wapi_requestAnimationFrame: _wapi_requestAnimationFrame
    };
    function invoke_viiii(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_vi(index, a1) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viii(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiii(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_ii(index, a1) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_vii(index, a1, a2) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiii(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iii(index, a1, a2) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_jiii(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
        return 0n;
      }
    }
    function invoke_jii(index, a1, a2) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
        return 0n;
      }
    }
    function invoke_iif(index, a1, a2) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iffii(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiii(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiif(index, a1, a2, a3, a4, a5, a6) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiff(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiif(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiffii(index, a1, a2, a3, a4, a5, a6) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_fi(index, a1) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiff(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiffii(index, a1, a2, a3, a4, a5, a6) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viff(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viifiii(index, a1, a2, a3, a4, a5, a6) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viffff(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_fif(index, a1, a2) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_fffff(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiff(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiji(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_vif(index, a1, a2) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiijdjd(index, a1, a2, a3, a4, a5, a6, a7) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_i(index) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)();
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_vijj(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_v(index) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)();
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viif(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiff(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiffiiiiiffff(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiffiiiiffff(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viffffff(index, a1, a2, a3, a4, a5, a6, a7) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_vffi(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_vifff(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiffi(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiffffff(index, a1, a2, a3, a4, a5, a6, a7) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiffi(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiif(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_fiii(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_diddi(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_fiif(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iffiii(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iffffffff(index, a1, a2, a3, a4, a5, a6, a7, a8) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iifi(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiifffi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiffffi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_fii(index, a1, a2) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_did(index, a1, a2) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiidd(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_dii(index, a1, a2) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiddiddd(index, a1, a2, a3, a4, a5, a6, a7, a8) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_vijjjj(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_dd(index, a1) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_dddd(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiid(index, a1, a2, a3, a4, a5) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_jiiii(index, a1, a2, a3, a4) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
        return 0n;
      }
    }
    function invoke_iiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_diii(index, a1, a2, a3) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_iiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    var calledRun;
    function callMain(args = []) {
      assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');
      assert(typeof onPreRuns === "undefined" || onPreRuns.length == 0, "cannot call main when preRun functions remain to be called");
      var entryFunction = _main;
      args.unshift(thisProgram);
      var argc = args.length;
      var argv = stackAlloc((argc + 1) * 4);
      var argv_ptr = argv;
      for (var arg of args) {
        HEAPU32[argv_ptr >> 2] = stringToUTF8OnStack(arg);
        argv_ptr += 4;
      }
      HEAPU32[argv_ptr >> 2] = 0;
      try {
        var ret = entryFunction(argc, argv);
        exitJS(
          ret,
          /* implicit = */
          true
        );
        return ret;
      } catch (e) {
        return handleException(e);
      }
    }
    function stackCheckInit() {
      _emscripten_stack_init();
      writeStackCookie();
    }
    function run(args = arguments_) {
      if (runDependencies > 0) {
        dependenciesFulfilled = run;
        return;
      }
      stackCheckInit();
      preRun();
      if (runDependencies > 0) {
        dependenciesFulfilled = run;
        return;
      }
      function doRun() {
        assert(!calledRun);
        calledRun = true;
        Module["calledRun"] = true;
        if (ABORT) return;
        initRuntime();
        preMain();
        readyPromiseResolve?.(Module);
        Module["onRuntimeInitialized"]?.();
        consumedModuleProp("onRuntimeInitialized");
        var noInitialRun = Module["noInitialRun"] || false;
        if (!noInitialRun) callMain(args);
        postRun();
      }
      if (Module["setStatus"]) {
        Module["setStatus"]("Running...");
        setTimeout(() => {
          setTimeout(() => Module["setStatus"](""), 1);
          doRun();
        }, 1);
      } else {
        doRun();
      }
      checkStackCookie();
    }
    function checkUnflushedContent() {
      var oldOut = out;
      var oldErr = err;
      var has = false;
      out = err = (x) => {
        has = true;
      };
      try {
        _fflush(0);
        for (var name of ["stdout", "stderr"]) {
          var info = FS.analyzePath("/dev/" + name);
          if (!info) return;
          var stream = info.object;
          var rdev = stream.rdev;
          var tty = TTY.ttys[rdev];
          if (tty?.output?.length) {
            has = true;
          }
        }
      } catch (e) {
      }
      out = oldOut;
      err = oldErr;
      if (has) {
        warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.");
      }
    }
    var wasmExports;
    wasmExports = await createWasm();
    run();
    if (runtimeInitialized) {
      moduleRtn = Module;
    } else {
      moduleRtn = new Promise((resolve, reject) => {
        readyPromiseResolve = resolve;
        readyPromiseReject = reject;
      });
    }
    for (const prop of Object.keys(Module)) {
      if (!(prop in moduleArg)) {
        Object.defineProperty(moduleArg, prop, {
          configurable: true,
          get() {
            abort(`Access to module property ('${prop}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`);
          }
        });
      }
    }
    return moduleRtn;
  }
  var render_wasm_default = createRustSkiaModule;
  return __toCommonJS(render_wasm_exports);
})();
