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 Module = moduleArg;
    var ENVIRONMENT_IS_WEB = true;
    var ENVIRONMENT_IS_WORKER = false;
    var ENVIRONMENT_IS_NODE = false;
    var ENVIRONMENT_IS_SHELL = false;
    var programArgs = [];
    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_WEB || ENVIRONMENT_IS_WORKER) {
      try {
        scriptDirectory = new URL(".", _scriptName).href;
      } catch {
      }
      {
        readAsync = async (url) => {
          var response = await fetch(url, { credentials: "same-origin" });
          if (response.ok) {
            return response.arrayBuffer();
          }
          throw new Error(response.status + " : " + response.url);
        };
      }
    } else {
    }
    var out = console.log.bind(console);
    var err = console.error.bind(console);
    var wasmBinary;
    var ABORT = false;
    var EXITSTATUS;
    function assert(condition, text) {
      if (!condition) {
        abort(text);
      }
    }
    var isFileURI = (filename) => filename.startsWith("file://");
    class EmscriptenEH {
    }
    class EmscriptenSjLj extends EmscriptenEH {
    }
    var runtimeInitialized = false;
    function getMemoryBuffer() {
      return wasmMemory.buffer;
    }
    function updateMemoryViews() {
      if (HEAP8?.buffer?.resizable) return;
      var b = getMemoryBuffer();
      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);
    }
    function preRun() {
      var preRun2 = Module["preRun"];
      if (preRun2) {
        if (typeof preRun2 == "function") preRun2 = [preRun2];
        onPreRuns.push(...preRun2);
      }
      callRuntimeCallbacks(onPreRuns);
    }
    function initRuntime() {
      runtimeInitialized = true;
      wasmExports["__wasm_call_ctors"]();
    }
    function postRun() {
      var postRun2 = Module["postRun"];
      if (postRun2) {
        if (typeof postRun2 == "function") postRun2 = [postRun2];
        onPostRuns.push(...postRun2);
      }
      callRuntimeCallbacks(onPostRuns);
    }
    function abort(what) {
      Module["onAbort"]?.(what);
      what = `Aborted(${what})`;
      err(what);
      ABORT = true;
      what += ". Build with -sASSERTIONS for more info.";
      var e = new WebAssembly.RuntimeError(what);
      throw e;
    }
    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 (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}`);
        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) {
        wasmExports = instance.exports;
        assignWasmExports(wasmExports);
        updateMemoryViews();
        return wasmExports;
      }
      function receiveInstantiationResult(result2) {
        return receiveInstance(result2["instance"]);
      }
      var info = getWasmImports();
      var instantiateWasm = Module["instantiateWasm"];
      if (instantiateWasm) {
        return new Promise((resolve) => {
          instantiateWasm(info, (inst) => resolve(receiveInstance(inst)));
        });
      }
      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(ptr2, type = "i8") {
      if (type.endsWith("*")) type = "*";
      switch (type) {
        case "i1":
          return HEAP8[ptr2];
        case "i8":
          return HEAP8[ptr2];
        case "i16":
          return HEAP16[ptr2 >> 1];
        case "i32":
          return HEAP32[ptr2 >> 2];
        case "i64":
          return HEAP64[ptr2 >> 3];
        case "float":
          return HEAPF32[ptr2 >> 2];
        case "double":
          return HEAPF64[ptr2 >> 3];
        case "*":
          return HEAPU32[ptr2 >> 2];
        default:
          abort(`invalid type for getValue: ${type}`);
      }
    }
    var noExitRuntime = true;
    function setValue(ptr2, value, type = "i8") {
      if (type.endsWith("*")) type = "*";
      switch (type) {
        case "i1":
          HEAP8[ptr2] = value;
          break;
        case "i8":
          HEAP8[ptr2] = value;
          break;
        case "i16":
          HEAP16[ptr2 >> 1] = value;
          break;
        case "i32":
          HEAP32[ptr2 >> 2] = value;
          break;
        case "i64":
          HEAP64[ptr2 >> 3] = BigInt(value);
          break;
        case "float":
          HEAPF32[ptr2 >> 2] = value;
          break;
        case "double":
          HEAPF64[ptr2 >> 3] = value;
          break;
        case "*":
          HEAPU32[ptr2 >> 2] = value;
          break;
        default:
          abort(`invalid type for setValue: ${type}`);
      }
    }
    var stackRestore = (val) => __emscripten_stack_restore(val);
    var stackSave = () => _emscripten_stack_get_current();
    var exceptionCaught = [];
    var uncaughtExceptionCount = 0;
    var ___cxa_begin_catch = (ptr2) => {
      var info = new ExceptionInfo(ptr2);
      if (!info.get_caught()) {
        info.set_caught(true);
        uncaughtExceptionCount--;
      }
      info.set_rethrown(false);
      exceptionCaught.push(info);
      return ___cxa_get_exception_ptr(ptr2);
    };
    var ___cxa_end_catch = () => {
      _setThrew(0, 0);
      var info = exceptionCaught.pop();
      ___cxa_decrement_exception_refcount(info.excPtr);
    };
    var findMatchingCatch = (args) => {
      setTempRet0(0);
      return 0;
    };
    var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
    var ___cxa_find_matching_catch_4 = (arg0, arg1) => findMatchingCatch([arg0, arg1]);
    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 ___cxa_throw = (ptr2, type, destructor) => {
      var info = new ExceptionInfo(ptr2);
      info.init(type, destructor);
      uncaughtExceptionCount++;
      abort();
    };
    var ___resumeException = (ptr2) => {
      abort();
    };
    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 {
          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 = (ptr2, maxBytesToRead, ignoreNul) => {
      return ptr2 ? UTF8ArrayToString(HEAPU8, ptr2, maxBytesToRead, ignoreNul) : "";
    };
    var SYSCALLS = {
      varargs: void 0,
      getStr(ptr2) {
        var ret = UTF8ToString(ptr2);
        return ret;
      }
    };
    function ___syscall_fcntl64(fd, cmd, varargs) {
      SYSCALLS.varargs = varargs;
      return 0;
    }
    var ___syscall_fstat64 = (fd, buf) => {
    };
    var ___syscall_getcwd = (buf, size) => {
    };
    function ___syscall_ioctl(fd, op, varargs) {
      SYSCALLS.varargs = varargs;
      return 0;
    }
    var ___syscall_lstat64 = (path, buf) => {
    };
    var ___syscall_newfstatat = (dirfd, path, buf, flags) => {
    };
    function ___syscall_openat(dirfd, path, flags, varargs) {
      SYSCALLS.varargs = varargs;
    }
    var ___syscall_stat64 = (path, buf) => {
    };
    var __abort_js = () => 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 __gmtime_js(time, tmPtr) {
      time = bigintToI53Checked(time);
      var date = new Date(time * 1e3);
      if (isNaN(date.getTime())) {
        return 1;
      }
      HEAP32[tmPtr >> 2] = date.getUTCSeconds();
      HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
      HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
      HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
      HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
      HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
      HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
      var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
      var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
      HEAP32[tmPtr + 28 >> 2] = yday;
      return 0;
      ;
    }
    function __mmap_js(len, prot, flags, fd, offset, allocated, addr) {
      offset = bigintToI53Checked(offset);
      return -52;
      ;
    }
    function __munmap_js(addr, len, prot, flags, fd, offset) {
      offset = bigintToI53Checked(offset);
      ;
    }
    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
      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;
          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 stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
    };
    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);
      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 webglBufferSubData = (target, offset, size, data, src = HEAPU8) => {
      if (GL.currentContext.version >= 2) {
        size && GLctx.bufferSubData(target, offset, src, data, size);
        return;
      }
      GLctx.bufferSubData(target, offset, src.subarray(data, data + size));
    };
    var _emscripten_glBufferSubData = (target, offset, size, data) => webglBufferSubData(target, offset, size, data);
    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 writeI53ToI64 = (ptr2, num) => {
      HEAPU32[ptr2 >> 2] = num;
      var lower = HEAPU32[ptr2 >> 2];
      HEAPU32[ptr2 + 4 >> 2] = (num - lower) / 4294967296;
    };
    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 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 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 webglGetProgramUniformLocation = (program, location) => {
      if (program) {
        var webglLoc = program.uniformLocsById[location];
        if (typeof webglLoc == "number") {
          program.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(program, program.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, webglGetProgramUniformLocation(program, 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) => {
      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);
      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) : 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) : 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 webglGetUniformLocation = (location) => {
      return webglGetProgramUniformLocation(GLctx.currentProgram, location);
    };
    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, ptr2) => {
      GLctx.vertexAttribIPointer(index, size, type, stride, ptr2);
    };
    var _emscripten_glVertexAttribPointer = (index, size, type, normalized, stride, ptr2) => {
      GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr2);
    };
    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 alignMemory = (size, alignment) => {
      return Math.ceil(size / alignment) * alignment;
    };
    var growMemory = (size) => {
      var oldHeapSize = wasmMemory.buffer.byteLength;
      var pages = (size - oldHeapSize + 65535) / 65536 | 0;
      try {
        wasmMemory.grow(pages);
        updateMemoryViews();
        return 1;
      } catch (e) {
      }
    };
    var _emscripten_resize_heap = (requestedSize) => {
      var oldSize = HEAPU8.length;
      requestedSize >>>= 0;
      var maxHeapSize = getHeapMax();
      if (requestedSize > maxHeapSize) {
        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;
        }
      }
      return false;
    };
    var _emscripten_run_script = (ptr) => {
      eval(UTF8ToString(ptr));
    };
    var ENV = {};
    var getExecutableName = () => thisProgram;
    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 ptr2 = environ_buf + bufSize;
        HEAPU32[__environ + envp >> 2] = ptr2;
        bufSize += stringToUTF8(string, ptr2, 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;
      _proc_exit(status);
    };
    var _exit = exitJS;
    var _fd_close = (fd) => {
      return 52;
    };
    function _fd_pread(fd, iov, iovcnt, offset, pnum) {
      offset = bigintToI53Checked(offset);
      return 52;
      ;
    }
    var _fd_read = (fd, iov, iovcnt, pnum) => {
      return 52;
    };
    function _fd_seek(fd, offset, whence, newOffset) {
      offset = bigintToI53Checked(offset);
      return 70;
      ;
    }
    var printCharBuffers = [null, [], []];
    var printChar = (stream, curr) => {
      var buffer = printCharBuffers[stream];
      if (curr === 0 || curr === 10) {
        (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
        buffer.length = 0;
      } else {
        buffer.push(curr);
      }
    };
    var flush_NO_FILESYSTEM = () => {
      if (printCharBuffers[1].length) printChar(1, 10);
      if (printCharBuffers[2].length) printChar(2, 10);
    };
    var _fd_write = (fd, iov, iovcnt, pnum) => {
      var num = 0;
      for (var i2 = 0; i2 < iovcnt; i2++) {
        var ptr2 = HEAPU32[iov >> 2];
        var len = HEAPU32[iov + 4 >> 2];
        iov += 8;
        for (var j = 0; j < len; j++) {
          printChar(fd, HEAPU8[ptr2 + j]);
        }
        num += len;
      }
      HEAPU32[pnum >> 2] = num;
      return 0;
    };
    var _glGetIntegerv = _emscripten_glGetIntegerv;
    var _glGetString = _emscripten_glGetString;
    var _glGetStringi = _emscripten_glGetStringi;
    var _llvm_eh_typeid_for = (type) => type;
    var initRandomFill = () => {
      return (view) => (crypto.getRandomValues(view), 0);
    };
    var randomFill = (view) => (randomFill = initRandomFill())(view);
    var _random_get = (buffer, size) => randomFill(HEAPU8.subarray(buffer, buffer + size));
    function _wapi_notifyTilesRenderComplete() {
      if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
        return;
      }
      document.dispatchEvent(new CustomEvent("penpot:wasm:tiles-complete"));
    }
    var handleException = (e) => {
      if (e instanceof ExitStatus || e == "unwind") {
        return EXITSTATUS;
      }
      quit_(1, e);
    };
    var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
    var stringToUTF8OnStack = (str) => {
      var size = lengthBytesUTF8(str) + 1;
      var ret = stackAlloc(size);
      stringToUTF8(str, ret, size);
      return ret;
    };
    var wasmTableMirror = [];
    var getWasmTableEntry = (funcPtr) => {
      var func = wasmTableMirror[funcPtr];
      if (!func) {
        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
      }
      return func;
    };
    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["print"]) out = Module["print"];
      if (Module["printErr"]) err = Module["printErr"];
      if (Module["arguments"]) programArgs = Module["arguments"];
      if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
      var preInit = Module["preInit"];
      if (preInit) {
        if (typeof preInit == "function") Module["preInit"] = preInit = [preInit];
        while (preInit.length > 0) {
          preInit.shift()();
        }
      }
    }
    Module["UTF8ToString"] = UTF8ToString;
    Module["stringToUTF8"] = stringToUTF8;
    Module["GL"] = GL;
    var _malloc, _add_shape_center_stroke, _add_shape_child, _add_shape_fill, _add_shape_inner_stroke, _add_shape_outer_stroke, _add_shape_shadow, _add_shape_stroke_fill, _alloc_bytes, _begin_loading, _calculate_bool, _calculate_position_data, _capture_frames, _clean_modifiers, _clean_up, _clear_focus_mode, _clear_render_include_filter, _clear_shape_blur, _clear_shape_constraints, _clear_shape_fills, _clear_shape_layout, _clear_shape_shadows, _clear_shape_strokes, _clear_shape_text, _convert_stroke_to_path, _current_to_path, _debug_atlas_base64, _debug_atlas_console, _debug_cache_base64, _debug_cache_console, _debug_surface_console, _end_loading, _end_temp_objects, _find_guide_at, _force_update_shape_text_layout_for, _free_bytes, _free_gpu_resources, _get_grid_coords, _get_selection_rect, _get_shape_extrect, _get_text_dimensions, _has_shape, _hide_grid, _init, _init_shapes_pool, _intersect_position_in_shape, _is_font_uploaded, _is_image_cached, _propagate_modifiers, _read_error_code, _render, _render_blurred_snapshot, _render_from_cache, _render_loading_overlay, _render_preview, _render_shape_pdf, _render_shape_pixels, _render_stats, _render_sync, _render_sync_shape, _render_ui_only, _reset_canvas, _resize_viewbox, _set_antialias_threshold, _set_blur_downscale_threshold, _set_browser, _set_canvas_background, _set_children, _set_children_0, _set_children_1, _set_children_2, _set_children_3, _set_children_4, _set_children_5, _set_flex_layout_data, _set_focus_mode, _set_grid_cells, _set_grid_columns, _set_grid_layout_data, _set_grid_rows, _set_guides, _set_layout_data, _set_max_blocking_time_ms, _set_modifiers, _set_modifiers_end, _set_modifiers_start, _set_node_batch_threshold, _set_parent, _set_preview_mode, _set_render_include_filter, _set_render_options, _set_rulers_colors, _set_rulers_frame_visible, _set_rulers_offsets, _set_rulers_selection, _set_rulers_visible, _set_shape_base_props, _set_shape_blend_mode, _set_shape_blur, _set_shape_bool_type, _set_shape_clip_content, _set_shape_constraint_h, _set_shape_constraint_v, _set_shape_corners, _set_shape_fills, _set_shape_grow_type, _set_shape_hidden, _set_shape_masked_group, _set_shape_opacity, _set_shape_path_buffer, _set_shape_path_chunk_buffer, _set_shape_path_content, _set_shape_rotation, _set_shape_selrect, _set_shape_svg_attrs, _set_shape_svg_raw_content, _set_shape_text_content, _set_shape_transform, _set_shape_type, _set_shape_vertical_align, _set_structure_modifiers, _set_view, _set_view_end, _set_view_start, _set_viewport_interest_area_threshold, _show_grid, _start_shape_path_buffer, _start_temp_objects, _store_font, _store_image, _store_image_from_texture, _text_editor_apply_theme, _text_editor_blur, _text_editor_composition_end, _text_editor_composition_start, _text_editor_composition_update, _text_editor_delete_backward, _text_editor_delete_forward, _text_editor_dispose, _text_editor_export_content, _text_editor_export_selection, _text_editor_focus, _text_editor_get_active_shape_id, _text_editor_get_current_styles, _text_editor_get_cursor_rect, _text_editor_get_selection, _text_editor_get_selection_rects, _text_editor_has_focus, _text_editor_has_focus_with_id, _text_editor_has_selection, _text_editor_insert_paragraph, _text_editor_insert_text, _text_editor_move_cursor, _text_editor_pointer_down, _text_editor_pointer_move, _text_editor_pointer_up, _text_editor_poll_event, _text_editor_render_overlay, _text_editor_select_all, _text_editor_select_word_boundary, _text_editor_set_cursor_from_offset, _text_editor_set_cursor_from_point, _text_editor_toggle_overtype_mode, _text_editor_update_blink, _touch_shape, _update_shape_text_layout, _update_shape_text_layout_for, _use_shape, _main, _setThrew, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, ___cxa_decrement_exception_refcount, ___cxa_get_exception_ptr, memory, __indirect_function_table, wasmMemory, wasmTable;
    function assignWasmExports(wasmExports2) {
      _malloc = wasmExports2["malloc"];
      _add_shape_center_stroke = Module["_add_shape_center_stroke"] = wasmExports2["add_shape_center_stroke"];
      _add_shape_child = Module["_add_shape_child"] = wasmExports2["add_shape_child"];
      _add_shape_fill = Module["_add_shape_fill"] = wasmExports2["add_shape_fill"];
      _add_shape_inner_stroke = Module["_add_shape_inner_stroke"] = wasmExports2["add_shape_inner_stroke"];
      _add_shape_outer_stroke = Module["_add_shape_outer_stroke"] = wasmExports2["add_shape_outer_stroke"];
      _add_shape_shadow = Module["_add_shape_shadow"] = wasmExports2["add_shape_shadow"];
      _add_shape_stroke_fill = Module["_add_shape_stroke_fill"] = wasmExports2["add_shape_stroke_fill"];
      _alloc_bytes = Module["_alloc_bytes"] = wasmExports2["alloc_bytes"];
      _begin_loading = Module["_begin_loading"] = wasmExports2["begin_loading"];
      _calculate_bool = Module["_calculate_bool"] = wasmExports2["calculate_bool"];
      _calculate_position_data = Module["_calculate_position_data"] = wasmExports2["calculate_position_data"];
      _capture_frames = Module["_capture_frames"] = wasmExports2["capture_frames"];
      _clean_modifiers = Module["_clean_modifiers"] = wasmExports2["clean_modifiers"];
      _clean_up = Module["_clean_up"] = wasmExports2["clean_up"];
      _clear_focus_mode = Module["_clear_focus_mode"] = wasmExports2["clear_focus_mode"];
      _clear_render_include_filter = Module["_clear_render_include_filter"] = wasmExports2["clear_render_include_filter"];
      _clear_shape_blur = Module["_clear_shape_blur"] = wasmExports2["clear_shape_blur"];
      _clear_shape_constraints = Module["_clear_shape_constraints"] = wasmExports2["clear_shape_constraints"];
      _clear_shape_fills = Module["_clear_shape_fills"] = wasmExports2["clear_shape_fills"];
      _clear_shape_layout = Module["_clear_shape_layout"] = wasmExports2["clear_shape_layout"];
      _clear_shape_shadows = Module["_clear_shape_shadows"] = wasmExports2["clear_shape_shadows"];
      _clear_shape_strokes = Module["_clear_shape_strokes"] = wasmExports2["clear_shape_strokes"];
      _clear_shape_text = Module["_clear_shape_text"] = wasmExports2["clear_shape_text"];
      _convert_stroke_to_path = Module["_convert_stroke_to_path"] = wasmExports2["convert_stroke_to_path"];
      _current_to_path = Module["_current_to_path"] = wasmExports2["current_to_path"];
      _debug_atlas_base64 = Module["_debug_atlas_base64"] = wasmExports2["debug_atlas_base64"];
      _debug_atlas_console = Module["_debug_atlas_console"] = wasmExports2["debug_atlas_console"];
      _debug_cache_base64 = Module["_debug_cache_base64"] = wasmExports2["debug_cache_base64"];
      _debug_cache_console = Module["_debug_cache_console"] = wasmExports2["debug_cache_console"];
      _debug_surface_console = Module["_debug_surface_console"] = wasmExports2["debug_surface_console"];
      _end_loading = Module["_end_loading"] = wasmExports2["end_loading"];
      _end_temp_objects = Module["_end_temp_objects"] = wasmExports2["end_temp_objects"];
      _find_guide_at = Module["_find_guide_at"] = wasmExports2["find_guide_at"];
      _force_update_shape_text_layout_for = Module["_force_update_shape_text_layout_for"] = wasmExports2["force_update_shape_text_layout_for"];
      _free_bytes = Module["_free_bytes"] = wasmExports2["free_bytes"];
      _free_gpu_resources = Module["_free_gpu_resources"] = wasmExports2["free_gpu_resources"];
      _get_grid_coords = Module["_get_grid_coords"] = wasmExports2["get_grid_coords"];
      _get_selection_rect = Module["_get_selection_rect"] = wasmExports2["get_selection_rect"];
      _get_shape_extrect = Module["_get_shape_extrect"] = wasmExports2["get_shape_extrect"];
      _get_text_dimensions = Module["_get_text_dimensions"] = wasmExports2["get_text_dimensions"];
      _has_shape = Module["_has_shape"] = wasmExports2["has_shape"];
      _hide_grid = Module["_hide_grid"] = wasmExports2["hide_grid"];
      _init = Module["_init"] = wasmExports2["init"];
      _init_shapes_pool = Module["_init_shapes_pool"] = wasmExports2["init_shapes_pool"];
      _intersect_position_in_shape = Module["_intersect_position_in_shape"] = wasmExports2["intersect_position_in_shape"];
      _is_font_uploaded = Module["_is_font_uploaded"] = wasmExports2["is_font_uploaded"];
      _is_image_cached = Module["_is_image_cached"] = wasmExports2["is_image_cached"];
      _propagate_modifiers = Module["_propagate_modifiers"] = wasmExports2["propagate_modifiers"];
      _read_error_code = Module["_read_error_code"] = wasmExports2["read_error_code"];
      _render = Module["_render"] = wasmExports2["render"];
      _render_blurred_snapshot = Module["_render_blurred_snapshot"] = wasmExports2["render_blurred_snapshot"];
      _render_from_cache = Module["_render_from_cache"] = wasmExports2["render_from_cache"];
      _render_loading_overlay = Module["_render_loading_overlay"] = wasmExports2["render_loading_overlay"];
      _render_preview = Module["_render_preview"] = wasmExports2["render_preview"];
      _render_shape_pdf = Module["_render_shape_pdf"] = wasmExports2["render_shape_pdf"];
      _render_shape_pixels = Module["_render_shape_pixels"] = wasmExports2["render_shape_pixels"];
      _render_stats = Module["_render_stats"] = wasmExports2["render_stats"];
      _render_sync = Module["_render_sync"] = wasmExports2["render_sync"];
      _render_sync_shape = Module["_render_sync_shape"] = wasmExports2["render_sync_shape"];
      _render_ui_only = Module["_render_ui_only"] = wasmExports2["render_ui_only"];
      _reset_canvas = Module["_reset_canvas"] = wasmExports2["reset_canvas"];
      _resize_viewbox = Module["_resize_viewbox"] = wasmExports2["resize_viewbox"];
      _set_antialias_threshold = Module["_set_antialias_threshold"] = wasmExports2["set_antialias_threshold"];
      _set_blur_downscale_threshold = Module["_set_blur_downscale_threshold"] = wasmExports2["set_blur_downscale_threshold"];
      _set_browser = Module["_set_browser"] = wasmExports2["set_browser"];
      _set_canvas_background = Module["_set_canvas_background"] = wasmExports2["set_canvas_background"];
      _set_children = Module["_set_children"] = wasmExports2["set_children"];
      _set_children_0 = Module["_set_children_0"] = wasmExports2["set_children_0"];
      _set_children_1 = Module["_set_children_1"] = wasmExports2["set_children_1"];
      _set_children_2 = Module["_set_children_2"] = wasmExports2["set_children_2"];
      _set_children_3 = Module["_set_children_3"] = wasmExports2["set_children_3"];
      _set_children_4 = Module["_set_children_4"] = wasmExports2["set_children_4"];
      _set_children_5 = Module["_set_children_5"] = wasmExports2["set_children_5"];
      _set_flex_layout_data = Module["_set_flex_layout_data"] = wasmExports2["set_flex_layout_data"];
      _set_focus_mode = Module["_set_focus_mode"] = wasmExports2["set_focus_mode"];
      _set_grid_cells = Module["_set_grid_cells"] = wasmExports2["set_grid_cells"];
      _set_grid_columns = Module["_set_grid_columns"] = wasmExports2["set_grid_columns"];
      _set_grid_layout_data = Module["_set_grid_layout_data"] = wasmExports2["set_grid_layout_data"];
      _set_grid_rows = Module["_set_grid_rows"] = wasmExports2["set_grid_rows"];
      _set_guides = Module["_set_guides"] = wasmExports2["set_guides"];
      _set_layout_data = Module["_set_layout_data"] = wasmExports2["set_layout_data"];
      _set_max_blocking_time_ms = Module["_set_max_blocking_time_ms"] = wasmExports2["set_max_blocking_time_ms"];
      _set_modifiers = Module["_set_modifiers"] = wasmExports2["set_modifiers"];
      _set_modifiers_end = Module["_set_modifiers_end"] = wasmExports2["set_modifiers_end"];
      _set_modifiers_start = Module["_set_modifiers_start"] = wasmExports2["set_modifiers_start"];
      _set_node_batch_threshold = Module["_set_node_batch_threshold"] = wasmExports2["set_node_batch_threshold"];
      _set_parent = Module["_set_parent"] = wasmExports2["set_parent"];
      _set_preview_mode = Module["_set_preview_mode"] = wasmExports2["set_preview_mode"];
      _set_render_include_filter = Module["_set_render_include_filter"] = wasmExports2["set_render_include_filter"];
      _set_render_options = Module["_set_render_options"] = wasmExports2["set_render_options"];
      _set_rulers_colors = Module["_set_rulers_colors"] = wasmExports2["set_rulers_colors"];
      _set_rulers_frame_visible = Module["_set_rulers_frame_visible"] = wasmExports2["set_rulers_frame_visible"];
      _set_rulers_offsets = Module["_set_rulers_offsets"] = wasmExports2["set_rulers_offsets"];
      _set_rulers_selection = Module["_set_rulers_selection"] = wasmExports2["set_rulers_selection"];
      _set_rulers_visible = Module["_set_rulers_visible"] = wasmExports2["set_rulers_visible"];
      _set_shape_base_props = Module["_set_shape_base_props"] = wasmExports2["set_shape_base_props"];
      _set_shape_blend_mode = Module["_set_shape_blend_mode"] = wasmExports2["set_shape_blend_mode"];
      _set_shape_blur = Module["_set_shape_blur"] = wasmExports2["set_shape_blur"];
      _set_shape_bool_type = Module["_set_shape_bool_type"] = wasmExports2["set_shape_bool_type"];
      _set_shape_clip_content = Module["_set_shape_clip_content"] = wasmExports2["set_shape_clip_content"];
      _set_shape_constraint_h = Module["_set_shape_constraint_h"] = wasmExports2["set_shape_constraint_h"];
      _set_shape_constraint_v = Module["_set_shape_constraint_v"] = wasmExports2["set_shape_constraint_v"];
      _set_shape_corners = Module["_set_shape_corners"] = wasmExports2["set_shape_corners"];
      _set_shape_fills = Module["_set_shape_fills"] = wasmExports2["set_shape_fills"];
      _set_shape_grow_type = Module["_set_shape_grow_type"] = wasmExports2["set_shape_grow_type"];
      _set_shape_hidden = Module["_set_shape_hidden"] = wasmExports2["set_shape_hidden"];
      _set_shape_masked_group = Module["_set_shape_masked_group"] = wasmExports2["set_shape_masked_group"];
      _set_shape_opacity = Module["_set_shape_opacity"] = wasmExports2["set_shape_opacity"];
      _set_shape_path_buffer = Module["_set_shape_path_buffer"] = wasmExports2["set_shape_path_buffer"];
      _set_shape_path_chunk_buffer = Module["_set_shape_path_chunk_buffer"] = wasmExports2["set_shape_path_chunk_buffer"];
      _set_shape_path_content = Module["_set_shape_path_content"] = wasmExports2["set_shape_path_content"];
      _set_shape_rotation = Module["_set_shape_rotation"] = wasmExports2["set_shape_rotation"];
      _set_shape_selrect = Module["_set_shape_selrect"] = wasmExports2["set_shape_selrect"];
      _set_shape_svg_attrs = Module["_set_shape_svg_attrs"] = wasmExports2["set_shape_svg_attrs"];
      _set_shape_svg_raw_content = Module["_set_shape_svg_raw_content"] = wasmExports2["set_shape_svg_raw_content"];
      _set_shape_text_content = Module["_set_shape_text_content"] = wasmExports2["set_shape_text_content"];
      _set_shape_transform = Module["_set_shape_transform"] = wasmExports2["set_shape_transform"];
      _set_shape_type = Module["_set_shape_type"] = wasmExports2["set_shape_type"];
      _set_shape_vertical_align = Module["_set_shape_vertical_align"] = wasmExports2["set_shape_vertical_align"];
      _set_structure_modifiers = Module["_set_structure_modifiers"] = wasmExports2["set_structure_modifiers"];
      _set_view = Module["_set_view"] = wasmExports2["set_view"];
      _set_view_end = Module["_set_view_end"] = wasmExports2["set_view_end"];
      _set_view_start = Module["_set_view_start"] = wasmExports2["set_view_start"];
      _set_viewport_interest_area_threshold = Module["_set_viewport_interest_area_threshold"] = wasmExports2["set_viewport_interest_area_threshold"];
      _show_grid = Module["_show_grid"] = wasmExports2["show_grid"];
      _start_shape_path_buffer = Module["_start_shape_path_buffer"] = wasmExports2["start_shape_path_buffer"];
      _start_temp_objects = Module["_start_temp_objects"] = wasmExports2["start_temp_objects"];
      _store_font = Module["_store_font"] = wasmExports2["store_font"];
      _store_image = Module["_store_image"] = wasmExports2["store_image"];
      _store_image_from_texture = Module["_store_image_from_texture"] = wasmExports2["store_image_from_texture"];
      _text_editor_apply_theme = Module["_text_editor_apply_theme"] = wasmExports2["text_editor_apply_theme"];
      _text_editor_blur = Module["_text_editor_blur"] = wasmExports2["text_editor_blur"];
      _text_editor_composition_end = Module["_text_editor_composition_end"] = wasmExports2["text_editor_composition_end"];
      _text_editor_composition_start = Module["_text_editor_composition_start"] = wasmExports2["text_editor_composition_start"];
      _text_editor_composition_update = Module["_text_editor_composition_update"] = wasmExports2["text_editor_composition_update"];
      _text_editor_delete_backward = Module["_text_editor_delete_backward"] = wasmExports2["text_editor_delete_backward"];
      _text_editor_delete_forward = Module["_text_editor_delete_forward"] = wasmExports2["text_editor_delete_forward"];
      _text_editor_dispose = Module["_text_editor_dispose"] = wasmExports2["text_editor_dispose"];
      _text_editor_export_content = Module["_text_editor_export_content"] = wasmExports2["text_editor_export_content"];
      _text_editor_export_selection = Module["_text_editor_export_selection"] = wasmExports2["text_editor_export_selection"];
      _text_editor_focus = Module["_text_editor_focus"] = wasmExports2["text_editor_focus"];
      _text_editor_get_active_shape_id = Module["_text_editor_get_active_shape_id"] = wasmExports2["text_editor_get_active_shape_id"];
      _text_editor_get_current_styles = Module["_text_editor_get_current_styles"] = wasmExports2["text_editor_get_current_styles"];
      _text_editor_get_cursor_rect = Module["_text_editor_get_cursor_rect"] = wasmExports2["text_editor_get_cursor_rect"];
      _text_editor_get_selection = Module["_text_editor_get_selection"] = wasmExports2["text_editor_get_selection"];
      _text_editor_get_selection_rects = Module["_text_editor_get_selection_rects"] = wasmExports2["text_editor_get_selection_rects"];
      _text_editor_has_focus = Module["_text_editor_has_focus"] = wasmExports2["text_editor_has_focus"];
      _text_editor_has_focus_with_id = Module["_text_editor_has_focus_with_id"] = wasmExports2["text_editor_has_focus_with_id"];
      _text_editor_has_selection = Module["_text_editor_has_selection"] = wasmExports2["text_editor_has_selection"];
      _text_editor_insert_paragraph = Module["_text_editor_insert_paragraph"] = wasmExports2["text_editor_insert_paragraph"];
      _text_editor_insert_text = Module["_text_editor_insert_text"] = wasmExports2["text_editor_insert_text"];
      _text_editor_move_cursor = Module["_text_editor_move_cursor"] = wasmExports2["text_editor_move_cursor"];
      _text_editor_pointer_down = Module["_text_editor_pointer_down"] = wasmExports2["text_editor_pointer_down"];
      _text_editor_pointer_move = Module["_text_editor_pointer_move"] = wasmExports2["text_editor_pointer_move"];
      _text_editor_pointer_up = Module["_text_editor_pointer_up"] = wasmExports2["text_editor_pointer_up"];
      _text_editor_poll_event = Module["_text_editor_poll_event"] = wasmExports2["text_editor_poll_event"];
      _text_editor_render_overlay = Module["_text_editor_render_overlay"] = wasmExports2["text_editor_render_overlay"];
      _text_editor_select_all = Module["_text_editor_select_all"] = wasmExports2["text_editor_select_all"];
      _text_editor_select_word_boundary = Module["_text_editor_select_word_boundary"] = wasmExports2["text_editor_select_word_boundary"];
      _text_editor_set_cursor_from_offset = Module["_text_editor_set_cursor_from_offset"] = wasmExports2["text_editor_set_cursor_from_offset"];
      _text_editor_set_cursor_from_point = Module["_text_editor_set_cursor_from_point"] = wasmExports2["text_editor_set_cursor_from_point"];
      _text_editor_toggle_overtype_mode = Module["_text_editor_toggle_overtype_mode"] = wasmExports2["text_editor_toggle_overtype_mode"];
      _text_editor_update_blink = Module["_text_editor_update_blink"] = wasmExports2["text_editor_update_blink"];
      _touch_shape = Module["_touch_shape"] = wasmExports2["touch_shape"];
      _update_shape_text_layout = Module["_update_shape_text_layout"] = wasmExports2["update_shape_text_layout"];
      _update_shape_text_layout_for = Module["_update_shape_text_layout_for"] = wasmExports2["update_shape_text_layout_for"];
      _use_shape = Module["_use_shape"] = wasmExports2["use_shape"];
      _main = Module["_main"] = wasmExports2["main"];
      _setThrew = wasmExports2["setThrew"];
      __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 = wasmExports2["__cxa_decrement_exception_refcount"];
      ___cxa_get_exception_ptr = wasmExports2["__cxa_get_exception_ptr"];
      memory = wasmMemory = wasmExports2["memory"];
      __indirect_function_table = wasmTable = wasmExports2["__indirect_function_table"];
    }
    var wasmImports = {
      /** @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_4: ___cxa_find_matching_catch_4,
      /** @export */
      __cxa_throw: ___cxa_throw,
      /** @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 */
      _gmtime_js: __gmtime_js,
      /** @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 */
      emscripten_run_script: _emscripten_run_script,
      /** @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_dii,
      /** @export */
      invoke_fiii,
      /** @export */
      invoke_i,
      /** @export */
      invoke_ii,
      /** @export */
      invoke_iii,
      /** @export */
      invoke_iiii,
      /** @export */
      invoke_iiiii,
      /** @export */
      invoke_iiiiii,
      /** @export */
      invoke_iiiiiii,
      /** @export */
      invoke_iiiiiiii,
      /** @export */
      invoke_iiiiiiiiii,
      /** @export */
      invoke_jiii,
      /** @export */
      invoke_v,
      /** @export */
      invoke_vff,
      /** @export */
      invoke_vi,
      /** @export */
      invoke_vifiii,
      /** @export */
      invoke_vii,
      /** @export */
      invoke_viiddidd,
      /** @export */
      invoke_viifff,
      /** @export */
      invoke_viififfff,
      /** @export */
      invoke_viii,
      /** @export */
      invoke_viiif,
      /** @export */
      invoke_viiii,
      /** @export */
      invoke_viiiifiii,
      /** @export */
      invoke_viiiii,
      /** @export */
      invoke_viiiiif,
      /** @export */
      invoke_viiiiifi,
      /** @export */
      invoke_viiiiifif,
      /** @export */
      invoke_viiiiifiii,
      /** @export */
      invoke_viiiiii,
      /** @export */
      invoke_viiiiiif,
      /** @export */
      invoke_viiiiiifii,
      /** @export */
      invoke_viiiiiii,
      /** @export */
      invoke_viiiiiiifif,
      /** @export */
      invoke_viiiiiiififi,
      /** @export */
      invoke_viiiiiiii,
      /** @export */
      invoke_viiiiiiiif,
      /** @export */
      invoke_viiiiiiiifif,
      /** @export */
      invoke_viiiiiiiififif,
      /** @export */
      invoke_viiiiiiiii,
      /** @export */
      invoke_viiiiiiiiif,
      /** @export */
      invoke_viiiiiiiiii,
      /** @export */
      invoke_viiiiiiiiiif,
      /** @export */
      invoke_viiiiiiiiiifif,
      /** @export */
      invoke_viiiiiiiiiii,
      /** @export */
      invoke_viiiiiiiiiiif,
      /** @export */
      invoke_viiiiiiiiiiiifi,
      /** @export */
      invoke_viiiiiiiiiiiiifif,
      /** @export */
      invoke_viiiiiiiiiiiiii,
      /** @export */
      invoke_viijj,
      /** @export */
      invoke_vijjjj,
      /** @export */
      llvm_eh_typeid_for: _llvm_eh_typeid_for,
      /** @export */
      random_get: _random_get,
      /** @export */
      wapi_notifyTilesRenderComplete: _wapi_notifyTilesRenderComplete
    };
    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_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_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_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_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_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_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_vifiii(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_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_viiddidd(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_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_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_viifff(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_viiiiiiiif(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_viiiiiiififi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
      var sp = stackSave();
      try {
        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_viiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiiiififif(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_viiiiiiiiiifif(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_viiiiiiiifif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
      var sp = stackSave();
      try {
        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_viiiiifi(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_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_viiiiiiiiiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
      var sp = stackSave();
      try {
        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_viijj(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_viiiiiiiiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiifii(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_i(index) {
      var sp = stackSave();
      try {
        return getWasmTableEntry(index)();
      } 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_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_viiiiiiiiiiiiifif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) {
      var sp = stackSave();
      try {
        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
      } catch (e) {
        stackRestore(sp);
        if (!(e instanceof EmscriptenEH)) throw e;
        _setThrew(1, 0);
      }
    }
    function invoke_viiiiiiiiiiif(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_viiiiiif(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_viiiiiiifif(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_viiiiifif(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_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_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_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_viiiiiiiiif(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_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_viififfff(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_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_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_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_viiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
      var sp = stackSave();
      try {
        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_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_vff(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_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_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_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_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_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_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 callMain(args = []) {
      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);
      }
    }
    async function run(args = programArgs) {
      preRun();
      var setStatus = Module["setStatus"];
      if (setStatus) {
        setStatus("Running...");
        await new Promise((resolve) => setTimeout(resolve, 1));
        setTimeout(setStatus, 1, "");
      }
      if (ABORT) return;
      initRuntime();
      Module["onRuntimeInitialized"]?.();
      var noInitialRun = Module["noInitialRun"] || true;
      if (!noInitialRun) callMain(args);
      postRun();
    }
    var wasmExports;
    wasmExports = await createWasm();
    await run();
    return Module;
  }
  var render_wasm_default = createRustSkiaModule;
  return __toCommonJS(render_wasm_exports);
})();
