/*!
 *  Effekseer for WebGL v1.70b
 *  https://github.com/effekseer/EffekseerForWebGL
 *
 *  This software is licensed under the MIT License.
 *  http://www.opensource.org/licenses/mit-license
 */
var effekseer_native = (function () {
  var _scriptDir =
    typeof document !== "undefined" && document.currentScript
      ? document.currentScript.src
      : undefined;
  if (typeof __filename !== "undefined") _scriptDir = _scriptDir || __filename;
  return function (effekseer_native) {
    effekseer_native = effekseer_native || {};

    var Module =
      typeof effekseer_native !== "undefined" ? effekseer_native : {};
    var moduleOverrides = {};
    var key;
    for (key in Module) {
      if (Module.hasOwnProperty(key)) {
        moduleOverrides[key] = Module[key];
      }
    }
    var arguments_ = [];
    var thisProgram = "./this.program";
    var quit_ = function (status, toThrow) {
      throw toThrow;
    };
    var ENVIRONMENT_IS_WEB = false;
    var ENVIRONMENT_IS_WORKER = false;
    var ENVIRONMENT_IS_NODE = false;
    var ENVIRONMENT_IS_SHELL = false;
    ENVIRONMENT_IS_WEB = typeof window === "object";
    ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
    ENVIRONMENT_IS_NODE =
      typeof process === "object" &&
      typeof process.versions === "object" &&
      typeof process.versions.node === "string";
    ENVIRONMENT_IS_SHELL =
      !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
    var scriptDirectory = "";
    function locateFile(path) {
      if (Module["locateFile"]) {
        return Module["locateFile"](path, scriptDirectory);
      }
      return scriptDirectory + path;
    }
    var read_, readAsync, readBinary, setWindowTitle;
    var nodeFS;
    var nodePath;
    if (ENVIRONMENT_IS_NODE) {
      if (ENVIRONMENT_IS_WORKER) {
        scriptDirectory = require("path").dirname(scriptDirectory) + "/";
      } else {
        scriptDirectory = __dirname + "/";
      }
      read_ = function shell_read(filename, binary) {
        if (!nodeFS) nodeFS = require("fs");
        if (!nodePath) nodePath = require("path");
        filename = nodePath["normalize"](filename);
        return nodeFS["readFileSync"](filename, binary ? null : "utf8");
      };
      readBinary = function readBinary(filename) {
        var ret = read_(filename, true);
        if (!ret.buffer) {
          ret = new Uint8Array(ret);
        }
        assert(ret.buffer);
        return ret;
      };
      if (process["argv"].length > 1) {
        thisProgram = process["argv"][1].replace(/\\/g, "/");
      }
      arguments_ = process["argv"].slice(2);
      process["on"]("uncaughtException", function (ex) {
        if (!(ex instanceof ExitStatus)) {
          throw ex;
        }
      });
      process["on"]("unhandledRejection", abort);
      quit_ = function (status) {
        process["exit"](status);
      };
      Module["inspect"] = function () {
        return "[Emscripten Module object]";
      };
    } else if (ENVIRONMENT_IS_SHELL) {
      if (typeof read != "undefined") {
        read_ = function shell_read(f) {
          return read(f);
        };
      }
      readBinary = function readBinary(f) {
        var data;
        if (typeof readbuffer === "function") {
          return new Uint8Array(readbuffer(f));
        }
        data = read(f, "binary");
        assert(typeof data === "object");
        return data;
      };
      if (typeof scriptArgs != "undefined") {
        arguments_ = scriptArgs;
      } else if (typeof arguments != "undefined") {
        arguments_ = arguments;
      }
      if (typeof quit === "function") {
        quit_ = function (status) {
          quit(status);
        };
      }
      if (typeof print !== "undefined") {
        if (typeof console === "undefined") console = {};
        console.log = print;
        console.warn = console.error =
          typeof printErr !== "undefined" ? printErr : print;
      }
    } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
      if (ENVIRONMENT_IS_WORKER) {
        scriptDirectory = self.location.href;
      } else if (document.currentScript) {
        scriptDirectory = document.currentScript.src;
      }
      if (_scriptDir) {
        scriptDirectory = _scriptDir;
      }
      if (scriptDirectory.indexOf("blob:") !== 0) {
        scriptDirectory = scriptDirectory.substr(
          0,
          scriptDirectory.lastIndexOf("/") + 1
        );
      } else {
        scriptDirectory = "";
      }
      {
        read_ = function shell_read(url) {
          var xhr = new XMLHttpRequest();
          xhr.open("GET", url, false);
          xhr.send(null);
          return xhr.responseText;
        };
        if (ENVIRONMENT_IS_WORKER) {
          readBinary = function readBinary(url) {
            var xhr = new XMLHttpRequest();
            xhr.open("GET", url, false);
            xhr.responseType = "arraybuffer";
            xhr.send(null);
            return new Uint8Array(xhr.response);
          };
        }
        readAsync = function readAsync(url, onload, onerror) {
          var xhr = new XMLHttpRequest();
          xhr.open("GET", url, true);
          xhr.responseType = "arraybuffer";
          xhr.onload = function xhr_onload() {
            if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
              onload(xhr.response);
              return;
            }
            onerror();
          };
          xhr.onerror = onerror;
          xhr.send(null);
        };
      }
      setWindowTitle = function (title) {
        document.title = title;
      };
    } else {
    }
    var out = Module["print"] || console.log.bind(console);
    var err = Module["printErr"] || console.warn.bind(console);
    for (key in moduleOverrides) {
      if (moduleOverrides.hasOwnProperty(key)) {
        Module[key] = moduleOverrides[key];
      }
    }
    moduleOverrides = null;
    if (Module["arguments"]) arguments_ = Module["arguments"];
    if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
    if (Module["quit"]) quit_ = Module["quit"];
    var STACK_ALIGN = 16;
    function dynamicAlloc(size) {
      var ret = HEAP32[DYNAMICTOP_PTR >> 2];
      var end = (ret + size + 15) & -16;
      HEAP32[DYNAMICTOP_PTR >> 2] = end;
      return ret;
    }
    function getNativeTypeSize(type) {
      switch (type) {
        case "i1":
        case "i8":
          return 1;
        case "i16":
          return 2;
        case "i32":
          return 4;
        case "i64":
          return 8;
        case "float":
          return 4;
        case "double":
          return 8;
        default: {
          if (type[type.length - 1] === "*") {
            return 4;
          } else if (type[0] === "i") {
            var bits = Number(type.substr(1));
            assert(
              bits % 8 === 0,
              "getNativeTypeSize invalid bits " + bits + ", type " + type
            );
            return bits / 8;
          } else {
            return 0;
          }
        }
      }
    }
    function warnOnce(text) {
      if (!warnOnce.shown) warnOnce.shown = {};
      if (!warnOnce.shown[text]) {
        warnOnce.shown[text] = 1;
        err(text);
      }
    }
    function convertJsFunctionToWasm(func, sig) {
      if (typeof WebAssembly.Function === "function") {
        var typeNames = { i: "i32", j: "i64", f: "f32", d: "f64" };
        var type = {
          parameters: [],
          results: sig[0] == "v" ? [] : [typeNames[sig[0]]],
        };
        for (var i = 1; i < sig.length; ++i) {
          type.parameters.push(typeNames[sig[i]]);
        }
        return new WebAssembly.Function(type, func);
      }
      var typeSection = [1, 0, 1, 96];
      var sigRet = sig.slice(0, 1);
      var sigParam = sig.slice(1);
      var typeCodes = { i: 127, j: 126, f: 125, d: 124 };
      typeSection.push(sigParam.length);
      for (var i = 0; i < sigParam.length; ++i) {
        typeSection.push(typeCodes[sigParam[i]]);
      }
      if (sigRet == "v") {
        typeSection.push(0);
      } else {
        typeSection = typeSection.concat([1, typeCodes[sigRet]]);
      }
      typeSection[1] = typeSection.length - 2;
      var bytes = new Uint8Array(
        [0, 97, 115, 109, 1, 0, 0, 0].concat(
          typeSection,
          [2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0]
        )
      );
      var module = new WebAssembly.Module(bytes);
      var instance = new WebAssembly.Instance(module, { e: { f: func } });
      var wrappedFunc = instance.exports["f"];
      return wrappedFunc;
    }
    var freeTableIndexes = [];
    var functionsInTableMap;
    function addFunctionWasm(func, sig) {
      var table = wasmTable;
      if (!functionsInTableMap) {
        functionsInTableMap = new WeakMap();
        for (var i = 0; i < table.length; i++) {
          var item = table.get(i);
          if (item) {
            functionsInTableMap.set(item, i);
          }
        }
      }
      if (functionsInTableMap.has(func)) {
        return functionsInTableMap.get(func);
      }
      var ret;
      if (freeTableIndexes.length) {
        ret = freeTableIndexes.pop();
      } else {
        ret = table.length;
        try {
          table.grow(1);
        } catch (err) {
          if (!(err instanceof RangeError)) {
            throw err;
          }
          throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
        }
      }
      try {
        table.set(ret, func);
      } catch (err) {
        if (!(err instanceof TypeError)) {
          throw err;
        }
        assert(
          typeof sig !== "undefined",
          "Missing signature argument to addFunction"
        );
        var wrapped = convertJsFunctionToWasm(func, sig);
        table.set(ret, wrapped);
      }
      functionsInTableMap.set(func, ret);
      return ret;
    }
    function removeFunctionWasm(index) {
      functionsInTableMap.delete(wasmTable.get(index));
      freeTableIndexes.push(index);
    }
    var funcWrappers = {};
    function dynCall(sig, ptr, args) {
      if (args && args.length) {
        return Module["dynCall_" + sig].apply(null, [ptr].concat(args));
      } else {
        return Module["dynCall_" + sig].call(null, ptr);
      }
    }
    var tempRet0 = 0;
    var setTempRet0 = function (value) {
      tempRet0 = value;
    };
    var wasmBinary;
    if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
    var noExitRuntime;
    if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
    if (typeof WebAssembly !== "object") {
      err("no native wasm support detected");
    }
    function setValue(ptr, value, type, noSafe) {
      type = type || "i8";
      if (type.charAt(type.length - 1) === "*") type = "i32";
      switch (type) {
        case "i1":
          HEAP8[ptr >> 0] = value;
          break;
        case "i8":
          HEAP8[ptr >> 0] = value;
          break;
        case "i16":
          HEAP16[ptr >> 1] = value;
          break;
        case "i32":
          HEAP32[ptr >> 2] = value;
          break;
        case "i64":
          (tempI64 = [
            value >>> 0,
            ((tempDouble = value),
            +Math_abs(tempDouble) >= 1
              ? tempDouble > 0
                ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) |
                    0) >>>
                  0
                : ~~+Math_ceil(
                    (tempDouble - +(~~tempDouble >>> 0)) / 4294967296
                  ) >>> 0
              : 0),
          ]),
            (HEAP32[ptr >> 2] = tempI64[0]),
            (HEAP32[(ptr + 4) >> 2] = tempI64[1]);
          break;
        case "float":
          HEAPF32[ptr >> 2] = value;
          break;
        case "double":
          HEAPF64[ptr >> 3] = value;
          break;
        default:
          abort("invalid type for setValue: " + type);
      }
    }
    var wasmMemory;
    var wasmTable = new WebAssembly.Table({
      initial: 1295,
      maximum: 1295 + 0,
      element: "anyfunc",
    });
    var ABORT = false;
    var EXITSTATUS = 0;
    function assert(condition, text) {
      if (!condition) {
        abort("Assertion failed: " + text);
      }
    }
    function getCFunc(ident) {
      var func = Module["_" + ident];
      assert(
        func,
        "Cannot call unknown function " + ident + ", make sure it is exported"
      );
      return func;
    }
    function ccall(ident, returnType, argTypes, args, opts) {
      var toC = {
        string: function (str) {
          var ret = 0;
          if (str !== null && str !== undefined && str !== 0) {
            var len = (str.length << 2) + 1;
            ret = stackAlloc(len);
            stringToUTF8(str, ret, len);
          }
          return ret;
        },
        array: function (arr) {
          var ret = stackAlloc(arr.length);
          writeArrayToMemory(arr, ret);
          return ret;
        },
      };
      function convertReturnValue(ret) {
        if (returnType === "string") return UTF8ToString(ret);
        if (returnType === "boolean") return Boolean(ret);
        return ret;
      }
      var func = getCFunc(ident);
      var cArgs = [];
      var stack = 0;
      if (args) {
        for (var i = 0; i < args.length; i++) {
          var converter = toC[argTypes[i]];
          if (converter) {
            if (stack === 0) stack = stackSave();
            cArgs[i] = converter(args[i]);
          } else {
            cArgs[i] = args[i];
          }
        }
      }
      var ret = func.apply(null, cArgs);
      ret = convertReturnValue(ret);
      if (stack !== 0) stackRestore(stack);
      return ret;
    }
    function cwrap(ident, returnType, argTypes, opts) {
      argTypes = argTypes || [];
      var numericArgs = argTypes.every(function (type) {
        return type === "number";
      });
      var numericRet = returnType !== "string";
      if (numericRet && numericArgs && !opts) {
        return getCFunc(ident);
      }
      return function () {
        return ccall(ident, returnType, argTypes, arguments, opts);
      };
    }
    var ALLOC_NONE = 3;
    var UTF8Decoder =
      typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
    function UTF8ArrayToString(heap, idx, maxBytesToRead) {
      var endIdx = idx + maxBytesToRead;
      var endPtr = idx;
      while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
      if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
        return UTF8Decoder.decode(heap.subarray(idx, endPtr));
      } else {
        var str = "";
        while (idx < endPtr) {
          var u0 = heap[idx++];
          if (!(u0 & 128)) {
            str += String.fromCharCode(u0);
            continue;
          }
          var u1 = heap[idx++] & 63;
          if ((u0 & 224) == 192) {
            str += String.fromCharCode(((u0 & 31) << 6) | u1);
            continue;
          }
          var u2 = heap[idx++] & 63;
          if ((u0 & 240) == 224) {
            u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
          } else {
            u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[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;
    }
    function UTF8ToString(ptr, maxBytesToRead) {
      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
    }
    function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
      if (!(maxBytesToWrite > 0)) return 0;
      var startIdx = outIdx;
      var endIdx = outIdx + maxBytesToWrite - 1;
      for (var i = 0; i < str.length; ++i) {
        var u = str.charCodeAt(i);
        if (u >= 55296 && u <= 57343) {
          var u1 = str.charCodeAt(++i);
          u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
        }
        if (u <= 127) {
          if (outIdx >= endIdx) break;
          heap[outIdx++] = u;
        } else if (u <= 2047) {
          if (outIdx + 1 >= endIdx) break;
          heap[outIdx++] = 192 | (u >> 6);
          heap[outIdx++] = 128 | (u & 63);
        } else if (u <= 65535) {
          if (outIdx + 2 >= endIdx) break;
          heap[outIdx++] = 224 | (u >> 12);
          heap[outIdx++] = 128 | ((u >> 6) & 63);
          heap[outIdx++] = 128 | (u & 63);
        } else {
          if (outIdx + 3 >= endIdx) break;
          heap[outIdx++] = 240 | (u >> 18);
          heap[outIdx++] = 128 | ((u >> 12) & 63);
          heap[outIdx++] = 128 | ((u >> 6) & 63);
          heap[outIdx++] = 128 | (u & 63);
        }
      }
      heap[outIdx] = 0;
      return outIdx - startIdx;
    }
    function stringToUTF8(str, outPtr, maxBytesToWrite) {
      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
    }
    function lengthBytesUTF8(str) {
      var len = 0;
      for (var i = 0; i < str.length; ++i) {
        var u = str.charCodeAt(i);
        if (u >= 55296 && u <= 57343)
          u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
        if (u <= 127) ++len;
        else if (u <= 2047) len += 2;
        else if (u <= 65535) len += 3;
        else len += 4;
      }
      return len;
    }
    var UTF16Decoder =
      typeof TextDecoder !== "undefined"
        ? new TextDecoder("utf-16le")
        : undefined;
    function UTF16ToString(ptr) {
      var endPtr = ptr;
      var idx = endPtr >> 1;
      while (HEAP16[idx]) ++idx;
      endPtr = idx << 1;
      if (endPtr - ptr > 32 && UTF16Decoder) {
        return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
      } else {
        var i = 0;
        var str = "";
        while (1) {
          var codeUnit = HEAP16[(ptr + i * 2) >> 1];
          if (codeUnit == 0) return str;
          ++i;
          str += String.fromCharCode(codeUnit);
        }
      }
    }
    function writeArrayToMemory(array, buffer) {
      HEAP8.set(array, buffer);
    }
    function writeAsciiToMemory(str, buffer, dontAddNull) {
      for (var i = 0; i < str.length; ++i) {
        HEAP8[buffer++ >> 0] = str.charCodeAt(i);
      }
      if (!dontAddNull) HEAP8[buffer >> 0] = 0;
    }
    var WASM_PAGE_SIZE = 65536;
    function alignUp(x, multiple) {
      if (x % multiple > 0) {
        x += multiple - (x % multiple);
      }
      return x;
    }
    var buffer,
      HEAP8,
      HEAPU8,
      HEAP16,
      HEAPU16,
      HEAP32,
      HEAPU32,
      HEAPF32,
      HEAPF64;
    function updateGlobalBufferAndViews(buf) {
      buffer = buf;
      Module["HEAP8"] = HEAP8 = new Int8Array(buf);
      Module["HEAP16"] = HEAP16 = new Int16Array(buf);
      Module["HEAP32"] = HEAP32 = new Int32Array(buf);
      Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
      Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
      Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
      Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
      Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
    }
    var STACK_BASE = 5615984,
      DYNAMIC_BASE = 5615984,
      DYNAMICTOP_PTR = 372944;
    var INITIAL_INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 33554432;
    if (Module["wasmMemory"]) {
      wasmMemory = Module["wasmMemory"];
    } else {
      wasmMemory = new WebAssembly.Memory({
        initial: INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE,
        maximum: 2147483648 / WASM_PAGE_SIZE,
      });
    }
    if (wasmMemory) {
      buffer = wasmMemory.buffer;
    }
    INITIAL_INITIAL_MEMORY = buffer.byteLength;
    updateGlobalBufferAndViews(buffer);
    HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
    function callRuntimeCallbacks(callbacks) {
      while (callbacks.length > 0) {
        var callback = callbacks.shift();
        if (typeof callback == "function") {
          callback(Module);
          continue;
        }
        var func = callback.func;
        if (typeof func === "number") {
          if (callback.arg === undefined) {
            Module["dynCall_v"](func);
          } else {
            Module["dynCall_vi"](func, callback.arg);
          }
        } else {
          func(callback.arg === undefined ? null : callback.arg);
        }
      }
    }
    var __ATPRERUN__ = [];
    var __ATINIT__ = [];
    var __ATMAIN__ = [];
    var __ATEXIT__ = [];
    var __ATPOSTRUN__ = [];
    var runtimeInitialized = false;
    var runtimeExited = false;
    function preRun() {
      if (Module["preRun"]) {
        if (typeof Module["preRun"] == "function")
          Module["preRun"] = [Module["preRun"]];
        while (Module["preRun"].length) {
          addOnPreRun(Module["preRun"].shift());
        }
      }
      callRuntimeCallbacks(__ATPRERUN__);
    }
    function initRuntime() {
      runtimeInitialized = true;
      callRuntimeCallbacks(__ATINIT__);
    }
    function preMain() {
      callRuntimeCallbacks(__ATMAIN__);
    }
    function exitRuntime() {
      runtimeExited = true;
    }
    function postRun() {
      if (Module["postRun"]) {
        if (typeof Module["postRun"] == "function")
          Module["postRun"] = [Module["postRun"]];
        while (Module["postRun"].length) {
          addOnPostRun(Module["postRun"].shift());
        }
      }
      callRuntimeCallbacks(__ATPOSTRUN__);
    }
    function addOnPreRun(cb) {
      __ATPRERUN__.unshift(cb);
    }
    function addOnPostRun(cb) {
      __ATPOSTRUN__.unshift(cb);
    }
    var Math_abs = Math.abs;
    var Math_ceil = Math.ceil;
    var Math_floor = Math.floor;
    var Math_min = Math.min;
    var runDependencies = 0;
    var runDependencyWatcher = null;
    var dependenciesFulfilled = null;
    function getUniqueRunDependency(id) {
      return id;
    }
    function addRunDependency(id) {
      runDependencies++;
      if (Module["monitorRunDependencies"]) {
        Module["monitorRunDependencies"](runDependencies);
      }
    }
    function removeRunDependency(id) {
      runDependencies--;
      if (Module["monitorRunDependencies"]) {
        Module["monitorRunDependencies"](runDependencies);
      }
      if (runDependencies == 0) {
        if (runDependencyWatcher !== null) {
          clearInterval(runDependencyWatcher);
          runDependencyWatcher = null;
        }
        if (dependenciesFulfilled) {
          var callback = dependenciesFulfilled;
          dependenciesFulfilled = null;
          callback();
        }
      }
    }
    Module["preloadedImages"] = {};
    Module["preloadedAudios"] = {};
    function abort(what) {
      if (Module["onAbort"]) {
        Module["onAbort"](what);
      }
      what += "";
      out(what);
      err(what);
      ABORT = true;
      EXITSTATUS = 1;
      what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
      throw new WebAssembly.RuntimeError(what);
    }
    function hasPrefix(str, prefix) {
      return String.prototype.startsWith
        ? str.startsWith(prefix)
        : str.indexOf(prefix) === 0;
    }
    var dataURIPrefix = "data:application/octet-stream;base64,";
    function isDataURI(filename) {
      return hasPrefix(filename, dataURIPrefix);
    }
    var fileURIPrefix = "file://";
    function isFileURI(filename) {
      return hasPrefix(filename, fileURIPrefix);
    }
    var wasmBinaryFile = "effekseer.core.wasm";
    if (!isDataURI(wasmBinaryFile)) {
      wasmBinaryFile = locateFile(wasmBinaryFile);
    }
    function getBinary() {
      try {
        if (wasmBinary) {
          return new Uint8Array(wasmBinary);
        }
        if (readBinary) {
          return readBinary(wasmBinaryFile);
        } else {
          throw "both async and sync fetching of the wasm failed";
        }
      } catch (err) {
        abort(err);
      }
    }
    function getBinaryPromise() {
      if (
        !wasmBinary &&
        (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) &&
        typeof fetch === "function" &&
        !isFileURI(wasmBinaryFile)
      ) {
        return fetch(wasmBinaryFile, { credentials: "same-origin" })
          .then(function (response) {
            if (!response["ok"]) {
              throw (
                "failed to load wasm binary file at '" + wasmBinaryFile + "'"
              );
            }
            return response["arrayBuffer"]();
          })
          .catch(function () {
            return getBinary();
          });
      }
      return new Promise(function (resolve, reject) {
        resolve(getBinary());
      });
    }
    function createWasm() {
      var info = { env: asmLibraryArg, wasi_snapshot_preview1: asmLibraryArg };
      function receiveInstance(instance, module) {
        var exports = instance.exports;
        Module["asm"] = exports;
        removeRunDependency("wasm-instantiate");
      }
      addRunDependency("wasm-instantiate");
      function receiveInstantiatedSource(output) {
        receiveInstance(output["instance"]);
      }
      function instantiateArrayBuffer(receiver) {
        return getBinaryPromise()
          .then(function (binary) {
            return WebAssembly.instantiate(binary, info);
          })
          .then(receiver, function (reason) {
            err("failed to asynchronously prepare wasm: " + reason);
            abort(reason);
          });
      }
      function instantiateAsync() {
        if (
          !wasmBinary &&
          typeof WebAssembly.instantiateStreaming === "function" &&
          !isDataURI(wasmBinaryFile) &&
          !isFileURI(wasmBinaryFile) &&
          typeof fetch === "function"
        ) {
          fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (
            response
          ) {
            var result = WebAssembly.instantiateStreaming(response, info);
            return result.then(receiveInstantiatedSource, function (reason) {
              err("wasm streaming compile failed: " + reason);
              err("falling back to ArrayBuffer instantiation");
              instantiateArrayBuffer(receiveInstantiatedSource);
            });
          });
        } else {
          return instantiateArrayBuffer(receiveInstantiatedSource);
        }
      }
      if (Module["instantiateWasm"]) {
        try {
          var exports = Module["instantiateWasm"](info, receiveInstance);
          return exports;
        } catch (e) {
          err("Module.instantiateWasm callback failed with error: " + e);
          return false;
        }
      }
      instantiateAsync();
      return {};
    }
    var tempDouble;
    var tempI64;
    var ASM_CONSTS = {
      343260: function ($0, $1) {
        return Module._loadBinary(UTF16ToString($0), $1) != null;
      },
      343325: function ($0, $1, $2, $3) {
        var buffer = Module._loadBinary(UTF16ToString($0), $3);
        var memptr = _malloc(buffer.byteLength);
        HEAP8.set(new Uint8Array(buffer), memptr);
        setValue($1, memptr, "i32");
        setValue($2, buffer.byteLength, "i32");
      },
      343768: function ($0) {
        return Module._loadImage(UTF16ToString($0)) != null;
      },
      343827: function ($0, $1) {
        var binding = GLctx.getParameter(GLctx.TEXTURE_BINDING_2D);
        var img = Module._loadImage(UTF16ToString($0));
        GLctx.bindTexture(GLctx.TEXTURE_2D, GL.textures[$1]);
        var pa = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);
        var oldFlipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);
        GLctx.pixelStorei(GLctx.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
        GLctx.pixelStorei(GLctx.UNPACK_FLIP_Y_WEBGL, false);
        GLctx.texImage2D(
          GLctx.TEXTURE_2D,
          0,
          GLctx.RGBA,
          GLctx.RGBA,
          GLctx.UNSIGNED_BYTE,
          img
        );
        if (Module._isPowerOfTwo(img)) {
          GLctx.generateMipmap(GLctx.TEXTURE_2D);
        }
        GLctx.pixelStorei(GLctx.UNPACK_PREMULTIPLY_ALPHA_WEBGL, pa);
        GLctx.pixelStorei(GLctx.UNPACK_FLIP_Y_WEBGL, oldFlipY);
        GLctx.bindTexture(GLctx.TEXTURE_2D, binding);
      },
    };
    function _emscripten_asm_const_iii(code, sigPtr, argbuf) {
      var args = readAsmConstArgs(sigPtr, argbuf);
      return ASM_CONSTS[code].apply(null, args);
    }
    __ATINIT__.push({
      func: function () {
        ___wasm_call_ctors();
      },
    });
    function demangle(func) {
      return func;
    }
    function demangleAll(text) {
      var regex = /\b_Z[\w\d_]+/g;
      return text.replace(regex, function (x) {
        var y = demangle(x);
        return x === y ? x : y + " [" + x + "]";
      });
    }
    function jsStackTrace() {
      var err = new Error();
      if (!err.stack) {
        try {
          throw new Error();
        } catch (e) {
          err = e;
        }
        if (!err.stack) {
          return "(no stack trace available)";
        }
      }
      return err.stack.toString();
    }
    function ___cxa_allocate_exception(size) {
      return _malloc(size);
    }
    function _atexit(func, arg) {
      __ATEXIT__.unshift({ func: func, arg: arg });
    }
    function ___cxa_atexit(a0, a1) {
      return _atexit(a0, a1);
    }
    var ___exception_infos = {};
    var ___exception_last = 0;
    function __ZSt18uncaught_exceptionv() {
      return __ZSt18uncaught_exceptionv.uncaught_exceptions > 0;
    }
    function ___cxa_throw(ptr, type, destructor) {
      ___exception_infos[ptr] = {
        ptr: ptr,
        adjusted: [ptr],
        type: type,
        destructor: destructor,
        refcount: 0,
        caught: false,
        rethrown: false,
      };
      ___exception_last = ptr;
      if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
        __ZSt18uncaught_exceptionv.uncaught_exceptions = 1;
      } else {
        __ZSt18uncaught_exceptionv.uncaught_exceptions++;
      }
      throw ptr;
    }
    function setErrNo(value) {
      HEAP32[___errno_location() >> 2] = value;
      return value;
    }
    function ___map_file(pathname, size) {
      setErrNo(63);
      return -1;
    }
    var PATH = {
      splitPath: function (filename) {
        var splitPathRe =
          /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
        return splitPathRe.exec(filename).slice(1);
      },
      normalizeArray: function (parts, allowAboveRoot) {
        var up = 0;
        for (var i = parts.length - 1; i >= 0; i--) {
          var last = parts[i];
          if (last === ".") {
            parts.splice(i, 1);
          } else if (last === "..") {
            parts.splice(i, 1);
            up++;
          } else if (up) {
            parts.splice(i, 1);
            up--;
          }
        }
        if (allowAboveRoot) {
          for (; up; up--) {
            parts.unshift("..");
          }
        }
        return parts;
      },
      normalize: function (path) {
        var isAbsolute = path.charAt(0) === "/",
          trailingSlash = path.substr(-1) === "/";
        path = PATH.normalizeArray(
          path.split("/").filter(function (p) {
            return !!p;
          }),
          !isAbsolute
        ).join("/");
        if (!path && !isAbsolute) {
          path = ".";
        }
        if (path && trailingSlash) {
          path += "/";
        }
        return (isAbsolute ? "/" : "") + path;
      },
      dirname: function (path) {
        var result = PATH.splitPath(path),
          root = result[0],
          dir = result[1];
        if (!root && !dir) {
          return ".";
        }
        if (dir) {
          dir = dir.substr(0, dir.length - 1);
        }
        return root + dir;
      },
      basename: function (path) {
        if (path === "/") return "/";
        var lastSlash = path.lastIndexOf("/");
        if (lastSlash === -1) return path;
        return path.substr(lastSlash + 1);
      },
      extname: function (path) {
        return PATH.splitPath(path)[3];
      },
      join: function () {
        var paths = Array.prototype.slice.call(arguments, 0);
        return PATH.normalize(paths.join("/"));
      },
      join2: function (l, r) {
        return PATH.normalize(l + "/" + r);
      },
    };
    var SYSCALLS = {
      mappings: {},
      buffers: [null, [], []],
      printChar: function (stream, curr) {
        var buffer = SYSCALLS.buffers[stream];
        if (curr === 0 || curr === 10) {
          (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
          buffer.length = 0;
        } else {
          buffer.push(curr);
        }
      },
      varargs: undefined,
      get: function () {
        SYSCALLS.varargs += 4;
        var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
        return ret;
      },
      getStr: function (ptr) {
        var ret = UTF8ToString(ptr);
        return ret;
      },
      get64: function (low, high) {
        return low;
      },
    };
    function ___sys_fcntl64(fd, cmd, varargs) {
      SYSCALLS.varargs = varargs;
      return 0;
    }
    function ___sys_ioctl(fd, op, varargs) {
      SYSCALLS.varargs = varargs;
      return 0;
    }
    function syscallMunmap(addr, len) {
      if ((addr | 0) === -1 || len === 0) {
        return -28;
      }
      var info = SYSCALLS.mappings[addr];
      if (!info) return 0;
      if (len === info.len) {
        SYSCALLS.mappings[addr] = null;
        if (info.allocated) {
          _free(info.malloc);
        }
      }
      return 0;
    }
    function ___sys_munmap(addr, len) {
      return syscallMunmap(addr, len);
    }
    function ___sys_open(path, flags, varargs) {
      SYSCALLS.varargs = varargs;
    }
    function _abort() {
      abort();
    }
    function _emscripten_set_main_loop_timing(mode, value) {
      Browser.mainLoop.timingMode = mode;
      Browser.mainLoop.timingValue = value;
      if (!Browser.mainLoop.func) {
        return 1;
      }
      if (mode == 0) {
        Browser.mainLoop.scheduler =
          function Browser_mainLoop_scheduler_setTimeout() {
            var timeUntilNextTick =
              Math.max(
                0,
                Browser.mainLoop.tickStartTime + value - _emscripten_get_now()
              ) | 0;
            setTimeout(Browser.mainLoop.runner, timeUntilNextTick);
          };
        Browser.mainLoop.method = "timeout";
      } else if (mode == 1) {
        Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() {
          Browser.requestAnimationFrame(Browser.mainLoop.runner);
        };
        Browser.mainLoop.method = "rAF";
      } else if (mode == 2) {
        if (typeof setImmediate === "undefined") {
          var setImmediates = [];
          var emscriptenMainLoopMessageId = "setimmediate";
          var Browser_setImmediate_messageHandler = function (event) {
            if (
              event.data === emscriptenMainLoopMessageId ||
              event.data.target === emscriptenMainLoopMessageId
            ) {
              event.stopPropagation();
              setImmediates.shift()();
            }
          };
          addEventListener(
            "message",
            Browser_setImmediate_messageHandler,
            true
          );
          setImmediate = function Browser_emulated_setImmediate(func) {
            setImmediates.push(func);
            if (ENVIRONMENT_IS_WORKER) {
              if (Module["setImmediates"] === undefined)
                Module["setImmediates"] = [];
              Module["setImmediates"].push(func);
              postMessage({ target: emscriptenMainLoopMessageId });
            } else postMessage(emscriptenMainLoopMessageId, "*");
          };
        }
        Browser.mainLoop.scheduler =
          function Browser_mainLoop_scheduler_setImmediate() {
            setImmediate(Browser.mainLoop.runner);
          };
        Browser.mainLoop.method = "immediate";
      }
      return 0;
    }
    var _emscripten_get_now;
    if (ENVIRONMENT_IS_NODE) {
      _emscripten_get_now = function () {
        var t = process["hrtime"]();
        return t[0] * 1e3 + t[1] / 1e6;
      };
    } else if (typeof dateNow !== "undefined") {
      _emscripten_get_now = dateNow;
    } else
      _emscripten_get_now = function () {
        return performance.now();
      };
    function _emscripten_set_main_loop(
      func,
      fps,
      simulateInfiniteLoop,
      arg,
      noSetTiming
    ) {
      noExitRuntime = true;
      assert(
        !Browser.mainLoop.func,
        "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters."
      );
      Browser.mainLoop.func = func;
      Browser.mainLoop.arg = arg;
      var browserIterationFunc;
      if (typeof arg !== "undefined") {
        browserIterationFunc = function () {
          Module["dynCall_vi"](func, arg);
        };
      } else {
        browserIterationFunc = function () {
          Module["dynCall_v"](func);
        };
      }
      var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop;
      Browser.mainLoop.runner = function Browser_mainLoop_runner() {
        if (ABORT) return;
        if (Browser.mainLoop.queue.length > 0) {
          var start = Date.now();
          var blocker = Browser.mainLoop.queue.shift();
          blocker.func(blocker.arg);
          if (Browser.mainLoop.remainingBlockers) {
            var remaining = Browser.mainLoop.remainingBlockers;
            var next =
              remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
            if (blocker.counted) {
              Browser.mainLoop.remainingBlockers = next;
            } else {
              next = next + 0.5;
              Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9;
            }
          }
          console.log(
            'main loop blocker "' +
              blocker.name +
              '" took ' +
              (Date.now() - start) +
              " ms"
          );
          Browser.mainLoop.updateStatus();
          if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop)
            return;
          setTimeout(Browser.mainLoop.runner, 0);
          return;
        }
        if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
        Browser.mainLoop.currentFrameNumber =
          (Browser.mainLoop.currentFrameNumber + 1) | 0;
        if (
          Browser.mainLoop.timingMode == 1 &&
          Browser.mainLoop.timingValue > 1 &&
          Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue !=
            0
        ) {
          Browser.mainLoop.scheduler();
          return;
        } else if (Browser.mainLoop.timingMode == 0) {
          Browser.mainLoop.tickStartTime = _emscripten_get_now();
        }
        Browser.mainLoop.runIter(browserIterationFunc);
        if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
        if (typeof SDL === "object" && SDL.audio && SDL.audio.queueNewAudioData)
          SDL.audio.queueNewAudioData();
        Browser.mainLoop.scheduler();
      };
      if (!noSetTiming) {
        if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps);
        else _emscripten_set_main_loop_timing(1, 1);
        Browser.mainLoop.scheduler();
      }
      if (simulateInfiniteLoop) {
        throw "unwind";
      }
    }
    var Browser = {
      mainLoop: {
        scheduler: null,
        method: "",
        currentlyRunningMainloop: 0,
        func: null,
        arg: 0,
        timingMode: 0,
        timingValue: 0,
        currentFrameNumber: 0,
        queue: [],
        pause: function () {
          Browser.mainLoop.scheduler = null;
          Browser.mainLoop.currentlyRunningMainloop++;
        },
        resume: function () {
          Browser.mainLoop.currentlyRunningMainloop++;
          var timingMode = Browser.mainLoop.timingMode;
          var timingValue = Browser.mainLoop.timingValue;
          var func = Browser.mainLoop.func;
          Browser.mainLoop.func = null;
          _emscripten_set_main_loop(func, 0, false, Browser.mainLoop.arg, true);
          _emscripten_set_main_loop_timing(timingMode, timingValue);
          Browser.mainLoop.scheduler();
        },
        updateStatus: function () {
          if (Module["setStatus"]) {
            var message = Module["statusMessage"] || "Please wait...";
            var remaining = Browser.mainLoop.remainingBlockers;
            var expected = Browser.mainLoop.expectedBlockers;
            if (remaining) {
              if (remaining < expected) {
                Module["setStatus"](
                  message + " (" + (expected - remaining) + "/" + expected + ")"
                );
              } else {
                Module["setStatus"](message);
              }
            } else {
              Module["setStatus"]("");
            }
          }
        },
        runIter: function (func) {
          if (ABORT) return;
          if (Module["preMainLoop"]) {
            var preRet = Module["preMainLoop"]();
            if (preRet === false) {
              return;
            }
          }
          try {
            func();
          } catch (e) {
            if (e instanceof ExitStatus) {
              return;
            } else {
              if (e && typeof e === "object" && e.stack)
                err("exception thrown: " + [e, e.stack]);
              throw e;
            }
          }
          if (Module["postMainLoop"]) Module["postMainLoop"]();
        },
      },
      isFullscreen: false,
      pointerLock: false,
      moduleContextCreatedCallbacks: [],
      workers: [],
      init: function () {
        if (!Module["preloadPlugins"]) Module["preloadPlugins"] = [];
        if (Browser.initted) return;
        Browser.initted = true;
        try {
          new Blob();
          Browser.hasBlobConstructor = true;
        } catch (e) {
          Browser.hasBlobConstructor = false;
          console.log(
            "warning: no blob constructor, cannot create blobs with mimetypes"
          );
        }
        Browser.BlobBuilder =
          typeof MozBlobBuilder != "undefined"
            ? MozBlobBuilder
            : typeof WebKitBlobBuilder != "undefined"
            ? WebKitBlobBuilder
            : !Browser.hasBlobConstructor
            ? console.log("warning: no BlobBuilder")
            : null;
        Browser.URLObject =
          typeof window != "undefined"
            ? window.URL
              ? window.URL
              : window.webkitURL
            : undefined;
        if (
          !Module.noImageDecoding &&
          typeof Browser.URLObject === "undefined"
        ) {
          console.log(
            "warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available."
          );
          Module.noImageDecoding = true;
        }
        var imagePlugin = {};
        imagePlugin["canHandle"] = function imagePlugin_canHandle(name) {
          return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
        };
        imagePlugin["handle"] = function imagePlugin_handle(
          byteArray,
          name,
          onload,
          onerror
        ) {
          var b = null;
          if (Browser.hasBlobConstructor) {
            try {
              b = new Blob([byteArray], { type: Browser.getMimetype(name) });
              if (b.size !== byteArray.length) {
                b = new Blob([new Uint8Array(byteArray).buffer], {
                  type: Browser.getMimetype(name),
                });
              }
            } catch (e) {
              warnOnce(
                "Blob constructor present but fails: " +
                  e +
                  "; falling back to blob builder"
              );
            }
          }
          if (!b) {
            var bb = new Browser.BlobBuilder();
            bb.append(new Uint8Array(byteArray).buffer);
            b = bb.getBlob();
          }
          var url = Browser.URLObject.createObjectURL(b);
          var img = new Image();
          img.onload = function img_onload() {
            assert(img.complete, "Image " + name + " could not be decoded");
            var canvas = document.createElement("canvas");
            canvas.width = img.width;
            canvas.height = img.height;
            var ctx = canvas.getContext("2d");
            ctx.drawImage(img, 0, 0);
            Module["preloadedImages"][name] = canvas;
            Browser.URLObject.revokeObjectURL(url);
            if (onload) onload(byteArray);
          };
          img.onerror = function img_onerror(event) {
            console.log("Image " + url + " could not be decoded");
            if (onerror) onerror();
          };
          img.src = url;
        };
        Module["preloadPlugins"].push(imagePlugin);
        var audioPlugin = {};
        audioPlugin["canHandle"] = function audioPlugin_canHandle(name) {
          return (
            !Module.noAudioDecoding &&
            name.substr(-4) in { ".ogg": 1, ".wav": 1, ".mp3": 1 }
          );
        };
        audioPlugin["handle"] = function audioPlugin_handle(
          byteArray,
          name,
          onload,
          onerror
        ) {
          var done = false;
          function finish(audio) {
            if (done) return;
            done = true;
            Module["preloadedAudios"][name] = audio;
            if (onload) onload(byteArray);
          }
          function fail() {
            if (done) return;
            done = true;
            Module["preloadedAudios"][name] = new Audio();
            if (onerror) onerror();
          }
          if (Browser.hasBlobConstructor) {
            try {
              var b = new Blob([byteArray], {
                type: Browser.getMimetype(name),
              });
            } catch (e) {
              return fail();
            }
            var url = Browser.URLObject.createObjectURL(b);
            var audio = new Audio();
            audio.addEventListener(
              "canplaythrough",
              function () {
                finish(audio);
              },
              false
            );
            audio.onerror = function audio_onerror(event) {
              if (done) return;
              console.log(
                "warning: browser could not fully decode audio " +
                  name +
                  ", trying slower base64 approach"
              );
              function encode64(data) {
                var BASE =
                  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
                var PAD = "=";
                var ret = "";
                var leftchar = 0;
                var leftbits = 0;
                for (var i = 0; i < data.length; i++) {
                  leftchar = (leftchar << 8) | data[i];
                  leftbits += 8;
                  while (leftbits >= 6) {
                    var curr = (leftchar >> (leftbits - 6)) & 63;
                    leftbits -= 6;
                    ret += BASE[curr];
                  }
                }
                if (leftbits == 2) {
                  ret += BASE[(leftchar & 3) << 4];
                  ret += PAD + PAD;
                } else if (leftbits == 4) {
                  ret += BASE[(leftchar & 15) << 2];
                  ret += PAD;
                }
                return ret;
              }
              audio.src =
                "data:audio/x-" +
                name.substr(-3) +
                ";base64," +
                encode64(byteArray);
              finish(audio);
            };
            audio.src = url;
            Browser.safeSetTimeout(function () {
              finish(audio);
            }, 1e4);
          } else {
            return fail();
          }
        };
        Module["preloadPlugins"].push(audioPlugin);
        function pointerLockChange() {
          Browser.pointerLock =
            document["pointerLockElement"] === Module["canvas"] ||
            document["mozPointerLockElement"] === Module["canvas"] ||
            document["webkitPointerLockElement"] === Module["canvas"] ||
            document["msPointerLockElement"] === Module["canvas"];
        }
        var canvas = Module["canvas"];
        if (canvas) {
          canvas.requestPointerLock =
            canvas["requestPointerLock"] ||
            canvas["mozRequestPointerLock"] ||
            canvas["webkitRequestPointerLock"] ||
            canvas["msRequestPointerLock"] ||
            function () {};
          canvas.exitPointerLock =
            document["exitPointerLock"] ||
            document["mozExitPointerLock"] ||
            document["webkitExitPointerLock"] ||
            document["msExitPointerLock"] ||
            function () {};
          canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
          document.addEventListener(
            "pointerlockchange",
            pointerLockChange,
            false
          );
          document.addEventListener(
            "mozpointerlockchange",
            pointerLockChange,
            false
          );
          document.addEventListener(
            "webkitpointerlockchange",
            pointerLockChange,
            false
          );
          document.addEventListener(
            "mspointerlockchange",
            pointerLockChange,
            false
          );
          if (Module["elementPointerLock"]) {
            canvas.addEventListener(
              "click",
              function (ev) {
                if (
                  !Browser.pointerLock &&
                  Module["canvas"].requestPointerLock
                ) {
                  Module["canvas"].requestPointerLock();
                  ev.preventDefault();
                }
              },
              false
            );
          }
        }
      },
      createContext: function (
        canvas,
        useWebGL,
        setInModule,
        webGLContextAttributes
      ) {
        if (useWebGL && Module.ctx && canvas == Module.canvas)
          return Module.ctx;
        var ctx;
        var contextHandle;
        if (useWebGL) {
          var contextAttributes = {
            antialias: false,
            alpha: false,
            majorVersion: 1,
          };
          if (webGLContextAttributes) {
            for (var attribute in webGLContextAttributes) {
              contextAttributes[attribute] = webGLContextAttributes[attribute];
            }
          }
          if (typeof GL !== "undefined") {
            contextHandle = GL.createContext(canvas, contextAttributes);
            if (contextHandle) {
              ctx = GL.getContext(contextHandle).GLctx;
            }
          }
        } else {
          ctx = canvas.getContext("2d");
        }
        if (!ctx) return null;
        if (setInModule) {
          if (!useWebGL)
            assert(
              typeof GLctx === "undefined",
              "cannot set in module if GLctx is used, but we are a non-GL context that would replace it"
            );
          Module.ctx = ctx;
          if (useWebGL) GL.makeContextCurrent(contextHandle);
          Module.useWebGL = useWebGL;
          Browser.moduleContextCreatedCallbacks.forEach(function (callback) {
            callback();
          });
          Browser.init();
        }
        return ctx;
      },
      destroyContext: function (canvas, useWebGL, setInModule) {},
      fullscreenHandlersInstalled: false,
      lockPointer: undefined,
      resizeCanvas: undefined,
      requestFullscreen: function (lockPointer, resizeCanvas) {
        Browser.lockPointer = lockPointer;
        Browser.resizeCanvas = resizeCanvas;
        if (typeof Browser.lockPointer === "undefined")
          Browser.lockPointer = true;
        if (typeof Browser.resizeCanvas === "undefined")
          Browser.resizeCanvas = false;
        var canvas = Module["canvas"];
        function fullscreenChange() {
          Browser.isFullscreen = false;
          var canvasContainer = canvas.parentNode;
          if (
            (document["fullscreenElement"] ||
              document["mozFullScreenElement"] ||
              document["msFullscreenElement"] ||
              document["webkitFullscreenElement"] ||
              document["webkitCurrentFullScreenElement"]) === canvasContainer
          ) {
            canvas.exitFullscreen = Browser.exitFullscreen;
            if (Browser.lockPointer) canvas.requestPointerLock();
            Browser.isFullscreen = true;
            if (Browser.resizeCanvas) {
              Browser.setFullscreenCanvasSize();
            } else {
              Browser.updateCanvasDimensions(canvas);
            }
          } else {
            canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
            canvasContainer.parentNode.removeChild(canvasContainer);
            if (Browser.resizeCanvas) {
              Browser.setWindowedCanvasSize();
            } else {
              Browser.updateCanvasDimensions(canvas);
            }
          }
          if (Module["onFullScreen"])
            Module["onFullScreen"](Browser.isFullscreen);
          if (Module["onFullscreen"])
            Module["onFullscreen"](Browser.isFullscreen);
        }
        if (!Browser.fullscreenHandlersInstalled) {
          Browser.fullscreenHandlersInstalled = true;
          document.addEventListener(
            "fullscreenchange",
            fullscreenChange,
            false
          );
          document.addEventListener(
            "mozfullscreenchange",
            fullscreenChange,
            false
          );
          document.addEventListener(
            "webkitfullscreenchange",
            fullscreenChange,
            false
          );
          document.addEventListener(
            "MSFullscreenChange",
            fullscreenChange,
            false
          );
        }
        var canvasContainer = document.createElement("div");
        canvas.parentNode.insertBefore(canvasContainer, canvas);
        canvasContainer.appendChild(canvas);
        canvasContainer.requestFullscreen =
          canvasContainer["requestFullscreen"] ||
          canvasContainer["mozRequestFullScreen"] ||
          canvasContainer["msRequestFullscreen"] ||
          (canvasContainer["webkitRequestFullscreen"]
            ? function () {
                canvasContainer["webkitRequestFullscreen"](
                  Element["ALLOW_KEYBOARD_INPUT"]
                );
              }
            : null) ||
          (canvasContainer["webkitRequestFullScreen"]
            ? function () {
                canvasContainer["webkitRequestFullScreen"](
                  Element["ALLOW_KEYBOARD_INPUT"]
                );
              }
            : null);
        canvasContainer.requestFullscreen();
      },
      exitFullscreen: function () {
        if (!Browser.isFullscreen) {
          return false;
        }
        var CFS =
          document["exitFullscreen"] ||
          document["cancelFullScreen"] ||
          document["mozCancelFullScreen"] ||
          document["msExitFullscreen"] ||
          document["webkitCancelFullScreen"] ||
          function () {};
        CFS.apply(document, []);
        return true;
      },
      nextRAF: 0,
      fakeRequestAnimationFrame: function (func) {
        var now = Date.now();
        if (Browser.nextRAF === 0) {
          Browser.nextRAF = now + 1e3 / 60;
        } else {
          while (now + 2 >= Browser.nextRAF) {
            Browser.nextRAF += 1e3 / 60;
          }
        }
        var delay = Math.max(Browser.nextRAF - now, 0);
        setTimeout(func, delay);
      },
      requestAnimationFrame: function (func) {
        if (typeof requestAnimationFrame === "function") {
          requestAnimationFrame(func);
          return;
        }
        var RAF = Browser.fakeRequestAnimationFrame;
        RAF(func);
      },
      safeCallback: function (func) {
        return function () {
          if (!ABORT) return func.apply(null, arguments);
        };
      },
      allowAsyncCallbacks: true,
      queuedAsyncCallbacks: [],
      pauseAsyncCallbacks: function () {
        Browser.allowAsyncCallbacks = false;
      },
      resumeAsyncCallbacks: function () {
        Browser.allowAsyncCallbacks = true;
        if (Browser.queuedAsyncCallbacks.length > 0) {
          var callbacks = Browser.queuedAsyncCallbacks;
          Browser.queuedAsyncCallbacks = [];
          callbacks.forEach(function (func) {
            func();
          });
        }
      },
      safeRequestAnimationFrame: function (func) {
        return Browser.requestAnimationFrame(function () {
          if (ABORT) return;
          if (Browser.allowAsyncCallbacks) {
            func();
          } else {
            Browser.queuedAsyncCallbacks.push(func);
          }
        });
      },
      safeSetTimeout: function (func, timeout) {
        noExitRuntime = true;
        return setTimeout(function () {
          if (ABORT) return;
          if (Browser.allowAsyncCallbacks) {
            func();
          } else {
            Browser.queuedAsyncCallbacks.push(func);
          }
        }, timeout);
      },
      safeSetInterval: function (func, timeout) {
        noExitRuntime = true;
        return setInterval(function () {
          if (ABORT) return;
          if (Browser.allowAsyncCallbacks) {
            func();
          }
        }, timeout);
      },
      getMimetype: function (name) {
        return {
          jpg: "image/jpeg",
          jpeg: "image/jpeg",
          png: "image/png",
          bmp: "image/bmp",
          ogg: "audio/ogg",
          wav: "audio/wav",
          mp3: "audio/mpeg",
        }[name.substr(name.lastIndexOf(".") + 1)];
      },
      getUserMedia: function (func) {
        if (!window.getUserMedia) {
          window.getUserMedia =
            navigator["getUserMedia"] || navigator["mozGetUserMedia"];
        }
        window.getUserMedia(func);
      },
      getMovementX: function (event) {
        return (
          event["movementX"] ||
          event["mozMovementX"] ||
          event["webkitMovementX"] ||
          0
        );
      },
      getMovementY: function (event) {
        return (
          event["movementY"] ||
          event["mozMovementY"] ||
          event["webkitMovementY"] ||
          0
        );
      },
      getMouseWheelDelta: function (event) {
        var delta = 0;
        switch (event.type) {
          case "DOMMouseScroll":
            delta = event.detail / 3;
            break;
          case "mousewheel":
            delta = event.wheelDelta / 120;
            break;
          case "wheel":
            delta = event.deltaY;
            switch (event.deltaMode) {
              case 0:
                delta /= 100;
                break;
              case 1:
                delta /= 3;
                break;
              case 2:
                delta *= 80;
                break;
              default:
                throw "unrecognized mouse wheel delta mode: " + event.deltaMode;
            }
            break;
          default:
            throw "unrecognized mouse wheel event: " + event.type;
        }
        return delta;
      },
      mouseX: 0,
      mouseY: 0,
      mouseMovementX: 0,
      mouseMovementY: 0,
      touches: {},
      lastTouches: {},
      calculateMouseEvent: function (event) {
        if (Browser.pointerLock) {
          if (event.type != "mousemove" && "mozMovementX" in event) {
            Browser.mouseMovementX = Browser.mouseMovementY = 0;
          } else {
            Browser.mouseMovementX = Browser.getMovementX(event);
            Browser.mouseMovementY = Browser.getMovementY(event);
          }
          if (typeof SDL != "undefined") {
            Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
            Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
          } else {
            Browser.mouseX += Browser.mouseMovementX;
            Browser.mouseY += Browser.mouseMovementY;
          }
        } else {
          var rect = Module["canvas"].getBoundingClientRect();
          var cw = Module["canvas"].width;
          var ch = Module["canvas"].height;
          var scrollX =
            typeof window.scrollX !== "undefined"
              ? window.scrollX
              : window.pageXOffset;
          var scrollY =
            typeof window.scrollY !== "undefined"
              ? window.scrollY
              : window.pageYOffset;
          if (
            event.type === "touchstart" ||
            event.type === "touchend" ||
            event.type === "touchmove"
          ) {
            var touch = event.touch;
            if (touch === undefined) {
              return;
            }
            var adjustedX = touch.pageX - (scrollX + rect.left);
            var adjustedY = touch.pageY - (scrollY + rect.top);
            adjustedX = adjustedX * (cw / rect.width);
            adjustedY = adjustedY * (ch / rect.height);
            var coords = { x: adjustedX, y: adjustedY };
            if (event.type === "touchstart") {
              Browser.lastTouches[touch.identifier] = coords;
              Browser.touches[touch.identifier] = coords;
            } else if (
              event.type === "touchend" ||
              event.type === "touchmove"
            ) {
              var last = Browser.touches[touch.identifier];
              if (!last) last = coords;
              Browser.lastTouches[touch.identifier] = last;
              Browser.touches[touch.identifier] = coords;
            }
            return;
          }
          var x = event.pageX - (scrollX + rect.left);
          var y = event.pageY - (scrollY + rect.top);
          x = x * (cw / rect.width);
          y = y * (ch / rect.height);
          Browser.mouseMovementX = x - Browser.mouseX;
          Browser.mouseMovementY = y - Browser.mouseY;
          Browser.mouseX = x;
          Browser.mouseY = y;
        }
      },
      asyncLoad: function (url, onload, onerror, noRunDep) {
        var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
        readAsync(
          url,
          function (arrayBuffer) {
            assert(
              arrayBuffer,
              'Loading data file "' + url + '" failed (no arrayBuffer).'
            );
            onload(new Uint8Array(arrayBuffer));
            if (dep) removeRunDependency(dep);
          },
          function (event) {
            if (onerror) {
              onerror();
            } else {
              throw 'Loading data file "' + url + '" failed.';
            }
          }
        );
        if (dep) addRunDependency(dep);
      },
      resizeListeners: [],
      updateResizeListeners: function () {
        var canvas = Module["canvas"];
        Browser.resizeListeners.forEach(function (listener) {
          listener(canvas.width, canvas.height);
        });
      },
      setCanvasSize: function (width, height, noUpdates) {
        var canvas = Module["canvas"];
        Browser.updateCanvasDimensions(canvas, width, height);
        if (!noUpdates) Browser.updateResizeListeners();
      },
      windowedWidth: 0,
      windowedHeight: 0,
      setFullscreenCanvasSize: function () {
        if (typeof SDL != "undefined") {
          var flags = HEAPU32[SDL.screen >> 2];
          flags = flags | 8388608;
          HEAP32[SDL.screen >> 2] = flags;
        }
        Browser.updateCanvasDimensions(Module["canvas"]);
        Browser.updateResizeListeners();
      },
      setWindowedCanvasSize: function () {
        if (typeof SDL != "undefined") {
          var flags = HEAPU32[SDL.screen >> 2];
          flags = flags & ~8388608;
          HEAP32[SDL.screen >> 2] = flags;
        }
        Browser.updateCanvasDimensions(Module["canvas"]);
        Browser.updateResizeListeners();
      },
      updateCanvasDimensions: function (canvas, wNative, hNative) {
        if (wNative && hNative) {
          canvas.widthNative = wNative;
          canvas.heightNative = hNative;
        } else {
          wNative = canvas.widthNative;
          hNative = canvas.heightNative;
        }
        var w = wNative;
        var h = hNative;
        if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) {
          if (w / h < Module["forcedAspectRatio"]) {
            w = Math.round(h * Module["forcedAspectRatio"]);
          } else {
            h = Math.round(w / Module["forcedAspectRatio"]);
          }
        }
        if (
          (document["fullscreenElement"] ||
            document["mozFullScreenElement"] ||
            document["msFullscreenElement"] ||
            document["webkitFullscreenElement"] ||
            document["webkitCurrentFullScreenElement"]) === canvas.parentNode &&
          typeof screen != "undefined"
        ) {
          var factor = Math.min(screen.width / w, screen.height / h);
          w = Math.round(w * factor);
          h = Math.round(h * factor);
        }
        if (Browser.resizeCanvas) {
          if (canvas.width != w) canvas.width = w;
          if (canvas.height != h) canvas.height = h;
          if (typeof canvas.style != "undefined") {
            canvas.style.removeProperty("width");
            canvas.style.removeProperty("height");
          }
        } else {
          if (canvas.width != wNative) canvas.width = wNative;
          if (canvas.height != hNative) canvas.height = hNative;
          if (typeof canvas.style != "undefined") {
            if (w != wNative || h != hNative) {
              canvas.style.setProperty("width", w + "px", "important");
              canvas.style.setProperty("height", h + "px", "important");
            } else {
              canvas.style.removeProperty("width");
              canvas.style.removeProperty("height");
            }
          }
        }
      },
      wgetRequests: {},
      nextWgetRequestHandle: 0,
      getNextWgetRequestHandle: function () {
        var handle = Browser.nextWgetRequestHandle;
        Browser.nextWgetRequestHandle++;
        return handle;
      },
    };
    var AL = {
      QUEUE_INTERVAL: 25,
      QUEUE_LOOKAHEAD: 0.1,
      DEVICE_NAME: "Emscripten OpenAL",
      CAPTURE_DEVICE_NAME: "Emscripten OpenAL capture",
      ALC_EXTENSIONS: { ALC_SOFT_pause_device: true, ALC_SOFT_HRTF: true },
      AL_EXTENSIONS: {
        AL_EXT_float32: true,
        AL_SOFT_loop_points: true,
        AL_SOFT_source_length: true,
        AL_EXT_source_distance_model: true,
        AL_SOFT_source_spatialize: true,
      },
      _alcErr: 0,
      alcErr: 0,
      deviceRefCounts: {},
      alcStringCache: {},
      paused: false,
      stringCache: {},
      contexts: {},
      currentCtx: null,
      buffers: {
        0: {
          id: 0,
          refCount: 0,
          audioBuf: null,
          frequency: 0,
          bytesPerSample: 2,
          channels: 1,
          length: 0,
        },
      },
      paramArray: [],
      _nextId: 1,
      newId: function () {
        return AL.freeIds.length > 0 ? AL.freeIds.pop() : AL._nextId++;
      },
      freeIds: [],
      scheduleContextAudio: function (ctx) {
        if (
          Browser.mainLoop.timingMode === 1 &&
          document["visibilityState"] != "visible"
        ) {
          return;
        }
        for (var i in ctx.sources) {
          AL.scheduleSourceAudio(ctx.sources[i]);
        }
      },
      scheduleSourceAudio: function (src, lookahead) {
        if (
          Browser.mainLoop.timingMode === 1 &&
          document["visibilityState"] != "visible"
        ) {
          return;
        }
        if (src.state !== 4114) {
          return;
        }
        var currentTime = AL.updateSourceTime(src);
        var startTime = src.bufStartTime;
        var startOffset = src.bufOffset;
        var bufCursor = src.bufsProcessed;
        for (var i = 0; i < src.audioQueue.length; i++) {
          var audioSrc = src.audioQueue[i];
          startTime = audioSrc._startTime + audioSrc._duration;
          startOffset = 0;
          bufCursor += audioSrc._skipCount + 1;
        }
        if (!lookahead) {
          lookahead = AL.QUEUE_LOOKAHEAD;
        }
        var lookaheadTime = currentTime + lookahead;
        var skipCount = 0;
        while (startTime < lookaheadTime) {
          if (bufCursor >= src.bufQueue.length) {
            if (src.looping) {
              bufCursor %= src.bufQueue.length;
            } else {
              break;
            }
          }
          var buf = src.bufQueue[bufCursor % src.bufQueue.length];
          if (buf.length === 0) {
            skipCount++;
            if (skipCount === src.bufQueue.length) {
              break;
            }
          } else {
            var audioSrc = src.context.audioCtx.createBufferSource();
            audioSrc.buffer = buf.audioBuf;
            audioSrc.playbackRate.value = src.playbackRate;
            if (buf.audioBuf._loopStart || buf.audioBuf._loopEnd) {
              audioSrc.loopStart = buf.audioBuf._loopStart;
              audioSrc.loopEnd = buf.audioBuf._loopEnd;
            }
            var duration = 0;
            if (src.type === 4136 && src.looping) {
              duration = Number.POSITIVE_INFINITY;
              audioSrc.loop = true;
              if (buf.audioBuf._loopStart) {
                audioSrc.loopStart = buf.audioBuf._loopStart;
              }
              if (buf.audioBuf._loopEnd) {
                audioSrc.loopEnd = buf.audioBuf._loopEnd;
              }
            } else {
              duration =
                (buf.audioBuf.duration - startOffset) / src.playbackRate;
            }
            audioSrc._startOffset = startOffset;
            audioSrc._duration = duration;
            audioSrc._skipCount = skipCount;
            skipCount = 0;
            audioSrc.connect(src.gain);
            if (typeof audioSrc.start !== "undefined") {
              startTime = Math.max(startTime, src.context.audioCtx.currentTime);
              audioSrc.start(startTime, startOffset);
            } else if (typeof audioSrc.noteOn !== "undefined") {
              startTime = Math.max(startTime, src.context.audioCtx.currentTime);
              audioSrc.noteOn(startTime);
            }
            audioSrc._startTime = startTime;
            src.audioQueue.push(audioSrc);
            startTime += duration;
          }
          startOffset = 0;
          bufCursor++;
        }
      },
      updateSourceTime: function (src) {
        var currentTime = src.context.audioCtx.currentTime;
        if (src.state !== 4114) {
          return currentTime;
        }
        if (!isFinite(src.bufStartTime)) {
          src.bufStartTime = currentTime - src.bufOffset / src.playbackRate;
          src.bufOffset = 0;
        }
        var nextStartTime = 0;
        while (src.audioQueue.length) {
          var audioSrc = src.audioQueue[0];
          src.bufsProcessed += audioSrc._skipCount;
          nextStartTime = audioSrc._startTime + audioSrc._duration;
          if (currentTime < nextStartTime) {
            break;
          }
          src.audioQueue.shift();
          src.bufStartTime = nextStartTime;
          src.bufOffset = 0;
          src.bufsProcessed++;
        }
        if (src.bufsProcessed >= src.bufQueue.length && !src.looping) {
          AL.setSourceState(src, 4116);
        } else if (src.type === 4136 && src.looping) {
          var buf = src.bufQueue[0];
          if (buf.length === 0) {
            src.bufOffset = 0;
          } else {
            var delta = (currentTime - src.bufStartTime) * src.playbackRate;
            var loopStart = buf.audioBuf._loopStart || 0;
            var loopEnd = buf.audioBuf._loopEnd || buf.audioBuf.duration;
            if (loopEnd <= loopStart) {
              loopEnd = buf.audioBuf.duration;
            }
            if (delta < loopEnd) {
              src.bufOffset = delta;
            } else {
              src.bufOffset =
                loopStart + ((delta - loopStart) % (loopEnd - loopStart));
            }
          }
        } else if (src.audioQueue[0]) {
          src.bufOffset =
            (currentTime - src.audioQueue[0]._startTime) * src.playbackRate;
        } else {
          if (src.type !== 4136 && src.looping) {
            var srcDuration = AL.sourceDuration(src) / src.playbackRate;
            if (srcDuration > 0) {
              src.bufStartTime +=
                Math.floor((currentTime - src.bufStartTime) / srcDuration) *
                srcDuration;
            }
          }
          for (var i = 0; i < src.bufQueue.length; i++) {
            if (src.bufsProcessed >= src.bufQueue.length) {
              if (src.looping) {
                src.bufsProcessed %= src.bufQueue.length;
              } else {
                AL.setSourceState(src, 4116);
                break;
              }
            }
            var buf = src.bufQueue[src.bufsProcessed];
            if (buf.length > 0) {
              nextStartTime =
                src.bufStartTime + buf.audioBuf.duration / src.playbackRate;
              if (currentTime < nextStartTime) {
                src.bufOffset =
                  (currentTime - src.bufStartTime) * src.playbackRate;
                break;
              }
              src.bufStartTime = nextStartTime;
            }
            src.bufOffset = 0;
            src.bufsProcessed++;
          }
        }
        return currentTime;
      },
      cancelPendingSourceAudio: function (src) {
        AL.updateSourceTime(src);
        for (var i = 1; i < src.audioQueue.length; i++) {
          var audioSrc = src.audioQueue[i];
          audioSrc.stop();
        }
        if (src.audioQueue.length > 1) {
          src.audioQueue.length = 1;
        }
      },
      stopSourceAudio: function (src) {
        for (var i = 0; i < src.audioQueue.length; i++) {
          src.audioQueue[i].stop();
        }
        src.audioQueue.length = 0;
      },
      setSourceState: function (src, state) {
        if (state === 4114) {
          if (src.state === 4114 || src.state == 4116) {
            src.bufsProcessed = 0;
            src.bufOffset = 0;
          } else {
          }
          AL.stopSourceAudio(src);
          src.state = 4114;
          src.bufStartTime = Number.NEGATIVE_INFINITY;
          AL.scheduleSourceAudio(src);
        } else if (state === 4115) {
          if (src.state === 4114) {
            AL.updateSourceTime(src);
            AL.stopSourceAudio(src);
            src.state = 4115;
          }
        } else if (state === 4116) {
          if (src.state !== 4113) {
            src.state = 4116;
            src.bufsProcessed = src.bufQueue.length;
            src.bufStartTime = Number.NEGATIVE_INFINITY;
            src.bufOffset = 0;
            AL.stopSourceAudio(src);
          }
        } else if (state === 4113) {
          if (src.state !== 4113) {
            src.state = 4113;
            src.bufsProcessed = 0;
            src.bufStartTime = Number.NEGATIVE_INFINITY;
            src.bufOffset = 0;
            AL.stopSourceAudio(src);
          }
        }
      },
      initSourcePanner: function (src) {
        if (src.type === 4144) {
          return;
        }
        var templateBuf = AL.buffers[0];
        for (var i = 0; i < src.bufQueue.length; i++) {
          if (src.bufQueue[i].id !== 0) {
            templateBuf = src.bufQueue[i];
            break;
          }
        }
        if (
          src.spatialize === 1 ||
          (src.spatialize === 2 && templateBuf.channels === 1)
        ) {
          if (src.panner) {
            return;
          }
          src.panner = src.context.audioCtx.createPanner();
          AL.updateSourceGlobal(src);
          AL.updateSourceSpace(src);
          src.panner.connect(src.context.gain);
          src.gain.disconnect();
          src.gain.connect(src.panner);
        } else {
          if (!src.panner) {
            return;
          }
          src.panner.disconnect();
          src.gain.disconnect();
          src.gain.connect(src.context.gain);
          src.panner = null;
        }
      },
      updateContextGlobal: function (ctx) {
        for (var i in ctx.sources) {
          AL.updateSourceGlobal(ctx.sources[i]);
        }
      },
      updateSourceGlobal: function (src) {
        var panner = src.panner;
        if (!panner) {
          return;
        }
        panner.refDistance = src.refDistance;
        panner.maxDistance = src.maxDistance;
        panner.rolloffFactor = src.rolloffFactor;
        panner.panningModel = src.context.hrtf ? "HRTF" : "equalpower";
        var distanceModel = src.context.sourceDistanceModel
          ? src.distanceModel
          : src.context.distanceModel;
        switch (distanceModel) {
          case 0:
            panner.distanceModel = "inverse";
            panner.refDistance = 3.40282e38;
            break;
          case 53249:
          case 53250:
            panner.distanceModel = "inverse";
            break;
          case 53251:
          case 53252:
            panner.distanceModel = "linear";
            break;
          case 53253:
          case 53254:
            panner.distanceModel = "exponential";
            break;
        }
      },
      updateListenerSpace: function (ctx) {
        var listener = ctx.audioCtx.listener;
        if (listener.positionX) {
          listener.positionX.value = ctx.listener.position[0];
          listener.positionY.value = ctx.listener.position[1];
          listener.positionZ.value = ctx.listener.position[2];
        } else {
          listener.setPosition(
            ctx.listener.position[0],
            ctx.listener.position[1],
            ctx.listener.position[2]
          );
        }
        if (listener.forwardX) {
          listener.forwardX.value = ctx.listener.direction[0];
          listener.forwardY.value = ctx.listener.direction[1];
          listener.forwardZ.value = ctx.listener.direction[2];
          listener.upX.value = ctx.listener.up[0];
          listener.upY.value = ctx.listener.up[1];
          listener.upZ.value = ctx.listener.up[2];
        } else {
          listener.setOrientation(
            ctx.listener.direction[0],
            ctx.listener.direction[1],
            ctx.listener.direction[2],
            ctx.listener.up[0],
            ctx.listener.up[1],
            ctx.listener.up[2]
          );
        }
        for (var i in ctx.sources) {
          AL.updateSourceSpace(ctx.sources[i]);
        }
      },
      updateSourceSpace: function (src) {
        if (!src.panner) {
          return;
        }
        var panner = src.panner;
        var posX = src.position[0];
        var posY = src.position[1];
        var posZ = src.position[2];
        var dirX = src.direction[0];
        var dirY = src.direction[1];
        var dirZ = src.direction[2];
        var listener = src.context.listener;
        var lPosX = listener.position[0];
        var lPosY = listener.position[1];
        var lPosZ = listener.position[2];
        if (src.relative) {
          var lBackX = -listener.direction[0];
          var lBackY = -listener.direction[1];
          var lBackZ = -listener.direction[2];
          var lUpX = listener.up[0];
          var lUpY = listener.up[1];
          var lUpZ = listener.up[2];
          var inverseMagnitude = function (x, y, z) {
            var length = Math.sqrt(x * x + y * y + z * z);
            if (length < Number.EPSILON) {
              return 0;
            }
            return 1 / length;
          };
          var invMag = inverseMagnitude(lBackX, lBackY, lBackZ);
          lBackX *= invMag;
          lBackY *= invMag;
          lBackZ *= invMag;
          invMag = inverseMagnitude(lUpX, lUpY, lUpZ);
          lUpX *= invMag;
          lUpY *= invMag;
          lUpZ *= invMag;
          var lRightX = lUpY * lBackZ - lUpZ * lBackY;
          var lRightY = lUpZ * lBackX - lUpX * lBackZ;
          var lRightZ = lUpX * lBackY - lUpY * lBackX;
          invMag = inverseMagnitude(lRightX, lRightY, lRightZ);
          lRightX *= invMag;
          lRightY *= invMag;
          lRightZ *= invMag;
          lUpX = lBackY * lRightZ - lBackZ * lRightY;
          lUpY = lBackZ * lRightX - lBackX * lRightZ;
          lUpZ = lBackX * lRightY - lBackY * lRightX;
          var oldX = dirX;
          var oldY = dirY;
          var oldZ = dirZ;
          dirX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
          dirY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
          dirZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
          oldX = posX;
          oldY = posY;
          oldZ = posZ;
          posX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
          posY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
          posZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
          posX += lPosX;
          posY += lPosY;
          posZ += lPosZ;
        }
        if (panner.positionX) {
          panner.positionX.value = posX;
          panner.positionY.value = posY;
          panner.positionZ.value = posZ;
        } else {
          panner.setPosition(posX, posY, posZ);
        }
        if (panner.orientationX) {
          panner.orientationX.value = dirX;
          panner.orientationY.value = dirY;
          panner.orientationZ.value = dirZ;
        } else {
          panner.setOrientation(dirX, dirY, dirZ);
        }
        var oldShift = src.dopplerShift;
        var velX = src.velocity[0];
        var velY = src.velocity[1];
        var velZ = src.velocity[2];
        var lVelX = listener.velocity[0];
        var lVelY = listener.velocity[1];
        var lVelZ = listener.velocity[2];
        if (
          (posX === lPosX && posY === lPosY && posZ === lPosZ) ||
          (velX === lVelX && velY === lVelY && velZ === lVelZ)
        ) {
          src.dopplerShift = 1;
        } else {
          var speedOfSound = src.context.speedOfSound;
          var dopplerFactor = src.context.dopplerFactor;
          var slX = lPosX - posX;
          var slY = lPosY - posY;
          var slZ = lPosZ - posZ;
          var magSl = Math.sqrt(slX * slX + slY * slY + slZ * slZ);
          var vls = (slX * lVelX + slY * lVelY + slZ * lVelZ) / magSl;
          var vss = (slX * velX + slY * velY + slZ * velZ) / magSl;
          vls = Math.min(vls, speedOfSound / dopplerFactor);
          vss = Math.min(vss, speedOfSound / dopplerFactor);
          src.dopplerShift =
            (speedOfSound - dopplerFactor * vls) /
            (speedOfSound - dopplerFactor * vss);
        }
        if (src.dopplerShift !== oldShift) {
          AL.updateSourceRate(src);
        }
      },
      updateSourceRate: function (src) {
        if (src.state === 4114) {
          AL.cancelPendingSourceAudio(src);
          var audioSrc = src.audioQueue[0];
          if (!audioSrc) {
            return;
          }
          var duration;
          if (src.type === 4136 && src.looping) {
            duration = Number.POSITIVE_INFINITY;
          } else {
            duration =
              (audioSrc.buffer.duration - audioSrc._startOffset) /
              src.playbackRate;
          }
          audioSrc._duration = duration;
          audioSrc.playbackRate.value = src.playbackRate;
          AL.scheduleSourceAudio(src);
        }
      },
      sourceDuration: function (src) {
        var length = 0;
        for (var i = 0; i < src.bufQueue.length; i++) {
          var audioBuf = src.bufQueue[i].audioBuf;
          length += audioBuf ? audioBuf.duration : 0;
        }
        return length;
      },
      sourceTell: function (src) {
        AL.updateSourceTime(src);
        var offset = 0;
        for (var i = 0; i < src.bufsProcessed; i++) {
          offset += src.bufQueue[i].audioBuf.duration;
        }
        offset += src.bufOffset;
        return offset;
      },
      sourceSeek: function (src, offset) {
        var playing = src.state == 4114;
        if (playing) {
          AL.setSourceState(src, 4113);
        }
        if (src.bufQueue[src.bufsProcessed].audioBuf !== null) {
          src.bufsProcessed = 0;
          while (offset > src.bufQueue[src.bufsProcessed].audioBuf.duration) {
            offset -= src.bufQueue[src.bufsProcessed].audiobuf.duration;
            src.bufsProcessed++;
          }
          src.bufOffset = offset;
        }
        if (playing) {
          AL.setSourceState(src, 4114);
        }
      },
      getGlobalParam: function (funcname, param) {
        if (!AL.currentCtx) {
          return null;
        }
        switch (param) {
          case 49152:
            return AL.currentCtx.dopplerFactor;
          case 49155:
            return AL.currentCtx.speedOfSound;
          case 53248:
            return AL.currentCtx.distanceModel;
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setGlobalParam: function (funcname, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        switch (param) {
          case 49152:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.currentCtx.dopplerFactor = value;
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 49155:
            if (!Number.isFinite(value) || value <= 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.currentCtx.speedOfSound = value;
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 53248:
            switch (value) {
              case 0:
              case 53249:
              case 53250:
              case 53251:
              case 53252:
              case 53253:
              case 53254:
                AL.currentCtx.distanceModel = value;
                AL.updateContextGlobal(AL.currentCtx);
                break;
              default:
                AL.currentCtx.err = 40963;
                return;
            }
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      getListenerParam: function (funcname, param) {
        if (!AL.currentCtx) {
          return null;
        }
        switch (param) {
          case 4100:
            return AL.currentCtx.listener.position;
          case 4102:
            return AL.currentCtx.listener.velocity;
          case 4111:
            return AL.currentCtx.listener.direction.concat(
              AL.currentCtx.listener.up
            );
          case 4106:
            return AL.currentCtx.gain.gain.value;
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setListenerParam: function (funcname, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        if (value === null) {
          AL.currentCtx.err = 40962;
          return;
        }
        var listener = AL.currentCtx.listener;
        switch (param) {
          case 4100:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            listener.position[0] = value[0];
            listener.position[1] = value[1];
            listener.position[2] = value[2];
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 4102:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            listener.velocity[0] = value[0];
            listener.velocity[1] = value[1];
            listener.velocity[2] = value[2];
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 4106:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.currentCtx.gain.gain.value = value;
            break;
          case 4111:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2]) ||
              !Number.isFinite(value[3]) ||
              !Number.isFinite(value[4]) ||
              !Number.isFinite(value[5])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            listener.direction[0] = value[0];
            listener.direction[1] = value[1];
            listener.direction[2] = value[2];
            listener.up[0] = value[3];
            listener.up[1] = value[4];
            listener.up[2] = value[5];
            AL.updateListenerSpace(AL.currentCtx);
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      getBufferParam: function (funcname, bufferId, param) {
        if (!AL.currentCtx) {
          return;
        }
        var buf = AL.buffers[bufferId];
        if (!buf || bufferId === 0) {
          AL.currentCtx.err = 40961;
          return;
        }
        switch (param) {
          case 8193:
            return buf.frequency;
          case 8194:
            return buf.bytesPerSample * 8;
          case 8195:
            return buf.channels;
          case 8196:
            return buf.length * buf.bytesPerSample * buf.channels;
          case 8213:
            if (buf.length === 0) {
              return [0, 0];
            } else {
              return [
                (buf.audioBuf._loopStart || 0) * buf.frequency,
                (buf.audioBuf._loopEnd || buf.length) * buf.frequency,
              ];
            }
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setBufferParam: function (funcname, bufferId, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        var buf = AL.buffers[bufferId];
        if (!buf || bufferId === 0) {
          AL.currentCtx.err = 40961;
          return;
        }
        if (value === null) {
          AL.currentCtx.err = 40962;
          return;
        }
        switch (param) {
          case 8196:
            if (value !== 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            break;
          case 8213:
            if (
              value[0] < 0 ||
              value[0] > buf.length ||
              value[1] < 0 ||
              value[1] > buf.Length ||
              value[0] >= value[1]
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            if (buf.refCount > 0) {
              AL.currentCtx.err = 40964;
              return;
            }
            if (buf.audioBuf) {
              buf.audioBuf._loopStart = value[0] / buf.frequency;
              buf.audioBuf._loopEnd = value[1] / buf.frequency;
            }
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      getSourceParam: function (funcname, sourceId, param) {
        if (!AL.currentCtx) {
          return null;
        }
        var src = AL.currentCtx.sources[sourceId];
        if (!src) {
          AL.currentCtx.err = 40961;
          return null;
        }
        switch (param) {
          case 514:
            return src.relative;
          case 4097:
            return src.coneInnerAngle;
          case 4098:
            return src.coneOuterAngle;
          case 4099:
            return src.pitch;
          case 4100:
            return src.position;
          case 4101:
            return src.direction;
          case 4102:
            return src.velocity;
          case 4103:
            return src.looping;
          case 4105:
            if (src.type === 4136) {
              return src.bufQueue[0].id;
            } else {
              return 0;
            }
          case 4106:
            return src.gain.gain.value;
          case 4109:
            return src.minGain;
          case 4110:
            return src.maxGain;
          case 4112:
            return src.state;
          case 4117:
            if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
              return 0;
            } else {
              return src.bufQueue.length;
            }
          case 4118:
            if (
              (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) ||
              src.looping
            ) {
              return 0;
            } else {
              return src.bufsProcessed;
            }
          case 4128:
            return src.refDistance;
          case 4129:
            return src.rolloffFactor;
          case 4130:
            return src.coneOuterGain;
          case 4131:
            return src.maxDistance;
          case 4132:
            return AL.sourceTell(src);
          case 4133:
            var offset = AL.sourceTell(src);
            if (offset > 0) {
              offset *= src.bufQueue[0].frequency;
            }
            return offset;
          case 4134:
            var offset = AL.sourceTell(src);
            if (offset > 0) {
              offset *=
                src.bufQueue[0].frequency * src.bufQueue[0].bytesPerSample;
            }
            return offset;
          case 4135:
            return src.type;
          case 4628:
            return src.spatialize;
          case 8201:
            var length = 0;
            var bytesPerFrame = 0;
            for (var i = 0; i < src.bufQueue.length; i++) {
              length += src.bufQueue[i].length;
              if (src.bufQueue[i].id !== 0) {
                bytesPerFrame =
                  src.bufQueue[i].bytesPerSample * src.bufQueue[i].channels;
              }
            }
            return length * bytesPerFrame;
          case 8202:
            var length = 0;
            for (var i = 0; i < src.bufQueue.length; i++) {
              length += src.bufQueue[i].length;
            }
            return length;
          case 8203:
            return AL.sourceDuration(src);
          case 53248:
            return src.distanceModel;
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setSourceParam: function (funcname, sourceId, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        var src = AL.currentCtx.sources[sourceId];
        if (!src) {
          AL.currentCtx.err = 40961;
          return;
        }
        if (value === null) {
          AL.currentCtx.err = 40962;
          return;
        }
        switch (param) {
          case 514:
            if (value === 1) {
              src.relative = true;
              AL.updateSourceSpace(src);
            } else if (value === 0) {
              src.relative = false;
              AL.updateSourceSpace(src);
            } else {
              AL.currentCtx.err = 40963;
              return;
            }
            break;
          case 4097:
            if (!Number.isFinite(value)) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.coneInnerAngle = value;
            if (src.panner) {
              src.panner.coneInnerAngle = value % 360;
            }
            break;
          case 4098:
            if (!Number.isFinite(value)) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.coneOuterAngle = value;
            if (src.panner) {
              src.panner.coneOuterAngle = value % 360;
            }
            break;
          case 4099:
            if (!Number.isFinite(value) || value <= 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            if (src.pitch === value) {
              break;
            }
            src.pitch = value;
            AL.updateSourceRate(src);
            break;
          case 4100:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.position[0] = value[0];
            src.position[1] = value[1];
            src.position[2] = value[2];
            AL.updateSourceSpace(src);
            break;
          case 4101:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.direction[0] = value[0];
            src.direction[1] = value[1];
            src.direction[2] = value[2];
            AL.updateSourceSpace(src);
            break;
          case 4102:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.velocity[0] = value[0];
            src.velocity[1] = value[1];
            src.velocity[2] = value[2];
            AL.updateSourceSpace(src);
            break;
          case 4103:
            if (value === 1) {
              src.looping = true;
              AL.updateSourceTime(src);
              if (src.type === 4136 && src.audioQueue.length > 0) {
                var audioSrc = src.audioQueue[0];
                audioSrc.loop = true;
                audioSrc._duration = Number.POSITIVE_INFINITY;
              }
            } else if (value === 0) {
              src.looping = false;
              var currentTime = AL.updateSourceTime(src);
              if (src.type === 4136 && src.audioQueue.length > 0) {
                var audioSrc = src.audioQueue[0];
                audioSrc.loop = false;
                audioSrc._duration =
                  src.bufQueue[0].audioBuf.duration / src.playbackRate;
                audioSrc._startTime =
                  currentTime - src.bufOffset / src.playbackRate;
              }
            } else {
              AL.currentCtx.err = 40963;
              return;
            }
            break;
          case 4105:
            if (src.state === 4114 || src.state === 4115) {
              AL.currentCtx.err = 40964;
              return;
            }
            if (value === 0) {
              for (var i in src.bufQueue) {
                src.bufQueue[i].refCount--;
              }
              src.bufQueue.length = 1;
              src.bufQueue[0] = AL.buffers[0];
              src.bufsProcessed = 0;
              src.type = 4144;
            } else {
              var buf = AL.buffers[value];
              if (!buf) {
                AL.currentCtx.err = 40963;
                return;
              }
              for (var i in src.bufQueue) {
                src.bufQueue[i].refCount--;
              }
              src.bufQueue.length = 0;
              buf.refCount++;
              src.bufQueue = [buf];
              src.bufsProcessed = 0;
              src.type = 4136;
            }
            AL.initSourcePanner(src);
            AL.scheduleSourceAudio(src);
            break;
          case 4106:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.gain.gain.value = value;
            break;
          case 4109:
            if (
              !Number.isFinite(value) ||
              value < 0 ||
              value > Math.min(src.maxGain, 1)
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.minGain = value;
            break;
          case 4110:
            if (
              !Number.isFinite(value) ||
              value < Math.max(0, src.minGain) ||
              value > 1
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.maxGain = value;
            break;
          case 4128:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.refDistance = value;
            if (src.panner) {
              src.panner.refDistance = value;
            }
            break;
          case 4129:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.rolloffFactor = value;
            if (src.panner) {
              src.panner.rolloffFactor = value;
            }
            break;
          case 4130:
            if (!Number.isFinite(value) || value < 0 || value > 1) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.coneOuterGain = value;
            if (src.panner) {
              src.panner.coneOuterGain = value;
            }
            break;
          case 4131:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.maxDistance = value;
            if (src.panner) {
              src.panner.maxDistance = value;
            }
            break;
          case 4132:
            if (value < 0 || value > AL.sourceDuration(src)) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.sourceSeek(src, value);
            break;
          case 4133:
            var srcLen = AL.sourceDuration(src);
            if (srcLen > 0) {
              var frequency;
              for (var bufId in src.bufQueue) {
                if (bufId) {
                  frequency = src.bufQueue[bufId].frequency;
                  break;
                }
              }
              value /= frequency;
            }
            if (value < 0 || value > srcLen) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.sourceSeek(src, value);
            break;
          case 4134:
            var srcLen = AL.sourceDuration(src);
            if (srcLen > 0) {
              var bytesPerSec;
              for (var bufId in src.bufQueue) {
                if (bufId) {
                  var buf = src.bufQueue[bufId];
                  bytesPerSec =
                    buf.frequency * buf.bytesPerSample * buf.channels;
                  break;
                }
              }
              value /= bytesPerSec;
            }
            if (value < 0 || value > srcLen) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.sourceSeek(src, value);
            break;
          case 4628:
            if (value !== 0 && value !== 1 && value !== 2) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.spatialize = value;
            AL.initSourcePanner(src);
            break;
          case 8201:
          case 8202:
          case 8203:
            AL.currentCtx.err = 40964;
            break;
          case 53248:
            switch (value) {
              case 0:
              case 53249:
              case 53250:
              case 53251:
              case 53252:
              case 53253:
              case 53254:
                src.distanceModel = value;
                if (AL.currentCtx.sourceDistanceModel) {
                  AL.updateContextGlobal(AL.currentCtx);
                }
                break;
              default:
                AL.currentCtx.err = 40963;
                return;
            }
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      captures: {},
      sharedCaptureAudioCtx: null,
      requireValidCaptureDevice: function (deviceId, funcname) {
        if (deviceId === 0) {
          AL.alcErr = 40961;
          return null;
        }
        var c = AL.captures[deviceId];
        if (!c) {
          AL.alcErr = 40961;
          return null;
        }
        var err = c.mediaStreamError;
        if (err) {
          AL.alcErr = 40961;
          return null;
        }
        return c;
      },
    };
    function _alBufferData(bufferId, format, pData, size, freq) {
      if (!AL.currentCtx) {
        return;
      }
      var buf = AL.buffers[bufferId];
      if (!buf) {
        AL.currentCtx.err = 40963;
        return;
      }
      if (freq <= 0) {
        AL.currentCtx.err = 40963;
        return;
      }
      var audioBuf = null;
      try {
        switch (format) {
          case 4352:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size, freq);
              var channel0 = audioBuf.getChannelData(0);
              for (var i = 0; i < size; ++i) {
                channel0[i] = HEAPU8[pData++] * 0.0078125 - 1;
              }
            }
            buf.bytesPerSample = 1;
            buf.channels = 1;
            buf.length = size;
            break;
          case 4353:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                1,
                size >> 1,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              pData >>= 1;
              for (var i = 0; i < size >> 1; ++i) {
                channel0[i] = HEAP16[pData++] * 30517578125e-15;
              }
            }
            buf.bytesPerSample = 2;
            buf.channels = 1;
            buf.length = size >> 1;
            break;
          case 4354:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                2,
                size >> 1,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              var channel1 = audioBuf.getChannelData(1);
              for (var i = 0; i < size >> 1; ++i) {
                channel0[i] = HEAPU8[pData++] * 0.0078125 - 1;
                channel1[i] = HEAPU8[pData++] * 0.0078125 - 1;
              }
            }
            buf.bytesPerSample = 1;
            buf.channels = 2;
            buf.length = size >> 1;
            break;
          case 4355:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                2,
                size >> 2,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              var channel1 = audioBuf.getChannelData(1);
              pData >>= 1;
              for (var i = 0; i < size >> 2; ++i) {
                channel0[i] = HEAP16[pData++] * 30517578125e-15;
                channel1[i] = HEAP16[pData++] * 30517578125e-15;
              }
            }
            buf.bytesPerSample = 2;
            buf.channels = 2;
            buf.length = size >> 2;
            break;
          case 65552:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                1,
                size >> 2,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              pData >>= 2;
              for (var i = 0; i < size >> 2; ++i) {
                channel0[i] = HEAPF32[pData++];
              }
            }
            buf.bytesPerSample = 4;
            buf.channels = 1;
            buf.length = size >> 2;
            break;
          case 65553:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                2,
                size >> 3,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              var channel1 = audioBuf.getChannelData(1);
              pData >>= 2;
              for (var i = 0; i < size >> 3; ++i) {
                channel0[i] = HEAPF32[pData++];
                channel1[i] = HEAPF32[pData++];
              }
            }
            buf.bytesPerSample = 4;
            buf.channels = 2;
            buf.length = size >> 3;
            break;
          default:
            AL.currentCtx.err = 40963;
            return;
        }
        buf.frequency = freq;
        buf.audioBuf = audioBuf;
      } catch (e) {
        AL.currentCtx.err = 40963;
        return;
      }
    }
    function _alDeleteBuffers(count, pBufferIds) {
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[(pBufferIds + i * 4) >> 2];
        if (bufId === 0) {
          continue;
        }
        if (!AL.buffers[bufId]) {
          AL.currentCtx.err = 40961;
          return;
        }
        if (AL.buffers[bufId].refCount) {
          AL.currentCtx.err = 40964;
          return;
        }
      }
      for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[(pBufferIds + i * 4) >> 2];
        if (bufId === 0) {
          continue;
        }
        AL.deviceRefCounts[AL.buffers[bufId].deviceId]--;
        delete AL.buffers[bufId];
        AL.freeIds.push(bufId);
      }
    }
    function _alSourcei(sourceId, param, value) {
      switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
          AL.setSourceParam("alSourcei", sourceId, param, value);
          break;
        default:
          AL.setSourceParam("alSourcei", sourceId, param, null);
          break;
      }
    }
    function _alDeleteSources(count, pSourceIds) {
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[(pSourceIds + i * 4) >> 2];
        if (!AL.currentCtx.sources[srcId]) {
          AL.currentCtx.err = 40961;
          return;
        }
      }
      for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[(pSourceIds + i * 4) >> 2];
        AL.setSourceState(AL.currentCtx.sources[srcId], 4116);
        _alSourcei(srcId, 4105, 0);
        delete AL.currentCtx.sources[srcId];
        AL.freeIds.push(srcId);
      }
    }
    function _alGenBuffers(count, pBufferIds) {
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var buf = {
          deviceId: AL.currentCtx.deviceId,
          id: AL.newId(),
          refCount: 0,
          audioBuf: null,
          frequency: 0,
          bytesPerSample: 2,
          channels: 1,
          length: 0,
        };
        AL.deviceRefCounts[buf.deviceId]++;
        AL.buffers[buf.id] = buf;
        HEAP32[(pBufferIds + i * 4) >> 2] = buf.id;
      }
    }
    function _alGenSources(count, pSourceIds) {
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var gain = AL.currentCtx.audioCtx.createGain();
        gain.connect(AL.currentCtx.gain);
        var src = {
          context: AL.currentCtx,
          id: AL.newId(),
          type: 4144,
          state: 4113,
          bufQueue: [AL.buffers[0]],
          audioQueue: [],
          looping: false,
          pitch: 1,
          dopplerShift: 1,
          gain: gain,
          minGain: 0,
          maxGain: 1,
          panner: null,
          bufsProcessed: 0,
          bufStartTime: Number.NEGATIVE_INFINITY,
          bufOffset: 0,
          relative: false,
          refDistance: 1,
          maxDistance: 3.40282e38,
          rolloffFactor: 1,
          position: [0, 0, 0],
          velocity: [0, 0, 0],
          direction: [0, 0, 0],
          coneOuterGain: 0,
          coneInnerAngle: 360,
          coneOuterAngle: 360,
          distanceModel: 53250,
          spatialize: 2,
          get playbackRate() {
            return this.pitch * this.dopplerShift;
          },
        };
        AL.currentCtx.sources[src.id] = src;
        HEAP32[(pSourceIds + i * 4) >> 2] = src.id;
      }
    }
    function _alGetSourcei(sourceId, param, pValue) {
      var val = AL.getSourceParam("alGetSourcei", sourceId, param);
      if (val === null) {
        return;
      }
      if (!pValue) {
        AL.currentCtx.err = 40963;
        return;
      }
      switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4112:
        case 4117:
        case 4118:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4135:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
          HEAP32[pValue >> 2] = val;
          break;
        default:
          AL.currentCtx.err = 40962;
          return;
      }
    }
    function _alListenerfv(param, pValues) {
      if (!AL.currentCtx) {
        return;
      }
      if (!pValues) {
        AL.currentCtx.err = 40963;
        return;
      }
      switch (param) {
        case 4100:
        case 4102:
          AL.paramArray[0] = HEAPF32[pValues >> 2];
          AL.paramArray[1] = HEAPF32[(pValues + 4) >> 2];
          AL.paramArray[2] = HEAPF32[(pValues + 8) >> 2];
          AL.setListenerParam("alListenerfv", param, AL.paramArray);
          break;
        case 4111:
          AL.paramArray[0] = HEAPF32[pValues >> 2];
          AL.paramArray[1] = HEAPF32[(pValues + 4) >> 2];
          AL.paramArray[2] = HEAPF32[(pValues + 8) >> 2];
          AL.paramArray[3] = HEAPF32[(pValues + 12) >> 2];
          AL.paramArray[4] = HEAPF32[(pValues + 16) >> 2];
          AL.paramArray[5] = HEAPF32[(pValues + 20) >> 2];
          AL.setListenerParam("alListenerfv", param, AL.paramArray);
          break;
        default:
          AL.setListenerParam("alListenerfv", param, null);
          break;
      }
    }
    function _alSourcePause(sourceId) {
      if (!AL.currentCtx) {
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
        AL.currentCtx.err = 40961;
        return;
      }
      AL.setSourceState(src, 4115);
    }
    function _alSourcePlay(sourceId) {
      if (!AL.currentCtx) {
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
        AL.currentCtx.err = 40961;
        return;
      }
      AL.setSourceState(src, 4114);
    }
    function _alSourceStop(sourceId) {
      if (!AL.currentCtx) {
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
        AL.currentCtx.err = 40961;
        return;
      }
      AL.setSourceState(src, 4116);
    }
    function _alSourcef(sourceId, param, value) {
      switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
          AL.setSourceParam("alSourcef", sourceId, param, value);
          break;
        default:
          AL.setSourceParam("alSourcef", sourceId, param, null);
          break;
      }
    }
    function _alSourcefv(sourceId, param, pValues) {
      if (!AL.currentCtx) {
        return;
      }
      if (!pValues) {
        AL.currentCtx.err = 40963;
        return;
      }
      switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
          var val = HEAPF32[pValues >> 2];
          AL.setSourceParam("alSourcefv", sourceId, param, val);
          break;
        case 4100:
        case 4101:
        case 4102:
          AL.paramArray[0] = HEAPF32[pValues >> 2];
          AL.paramArray[1] = HEAPF32[(pValues + 4) >> 2];
          AL.paramArray[2] = HEAPF32[(pValues + 8) >> 2];
          AL.setSourceParam("alSourcefv", sourceId, param, AL.paramArray);
          break;
        default:
          AL.setSourceParam("alSourcefv", sourceId, param, null);
          break;
      }
    }
    function _alcCreateContext(deviceId, pAttrList) {
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = 40961;
        return 0;
      }
      var options = null;
      var attrs = [];
      var hrtf = null;
      pAttrList >>= 2;
      if (pAttrList) {
        var attr = 0;
        var val = 0;
        while (true) {
          attr = HEAP32[pAttrList++];
          attrs.push(attr);
          if (attr === 0) {
            break;
          }
          val = HEAP32[pAttrList++];
          attrs.push(val);
          switch (attr) {
            case 4103:
              if (!options) {
                options = {};
              }
              options.sampleRate = val;
              break;
            case 4112:
            case 4113:
              break;
            case 6546:
              switch (val) {
                case 0:
                  hrtf = false;
                  break;
                case 1:
                  hrtf = true;
                  break;
                case 2:
                  break;
                default:
                  AL.alcErr = 40964;
                  return 0;
              }
              break;
            case 6550:
              if (val !== 0) {
                AL.alcErr = 40964;
                return 0;
              }
              break;
            default:
              AL.alcErr = 40964;
              return 0;
          }
        }
      }
      var AudioContext = window.AudioContext || window.webkitAudioContext;
      var ac = null;
      try {
        if (options) {
          ac = new AudioContext(options);
        } else {
          ac = new AudioContext();
        }
      } catch (e) {
        if (e.name === "NotSupportedError") {
          AL.alcErr = 40964;
        } else {
          AL.alcErr = 40961;
        }
        return 0;
      }
      if (typeof ac.createGain === "undefined") {
        ac.createGain = ac.createGainNode;
      }
      var gain = ac.createGain();
      gain.connect(ac.destination);
      var ctx = {
        deviceId: deviceId,
        id: AL.newId(),
        attrs: attrs,
        audioCtx: ac,
        listener: {
          position: [0, 0, 0],
          velocity: [0, 0, 0],
          direction: [0, 0, 0],
          up: [0, 0, 0],
        },
        sources: [],
        interval: setInterval(function () {
          AL.scheduleContextAudio(ctx);
        }, AL.QUEUE_INTERVAL),
        gain: gain,
        distanceModel: 53250,
        speedOfSound: 343.3,
        dopplerFactor: 1,
        sourceDistanceModel: false,
        hrtf: hrtf || false,
        _err: 0,
        get err() {
          return this._err;
        },
        set err(val) {
          if (this._err === 0 || val === 0) {
            this._err = val;
          }
        },
      };
      AL.deviceRefCounts[deviceId]++;
      AL.contexts[ctx.id] = ctx;
      if (hrtf !== null) {
        for (var ctxId in AL.contexts) {
          var c = AL.contexts[ctxId];
          if (c.deviceId === deviceId) {
            c.hrtf = hrtf;
            AL.updateContextGlobal(c);
          }
        }
      }
      return ctx.id;
    }
    function _alcMakeContextCurrent(contextId) {
      if (contextId === 0) {
        AL.currentCtx = null;
        return 0;
      } else {
        AL.currentCtx = AL.contexts[contextId];
        return 1;
      }
    }
    function _alcOpenDevice(pDeviceName) {
      if (pDeviceName) {
        var name = UTF8ToString(pDeviceName);
        if (name !== AL.DEVICE_NAME) {
          return 0;
        }
      }
      if (
        typeof AudioContext !== "undefined" ||
        typeof webkitAudioContext !== "undefined"
      ) {
        var deviceId = AL.newId();
        AL.deviceRefCounts[deviceId] = 0;
        return deviceId;
      } else {
        return 0;
      }
    }
    var _emscripten_get_now_is_monotonic = true;
    function _clock_gettime(clk_id, tp) {
      var now;
      if (clk_id === 0) {
        now = Date.now();
      } else if (
        (clk_id === 1 || clk_id === 4) &&
        _emscripten_get_now_is_monotonic
      ) {
        now = _emscripten_get_now();
      } else {
        setErrNo(28);
        return -1;
      }
      HEAP32[tp >> 2] = (now / 1e3) | 0;
      HEAP32[(tp + 4) >> 2] = ((now % 1e3) * 1e3 * 1e3) | 0;
      return 0;
    }
    var EGL = {
      errorCode: 12288,
      defaultDisplayInitialized: false,
      currentContext: 0,
      currentReadSurface: 0,
      currentDrawSurface: 0,
      contextAttributes: {
        alpha: false,
        depth: false,
        stencil: false,
        antialias: false,
      },
      stringCache: {},
      setErrorCode: function (code) {
        EGL.errorCode = code;
      },
      chooseConfig: function (
        display,
        attribList,
        config,
        config_size,
        numConfigs
      ) {
        if (display != 62e3) {
          EGL.setErrorCode(12296);
          return 0;
        }
        if (attribList) {
          for (;;) {
            var param = HEAP32[attribList >> 2];
            if (param == 12321) {
              var alphaSize = HEAP32[(attribList + 4) >> 2];
              EGL.contextAttributes.alpha = alphaSize > 0;
            } else if (param == 12325) {
              var depthSize = HEAP32[(attribList + 4) >> 2];
              EGL.contextAttributes.depth = depthSize > 0;
            } else if (param == 12326) {
              var stencilSize = HEAP32[(attribList + 4) >> 2];
              EGL.contextAttributes.stencil = stencilSize > 0;
            } else if (param == 12337) {
              var samples = HEAP32[(attribList + 4) >> 2];
              EGL.contextAttributes.antialias = samples > 0;
            } else if (param == 12338) {
              var samples = HEAP32[(attribList + 4) >> 2];
              EGL.contextAttributes.antialias = samples == 1;
            } else if (param == 12544) {
              var requestedPriority = HEAP32[(attribList + 4) >> 2];
              EGL.contextAttributes.lowLatency = requestedPriority != 12547;
            } else if (param == 12344) {
              break;
            }
            attribList += 8;
          }
        }
        if ((!config || !config_size) && !numConfigs) {
          EGL.setErrorCode(12300);
          return 0;
        }
        if (numConfigs) {
          HEAP32[numConfigs >> 2] = 1;
        }
        if (config && config_size > 0) {
          HEAP32[config >> 2] = 62002;
        }
        EGL.setErrorCode(12288);
        return 1;
      },
    };
    function _eglGetProcAddress(name_) {
      return _emscripten_GetProcAddress(name_);
    }
    function _emscripten_get_sbrk_ptr() {
      return 372944;
    }
    function __webgl_acquireInstancedArraysExtension(ctx) {
      var ext = ctx.getExtension("ANGLE_instanced_arrays");
      if (ext) {
        ctx["vertexAttribDivisor"] = function (index, divisor) {
          ext["vertexAttribDivisorANGLE"](index, divisor);
        };
        ctx["drawArraysInstanced"] = function (mode, first, count, primcount) {
          ext["drawArraysInstancedANGLE"](mode, first, count, primcount);
        };
        ctx["drawElementsInstanced"] = function (
          mode,
          count,
          type,
          indices,
          primcount
        ) {
          ext["drawElementsInstancedANGLE"](
            mode,
            count,
            type,
            indices,
            primcount
          );
        };
      }
    }
    function __webgl_acquireVertexArrayObjectExtension(ctx) {
      var ext = ctx.getExtension("OES_vertex_array_object");
      if (ext) {
        ctx["createVertexArray"] = function () {
          return ext["createVertexArrayOES"]();
        };
        ctx["deleteVertexArray"] = function (vao) {
          ext["deleteVertexArrayOES"](vao);
        };
        ctx["bindVertexArray"] = function (vao) {
          ext["bindVertexArrayOES"](vao);
        };
        ctx["isVertexArray"] = function (vao) {
          return ext["isVertexArrayOES"](vao);
        };
      }
    }
    function __webgl_acquireDrawBuffersExtension(ctx) {
      var ext = ctx.getExtension("WEBGL_draw_buffers");
      if (ext) {
        ctx["drawBuffers"] = function (n, bufs) {
          ext["drawBuffersWEBGL"](n, bufs);
        };
      }
    }
    var GL = {
      counter: 1,
      lastError: 0,
      buffers: [],
      mappedBuffers: {},
      programs: [],
      framebuffers: [],
      renderbuffers: [],
      textures: [],
      uniforms: [],
      shaders: [],
      vaos: [],
      contexts: [],
      currentContext: null,
      offscreenCanvases: {},
      timerQueriesEXT: [],
      programInfos: {},
      stringCache: {},
      unpackAlignment: 4,
      init: function () {
        var miniTempFloatBuffer = new Float32Array(GL.MINI_TEMP_BUFFER_SIZE);
        for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) {
          GL.miniTempBufferFloatViews[i] = miniTempFloatBuffer.subarray(
            0,
            i + 1
          );
        }
        var miniTempIntBuffer = new Int32Array(GL.MINI_TEMP_BUFFER_SIZE);
        for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) {
          GL.miniTempBufferIntViews[i] = miniTempIntBuffer.subarray(0, i + 1);
        }
      },
      recordError: function recordError(errorCode) {
        if (!GL.lastError) {
          GL.lastError = errorCode;
        }
      },
      getNewId: function (table) {
        var ret = GL.counter++;
        for (var i = table.length; i < ret; i++) {
          table[i] = null;
        }
        return ret;
      },
      MINI_TEMP_BUFFER_SIZE: 256,
      miniTempBufferFloatViews: [0],
      miniTempBufferIntViews: [0],
      getSource: function (shader, count, string, length) {
        var source = "";
        for (var i = 0; i < count; ++i) {
          var len = length ? HEAP32[(length + i * 4) >> 2] : -1;
          source += UTF8ToString(
            HEAP32[(string + i * 4) >> 2],
            len < 0 ? undefined : len
          );
        }
        return source;
      },
      createContext: function (canvas, webGLContextAttributes) {
        var ctx = canvas.getContext("webgl", webGLContextAttributes);
        if (!ctx) return 0;
        var handle = GL.registerContext(ctx, webGLContextAttributes);
        return handle;
      },
      registerContext: function (ctx, webGLContextAttributes) {
        var handle = GL.getNewId(GL.contexts);
        var context = {
          handle: 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: function (contextHandle) {
        GL.currentContext = GL.contexts[contextHandle];
        Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx;
        return !(contextHandle && !GLctx);
      },
      getContext: function (contextHandle) {
        return GL.contexts[contextHandle];
      },
      deleteContext: function (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] &&
          GL.contexts[contextHandle].GLctx.canvas
        )
          GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
        GL.contexts[contextHandle] = null;
      },
      initExtensions: function (context) {
        if (!context) context = GL.currentContext;
        if (context.initExtensionsDone) return;
        context.initExtensionsDone = true;
        var GLctx = context.GLctx;
        if (context.version < 2) {
          __webgl_acquireInstancedArraysExtension(GLctx);
          __webgl_acquireVertexArrayObjectExtension(GLctx);
          __webgl_acquireDrawBuffersExtension(GLctx);
        }
        GLctx.disjointTimerQueryExt = GLctx.getExtension(
          "EXT_disjoint_timer_query"
        );
        var automaticallyEnabledExtensions = [
          "OES_texture_float",
          "OES_texture_half_float",
          "OES_standard_derivatives",
          "OES_vertex_array_object",
          "WEBGL_compressed_texture_s3tc",
          "WEBGL_depth_texture",
          "OES_element_index_uint",
          "EXT_texture_filter_anisotropic",
          "EXT_frag_depth",
          "WEBGL_draw_buffers",
          "ANGLE_instanced_arrays",
          "OES_texture_float_linear",
          "OES_texture_half_float_linear",
          "EXT_blend_minmax",
          "EXT_shader_texture_lod",
          "EXT_texture_norm16",
          "WEBGL_compressed_texture_pvrtc",
          "EXT_color_buffer_half_float",
          "WEBGL_color_buffer_float",
          "EXT_sRGB",
          "WEBGL_compressed_texture_etc1",
          "EXT_disjoint_timer_query",
          "WEBGL_compressed_texture_etc",
          "WEBGL_compressed_texture_astc",
          "EXT_color_buffer_float",
          "WEBGL_compressed_texture_s3tc_srgb",
          "EXT_disjoint_timer_query_webgl2",
          "WEBKIT_WEBGL_compressed_texture_pvrtc",
        ];
        var exts = GLctx.getSupportedExtensions() || [];
        exts.forEach(function (ext) {
          if (automaticallyEnabledExtensions.indexOf(ext) != -1) {
            GLctx.getExtension(ext);
          }
        });
      },
      populateUniformTable: function (program) {
        var p = GL.programs[program];
        var ptable = (GL.programInfos[program] = {
          uniforms: {},
          maxUniformLength: 0,
          maxAttributeLength: -1,
          maxUniformBlockNameLength: -1,
        });
        var utable = ptable.uniforms;
        var numUniforms = GLctx.getProgramParameter(p, 35718);
        for (var i = 0; i < numUniforms; ++i) {
          var u = GLctx.getActiveUniform(p, i);
          var name = u.name;
          ptable.maxUniformLength = Math.max(
            ptable.maxUniformLength,
            name.length + 1
          );
          if (name.slice(-1) == "]") {
            name = name.slice(0, name.lastIndexOf("["));
          }
          var loc = GLctx.getUniformLocation(p, name);
          if (loc) {
            var id = GL.getNewId(GL.uniforms);
            utable[name] = [u.size, id];
            GL.uniforms[id] = loc;
            for (var j = 1; j < u.size; ++j) {
              var n = name + "[" + j + "]";
              loc = GLctx.getUniformLocation(p, n);
              id = GL.getNewId(GL.uniforms);
              GL.uniforms[id] = loc;
            }
          }
        }
      },
    };
    function _emscripten_glActiveTexture(x0) {
      GLctx["activeTexture"](x0);
    }
    function _emscripten_glAttachShader(program, shader) {
      GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
    }
    function _emscripten_glBeginQueryEXT(target, id) {
      GLctx.disjointTimerQueryExt["beginQueryEXT"](
        target,
        GL.timerQueriesEXT[id]
      );
    }
    function _emscripten_glBindAttribLocation(program, index, name) {
      GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
    }
    function _emscripten_glBindBuffer(target, buffer) {
      GLctx.bindBuffer(target, GL.buffers[buffer]);
    }
    function _emscripten_glBindFramebuffer(target, framebuffer) {
      GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
    }
    function _emscripten_glBindRenderbuffer(target, renderbuffer) {
      GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
    }
    function _emscripten_glBindTexture(target, texture) {
      GLctx.bindTexture(target, GL.textures[texture]);
    }
    function _emscripten_glBindVertexArrayOES(vao) {
      GLctx["bindVertexArray"](GL.vaos[vao]);
    }
    function _emscripten_glBlendColor(x0, x1, x2, x3) {
      GLctx["blendColor"](x0, x1, x2, x3);
    }
    function _emscripten_glBlendEquation(x0) {
      GLctx["blendEquation"](x0);
    }
    function _emscripten_glBlendEquationSeparate(x0, x1) {
      GLctx["blendEquationSeparate"](x0, x1);
    }
    function _emscripten_glBlendFunc(x0, x1) {
      GLctx["blendFunc"](x0, x1);
    }
    function _emscripten_glBlendFuncSeparate(x0, x1, x2, x3) {
      GLctx["blendFuncSeparate"](x0, x1, x2, x3);
    }
    function _emscripten_glBufferData(target, size, data, usage) {
      GLctx.bufferData(
        target,
        data ? HEAPU8.subarray(data, data + size) : size,
        usage
      );
    }
    function _emscripten_glBufferSubData(target, offset, size, data) {
      GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size));
    }
    function _emscripten_glCheckFramebufferStatus(x0) {
      return GLctx["checkFramebufferStatus"](x0);
    }
    function _emscripten_glClear(x0) {
      GLctx["clear"](x0);
    }
    function _emscripten_glClearColor(x0, x1, x2, x3) {
      GLctx["clearColor"](x0, x1, x2, x3);
    }
    function _emscripten_glClearDepthf(x0) {
      GLctx["clearDepth"](x0);
    }
    function _emscripten_glClearStencil(x0) {
      GLctx["clearStencil"](x0);
    }
    function _emscripten_glColorMask(red, green, blue, alpha) {
      GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
    }
    function _emscripten_glCompileShader(shader) {
      GLctx.compileShader(GL.shaders[shader]);
    }
    function _emscripten_glCompressedTexImage2D(
      target,
      level,
      internalFormat,
      width,
      height,
      border,
      imageSize,
      data
    ) {
      GLctx["compressedTexImage2D"](
        target,
        level,
        internalFormat,
        width,
        height,
        border,
        data ? HEAPU8.subarray(data, data + imageSize) : null
      );
    }
    function _emscripten_glCompressedTexSubImage2D(
      target,
      level,
      xoffset,
      yoffset,
      width,
      height,
      format,
      imageSize,
      data
    ) {
      GLctx["compressedTexSubImage2D"](
        target,
        level,
        xoffset,
        yoffset,
        width,
        height,
        format,
        data ? HEAPU8.subarray(data, data + imageSize) : null
      );
    }
    function _emscripten_glCopyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
      GLctx["copyTexImage2D"](x0, x1, x2, x3, x4, x5, x6, x7);
    }
    function _emscripten_glCopyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
      GLctx["copyTexSubImage2D"](x0, x1, x2, x3, x4, x5, x6, x7);
    }
    function _emscripten_glCreateProgram() {
      var id = GL.getNewId(GL.programs);
      var program = GLctx.createProgram();
      program.name = id;
      GL.programs[id] = program;
      return id;
    }
    function _emscripten_glCreateShader(shaderType) {
      var id = GL.getNewId(GL.shaders);
      GL.shaders[id] = GLctx.createShader(shaderType);
      return id;
    }
    function _emscripten_glCullFace(x0) {
      GLctx["cullFace"](x0);
    }
    function _emscripten_glDeleteBuffers(n, buffers) {
      for (var i = 0; i < n; i++) {
        var id = HEAP32[(buffers + i * 4) >> 2];
        var buffer = GL.buffers[id];
        if (!buffer) continue;
        GLctx.deleteBuffer(buffer);
        buffer.name = 0;
        GL.buffers[id] = null;
        if (id == GL.currArrayBuffer) GL.currArrayBuffer = 0;
        if (id == GL.currElementArrayBuffer) GL.currElementArrayBuffer = 0;
      }
    }
    function _emscripten_glDeleteFramebuffers(n, framebuffers) {
      for (var i = 0; i < n; ++i) {
        var id = HEAP32[(framebuffers + i * 4) >> 2];
        var framebuffer = GL.framebuffers[id];
        if (!framebuffer) continue;
        GLctx.deleteFramebuffer(framebuffer);
        framebuffer.name = 0;
        GL.framebuffers[id] = null;
      }
    }
    function _emscripten_glDeleteProgram(id) {
      if (!id) return;
      var program = GL.programs[id];
      if (!program) {
        GL.recordError(1281);
        return;
      }
      GLctx.deleteProgram(program);
      program.name = 0;
      GL.programs[id] = null;
      GL.programInfos[id] = null;
    }
    function _emscripten_glDeleteQueriesEXT(n, ids) {
      for (var i = 0; i < n; i++) {
        var id = HEAP32[(ids + i * 4) >> 2];
        var query = GL.timerQueriesEXT[id];
        if (!query) continue;
        GLctx.disjointTimerQueryExt["deleteQueryEXT"](query);
        GL.timerQueriesEXT[id] = null;
      }
    }
    function _emscripten_glDeleteRenderbuffers(n, renderbuffers) {
      for (var i = 0; i < n; i++) {
        var id = HEAP32[(renderbuffers + i * 4) >> 2];
        var renderbuffer = GL.renderbuffers[id];
        if (!renderbuffer) continue;
        GLctx.deleteRenderbuffer(renderbuffer);
        renderbuffer.name = 0;
        GL.renderbuffers[id] = null;
      }
    }
    function _emscripten_glDeleteShader(id) {
      if (!id) return;
      var shader = GL.shaders[id];
      if (!shader) {
        GL.recordError(1281);
        return;
      }
      GLctx.deleteShader(shader);
      GL.shaders[id] = null;
    }
    function _emscripten_glDeleteTextures(n, textures) {
      for (var i = 0; i < n; i++) {
        var id = HEAP32[(textures + i * 4) >> 2];
        var texture = GL.textures[id];
        if (!texture) continue;
        GLctx.deleteTexture(texture);
        texture.name = 0;
        GL.textures[id] = null;
      }
    }
    function _emscripten_glDeleteVertexArraysOES(n, vaos) {
      for (var i = 0; i < n; i++) {
        var id = HEAP32[(vaos + i * 4) >> 2];
        GLctx["deleteVertexArray"](GL.vaos[id]);
        GL.vaos[id] = null;
      }
    }
    function _emscripten_glDepthFunc(x0) {
      GLctx["depthFunc"](x0);
    }
    function _emscripten_glDepthMask(flag) {
      GLctx.depthMask(!!flag);
    }
    function _emscripten_glDepthRangef(x0, x1) {
      GLctx["depthRange"](x0, x1);
    }
    function _emscripten_glDetachShader(program, shader) {
      GLctx.detachShader(GL.programs[program], GL.shaders[shader]);
    }
    function _emscripten_glDisable(x0) {
      GLctx["disable"](x0);
    }
    function _emscripten_glDisableVertexAttribArray(index) {
      GLctx.disableVertexAttribArray(index);
    }
    function _emscripten_glDrawArrays(mode, first, count) {
      GLctx.drawArrays(mode, first, count);
    }
    function _emscripten_glDrawArraysInstancedANGLE(
      mode,
      first,
      count,
      primcount
    ) {
      GLctx["drawArraysInstanced"](mode, first, count, primcount);
    }
    var __tempFixedLengthArray = [];
    function _emscripten_glDrawBuffersWEBGL(n, bufs) {
      var bufArray = __tempFixedLengthArray[n];
      for (var i = 0; i < n; i++) {
        bufArray[i] = HEAP32[(bufs + i * 4) >> 2];
      }
      GLctx["drawBuffers"](bufArray);
    }
    function _emscripten_glDrawElements(mode, count, type, indices) {
      GLctx.drawElements(mode, count, type, indices);
    }
    function _emscripten_glDrawElementsInstancedANGLE(
      mode,
      count,
      type,
      indices,
      primcount
    ) {
      GLctx["drawElementsInstanced"](mode, count, type, indices, primcount);
    }
    function _emscripten_glEnable(x0) {
      GLctx["enable"](x0);
    }
    function _emscripten_glEnableVertexAttribArray(index) {
      GLctx.enableVertexAttribArray(index);
    }
    function _emscripten_glEndQueryEXT(target) {
      GLctx.disjointTimerQueryExt["endQueryEXT"](target);
    }
    function _emscripten_glFinish() {
      GLctx["finish"]();
    }
    function _emscripten_glFlush() {
      GLctx["flush"]();
    }
    function _emscripten_glFramebufferRenderbuffer(
      target,
      attachment,
      renderbuffertarget,
      renderbuffer
    ) {
      GLctx.framebufferRenderbuffer(
        target,
        attachment,
        renderbuffertarget,
        GL.renderbuffers[renderbuffer]
      );
    }
    function _emscripten_glFramebufferTexture2D(
      target,
      attachment,
      textarget,
      texture,
      level
    ) {
      GLctx.framebufferTexture2D(
        target,
        attachment,
        textarget,
        GL.textures[texture],
        level
      );
    }
    function _emscripten_glFrontFace(x0) {
      GLctx["frontFace"](x0);
    }
    function __glGenObject(n, buffers, createFunction, objectTable) {
      for (var i = 0; i < n; i++) {
        var buffer = GLctx[createFunction]();
        var id = buffer && GL.getNewId(objectTable);
        if (buffer) {
          buffer.name = id;
          objectTable[id] = buffer;
        } else {
          GL.recordError(1282);
        }
        HEAP32[(buffers + i * 4) >> 2] = id;
      }
    }
    function _emscripten_glGenBuffers(n, buffers) {
      __glGenObject(n, buffers, "createBuffer", GL.buffers);
    }
    function _emscripten_glGenFramebuffers(n, ids) {
      __glGenObject(n, ids, "createFramebuffer", GL.framebuffers);
    }
    function _emscripten_glGenQueriesEXT(n, ids) {
      for (var i = 0; i < n; i++) {
        var query = GLctx.disjointTimerQueryExt["createQueryEXT"]();
        if (!query) {
          GL.recordError(1282);
          while (i < n) HEAP32[(ids + i++ * 4) >> 2] = 0;
          return;
        }
        var id = GL.getNewId(GL.timerQueriesEXT);
        query.name = id;
        GL.timerQueriesEXT[id] = query;
        HEAP32[(ids + i * 4) >> 2] = id;
      }
    }
    function _emscripten_glGenRenderbuffers(n, renderbuffers) {
      __glGenObject(n, renderbuffers, "createRenderbuffer", GL.renderbuffers);
    }
    function _emscripten_glGenTextures(n, textures) {
      __glGenObject(n, textures, "createTexture", GL.textures);
    }
    function _emscripten_glGenVertexArraysOES(n, arrays) {
      __glGenObject(n, arrays, "createVertexArray", GL.vaos);
    }
    function _emscripten_glGenerateMipmap(x0) {
      GLctx["generateMipmap"](x0);
    }
    function _emscripten_glGetActiveAttrib(
      program,
      index,
      bufSize,
      length,
      size,
      type,
      name
    ) {
      program = GL.programs[program];
      var info = GLctx.getActiveAttrib(program, index);
      if (!info) return;
      var numBytesWrittenExclNull =
        bufSize > 0 && name ? stringToUTF8(info.name, name, bufSize) : 0;
      if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
      if (size) HEAP32[size >> 2] = info.size;
      if (type) HEAP32[type >> 2] = info.type;
    }
    function _emscripten_glGetActiveUniform(
      program,
      index,
      bufSize,
      length,
      size,
      type,
      name
    ) {
      program = GL.programs[program];
      var info = GLctx.getActiveUniform(program, index);
      if (!info) return;
      var numBytesWrittenExclNull =
        bufSize > 0 && name ? stringToUTF8(info.name, name, bufSize) : 0;
      if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
      if (size) HEAP32[size >> 2] = info.size;
      if (type) HEAP32[type >> 2] = info.type;
    }
    function _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 i = 0; i < len; ++i) {
        var id = GL.shaders.indexOf(result[i]);
        HEAP32[(shaders + i * 4) >> 2] = id;
      }
    }
    function _emscripten_glGetAttribLocation(program, name) {
      return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
    }
    function writeI53ToI64(ptr, num) {
      HEAPU32[ptr >> 2] = num;
      HEAPU32[(ptr + 4) >> 2] = (num - HEAPU32[ptr >> 2]) / 4294967296;
    }
    function emscriptenWebGLGet(name_, p, type) {
      if (!p) {
        GL.recordError(1281);
        return;
      }
      var ret = undefined;
      switch (name_) {
        case 36346:
          ret = 1;
          break;
        case 36344:
          if (type != 0 && type != 1) {
            GL.recordError(1280);
          }
          return;
        case 36345:
          ret = 0;
          break;
        case 34466:
          var formats = GLctx.getParameter(34467);
          ret = formats ? formats.length : 0;
          break;
      }
      if (ret === undefined) {
        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:
                case 35725:
                case 34965:
                case 36006:
                case 36007:
                case 32873:
                case 34229:
                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 i = 0; i < result.length; ++i) {
                switch (type) {
                  case 0:
                    HEAP32[(p + i * 4) >> 2] = result[i];
                    break;
                  case 2:
                    HEAPF32[(p + i * 4) >> 2] = result[i];
                    break;
                  case 4:
                    HEAP8[(p + i) >> 0] = result[i] ? 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 >> 0] = ret ? 1 : 0;
          break;
      }
    }
    function _emscripten_glGetBooleanv(name_, p) {
      emscriptenWebGLGet(name_, p, 4);
    }
    function _emscripten_glGetBufferParameteriv(target, value, data) {
      if (!data) {
        GL.recordError(1281);
        return;
      }
      HEAP32[data >> 2] = GLctx.getBufferParameter(target, value);
    }
    function _emscripten_glGetError() {
      var error = GLctx.getError() || GL.lastError;
      GL.lastError = 0;
      return error;
    }
    function _emscripten_glGetFloatv(name_, p) {
      emscriptenWebGLGet(name_, p, 2);
    }
    function _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;
    }
    function _emscripten_glGetIntegerv(name_, p) {
      emscriptenWebGLGet(name_, p, 0);
    }
    function _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;
    }
    function _emscripten_glGetProgramiv(program, pname, p) {
      if (!p) {
        GL.recordError(1281);
        return;
      }
      if (program >= GL.counter) {
        GL.recordError(1281);
        return;
      }
      var ptable = GL.programInfos[program];
      if (!ptable) {
        GL.recordError(1282);
        return;
      }
      if (pname == 35716) {
        var log = GLctx.getProgramInfoLog(GL.programs[program]);
        if (log === null) log = "(unknown error)";
        HEAP32[p >> 2] = log.length + 1;
      } else if (pname == 35719) {
        HEAP32[p >> 2] = ptable.maxUniformLength;
      } else if (pname == 35722) {
        if (ptable.maxAttributeLength == -1) {
          program = GL.programs[program];
          var numAttribs = GLctx.getProgramParameter(program, 35721);
          ptable.maxAttributeLength = 0;
          for (var i = 0; i < numAttribs; ++i) {
            var activeAttrib = GLctx.getActiveAttrib(program, i);
            ptable.maxAttributeLength = Math.max(
              ptable.maxAttributeLength,
              activeAttrib.name.length + 1
            );
          }
        }
        HEAP32[p >> 2] = ptable.maxAttributeLength;
      } else if (pname == 35381) {
        if (ptable.maxUniformBlockNameLength == -1) {
          program = GL.programs[program];
          var numBlocks = GLctx.getProgramParameter(program, 35382);
          ptable.maxUniformBlockNameLength = 0;
          for (var i = 0; i < numBlocks; ++i) {
            var activeBlockName = GLctx.getActiveUniformBlockName(program, i);
            ptable.maxUniformBlockNameLength = Math.max(
              ptable.maxUniformBlockNameLength,
              activeBlockName.length + 1
            );
          }
        }
        HEAP32[p >> 2] = ptable.maxUniformBlockNameLength;
      } else {
        HEAP32[p >> 2] = GLctx.getProgramParameter(GL.programs[program], pname);
      }
    }
    function _emscripten_glGetQueryObjecti64vEXT(id, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      var query = GL.timerQueriesEXT[id];
      var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](
        query,
        pname
      );
      var ret;
      if (typeof param == "boolean") {
        ret = param ? 1 : 0;
      } else {
        ret = param;
      }
      writeI53ToI64(params, ret);
    }
    function _emscripten_glGetQueryObjectivEXT(id, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      var query = GL.timerQueriesEXT[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;
    }
    function _emscripten_glGetQueryObjectui64vEXT(id, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      var query = GL.timerQueriesEXT[id];
      var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](
        query,
        pname
      );
      var ret;
      if (typeof param == "boolean") {
        ret = param ? 1 : 0;
      } else {
        ret = param;
      }
      writeI53ToI64(params, ret);
    }
    function _emscripten_glGetQueryObjectuivEXT(id, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      var query = GL.timerQueriesEXT[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;
    }
    function _emscripten_glGetQueryivEXT(target, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      HEAP32[params >> 2] = GLctx.disjointTimerQueryExt["getQueryEXT"](
        target,
        pname
      );
    }
    function _emscripten_glGetRenderbufferParameteriv(target, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname);
    }
    function _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;
    }
    function _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;
    }
    function _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;
    }
    function _emscripten_glGetShaderiv(shader, pname, p) {
      if (!p) {
        GL.recordError(1281);
        return;
      }
      if (pname == 35716) {
        var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
        if (log === null) log = "(unknown error)";
        HEAP32[p >> 2] = log.length + 1;
      } else if (pname == 35720) {
        var source = GLctx.getShaderSource(GL.shaders[shader]);
        var sourceLength =
          source === null || source.length == 0 ? 0 : source.length + 1;
        HEAP32[p >> 2] = sourceLength;
      } else {
        HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
      }
    }
    function stringToNewUTF8(jsString) {
      var length = lengthBytesUTF8(jsString) + 1;
      var cString = _malloc(length);
      stringToUTF8(jsString, cString, length);
      return cString;
    }
    function _emscripten_glGetString(name_) {
      if (GL.stringCache[name_]) return GL.stringCache[name_];
      var ret;
      switch (name_) {
        case 7939:
          var exts = GLctx.getSupportedExtensions() || [];
          exts = exts.concat(
            exts.map(function (e) {
              return "GL_" + e;
            })
          );
          ret = stringToNewUTF8(exts.join(" "));
          break;
        case 7936:
        case 7937:
        case 37445:
        case 37446:
          var s = GLctx.getParameter(name_);
          if (!s) {
            GL.recordError(1280);
          }
          ret = stringToNewUTF8(s);
          break;
        case 7938:
          var glVersion = GLctx.getParameter(7938);
          {
            glVersion = "OpenGL ES 2.0 (" + glVersion + ")";
          }
          ret = stringToNewUTF8(glVersion);
          break;
        case 35724:
          var glslVersion = GLctx.getParameter(35724);
          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);
          return 0;
      }
      GL.stringCache[name_] = ret;
      return ret;
    }
    function _emscripten_glGetTexParameterfv(target, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      HEAPF32[params >> 2] = GLctx.getTexParameter(target, pname);
    }
    function _emscripten_glGetTexParameteriv(target, pname, params) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      HEAP32[params >> 2] = GLctx.getTexParameter(target, pname);
    }
    function jstoi_q(str) {
      return parseInt(str);
    }
    function _emscripten_glGetUniformLocation(program, name) {
      name = UTF8ToString(name);
      var arrayIndex = 0;
      if (name[name.length - 1] == "]") {
        var leftBrace = name.lastIndexOf("[");
        arrayIndex =
          name[leftBrace + 1] != "]" ? jstoi_q(name.slice(leftBrace + 1)) : 0;
        name = name.slice(0, leftBrace);
      }
      var uniformInfo =
        GL.programInfos[program] && GL.programInfos[program].uniforms[name];
      if (uniformInfo && arrayIndex >= 0 && arrayIndex < uniformInfo[0]) {
        return uniformInfo[1] + arrayIndex;
      } else {
        return -1;
      }
    }
    function emscriptenWebGLGetUniform(program, location, params, type) {
      if (!params) {
        GL.recordError(1281);
        return;
      }
      var data = GLctx.getUniform(GL.programs[program], GL.uniforms[location]);
      if (typeof data == "number" || typeof data == "boolean") {
        switch (type) {
          case 0:
            HEAP32[params >> 2] = data;
            break;
          case 2:
            HEAPF32[params >> 2] = data;
            break;
          default:
            throw (
              "internal emscriptenWebGLGetUniform() error, bad type: " + type
            );
        }
      } else {
        for (var i = 0; i < data.length; i++) {
          switch (type) {
            case 0:
              HEAP32[(params + i * 4) >> 2] = data[i];
              break;
            case 2:
              HEAPF32[(params + i * 4) >> 2] = data[i];
              break;
            default:
              throw (
                "internal emscriptenWebGLGetUniform() error, bad type: " + type
              );
          }
        }
      }
    }
    function _emscripten_glGetUniformfv(program, location, params) {
      emscriptenWebGLGetUniform(program, location, params, 2);
    }
    function _emscripten_glGetUniformiv(program, location, params) {
      emscriptenWebGLGetUniform(program, location, params, 0);
    }
    function _emscripten_glGetVertexAttribPointerv(index, pname, pointer) {
      if (!pointer) {
        GL.recordError(1281);
        return;
      }
      HEAP32[pointer >> 2] = GLctx.getVertexAttribOffset(index, pname);
    }
    function emscriptenWebGLGetVertexAttrib(index, pname, params, type) {
      if (!params) {
        GL.recordError(1281);
        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;
          default:
            throw (
              "internal emscriptenWebGLGetVertexAttrib() error, bad type: " +
              type
            );
        }
      } else {
        for (var i = 0; i < data.length; i++) {
          switch (type) {
            case 0:
              HEAP32[(params + i * 4) >> 2] = data[i];
              break;
            case 2:
              HEAPF32[(params + i * 4) >> 2] = data[i];
              break;
            case 5:
              HEAP32[(params + i * 4) >> 2] = Math.fround(data[i]);
              break;
            default:
              throw (
                "internal emscriptenWebGLGetVertexAttrib() error, bad type: " +
                type
              );
          }
        }
      }
    }
    function _emscripten_glGetVertexAttribfv(index, pname, params) {
      emscriptenWebGLGetVertexAttrib(index, pname, params, 2);
    }
    function _emscripten_glGetVertexAttribiv(index, pname, params) {
      emscriptenWebGLGetVertexAttrib(index, pname, params, 5);
    }
    function _emscripten_glHint(x0, x1) {
      GLctx["hint"](x0, x1);
    }
    function _emscripten_glIsBuffer(buffer) {
      var b = GL.buffers[buffer];
      if (!b) return 0;
      return GLctx.isBuffer(b);
    }
    function _emscripten_glIsEnabled(x0) {
      return GLctx["isEnabled"](x0);
    }
    function _emscripten_glIsFramebuffer(framebuffer) {
      var fb = GL.framebuffers[framebuffer];
      if (!fb) return 0;
      return GLctx.isFramebuffer(fb);
    }
    function _emscripten_glIsProgram(program) {
      program = GL.programs[program];
      if (!program) return 0;
      return GLctx.isProgram(program);
    }
    function _emscripten_glIsQueryEXT(id) {
      var query = GL.timerQueriesEXT[id];
      if (!query) return 0;
      return GLctx.disjointTimerQueryExt["isQueryEXT"](query);
    }
    function _emscripten_glIsRenderbuffer(renderbuffer) {
      var rb = GL.renderbuffers[renderbuffer];
      if (!rb) return 0;
      return GLctx.isRenderbuffer(rb);
    }
    function _emscripten_glIsShader(shader) {
      var s = GL.shaders[shader];
      if (!s) return 0;
      return GLctx.isShader(s);
    }
    function _emscripten_glIsTexture(id) {
      var texture = GL.textures[id];
      if (!texture) return 0;
      return GLctx.isTexture(texture);
    }
    function _emscripten_glIsVertexArrayOES(array) {
      var vao = GL.vaos[array];
      if (!vao) return 0;
      return GLctx["isVertexArray"](vao);
    }
    function _emscripten_glLineWidth(x0) {
      GLctx["lineWidth"](x0);
    }
    function _emscripten_glLinkProgram(program) {
      GLctx.linkProgram(GL.programs[program]);
      GL.populateUniformTable(program);
    }
    function _emscripten_glPixelStorei(pname, param) {
      if (pname == 3317) {
        GL.unpackAlignment = param;
      }
      GLctx.pixelStorei(pname, param);
    }
    function _emscripten_glPolygonOffset(x0, x1) {
      GLctx["polygonOffset"](x0, x1);
    }
    function _emscripten_glQueryCounterEXT(id, target) {
      GLctx.disjointTimerQueryExt["queryCounterEXT"](
        GL.timerQueriesEXT[id],
        target
      );
    }
    function __computeUnpackAlignedImageSize(
      width,
      height,
      sizePerPixel,
      alignment
    ) {
      function roundedToNextMultipleOf(x, y) {
        return (x + y - 1) & -y;
      }
      var plainRowSize = width * sizePerPixel;
      var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment);
      return height * alignedRowSize;
    }
    function __colorChannelsInGlTextureFormat(format) {
      var colorChannels = { 5: 3, 6: 4, 8: 2, 29502: 3, 29504: 4 };
      return colorChannels[format - 6402] || 1;
    }
    function __heapObjectForWebGLType(type) {
      type -= 5120;
      if (type == 1) return HEAPU8;
      if (type == 4) return HEAP32;
      if (type == 6) return HEAPF32;
      if (type == 5 || type == 28922) return HEAPU32;
      return HEAPU16;
    }
    function __heapAccessShiftForWebGLHeap(heap) {
      return 31 - Math.clz32(heap.BYTES_PER_ELEMENT);
    }
    function emscriptenWebGLGetTexPixelData(
      type,
      format,
      width,
      height,
      pixels,
      internalFormat
    ) {
      var heap = __heapObjectForWebGLType(type);
      var shift = __heapAccessShiftForWebGLHeap(heap);
      var byteSize = 1 << shift;
      var sizePerPixel = __colorChannelsInGlTextureFormat(format) * byteSize;
      var bytes = __computeUnpackAlignedImageSize(
        width,
        height,
        sizePerPixel,
        GL.unpackAlignment
      );
      return heap.subarray(pixels >> shift, (pixels + bytes) >> shift);
    }
    function _emscripten_glReadPixels(
      x,
      y,
      width,
      height,
      format,
      type,
      pixels
    ) {
      var pixelData = emscriptenWebGLGetTexPixelData(
        type,
        format,
        width,
        height,
        pixels,
        format
      );
      if (!pixelData) {
        GL.recordError(1280);
        return;
      }
      GLctx.readPixels(x, y, width, height, format, type, pixelData);
    }
    function _emscripten_glReleaseShaderCompiler() {}
    function _emscripten_glRenderbufferStorage(x0, x1, x2, x3) {
      GLctx["renderbufferStorage"](x0, x1, x2, x3);
    }
    function _emscripten_glSampleCoverage(value, invert) {
      GLctx.sampleCoverage(value, !!invert);
    }
    function _emscripten_glScissor(x0, x1, x2, x3) {
      GLctx["scissor"](x0, x1, x2, x3);
    }
    function _emscripten_glShaderBinary() {
      GL.recordError(1280);
    }
    function _emscripten_glShaderSource(shader, count, string, length) {
      var source = GL.getSource(shader, count, string, length);
      GLctx.shaderSource(GL.shaders[shader], source);
    }
    function _emscripten_glStencilFunc(x0, x1, x2) {
      GLctx["stencilFunc"](x0, x1, x2);
    }
    function _emscripten_glStencilFuncSeparate(x0, x1, x2, x3) {
      GLctx["stencilFuncSeparate"](x0, x1, x2, x3);
    }
    function _emscripten_glStencilMask(x0) {
      GLctx["stencilMask"](x0);
    }
    function _emscripten_glStencilMaskSeparate(x0, x1) {
      GLctx["stencilMaskSeparate"](x0, x1);
    }
    function _emscripten_glStencilOp(x0, x1, x2) {
      GLctx["stencilOp"](x0, x1, x2);
    }
    function _emscripten_glStencilOpSeparate(x0, x1, x2, x3) {
      GLctx["stencilOpSeparate"](x0, x1, x2, x3);
    }
    function _emscripten_glTexImage2D(
      target,
      level,
      internalFormat,
      width,
      height,
      border,
      format,
      type,
      pixels
    ) {
      GLctx.texImage2D(
        target,
        level,
        internalFormat,
        width,
        height,
        border,
        format,
        type,
        pixels
          ? emscriptenWebGLGetTexPixelData(
              type,
              format,
              width,
              height,
              pixels,
              internalFormat
            )
          : null
      );
    }
    function _emscripten_glTexParameterf(x0, x1, x2) {
      GLctx["texParameterf"](x0, x1, x2);
    }
    function _emscripten_glTexParameterfv(target, pname, params) {
      var param = HEAPF32[params >> 2];
      GLctx.texParameterf(target, pname, param);
    }
    function _emscripten_glTexParameteri(x0, x1, x2) {
      GLctx["texParameteri"](x0, x1, x2);
    }
    function _emscripten_glTexParameteriv(target, pname, params) {
      var param = HEAP32[params >> 2];
      GLctx.texParameteri(target, pname, param);
    }
    function _emscripten_glTexSubImage2D(
      target,
      level,
      xoffset,
      yoffset,
      width,
      height,
      format,
      type,
      pixels
    ) {
      var pixelData = null;
      if (pixels)
        pixelData = emscriptenWebGLGetTexPixelData(
          type,
          format,
          width,
          height,
          pixels,
          0
        );
      GLctx.texSubImage2D(
        target,
        level,
        xoffset,
        yoffset,
        width,
        height,
        format,
        type,
        pixelData
      );
    }
    function _emscripten_glUniform1f(location, v0) {
      GLctx.uniform1f(GL.uniforms[location], v0);
    }
    function _emscripten_glUniform1fv(location, count, value) {
      if (count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[count - 1];
        for (var i = 0; i < count; ++i) {
          view[i] = HEAPF32[(value + 4 * i) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 4) >> 2);
      }
      GLctx.uniform1fv(GL.uniforms[location], view);
    }
    function _emscripten_glUniform1i(location, v0) {
      GLctx.uniform1i(GL.uniforms[location], v0);
    }
    function _emscripten_glUniform1iv(location, count, value) {
      if (count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferIntViews[count - 1];
        for (var i = 0; i < count; ++i) {
          view[i] = HEAP32[(value + 4 * i) >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, (value + count * 4) >> 2);
      }
      GLctx.uniform1iv(GL.uniforms[location], view);
    }
    function _emscripten_glUniform2f(location, v0, v1) {
      GLctx.uniform2f(GL.uniforms[location], v0, v1);
    }
    function _emscripten_glUniform2fv(location, count, value) {
      if (2 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[2 * count - 1];
        for (var i = 0; i < 2 * count; i += 2) {
          view[i] = HEAPF32[(value + 4 * i) >> 2];
          view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 8) >> 2);
      }
      GLctx.uniform2fv(GL.uniforms[location], view);
    }
    function _emscripten_glUniform2i(location, v0, v1) {
      GLctx.uniform2i(GL.uniforms[location], v0, v1);
    }
    function _emscripten_glUniform2iv(location, count, value) {
      if (2 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferIntViews[2 * count - 1];
        for (var i = 0; i < 2 * count; i += 2) {
          view[i] = HEAP32[(value + 4 * i) >> 2];
          view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, (value + count * 8) >> 2);
      }
      GLctx.uniform2iv(GL.uniforms[location], view);
    }
    function _emscripten_glUniform3f(location, v0, v1, v2) {
      GLctx.uniform3f(GL.uniforms[location], v0, v1, v2);
    }
    function _emscripten_glUniform3fv(location, count, value) {
      if (3 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[3 * count - 1];
        for (var i = 0; i < 3 * count; i += 3) {
          view[i] = HEAPF32[(value + 4 * i) >> 2];
          view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
          view[i + 2] = HEAPF32[(value + (4 * i + 8)) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 12) >> 2);
      }
      GLctx.uniform3fv(GL.uniforms[location], view);
    }
    function _emscripten_glUniform3i(location, v0, v1, v2) {
      GLctx.uniform3i(GL.uniforms[location], v0, v1, v2);
    }
    function _emscripten_glUniform3iv(location, count, value) {
      if (3 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferIntViews[3 * count - 1];
        for (var i = 0; i < 3 * count; i += 3) {
          view[i] = HEAP32[(value + 4 * i) >> 2];
          view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2];
          view[i + 2] = HEAP32[(value + (4 * i + 8)) >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, (value + count * 12) >> 2);
      }
      GLctx.uniform3iv(GL.uniforms[location], view);
    }
    function _emscripten_glUniform4f(location, v0, v1, v2, v3) {
      GLctx.uniform4f(GL.uniforms[location], v0, v1, v2, v3);
    }
    function _emscripten_glUniform4fv(location, count, value) {
      if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[4 * count - 1];
        var heap = HEAPF32;
        value >>= 2;
        for (var i = 0; i < 4 * count; i += 4) {
          var dst = value + i;
          view[i] = heap[dst];
          view[i + 1] = heap[dst + 1];
          view[i + 2] = heap[dst + 2];
          view[i + 3] = heap[dst + 3];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 16) >> 2);
      }
      GLctx.uniform4fv(GL.uniforms[location], view);
    }
    function _emscripten_glUniform4i(location, v0, v1, v2, v3) {
      GLctx.uniform4i(GL.uniforms[location], v0, v1, v2, v3);
    }
    function _emscripten_glUniform4iv(location, count, value) {
      if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferIntViews[4 * count - 1];
        for (var i = 0; i < 4 * count; i += 4) {
          view[i] = HEAP32[(value + 4 * i) >> 2];
          view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2];
          view[i + 2] = HEAP32[(value + (4 * i + 8)) >> 2];
          view[i + 3] = HEAP32[(value + (4 * i + 12)) >> 2];
        }
      } else {
        var view = HEAP32.subarray(value >> 2, (value + count * 16) >> 2);
      }
      GLctx.uniform4iv(GL.uniforms[location], view);
    }
    function _emscripten_glUniformMatrix2fv(location, count, transpose, value) {
      if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[4 * count - 1];
        for (var i = 0; i < 4 * count; i += 4) {
          view[i] = HEAPF32[(value + 4 * i) >> 2];
          view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
          view[i + 2] = HEAPF32[(value + (4 * i + 8)) >> 2];
          view[i + 3] = HEAPF32[(value + (4 * i + 12)) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 16) >> 2);
      }
      GLctx.uniformMatrix2fv(GL.uniforms[location], !!transpose, view);
    }
    function _emscripten_glUniformMatrix3fv(location, count, transpose, value) {
      if (9 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[9 * count - 1];
        for (var i = 0; i < 9 * count; i += 9) {
          view[i] = HEAPF32[(value + 4 * i) >> 2];
          view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
          view[i + 2] = HEAPF32[(value + (4 * i + 8)) >> 2];
          view[i + 3] = HEAPF32[(value + (4 * i + 12)) >> 2];
          view[i + 4] = HEAPF32[(value + (4 * i + 16)) >> 2];
          view[i + 5] = HEAPF32[(value + (4 * i + 20)) >> 2];
          view[i + 6] = HEAPF32[(value + (4 * i + 24)) >> 2];
          view[i + 7] = HEAPF32[(value + (4 * i + 28)) >> 2];
          view[i + 8] = HEAPF32[(value + (4 * i + 32)) >> 2];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 36) >> 2);
      }
      GLctx.uniformMatrix3fv(GL.uniforms[location], !!transpose, view);
    }
    function _emscripten_glUniformMatrix4fv(location, count, transpose, value) {
      if (16 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[16 * count - 1];
        var heap = HEAPF32;
        value >>= 2;
        for (var i = 0; i < 16 * count; i += 16) {
          var dst = value + i;
          view[i] = heap[dst];
          view[i + 1] = heap[dst + 1];
          view[i + 2] = heap[dst + 2];
          view[i + 3] = heap[dst + 3];
          view[i + 4] = heap[dst + 4];
          view[i + 5] = heap[dst + 5];
          view[i + 6] = heap[dst + 6];
          view[i + 7] = heap[dst + 7];
          view[i + 8] = heap[dst + 8];
          view[i + 9] = heap[dst + 9];
          view[i + 10] = heap[dst + 10];
          view[i + 11] = heap[dst + 11];
          view[i + 12] = heap[dst + 12];
          view[i + 13] = heap[dst + 13];
          view[i + 14] = heap[dst + 14];
          view[i + 15] = heap[dst + 15];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 64) >> 2);
      }
      GLctx.uniformMatrix4fv(GL.uniforms[location], !!transpose, view);
    }
    function _emscripten_glUseProgram(program) {
      GLctx.useProgram(GL.programs[program]);
    }
    function _emscripten_glValidateProgram(program) {
      GLctx.validateProgram(GL.programs[program]);
    }
    function _emscripten_glVertexAttrib1f(x0, x1) {
      GLctx["vertexAttrib1f"](x0, x1);
    }
    function _emscripten_glVertexAttrib1fv(index, v) {
      GLctx.vertexAttrib1f(index, HEAPF32[v >> 2]);
    }
    function _emscripten_glVertexAttrib2f(x0, x1, x2) {
      GLctx["vertexAttrib2f"](x0, x1, x2);
    }
    function _emscripten_glVertexAttrib2fv(index, v) {
      GLctx.vertexAttrib2f(index, HEAPF32[v >> 2], HEAPF32[(v + 4) >> 2]);
    }
    function _emscripten_glVertexAttrib3f(x0, x1, x2, x3) {
      GLctx["vertexAttrib3f"](x0, x1, x2, x3);
    }
    function _emscripten_glVertexAttrib3fv(index, v) {
      GLctx.vertexAttrib3f(
        index,
        HEAPF32[v >> 2],
        HEAPF32[(v + 4) >> 2],
        HEAPF32[(v + 8) >> 2]
      );
    }
    function _emscripten_glVertexAttrib4f(x0, x1, x2, x3, x4) {
      GLctx["vertexAttrib4f"](x0, x1, x2, x3, x4);
    }
    function _emscripten_glVertexAttrib4fv(index, v) {
      GLctx.vertexAttrib4f(
        index,
        HEAPF32[v >> 2],
        HEAPF32[(v + 4) >> 2],
        HEAPF32[(v + 8) >> 2],
        HEAPF32[(v + 12) >> 2]
      );
    }
    function _emscripten_glVertexAttribDivisorANGLE(index, divisor) {
      GLctx["vertexAttribDivisor"](index, divisor);
    }
    function _emscripten_glVertexAttribPointer(
      index,
      size,
      type,
      normalized,
      stride,
      ptr
    ) {
      GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
    }
    function _emscripten_glViewport(x0, x1, x2, x3) {
      GLctx["viewport"](x0, x1, x2, x3);
    }
    function _emscripten_memcpy_big(dest, src, num) {
      HEAPU8.copyWithin(dest, src, src + num);
    }
    function _emscripten_get_heap_size() {
      return HEAPU8.length;
    }
    function emscripten_realloc_buffer(size) {
      try {
        wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
        updateGlobalBufferAndViews(wasmMemory.buffer);
        return 1;
      } catch (e) {}
    }
    function _emscripten_resize_heap(requestedSize) {
      requestedSize = requestedSize >>> 0;
      var oldSize = _emscripten_get_heap_size();
      var PAGE_MULTIPLE = 65536;
      var maxHeapSize = 2147483648;
      if (requestedSize > maxHeapSize) {
        return false;
      }
      var minHeapSize = 16777216;
      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
        overGrownHeapSize = Math.min(
          overGrownHeapSize,
          requestedSize + 100663296
        );
        var newSize = Math.min(
          maxHeapSize,
          alignUp(
            Math.max(minHeapSize, requestedSize, overGrownHeapSize),
            PAGE_MULTIPLE
          )
        );
        var replacement = emscripten_realloc_buffer(newSize);
        if (replacement) {
          return true;
        }
      }
      return false;
    }
    var ENV = {};
    function __getExecutableName() {
      return thisProgram || "./this.program";
    }
    function getEnvStrings() {
      if (!getEnvStrings.strings) {
        var env = {
          USER: "web_user",
          LOGNAME: "web_user",
          PATH: "/",
          PWD: "/",
          HOME: "/home/web_user",
          LANG:
            (
              (typeof navigator === "object" &&
                navigator.languages &&
                navigator.languages[0]) ||
              "C"
            ).replace("-", "_") + ".UTF-8",
          _: __getExecutableName(),
        };
        for (var x in ENV) {
          env[x] = ENV[x];
        }
        var strings = [];
        for (var x in env) {
          strings.push(x + "=" + env[x]);
        }
        getEnvStrings.strings = strings;
      }
      return getEnvStrings.strings;
    }
    function _environ_get(__environ, environ_buf) {
      var bufSize = 0;
      getEnvStrings().forEach(function (string, i) {
        var ptr = environ_buf + bufSize;
        HEAP32[(__environ + i * 4) >> 2] = ptr;
        writeAsciiToMemory(string, ptr);
        bufSize += string.length + 1;
      });
      return 0;
    }
    function _environ_sizes_get(penviron_count, penviron_buf_size) {
      var strings = getEnvStrings();
      HEAP32[penviron_count >> 2] = strings.length;
      var bufSize = 0;
      strings.forEach(function (string) {
        bufSize += string.length + 1;
      });
      HEAP32[penviron_buf_size >> 2] = bufSize;
      return 0;
    }
    function _fd_close(fd) {
      return 0;
    }
    function _fd_read(fd, iov, iovcnt, pnum) {
      var stream = SYSCALLS.getStreamFromFD(fd);
      var num = SYSCALLS.doReadv(stream, iov, iovcnt);
      HEAP32[pnum >> 2] = num;
      return 0;
    }
    function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {}
    function _fd_write(fd, iov, iovcnt, pnum) {
      var num = 0;
      for (var i = 0; i < iovcnt; i++) {
        var ptr = HEAP32[(iov + i * 8) >> 2];
        var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
        for (var j = 0; j < len; j++) {
          SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
        }
        num += len;
      }
      HEAP32[pnum >> 2] = num;
      return 0;
    }
    function _glActiveTexture(x0) {
      GLctx["activeTexture"](x0);
    }
    function _glAttachShader(program, shader) {
      GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
    }
    function _glBindBuffer(target, buffer) {
      GLctx.bindBuffer(target, GL.buffers[buffer]);
    }
    function _glBindFramebuffer(target, framebuffer) {
      GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
    }
    function _glBindTexture(target, texture) {
      GLctx.bindTexture(target, GL.textures[texture]);
    }
    function _glBlendEquation(x0) {
      GLctx["blendEquation"](x0);
    }
    function _glBlendEquationSeparate(x0, x1) {
      GLctx["blendEquationSeparate"](x0, x1);
    }
    function _glBlendFuncSeparate(x0, x1, x2, x3) {
      GLctx["blendFuncSeparate"](x0, x1, x2, x3);
    }
    function _glBufferData(target, size, data, usage) {
      GLctx.bufferData(
        target,
        data ? HEAPU8.subarray(data, data + size) : size,
        usage
      );
    }
    function _glBufferSubData(target, offset, size, data) {
      GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size));
    }
    function _glClear(x0) {
      GLctx["clear"](x0);
    }
    function _glClearColor(x0, x1, x2, x3) {
      GLctx["clearColor"](x0, x1, x2, x3);
    }
    function _glCompileShader(shader) {
      GLctx.compileShader(GL.shaders[shader]);
    }
    function _glCopyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
      GLctx["copyTexSubImage2D"](x0, x1, x2, x3, x4, x5, x6, x7);
    }
    function _glCreateProgram() {
      var id = GL.getNewId(GL.programs);
      var program = GLctx.createProgram();
      program.name = id;
      GL.programs[id] = program;
      return id;
    }
    function _glCreateShader(shaderType) {
      var id = GL.getNewId(GL.shaders);
      GL.shaders[id] = GLctx.createShader(shaderType);
      return id;
    }
    function _glCullFace(x0) {
      GLctx["cullFace"](x0);
    }
    function _glDeleteBuffers(n, buffers) {
      for (var i = 0; i < n; i++) {
        var id = HEAP32[(buffers + i * 4) >> 2];
        var buffer = GL.buffers[id];
        if (!buffer) continue;
        GLctx.deleteBuffer(buffer);
        buffer.name = 0;
        GL.buffers[id] = null;
        if (id == GL.currArrayBuffer) GL.currArrayBuffer = 0;
        if (id == GL.currElementArrayBuffer) GL.currElementArrayBuffer = 0;
      }
    }
    function _glDeleteFramebuffers(n, framebuffers) {
      for (var i = 0; i < n; ++i) {
        var id = HEAP32[(framebuffers + i * 4) >> 2];
        var framebuffer = GL.framebuffers[id];
        if (!framebuffer) continue;
        GLctx.deleteFramebuffer(framebuffer);
        framebuffer.name = 0;
        GL.framebuffers[id] = null;
      }
    }
    function _glDeleteProgram(id) {
      if (!id) return;
      var program = GL.programs[id];
      if (!program) {
        GL.recordError(1281);
        return;
      }
      GLctx.deleteProgram(program);
      program.name = 0;
      GL.programs[id] = null;
      GL.programInfos[id] = null;
    }
    function _glDeleteShader(id) {
      if (!id) return;
      var shader = GL.shaders[id];
      if (!shader) {
        GL.recordError(1281);
        return;
      }
      GLctx.deleteShader(shader);
      GL.shaders[id] = null;
    }
    function _glDeleteTextures(n, textures) {
      for (var i = 0; i < n; i++) {
        var id = HEAP32[(textures + i * 4) >> 2];
        var texture = GL.textures[id];
        if (!texture) continue;
        GLctx.deleteTexture(texture);
        texture.name = 0;
        GL.textures[id] = null;
      }
    }
    function _glDepthFunc(x0) {
      GLctx["depthFunc"](x0);
    }
    function _glDepthMask(flag) {
      GLctx.depthMask(!!flag);
    }
    function _glDisable(x0) {
      GLctx["disable"](x0);
    }
    function _glDisableVertexAttribArray(index) {
      GLctx.disableVertexAttribArray(index);
    }
    function _glDrawElements(mode, count, type, indices) {
      GLctx.drawElements(mode, count, type, indices);
    }
    function _glEnable(x0) {
      GLctx["enable"](x0);
    }
    function _glEnableVertexAttribArray(index) {
      GLctx.enableVertexAttribArray(index);
    }
    function _glFramebufferTexture2D(
      target,
      attachment,
      textarget,
      texture,
      level
    ) {
      GLctx.framebufferTexture2D(
        target,
        attachment,
        textarget,
        GL.textures[texture],
        level
      );
    }
    function _glGenBuffers(n, buffers) {
      __glGenObject(n, buffers, "createBuffer", GL.buffers);
    }
    function _glGenFramebuffers(n, ids) {
      __glGenObject(n, ids, "createFramebuffer", GL.framebuffers);
    }
    function _glGenTextures(n, textures) {
      __glGenObject(n, textures, "createTexture", GL.textures);
    }
    function _glGenerateMipmap(x0) {
      GLctx["generateMipmap"](x0);
    }
    function _glGetAttribLocation(program, name) {
      return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
    }
    function _glGetBooleanv(name_, p) {
      emscriptenWebGLGet(name_, p, 4);
    }
    function _glGetIntegerv(name_, p) {
      emscriptenWebGLGet(name_, p, 0);
    }
    function _glGetProgramiv(program, pname, p) {
      if (!p) {
        GL.recordError(1281);
        return;
      }
      if (program >= GL.counter) {
        GL.recordError(1281);
        return;
      }
      var ptable = GL.programInfos[program];
      if (!ptable) {
        GL.recordError(1282);
        return;
      }
      if (pname == 35716) {
        var log = GLctx.getProgramInfoLog(GL.programs[program]);
        if (log === null) log = "(unknown error)";
        HEAP32[p >> 2] = log.length + 1;
      } else if (pname == 35719) {
        HEAP32[p >> 2] = ptable.maxUniformLength;
      } else if (pname == 35722) {
        if (ptable.maxAttributeLength == -1) {
          program = GL.programs[program];
          var numAttribs = GLctx.getProgramParameter(program, 35721);
          ptable.maxAttributeLength = 0;
          for (var i = 0; i < numAttribs; ++i) {
            var activeAttrib = GLctx.getActiveAttrib(program, i);
            ptable.maxAttributeLength = Math.max(
              ptable.maxAttributeLength,
              activeAttrib.name.length + 1
            );
          }
        }
        HEAP32[p >> 2] = ptable.maxAttributeLength;
      } else if (pname == 35381) {
        if (ptable.maxUniformBlockNameLength == -1) {
          program = GL.programs[program];
          var numBlocks = GLctx.getProgramParameter(program, 35382);
          ptable.maxUniformBlockNameLength = 0;
          for (var i = 0; i < numBlocks; ++i) {
            var activeBlockName = GLctx.getActiveUniformBlockName(program, i);
            ptable.maxUniformBlockNameLength = Math.max(
              ptable.maxUniformBlockNameLength,
              activeBlockName.length + 1
            );
          }
        }
        HEAP32[p >> 2] = ptable.maxUniformBlockNameLength;
      } else {
        HEAP32[p >> 2] = GLctx.getProgramParameter(GL.programs[program], pname);
      }
    }
    function _glGetShaderiv(shader, pname, p) {
      if (!p) {
        GL.recordError(1281);
        return;
      }
      if (pname == 35716) {
        var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
        if (log === null) log = "(unknown error)";
        HEAP32[p >> 2] = log.length + 1;
      } else if (pname == 35720) {
        var source = GLctx.getShaderSource(GL.shaders[shader]);
        var sourceLength =
          source === null || source.length == 0 ? 0 : source.length + 1;
        HEAP32[p >> 2] = sourceLength;
      } else {
        HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
      }
    }
    function _glGetString(name_) {
      if (GL.stringCache[name_]) return GL.stringCache[name_];
      var ret;
      switch (name_) {
        case 7939:
          var exts = GLctx.getSupportedExtensions() || [];
          exts = exts.concat(
            exts.map(function (e) {
              return "GL_" + e;
            })
          );
          ret = stringToNewUTF8(exts.join(" "));
          break;
        case 7936:
        case 7937:
        case 37445:
        case 37446:
          var s = GLctx.getParameter(name_);
          if (!s) {
            GL.recordError(1280);
          }
          ret = stringToNewUTF8(s);
          break;
        case 7938:
          var glVersion = GLctx.getParameter(7938);
          {
            glVersion = "OpenGL ES 2.0 (" + glVersion + ")";
          }
          ret = stringToNewUTF8(glVersion);
          break;
        case 35724:
          var glslVersion = GLctx.getParameter(35724);
          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);
          return 0;
      }
      GL.stringCache[name_] = ret;
      return ret;
    }
    function _glGetUniformLocation(program, name) {
      name = UTF8ToString(name);
      var arrayIndex = 0;
      if (name[name.length - 1] == "]") {
        var leftBrace = name.lastIndexOf("[");
        arrayIndex =
          name[leftBrace + 1] != "]" ? jstoi_q(name.slice(leftBrace + 1)) : 0;
        name = name.slice(0, leftBrace);
      }
      var uniformInfo =
        GL.programInfos[program] && GL.programInfos[program].uniforms[name];
      if (uniformInfo && arrayIndex >= 0 && arrayIndex < uniformInfo[0]) {
        return uniformInfo[1] + arrayIndex;
      } else {
        return -1;
      }
    }
    function _glIsEnabled(x0) {
      return GLctx["isEnabled"](x0);
    }
    function _glLinkProgram(program) {
      GLctx.linkProgram(GL.programs[program]);
      GL.populateUniformTable(program);
    }
    function _glShaderSource(shader, count, string, length) {
      var source = GL.getSource(shader, count, string, length);
      GLctx.shaderSource(GL.shaders[shader], source);
    }
    function _glTexImage2D(
      target,
      level,
      internalFormat,
      width,
      height,
      border,
      format,
      type,
      pixels
    ) {
      GLctx.texImage2D(
        target,
        level,
        internalFormat,
        width,
        height,
        border,
        format,
        type,
        pixels
          ? emscriptenWebGLGetTexPixelData(
              type,
              format,
              width,
              height,
              pixels,
              internalFormat
            )
          : null
      );
    }
    function _glTexParameteri(x0, x1, x2) {
      GLctx["texParameteri"](x0, x1, x2);
    }
    function _glUniform1i(location, v0) {
      GLctx.uniform1i(GL.uniforms[location], v0);
    }
    function _glUniform4fv(location, count, value) {
      if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[4 * count - 1];
        var heap = HEAPF32;
        value >>= 2;
        for (var i = 0; i < 4 * count; i += 4) {
          var dst = value + i;
          view[i] = heap[dst];
          view[i + 1] = heap[dst + 1];
          view[i + 2] = heap[dst + 2];
          view[i + 3] = heap[dst + 3];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 16) >> 2);
      }
      GLctx.uniform4fv(GL.uniforms[location], view);
    }
    function _glUniformMatrix4fv(location, count, transpose, value) {
      if (16 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
        var view = GL.miniTempBufferFloatViews[16 * count - 1];
        var heap = HEAPF32;
        value >>= 2;
        for (var i = 0; i < 16 * count; i += 16) {
          var dst = value + i;
          view[i] = heap[dst];
          view[i + 1] = heap[dst + 1];
          view[i + 2] = heap[dst + 2];
          view[i + 3] = heap[dst + 3];
          view[i + 4] = heap[dst + 4];
          view[i + 5] = heap[dst + 5];
          view[i + 6] = heap[dst + 6];
          view[i + 7] = heap[dst + 7];
          view[i + 8] = heap[dst + 8];
          view[i + 9] = heap[dst + 9];
          view[i + 10] = heap[dst + 10];
          view[i + 11] = heap[dst + 11];
          view[i + 12] = heap[dst + 12];
          view[i + 13] = heap[dst + 13];
          view[i + 14] = heap[dst + 14];
          view[i + 15] = heap[dst + 15];
        }
      } else {
        var view = HEAPF32.subarray(value >> 2, (value + count * 64) >> 2);
      }
      GLctx.uniformMatrix4fv(GL.uniforms[location], !!transpose, view);
    }
    function _glUseProgram(program) {
      GLctx.useProgram(GL.programs[program]);
    }
    function _glVertexAttribPointer(
      index,
      size,
      type,
      normalized,
      stride,
      ptr
    ) {
      GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
    }
    function _glViewport(x0, x1, x2, x3) {
      GLctx["viewport"](x0, x1, x2, x3);
    }
    function _pthread_create() {
      return 6;
    }
    function _pthread_join() {}
    function _pthread_mutexattr_destroy() {}
    function _pthread_mutexattr_init() {}
    function _pthread_mutexattr_settype() {}
    function _roundf(d) {
      d = +d;
      return d >= +0 ? +Math_floor(d + +0.5) : +Math_ceil(d - +0.5);
    }
    function _setTempRet0($i) {
      setTempRet0($i | 0);
    }
    function __isLeapYear(year) {
      return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
    }
    function __arraySum(array, index) {
      var sum = 0;
      for (var i = 0; i <= index; sum += array[i++]) {}
      return sum;
    }
    var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    function __addDays(date, days) {
      var newDate = new Date(date.getTime());
      while (days > 0) {
        var leap = __isLeapYear(newDate.getFullYear());
        var currentMonth = newDate.getMonth();
        var daysInCurrentMonth = (
          leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR
        )[currentMonth];
        if (days > daysInCurrentMonth - newDate.getDate()) {
          days -= daysInCurrentMonth - newDate.getDate() + 1;
          newDate.setDate(1);
          if (currentMonth < 11) {
            newDate.setMonth(currentMonth + 1);
          } else {
            newDate.setMonth(0);
            newDate.setFullYear(newDate.getFullYear() + 1);
          }
        } else {
          newDate.setDate(newDate.getDate() + days);
          return newDate;
        }
      }
      return newDate;
    }
    function _strftime(s, maxsize, format, tm) {
      var tm_zone = HEAP32[(tm + 40) >> 2];
      var date = {
        tm_sec: HEAP32[tm >> 2],
        tm_min: HEAP32[(tm + 4) >> 2],
        tm_hour: HEAP32[(tm + 8) >> 2],
        tm_mday: HEAP32[(tm + 12) >> 2],
        tm_mon: HEAP32[(tm + 16) >> 2],
        tm_year: HEAP32[(tm + 20) >> 2],
        tm_wday: HEAP32[(tm + 24) >> 2],
        tm_yday: HEAP32[(tm + 28) >> 2],
        tm_isdst: HEAP32[(tm + 32) >> 2],
        tm_gmtoff: HEAP32[(tm + 36) >> 2],
        tm_zone: tm_zone ? UTF8ToString(tm_zone) : "",
      };
      var pattern = UTF8ToString(format);
      var EXPANSION_RULES_1 = {
        "%c": "%a %b %d %H:%M:%S %Y",
        "%D": "%m/%d/%y",
        "%F": "%Y-%m-%d",
        "%h": "%b",
        "%r": "%I:%M:%S %p",
        "%R": "%H:%M",
        "%T": "%H:%M:%S",
        "%x": "%m/%d/%y",
        "%X": "%H:%M:%S",
        "%Ec": "%c",
        "%EC": "%C",
        "%Ex": "%m/%d/%y",
        "%EX": "%H:%M:%S",
        "%Ey": "%y",
        "%EY": "%Y",
        "%Od": "%d",
        "%Oe": "%e",
        "%OH": "%H",
        "%OI": "%I",
        "%Om": "%m",
        "%OM": "%M",
        "%OS": "%S",
        "%Ou": "%u",
        "%OU": "%U",
        "%OV": "%V",
        "%Ow": "%w",
        "%OW": "%W",
        "%Oy": "%y",
      };
      for (var rule in EXPANSION_RULES_1) {
        pattern = pattern.replace(
          new RegExp(rule, "g"),
          EXPANSION_RULES_1[rule]
        );
      }
      var WEEKDAYS = [
        "Sunday",
        "Monday",
        "Tuesday",
        "Wednesday",
        "Thursday",
        "Friday",
        "Saturday",
      ];
      var MONTHS = [
        "January",
        "February",
        "March",
        "April",
        "May",
        "June",
        "July",
        "August",
        "September",
        "October",
        "November",
        "December",
      ];
      function leadingSomething(value, digits, character) {
        var str = typeof value === "number" ? value.toString() : value || "";
        while (str.length < digits) {
          str = character[0] + str;
        }
        return str;
      }
      function leadingNulls(value, digits) {
        return leadingSomething(value, digits, "0");
      }
      function compareByDay(date1, date2) {
        function sgn(value) {
          return value < 0 ? -1 : value > 0 ? 1 : 0;
        }
        var compare;
        if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
          if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
            compare = sgn(date1.getDate() - date2.getDate());
          }
        }
        return compare;
      }
      function getFirstWeekStartDate(janFourth) {
        switch (janFourth.getDay()) {
          case 0:
            return new Date(janFourth.getFullYear() - 1, 11, 29);
          case 1:
            return janFourth;
          case 2:
            return new Date(janFourth.getFullYear(), 0, 3);
          case 3:
            return new Date(janFourth.getFullYear(), 0, 2);
          case 4:
            return new Date(janFourth.getFullYear(), 0, 1);
          case 5:
            return new Date(janFourth.getFullYear() - 1, 11, 31);
          case 6:
            return new Date(janFourth.getFullYear() - 1, 11, 30);
        }
      }
      function getWeekBasedYear(date) {
        var thisDate = __addDays(
          new Date(date.tm_year + 1900, 0, 1),
          date.tm_yday
        );
        var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
        var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
        var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
        var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
        if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
          if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
            return thisDate.getFullYear() + 1;
          } else {
            return thisDate.getFullYear();
          }
        } else {
          return thisDate.getFullYear() - 1;
        }
      }
      var EXPANSION_RULES_2 = {
        "%a": function (date) {
          return WEEKDAYS[date.tm_wday].substring(0, 3);
        },
        "%A": function (date) {
          return WEEKDAYS[date.tm_wday];
        },
        "%b": function (date) {
          return MONTHS[date.tm_mon].substring(0, 3);
        },
        "%B": function (date) {
          return MONTHS[date.tm_mon];
        },
        "%C": function (date) {
          var year = date.tm_year + 1900;
          return leadingNulls((year / 100) | 0, 2);
        },
        "%d": function (date) {
          return leadingNulls(date.tm_mday, 2);
        },
        "%e": function (date) {
          return leadingSomething(date.tm_mday, 2, " ");
        },
        "%g": function (date) {
          return getWeekBasedYear(date).toString().substring(2);
        },
        "%G": function (date) {
          return getWeekBasedYear(date);
        },
        "%H": function (date) {
          return leadingNulls(date.tm_hour, 2);
        },
        "%I": function (date) {
          var twelveHour = date.tm_hour;
          if (twelveHour == 0) twelveHour = 12;
          else if (twelveHour > 12) twelveHour -= 12;
          return leadingNulls(twelveHour, 2);
        },
        "%j": function (date) {
          return leadingNulls(
            date.tm_mday +
              __arraySum(
                __isLeapYear(date.tm_year + 1900)
                  ? __MONTH_DAYS_LEAP
                  : __MONTH_DAYS_REGULAR,
                date.tm_mon - 1
              ),
            3
          );
        },
        "%m": function (date) {
          return leadingNulls(date.tm_mon + 1, 2);
        },
        "%M": function (date) {
          return leadingNulls(date.tm_min, 2);
        },
        "%n": function () {
          return "\n";
        },
        "%p": function (date) {
          if (date.tm_hour >= 0 && date.tm_hour < 12) {
            return "AM";
          } else {
            return "PM";
          }
        },
        "%S": function (date) {
          return leadingNulls(date.tm_sec, 2);
        },
        "%t": function () {
          return "\t";
        },
        "%u": function (date) {
          return date.tm_wday || 7;
        },
        "%U": function (date) {
          var janFirst = new Date(date.tm_year + 1900, 0, 1);
          var firstSunday =
            janFirst.getDay() === 0
              ? janFirst
              : __addDays(janFirst, 7 - janFirst.getDay());
          var endDate = new Date(
            date.tm_year + 1900,
            date.tm_mon,
            date.tm_mday
          );
          if (compareByDay(firstSunday, endDate) < 0) {
            var februaryFirstUntilEndMonth =
              __arraySum(
                __isLeapYear(endDate.getFullYear())
                  ? __MONTH_DAYS_LEAP
                  : __MONTH_DAYS_REGULAR,
                endDate.getMonth() - 1
              ) - 31;
            var firstSundayUntilEndJanuary = 31 - firstSunday.getDate();
            var days =
              firstSundayUntilEndJanuary +
              februaryFirstUntilEndMonth +
              endDate.getDate();
            return leadingNulls(Math.ceil(days / 7), 2);
          }
          return compareByDay(firstSunday, janFirst) === 0 ? "01" : "00";
        },
        "%V": function (date) {
          var janFourthThisYear = new Date(date.tm_year + 1900, 0, 4);
          var janFourthNextYear = new Date(date.tm_year + 1901, 0, 4);
          var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
          var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
          var endDate = __addDays(
            new Date(date.tm_year + 1900, 0, 1),
            date.tm_yday
          );
          if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
            return "53";
          }
          if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
            return "01";
          }
          var daysDifference;
          if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) {
            daysDifference =
              date.tm_yday + 32 - firstWeekStartThisYear.getDate();
          } else {
            daysDifference =
              date.tm_yday + 1 - firstWeekStartThisYear.getDate();
          }
          return leadingNulls(Math.ceil(daysDifference / 7), 2);
        },
        "%w": function (date) {
          return date.tm_wday;
        },
        "%W": function (date) {
          var janFirst = new Date(date.tm_year, 0, 1);
          var firstMonday =
            janFirst.getDay() === 1
              ? janFirst
              : __addDays(
                  janFirst,
                  janFirst.getDay() === 0 ? 1 : 7 - janFirst.getDay() + 1
                );
          var endDate = new Date(
            date.tm_year + 1900,
            date.tm_mon,
            date.tm_mday
          );
          if (compareByDay(firstMonday, endDate) < 0) {
            var februaryFirstUntilEndMonth =
              __arraySum(
                __isLeapYear(endDate.getFullYear())
                  ? __MONTH_DAYS_LEAP
                  : __MONTH_DAYS_REGULAR,
                endDate.getMonth() - 1
              ) - 31;
            var firstMondayUntilEndJanuary = 31 - firstMonday.getDate();
            var days =
              firstMondayUntilEndJanuary +
              februaryFirstUntilEndMonth +
              endDate.getDate();
            return leadingNulls(Math.ceil(days / 7), 2);
          }
          return compareByDay(firstMonday, janFirst) === 0 ? "01" : "00";
        },
        "%y": function (date) {
          return (date.tm_year + 1900).toString().substring(2);
        },
        "%Y": function (date) {
          return date.tm_year + 1900;
        },
        "%z": function (date) {
          var off = date.tm_gmtoff;
          var ahead = off >= 0;
          off = Math.abs(off) / 60;
          off = (off / 60) * 100 + (off % 60);
          return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
        },
        "%Z": function (date) {
          return date.tm_zone;
        },
        "%%": function () {
          return "%";
        },
      };
      for (var rule in EXPANSION_RULES_2) {
        if (pattern.indexOf(rule) >= 0) {
          pattern = pattern.replace(
            new RegExp(rule, "g"),
            EXPANSION_RULES_2[rule](date)
          );
        }
      }
      var bytes = intArrayFromString(pattern, false);
      if (bytes.length > maxsize) {
        return 0;
      }
      writeArrayToMemory(bytes, s);
      return bytes.length - 1;
    }
    function _strftime_l(s, maxsize, format, tm) {
      return _strftime(s, maxsize, format, tm);
    }
    function readAsmConstArgs(sigPtr, buf) {
      if (!readAsmConstArgs.array) {
        readAsmConstArgs.array = [];
      }
      var args = readAsmConstArgs.array;
      args.length = 0;
      var ch;
      while ((ch = HEAPU8[sigPtr++])) {
        if (ch === 100 || ch === 102) {
          buf = (buf + 7) & ~7;
          args.push(HEAPF64[buf >> 3]);
          buf += 8;
        } else {
          buf = (buf + 3) & ~3;
          args.push(HEAP32[buf >> 2]);
          buf += 4;
        }
      }
      return args;
    }
    Module["requestFullscreen"] = function Module_requestFullscreen(
      lockPointer,
      resizeCanvas
    ) {
      Browser.requestFullscreen(lockPointer, resizeCanvas);
    };
    Module["requestAnimationFrame"] = function Module_requestAnimationFrame(
      func
    ) {
      Browser.requestAnimationFrame(func);
    };
    Module["setCanvasSize"] = function Module_setCanvasSize(
      width,
      height,
      noUpdates
    ) {
      Browser.setCanvasSize(width, height, noUpdates);
    };
    Module["pauseMainLoop"] = function Module_pauseMainLoop() {
      Browser.mainLoop.pause();
    };
    Module["resumeMainLoop"] = function Module_resumeMainLoop() {
      Browser.mainLoop.resume();
    };
    Module["getUserMedia"] = function Module_getUserMedia() {
      Browser.getUserMedia();
    };
    Module["createContext"] = function Module_createContext(
      canvas,
      useWebGL,
      setInModule,
      webGLContextAttributes
    ) {
      return Browser.createContext(
        canvas,
        useWebGL,
        setInModule,
        webGLContextAttributes
      );
    };
    var GLctx;
    GL.init();
    for (var i = 0; i < 32; i++) __tempFixedLengthArray.push(new Array(i));
    var ASSERTIONS = false;
    function intArrayFromString(stringy, dontAddNull, length) {
      var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
      var u8array = new Array(len);
      var numBytesWritten = stringToUTF8Array(
        stringy,
        u8array,
        0,
        u8array.length
      );
      if (dontAddNull) u8array.length = numBytesWritten;
      return u8array;
    }
    var asmLibraryArg = {
      __cxa_allocate_exception: ___cxa_allocate_exception,
      __cxa_atexit: ___cxa_atexit,
      __cxa_throw: ___cxa_throw,
      __map_file: ___map_file,
      __sys_fcntl64: ___sys_fcntl64,
      __sys_ioctl: ___sys_ioctl,
      __sys_munmap: ___sys_munmap,
      __sys_open: ___sys_open,
      abort: _abort,
      alBufferData: _alBufferData,
      alDeleteBuffers: _alDeleteBuffers,
      alDeleteSources: _alDeleteSources,
      alGenBuffers: _alGenBuffers,
      alGenSources: _alGenSources,
      alGetSourcei: _alGetSourcei,
      alListenerfv: _alListenerfv,
      alSourcePause: _alSourcePause,
      alSourcePlay: _alSourcePlay,
      alSourceStop: _alSourceStop,
      alSourcef: _alSourcef,
      alSourcefv: _alSourcefv,
      alSourcei: _alSourcei,
      alcCreateContext: _alcCreateContext,
      alcMakeContextCurrent: _alcMakeContextCurrent,
      alcOpenDevice: _alcOpenDevice,
      clock_gettime: _clock_gettime,
      eglGetProcAddress: _eglGetProcAddress,
      emscripten_asm_const_iii: _emscripten_asm_const_iii,
      emscripten_get_sbrk_ptr: _emscripten_get_sbrk_ptr,
      emscripten_glActiveTexture: _emscripten_glActiveTexture,
      emscripten_glAttachShader: _emscripten_glAttachShader,
      emscripten_glBeginQueryEXT: _emscripten_glBeginQueryEXT,
      emscripten_glBindAttribLocation: _emscripten_glBindAttribLocation,
      emscripten_glBindBuffer: _emscripten_glBindBuffer,
      emscripten_glBindFramebuffer: _emscripten_glBindFramebuffer,
      emscripten_glBindRenderbuffer: _emscripten_glBindRenderbuffer,
      emscripten_glBindTexture: _emscripten_glBindTexture,
      emscripten_glBindVertexArrayOES: _emscripten_glBindVertexArrayOES,
      emscripten_glBlendColor: _emscripten_glBlendColor,
      emscripten_glBlendEquation: _emscripten_glBlendEquation,
      emscripten_glBlendEquationSeparate: _emscripten_glBlendEquationSeparate,
      emscripten_glBlendFunc: _emscripten_glBlendFunc,
      emscripten_glBlendFuncSeparate: _emscripten_glBlendFuncSeparate,
      emscripten_glBufferData: _emscripten_glBufferData,
      emscripten_glBufferSubData: _emscripten_glBufferSubData,
      emscripten_glCheckFramebufferStatus: _emscripten_glCheckFramebufferStatus,
      emscripten_glClear: _emscripten_glClear,
      emscripten_glClearColor: _emscripten_glClearColor,
      emscripten_glClearDepthf: _emscripten_glClearDepthf,
      emscripten_glClearStencil: _emscripten_glClearStencil,
      emscripten_glColorMask: _emscripten_glColorMask,
      emscripten_glCompileShader: _emscripten_glCompileShader,
      emscripten_glCompressedTexImage2D: _emscripten_glCompressedTexImage2D,
      emscripten_glCompressedTexSubImage2D:
        _emscripten_glCompressedTexSubImage2D,
      emscripten_glCopyTexImage2D: _emscripten_glCopyTexImage2D,
      emscripten_glCopyTexSubImage2D: _emscripten_glCopyTexSubImage2D,
      emscripten_glCreateProgram: _emscripten_glCreateProgram,
      emscripten_glCreateShader: _emscripten_glCreateShader,
      emscripten_glCullFace: _emscripten_glCullFace,
      emscripten_glDeleteBuffers: _emscripten_glDeleteBuffers,
      emscripten_glDeleteFramebuffers: _emscripten_glDeleteFramebuffers,
      emscripten_glDeleteProgram: _emscripten_glDeleteProgram,
      emscripten_glDeleteQueriesEXT: _emscripten_glDeleteQueriesEXT,
      emscripten_glDeleteRenderbuffers: _emscripten_glDeleteRenderbuffers,
      emscripten_glDeleteShader: _emscripten_glDeleteShader,
      emscripten_glDeleteTextures: _emscripten_glDeleteTextures,
      emscripten_glDeleteVertexArraysOES: _emscripten_glDeleteVertexArraysOES,
      emscripten_glDepthFunc: _emscripten_glDepthFunc,
      emscripten_glDepthMask: _emscripten_glDepthMask,
      emscripten_glDepthRangef: _emscripten_glDepthRangef,
      emscripten_glDetachShader: _emscripten_glDetachShader,
      emscripten_glDisable: _emscripten_glDisable,
      emscripten_glDisableVertexAttribArray:
        _emscripten_glDisableVertexAttribArray,
      emscripten_glDrawArrays: _emscripten_glDrawArrays,
      emscripten_glDrawArraysInstancedANGLE:
        _emscripten_glDrawArraysInstancedANGLE,
      emscripten_glDrawBuffersWEBGL: _emscripten_glDrawBuffersWEBGL,
      emscripten_glDrawElements: _emscripten_glDrawElements,
      emscripten_glDrawElementsInstancedANGLE:
        _emscripten_glDrawElementsInstancedANGLE,
      emscripten_glEnable: _emscripten_glEnable,
      emscripten_glEnableVertexAttribArray:
        _emscripten_glEnableVertexAttribArray,
      emscripten_glEndQueryEXT: _emscripten_glEndQueryEXT,
      emscripten_glFinish: _emscripten_glFinish,
      emscripten_glFlush: _emscripten_glFlush,
      emscripten_glFramebufferRenderbuffer:
        _emscripten_glFramebufferRenderbuffer,
      emscripten_glFramebufferTexture2D: _emscripten_glFramebufferTexture2D,
      emscripten_glFrontFace: _emscripten_glFrontFace,
      emscripten_glGenBuffers: _emscripten_glGenBuffers,
      emscripten_glGenFramebuffers: _emscripten_glGenFramebuffers,
      emscripten_glGenQueriesEXT: _emscripten_glGenQueriesEXT,
      emscripten_glGenRenderbuffers: _emscripten_glGenRenderbuffers,
      emscripten_glGenTextures: _emscripten_glGenTextures,
      emscripten_glGenVertexArraysOES: _emscripten_glGenVertexArraysOES,
      emscripten_glGenerateMipmap: _emscripten_glGenerateMipmap,
      emscripten_glGetActiveAttrib: _emscripten_glGetActiveAttrib,
      emscripten_glGetActiveUniform: _emscripten_glGetActiveUniform,
      emscripten_glGetAttachedShaders: _emscripten_glGetAttachedShaders,
      emscripten_glGetAttribLocation: _emscripten_glGetAttribLocation,
      emscripten_glGetBooleanv: _emscripten_glGetBooleanv,
      emscripten_glGetBufferParameteriv: _emscripten_glGetBufferParameteriv,
      emscripten_glGetError: _emscripten_glGetError,
      emscripten_glGetFloatv: _emscripten_glGetFloatv,
      emscripten_glGetFramebufferAttachmentParameteriv:
        _emscripten_glGetFramebufferAttachmentParameteriv,
      emscripten_glGetIntegerv: _emscripten_glGetIntegerv,
      emscripten_glGetProgramInfoLog: _emscripten_glGetProgramInfoLog,
      emscripten_glGetProgramiv: _emscripten_glGetProgramiv,
      emscripten_glGetQueryObjecti64vEXT: _emscripten_glGetQueryObjecti64vEXT,
      emscripten_glGetQueryObjectivEXT: _emscripten_glGetQueryObjectivEXT,
      emscripten_glGetQueryObjectui64vEXT: _emscripten_glGetQueryObjectui64vEXT,
      emscripten_glGetQueryObjectuivEXT: _emscripten_glGetQueryObjectuivEXT,
      emscripten_glGetQueryivEXT: _emscripten_glGetQueryivEXT,
      emscripten_glGetRenderbufferParameteriv:
        _emscripten_glGetRenderbufferParameteriv,
      emscripten_glGetShaderInfoLog: _emscripten_glGetShaderInfoLog,
      emscripten_glGetShaderPrecisionFormat:
        _emscripten_glGetShaderPrecisionFormat,
      emscripten_glGetShaderSource: _emscripten_glGetShaderSource,
      emscripten_glGetShaderiv: _emscripten_glGetShaderiv,
      emscripten_glGetString: _emscripten_glGetString,
      emscripten_glGetTexParameterfv: _emscripten_glGetTexParameterfv,
      emscripten_glGetTexParameteriv: _emscripten_glGetTexParameteriv,
      emscripten_glGetUniformLocation: _emscripten_glGetUniformLocation,
      emscripten_glGetUniformfv: _emscripten_glGetUniformfv,
      emscripten_glGetUniformiv: _emscripten_glGetUniformiv,
      emscripten_glGetVertexAttribPointerv:
        _emscripten_glGetVertexAttribPointerv,
      emscripten_glGetVertexAttribfv: _emscripten_glGetVertexAttribfv,
      emscripten_glGetVertexAttribiv: _emscripten_glGetVertexAttribiv,
      emscripten_glHint: _emscripten_glHint,
      emscripten_glIsBuffer: _emscripten_glIsBuffer,
      emscripten_glIsEnabled: _emscripten_glIsEnabled,
      emscripten_glIsFramebuffer: _emscripten_glIsFramebuffer,
      emscripten_glIsProgram: _emscripten_glIsProgram,
      emscripten_glIsQueryEXT: _emscripten_glIsQueryEXT,
      emscripten_glIsRenderbuffer: _emscripten_glIsRenderbuffer,
      emscripten_glIsShader: _emscripten_glIsShader,
      emscripten_glIsTexture: _emscripten_glIsTexture,
      emscripten_glIsVertexArrayOES: _emscripten_glIsVertexArrayOES,
      emscripten_glLineWidth: _emscripten_glLineWidth,
      emscripten_glLinkProgram: _emscripten_glLinkProgram,
      emscripten_glPixelStorei: _emscripten_glPixelStorei,
      emscripten_glPolygonOffset: _emscripten_glPolygonOffset,
      emscripten_glQueryCounterEXT: _emscripten_glQueryCounterEXT,
      emscripten_glReadPixels: _emscripten_glReadPixels,
      emscripten_glReleaseShaderCompiler: _emscripten_glReleaseShaderCompiler,
      emscripten_glRenderbufferStorage: _emscripten_glRenderbufferStorage,
      emscripten_glSampleCoverage: _emscripten_glSampleCoverage,
      emscripten_glScissor: _emscripten_glScissor,
      emscripten_glShaderBinary: _emscripten_glShaderBinary,
      emscripten_glShaderSource: _emscripten_glShaderSource,
      emscripten_glStencilFunc: _emscripten_glStencilFunc,
      emscripten_glStencilFuncSeparate: _emscripten_glStencilFuncSeparate,
      emscripten_glStencilMask: _emscripten_glStencilMask,
      emscripten_glStencilMaskSeparate: _emscripten_glStencilMaskSeparate,
      emscripten_glStencilOp: _emscripten_glStencilOp,
      emscripten_glStencilOpSeparate: _emscripten_glStencilOpSeparate,
      emscripten_glTexImage2D: _emscripten_glTexImage2D,
      emscripten_glTexParameterf: _emscripten_glTexParameterf,
      emscripten_glTexParameterfv: _emscripten_glTexParameterfv,
      emscripten_glTexParameteri: _emscripten_glTexParameteri,
      emscripten_glTexParameteriv: _emscripten_glTexParameteriv,
      emscripten_glTexSubImage2D: _emscripten_glTexSubImage2D,
      emscripten_glUniform1f: _emscripten_glUniform1f,
      emscripten_glUniform1fv: _emscripten_glUniform1fv,
      emscripten_glUniform1i: _emscripten_glUniform1i,
      emscripten_glUniform1iv: _emscripten_glUniform1iv,
      emscripten_glUniform2f: _emscripten_glUniform2f,
      emscripten_glUniform2fv: _emscripten_glUniform2fv,
      emscripten_glUniform2i: _emscripten_glUniform2i,
      emscripten_glUniform2iv: _emscripten_glUniform2iv,
      emscripten_glUniform3f: _emscripten_glUniform3f,
      emscripten_glUniform3fv: _emscripten_glUniform3fv,
      emscripten_glUniform3i: _emscripten_glUniform3i,
      emscripten_glUniform3iv: _emscripten_glUniform3iv,
      emscripten_glUniform4f: _emscripten_glUniform4f,
      emscripten_glUniform4fv: _emscripten_glUniform4fv,
      emscripten_glUniform4i: _emscripten_glUniform4i,
      emscripten_glUniform4iv: _emscripten_glUniform4iv,
      emscripten_glUniformMatrix2fv: _emscripten_glUniformMatrix2fv,
      emscripten_glUniformMatrix3fv: _emscripten_glUniformMatrix3fv,
      emscripten_glUniformMatrix4fv: _emscripten_glUniformMatrix4fv,
      emscripten_glUseProgram: _emscripten_glUseProgram,
      emscripten_glValidateProgram: _emscripten_glValidateProgram,
      emscripten_glVertexAttrib1f: _emscripten_glVertexAttrib1f,
      emscripten_glVertexAttrib1fv: _emscripten_glVertexAttrib1fv,
      emscripten_glVertexAttrib2f: _emscripten_glVertexAttrib2f,
      emscripten_glVertexAttrib2fv: _emscripten_glVertexAttrib2fv,
      emscripten_glVertexAttrib3f: _emscripten_glVertexAttrib3f,
      emscripten_glVertexAttrib3fv: _emscripten_glVertexAttrib3fv,
      emscripten_glVertexAttrib4f: _emscripten_glVertexAttrib4f,
      emscripten_glVertexAttrib4fv: _emscripten_glVertexAttrib4fv,
      emscripten_glVertexAttribDivisorANGLE:
        _emscripten_glVertexAttribDivisorANGLE,
      emscripten_glVertexAttribPointer: _emscripten_glVertexAttribPointer,
      emscripten_glViewport: _emscripten_glViewport,
      emscripten_memcpy_big: _emscripten_memcpy_big,
      emscripten_resize_heap: _emscripten_resize_heap,
      environ_get: _environ_get,
      environ_sizes_get: _environ_sizes_get,
      fd_close: _fd_close,
      fd_read: _fd_read,
      fd_seek: _fd_seek,
      fd_write: _fd_write,
      glActiveTexture: _glActiveTexture,
      glAttachShader: _glAttachShader,
      glBindBuffer: _glBindBuffer,
      glBindFramebuffer: _glBindFramebuffer,
      glBindTexture: _glBindTexture,
      glBlendEquation: _glBlendEquation,
      glBlendEquationSeparate: _glBlendEquationSeparate,
      glBlendFuncSeparate: _glBlendFuncSeparate,
      glBufferData: _glBufferData,
      glBufferSubData: _glBufferSubData,
      glClear: _glClear,
      glClearColor: _glClearColor,
      glCompileShader: _glCompileShader,
      glCopyTexSubImage2D: _glCopyTexSubImage2D,
      glCreateProgram: _glCreateProgram,
      glCreateShader: _glCreateShader,
      glCullFace: _glCullFace,
      glDeleteBuffers: _glDeleteBuffers,
      glDeleteFramebuffers: _glDeleteFramebuffers,
      glDeleteProgram: _glDeleteProgram,
      glDeleteShader: _glDeleteShader,
      glDeleteTextures: _glDeleteTextures,
      glDepthFunc: _glDepthFunc,
      glDepthMask: _glDepthMask,
      glDisable: _glDisable,
      glDisableVertexAttribArray: _glDisableVertexAttribArray,
      glDrawElements: _glDrawElements,
      glEnable: _glEnable,
      glEnableVertexAttribArray: _glEnableVertexAttribArray,
      glFramebufferTexture2D: _glFramebufferTexture2D,
      glGenBuffers: _glGenBuffers,
      glGenFramebuffers: _glGenFramebuffers,
      glGenTextures: _glGenTextures,
      glGenerateMipmap: _glGenerateMipmap,
      glGetAttribLocation: _glGetAttribLocation,
      glGetBooleanv: _glGetBooleanv,
      glGetIntegerv: _glGetIntegerv,
      glGetProgramiv: _glGetProgramiv,
      glGetShaderiv: _glGetShaderiv,
      glGetString: _glGetString,
      glGetUniformLocation: _glGetUniformLocation,
      glIsEnabled: _glIsEnabled,
      glLinkProgram: _glLinkProgram,
      glShaderSource: _glShaderSource,
      glTexImage2D: _glTexImage2D,
      glTexParameteri: _glTexParameteri,
      glUniform1i: _glUniform1i,
      glUniform4fv: _glUniform4fv,
      glUniformMatrix4fv: _glUniformMatrix4fv,
      glUseProgram: _glUseProgram,
      glVertexAttribPointer: _glVertexAttribPointer,
      glViewport: _glViewport,
      memory: wasmMemory,
      pthread_create: _pthread_create,
      pthread_join: _pthread_join,
      pthread_mutexattr_destroy: _pthread_mutexattr_destroy,
      pthread_mutexattr_init: _pthread_mutexattr_init,
      pthread_mutexattr_settype: _pthread_mutexattr_settype,
      roundf: _roundf,
      setTempRet0: _setTempRet0,
      strftime_l: _strftime_l,
      table: wasmTable,
    };
    var asm = createWasm();
    Module["asm"] = asm;
    var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
      return (___wasm_call_ctors = Module["___wasm_call_ctors"] =
        Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
    });
    var _free = (Module["_free"] = function () {
      return (_free = Module["_free"] = Module["asm"]["free"]).apply(
        null,
        arguments
      );
    });
    var _strstr = (Module["_strstr"] = function () {
      return (_strstr = Module["_strstr"] = Module["asm"]["strstr"]).apply(
        null,
        arguments
      );
    });
    var _EffekseerInit = (Module["_EffekseerInit"] = function () {
      return (_EffekseerInit = Module["_EffekseerInit"] =
        Module["asm"]["EffekseerInit"]).apply(null, arguments);
    });
    var _EffekseerTerminate = (Module["_EffekseerTerminate"] = function () {
      return (_EffekseerTerminate = Module["_EffekseerTerminate"] =
        Module["asm"]["EffekseerTerminate"]).apply(null, arguments);
    });
    var _EffekseerUpdate = (Module["_EffekseerUpdate"] = function () {
      return (_EffekseerUpdate = Module["_EffekseerUpdate"] =
        Module["asm"]["EffekseerUpdate"]).apply(null, arguments);
    });
    var _EffekseerBeginUpdate = (Module["_EffekseerBeginUpdate"] = function () {
      return (_EffekseerBeginUpdate = Module["_EffekseerBeginUpdate"] =
        Module["asm"]["EffekseerBeginUpdate"]).apply(null, arguments);
    });
    var _EffekseerEndUpdate = (Module["_EffekseerEndUpdate"] = function () {
      return (_EffekseerEndUpdate = Module["_EffekseerEndUpdate"] =
        Module["asm"]["EffekseerEndUpdate"]).apply(null, arguments);
    });
    var _EffekseerUpdateHandle = (Module["_EffekseerUpdateHandle"] =
      function () {
        return (_EffekseerUpdateHandle = Module["_EffekseerUpdateHandle"] =
          Module["asm"]["EffekseerUpdateHandle"]).apply(null, arguments);
      });
    var _EffekseerDraw = (Module["_EffekseerDraw"] = function () {
      return (_EffekseerDraw = Module["_EffekseerDraw"] =
        Module["asm"]["EffekseerDraw"]).apply(null, arguments);
    });
    var _EffekseerBeginDraw = (Module["_EffekseerBeginDraw"] = function () {
      return (_EffekseerBeginDraw = Module["_EffekseerBeginDraw"] =
        Module["asm"]["EffekseerBeginDraw"]).apply(null, arguments);
    });
    var _EffekseerEndDraw = (Module["_EffekseerEndDraw"] = function () {
      return (_EffekseerEndDraw = Module["_EffekseerEndDraw"] =
        Module["asm"]["EffekseerEndDraw"]).apply(null, arguments);
    });
    var _EffekseerDrawHandle = (Module["_EffekseerDrawHandle"] = function () {
      return (_EffekseerDrawHandle = Module["_EffekseerDrawHandle"] =
        Module["asm"]["EffekseerDrawHandle"]).apply(null, arguments);
    });
    var _EffekseerSetProjectionMatrix = (Module[
      "_EffekseerSetProjectionMatrix"
    ] = function () {
      return (_EffekseerSetProjectionMatrix = Module[
        "_EffekseerSetProjectionMatrix"
      ] =
        Module["asm"]["EffekseerSetProjectionMatrix"]).apply(null, arguments);
    });
    var _EffekseerSetProjectionPerspective = (Module[
      "_EffekseerSetProjectionPerspective"
    ] = function () {
      return (_EffekseerSetProjectionPerspective = Module[
        "_EffekseerSetProjectionPerspective"
      ] =
        Module["asm"]["EffekseerSetProjectionPerspective"]).apply(
        null,
        arguments
      );
    });
    var _EffekseerSetProjectionOrthographic = (Module[
      "_EffekseerSetProjectionOrthographic"
    ] = function () {
      return (_EffekseerSetProjectionOrthographic = Module[
        "_EffekseerSetProjectionOrthographic"
      ] =
        Module["asm"]["EffekseerSetProjectionOrthographic"]).apply(
        null,
        arguments
      );
    });
    var _EffekseerSetCameraMatrix = (Module["_EffekseerSetCameraMatrix"] =
      function () {
        return (_EffekseerSetCameraMatrix = Module[
          "_EffekseerSetCameraMatrix"
        ] =
          Module["asm"]["EffekseerSetCameraMatrix"]).apply(null, arguments);
      });
    var _EffekseerSetCameraLookAt = (Module["_EffekseerSetCameraLookAt"] =
      function () {
        return (_EffekseerSetCameraLookAt = Module[
          "_EffekseerSetCameraLookAt"
        ] =
          Module["asm"]["EffekseerSetCameraLookAt"]).apply(null, arguments);
      });
    var _EffekseerLoadEffect = (Module["_EffekseerLoadEffect"] = function () {
      return (_EffekseerLoadEffect = Module["_EffekseerLoadEffect"] =
        Module["asm"]["EffekseerLoadEffect"]).apply(null, arguments);
    });
    var _EffekseerReleaseEffect = (Module["_EffekseerReleaseEffect"] =
      function () {
        return (_EffekseerReleaseEffect = Module["_EffekseerReleaseEffect"] =
          Module["asm"]["EffekseerReleaseEffect"]).apply(null, arguments);
      });
    var _EffekseerReloadResources = (Module["_EffekseerReloadResources"] =
      function () {
        return (_EffekseerReloadResources = Module[
          "_EffekseerReloadResources"
        ] =
          Module["asm"]["EffekseerReloadResources"]).apply(null, arguments);
      });
    var _EffekseerStopAllEffects = (Module["_EffekseerStopAllEffects"] =
      function () {
        return (_EffekseerStopAllEffects = Module["_EffekseerStopAllEffects"] =
          Module["asm"]["EffekseerStopAllEffects"]).apply(null, arguments);
      });
    var _EffekseerPlayEffect = (Module["_EffekseerPlayEffect"] = function () {
      return (_EffekseerPlayEffect = Module["_EffekseerPlayEffect"] =
        Module["asm"]["EffekseerPlayEffect"]).apply(null, arguments);
    });
    var _EffekseerStopEffect = (Module["_EffekseerStopEffect"] = function () {
      return (_EffekseerStopEffect = Module["_EffekseerStopEffect"] =
        Module["asm"]["EffekseerStopEffect"]).apply(null, arguments);
    });
    var _EffekseerStopRoot = (Module["_EffekseerStopRoot"] = function () {
      return (_EffekseerStopRoot = Module["_EffekseerStopRoot"] =
        Module["asm"]["EffekseerStopRoot"]).apply(null, arguments);
    });
    var _EffekseerExists = (Module["_EffekseerExists"] = function () {
      return (_EffekseerExists = Module["_EffekseerExists"] =
        Module["asm"]["EffekseerExists"]).apply(null, arguments);
    });
    var _EffekseerSetFrame = (Module["_EffekseerSetFrame"] = function () {
      return (_EffekseerSetFrame = Module["_EffekseerSetFrame"] =
        Module["asm"]["EffekseerSetFrame"]).apply(null, arguments);
    });
    var _EffekseerSetLocation = (Module["_EffekseerSetLocation"] = function () {
      return (_EffekseerSetLocation = Module["_EffekseerSetLocation"] =
        Module["asm"]["EffekseerSetLocation"]).apply(null, arguments);
    });
    var _EffekseerSetRotation = (Module["_EffekseerSetRotation"] = function () {
      return (_EffekseerSetRotation = Module["_EffekseerSetRotation"] =
        Module["asm"]["EffekseerSetRotation"]).apply(null, arguments);
    });
    var _EffekseerSetScale = (Module["_EffekseerSetScale"] = function () {
      return (_EffekseerSetScale = Module["_EffekseerSetScale"] =
        Module["asm"]["EffekseerSetScale"]).apply(null, arguments);
    });
    var _EffekseerSetMatrix = (Module["_EffekseerSetMatrix"] = function () {
      return (_EffekseerSetMatrix = Module["_EffekseerSetMatrix"] =
        Module["asm"]["EffekseerSetMatrix"]).apply(null, arguments);
    });
    var _EffekseerGetDynamicInput = (Module["_EffekseerGetDynamicInput"] =
      function () {
        return (_EffekseerGetDynamicInput = Module[
          "_EffekseerGetDynamicInput"
        ] =
          Module["asm"]["EffekseerGetDynamicInput"]).apply(null, arguments);
      });
    var _EffekseerSetDynamicInput = (Module["_EffekseerSetDynamicInput"] =
      function () {
        return (_EffekseerSetDynamicInput = Module[
          "_EffekseerSetDynamicInput"
        ] =
          Module["asm"]["EffekseerSetDynamicInput"]).apply(null, arguments);
      });
    var _EffekseerSendTrigger = (Module["_EffekseerSendTrigger"] = function () {
      return (_EffekseerSendTrigger = Module["_EffekseerSendTrigger"] =
        Module["asm"]["EffekseerSendTrigger"]).apply(null, arguments);
    });
    var _EffekseerSetAllColor = (Module["_EffekseerSetAllColor"] = function () {
      return (_EffekseerSetAllColor = Module["_EffekseerSetAllColor"] =
        Module["asm"]["EffekseerSetAllColor"]).apply(null, arguments);
    });
    var _EffekseerSetTargetLocation = (Module["_EffekseerSetTargetLocation"] =
      function () {
        return (_EffekseerSetTargetLocation = Module[
          "_EffekseerSetTargetLocation"
        ] =
          Module["asm"]["EffekseerSetTargetLocation"]).apply(null, arguments);
      });
    var _EffekseerSetPaused = (Module["_EffekseerSetPaused"] = function () {
      return (_EffekseerSetPaused = Module["_EffekseerSetPaused"] =
        Module["asm"]["EffekseerSetPaused"]).apply(null, arguments);
    });
    var _EffekseerSetShown = (Module["_EffekseerSetShown"] = function () {
      return (_EffekseerSetShown = Module["_EffekseerSetShown"] =
        Module["asm"]["EffekseerSetShown"]).apply(null, arguments);
    });
    var _EffekseerSetSpeed = (Module["_EffekseerSetSpeed"] = function () {
      return (_EffekseerSetSpeed = Module["_EffekseerSetSpeed"] =
        Module["asm"]["EffekseerSetSpeed"]).apply(null, arguments);
    });
    var _EffekseerSetRandomSeed = (Module["_EffekseerSetRandomSeed"] =
      function () {
        return (_EffekseerSetRandomSeed = Module["_EffekseerSetRandomSeed"] =
          Module["asm"]["EffekseerSetRandomSeed"]).apply(null, arguments);
      });
    var _EffekseerGetRestInstancesCount = (Module[
      "_EffekseerGetRestInstancesCount"
    ] = function () {
      return (_EffekseerGetRestInstancesCount = Module[
        "_EffekseerGetRestInstancesCount"
      ] =
        Module["asm"]["EffekseerGetRestInstancesCount"]).apply(null, arguments);
    });
    var _EffekseerGetUpdateTime = (Module["_EffekseerGetUpdateTime"] =
      function () {
        return (_EffekseerGetUpdateTime = Module["_EffekseerGetUpdateTime"] =
          Module["asm"]["EffekseerGetUpdateTime"]).apply(null, arguments);
      });
    var _EffekseerGetDrawTime = (Module["_EffekseerGetDrawTime"] = function () {
      return (_EffekseerGetDrawTime = Module["_EffekseerGetDrawTime"] =
        Module["asm"]["EffekseerGetDrawTime"]).apply(null, arguments);
    });
    var _EffekseerIsVertexArrayObjectSupported = (Module[
      "_EffekseerIsVertexArrayObjectSupported"
    ] = function () {
      return (_EffekseerIsVertexArrayObjectSupported = Module[
        "_EffekseerIsVertexArrayObjectSupported"
      ] =
        Module["asm"]["EffekseerIsVertexArrayObjectSupported"]).apply(
        null,
        arguments
      );
    });
    var _EffekseerSetRestorationOfStatesFlag = (Module[
      "_EffekseerSetRestorationOfStatesFlag"
    ] = function () {
      return (_EffekseerSetRestorationOfStatesFlag = Module[
        "_EffekseerSetRestorationOfStatesFlag"
      ] =
        Module["asm"]["EffekseerSetRestorationOfStatesFlag"]).apply(
        null,
        arguments
      );
    });
    var _EffekseerCaptureBackground = (Module["_EffekseerCaptureBackground"] =
      function () {
        return (_EffekseerCaptureBackground = Module[
          "_EffekseerCaptureBackground"
        ] =
          Module["asm"]["EffekseerCaptureBackground"]).apply(null, arguments);
      });
    var _EffekseerResetBackground = (Module["_EffekseerResetBackground"] =
      function () {
        return (_EffekseerResetBackground = Module[
          "_EffekseerResetBackground"
        ] =
          Module["asm"]["EffekseerResetBackground"]).apply(null, arguments);
      });
    var _EffekseerSetLogEnabled = (Module["_EffekseerSetLogEnabled"] =
      function () {
        return (_EffekseerSetLogEnabled = Module["_EffekseerSetLogEnabled"] =
          Module["asm"]["EffekseerSetLogEnabled"]).apply(null, arguments);
      });
    var ___errno_location = (Module["___errno_location"] = function () {
      return (___errno_location = Module["___errno_location"] =
        Module["asm"]["__errno_location"]).apply(null, arguments);
    });
    var _malloc = (Module["_malloc"] = function () {
      return (_malloc = Module["_malloc"] = Module["asm"]["malloc"]).apply(
        null,
        arguments
      );
    });
    var _setThrew = (Module["_setThrew"] = function () {
      return (_setThrew = Module["_setThrew"] =
        Module["asm"]["setThrew"]).apply(null, arguments);
    });
    var _emscripten_GetProcAddress = (Module["_emscripten_GetProcAddress"] =
      function () {
        return (_emscripten_GetProcAddress = Module[
          "_emscripten_GetProcAddress"
        ] =
          Module["asm"]["emscripten_GetProcAddress"]).apply(null, arguments);
      });
    var _emscripten_main_thread_process_queued_calls = (Module[
      "_emscripten_main_thread_process_queued_calls"
    ] = function () {
      return (_emscripten_main_thread_process_queued_calls = Module[
        "_emscripten_main_thread_process_queued_calls"
      ] =
        Module["asm"]["emscripten_main_thread_process_queued_calls"]).apply(
        null,
        arguments
      );
    });
    var stackSave = (Module["stackSave"] = function () {
      return (stackSave = Module["stackSave"] =
        Module["asm"]["stackSave"]).apply(null, arguments);
    });
    var stackAlloc = (Module["stackAlloc"] = function () {
      return (stackAlloc = Module["stackAlloc"] =
        Module["asm"]["stackAlloc"]).apply(null, arguments);
    });
    var stackRestore = (Module["stackRestore"] = function () {
      return (stackRestore = Module["stackRestore"] =
        Module["asm"]["stackRestore"]).apply(null, arguments);
    });
    var __growWasmMemory = (Module["__growWasmMemory"] = function () {
      return (__growWasmMemory = Module["__growWasmMemory"] =
        Module["asm"]["__growWasmMemory"]).apply(null, arguments);
    });
    var dynCall_ii = (Module["dynCall_ii"] = function () {
      return (dynCall_ii = Module["dynCall_ii"] =
        Module["asm"]["dynCall_ii"]).apply(null, arguments);
    });
    var dynCall_vi = (Module["dynCall_vi"] = function () {
      return (dynCall_vi = Module["dynCall_vi"] =
        Module["asm"]["dynCall_vi"]).apply(null, arguments);
    });
    var dynCall_viii = (Module["dynCall_viii"] = function () {
      return (dynCall_viii = Module["dynCall_viii"] =
        Module["asm"]["dynCall_viii"]).apply(null, arguments);
    });
    var dynCall_viiii = (Module["dynCall_viiii"] = function () {
      return (dynCall_viiii = Module["dynCall_viiii"] =
        Module["asm"]["dynCall_viiii"]).apply(null, arguments);
    });
    var dynCall_vii = (Module["dynCall_vii"] = function () {
      return (dynCall_vii = Module["dynCall_vii"] =
        Module["asm"]["dynCall_vii"]).apply(null, arguments);
    });
    var dynCall_iiiii = (Module["dynCall_iiiii"] = function () {
      return (dynCall_iiiii = Module["dynCall_iiiii"] =
        Module["asm"]["dynCall_iiiii"]).apply(null, arguments);
    });
    var dynCall_iiii = (Module["dynCall_iiii"] = function () {
      return (dynCall_iiii = Module["dynCall_iiii"] =
        Module["asm"]["dynCall_iiii"]).apply(null, arguments);
    });
    var dynCall_iiiiifi = (Module["dynCall_iiiiifi"] = function () {
      return (dynCall_iiiiifi = Module["dynCall_iiiiifi"] =
        Module["asm"]["dynCall_iiiiifi"]).apply(null, arguments);
    });
    var dynCall_viiiii = (Module["dynCall_viiiii"] = function () {
      return (dynCall_viiiii = Module["dynCall_viiiii"] =
        Module["asm"]["dynCall_viiiii"]).apply(null, arguments);
    });
    var dynCall_fi = (Module["dynCall_fi"] = function () {
      return (dynCall_fi = Module["dynCall_fi"] =
        Module["asm"]["dynCall_fi"]).apply(null, arguments);
    });
    var dynCall_iii = (Module["dynCall_iii"] = function () {
      return (dynCall_iii = Module["dynCall_iii"] =
        Module["asm"]["dynCall_iii"]).apply(null, arguments);
    });
    var dynCall_iiiiiiii = (Module["dynCall_iiiiiiii"] = function () {
      return (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] =
        Module["asm"]["dynCall_iiiiiiii"]).apply(null, arguments);
    });
    var dynCall_iiiiiii = (Module["dynCall_iiiiiii"] = function () {
      return (dynCall_iiiiiii = Module["dynCall_iiiiiii"] =
        Module["asm"]["dynCall_iiiiiii"]).apply(null, arguments);
    });
    var dynCall_viiiiii = (Module["dynCall_viiiiii"] = function () {
      return (dynCall_viiiiii = Module["dynCall_viiiiii"] =
        Module["asm"]["dynCall_viiiiii"]).apply(null, arguments);
    });
    var dynCall_i = (Module["dynCall_i"] = function () {
      return (dynCall_i = Module["dynCall_i"] =
        Module["asm"]["dynCall_i"]).apply(null, arguments);
    });
    var dynCall_fif = (Module["dynCall_fif"] = function () {
      return (dynCall_fif = Module["dynCall_fif"] =
        Module["asm"]["dynCall_fif"]).apply(null, arguments);
    });
    var dynCall_viifff = (Module["dynCall_viifff"] = function () {
      return (dynCall_viifff = Module["dynCall_viifff"] =
        Module["asm"]["dynCall_viifff"]).apply(null, arguments);
    });
    var dynCall_viiif = (Module["dynCall_viiif"] = function () {
      return (dynCall_viiif = Module["dynCall_viiif"] =
        Module["asm"]["dynCall_viiif"]).apply(null, arguments);
    });
    var dynCall_fiii = (Module["dynCall_fiii"] = function () {
      return (dynCall_fiii = Module["dynCall_fiii"] =
        Module["asm"]["dynCall_fiii"]).apply(null, arguments);
    });
    var dynCall_jii = (Module["dynCall_jii"] = function () {
      return (dynCall_jii = Module["dynCall_jii"] =
        Module["asm"]["dynCall_jii"]).apply(null, arguments);
    });
    var dynCall_viij = (Module["dynCall_viij"] = function () {
      return (dynCall_viij = Module["dynCall_viij"] =
        Module["asm"]["dynCall_viij"]).apply(null, arguments);
    });
    var dynCall_fii = (Module["dynCall_fii"] = function () {
      return (dynCall_fii = Module["dynCall_fii"] =
        Module["asm"]["dynCall_fii"]).apply(null, arguments);
    });
    var dynCall_viif = (Module["dynCall_viif"] = function () {
      return (dynCall_viif = Module["dynCall_viif"] =
        Module["asm"]["dynCall_viif"]).apply(null, arguments);
    });
    var dynCall_vijf = (Module["dynCall_vijf"] = function () {
      return (dynCall_vijf = Module["dynCall_vijf"] =
        Module["asm"]["dynCall_vijf"]).apply(null, arguments);
    });
    var dynCall_vif = (Module["dynCall_vif"] = function () {
      return (dynCall_vif = Module["dynCall_vif"] =
        Module["asm"]["dynCall_vif"]).apply(null, arguments);
    });
    var dynCall_iiifff = (Module["dynCall_iiifff"] = function () {
      return (dynCall_iiifff = Module["dynCall_iiifff"] =
        Module["asm"]["dynCall_iiifff"]).apply(null, arguments);
    });
    var dynCall_fiff = (Module["dynCall_fiff"] = function () {
      return (dynCall_fiff = Module["dynCall_fiff"] =
        Module["asm"]["dynCall_fiff"]).apply(null, arguments);
    });
    var dynCall_ji = (Module["dynCall_ji"] = function () {
      return (dynCall_ji = Module["dynCall_ji"] =
        Module["asm"]["dynCall_ji"]).apply(null, arguments);
    });
    var dynCall_vij = (Module["dynCall_vij"] = function () {
      return (dynCall_vij = Module["dynCall_vij"] =
        Module["asm"]["dynCall_vij"]).apply(null, arguments);
    });
    var dynCall_fiif = (Module["dynCall_fiif"] = function () {
      return (dynCall_fiif = Module["dynCall_fiif"] =
        Module["asm"]["dynCall_fiif"]).apply(null, arguments);
    });
    var dynCall_viijii = (Module["dynCall_viijii"] = function () {
      return (dynCall_viijii = Module["dynCall_viijii"] =
        Module["asm"]["dynCall_viijii"]).apply(null, arguments);
    });
    var dynCall_v = (Module["dynCall_v"] = function () {
      return (dynCall_v = Module["dynCall_v"] =
        Module["asm"]["dynCall_v"]).apply(null, arguments);
    });
    var dynCall_iiiiii = (Module["dynCall_iiiiii"] = function () {
      return (dynCall_iiiiii = Module["dynCall_iiiiii"] =
        Module["asm"]["dynCall_iiiiii"]).apply(null, arguments);
    });
    var dynCall_iiiiiiiii = (Module["dynCall_iiiiiiiii"] = function () {
      return (dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] =
        Module["asm"]["dynCall_iiiiiiiii"]).apply(null, arguments);
    });
    var dynCall_jiji = (Module["dynCall_jiji"] = function () {
      return (dynCall_jiji = Module["dynCall_jiji"] =
        Module["asm"]["dynCall_jiji"]).apply(null, arguments);
    });
    var dynCall_iidiiii = (Module["dynCall_iidiiii"] = function () {
      return (dynCall_iidiiii = Module["dynCall_iidiiii"] =
        Module["asm"]["dynCall_iidiiii"]).apply(null, arguments);
    });
    var dynCall_iiiiij = (Module["dynCall_iiiiij"] = function () {
      return (dynCall_iiiiij = Module["dynCall_iiiiij"] =
        Module["asm"]["dynCall_iiiiij"]).apply(null, arguments);
    });
    var dynCall_iiiiid = (Module["dynCall_iiiiid"] = function () {
      return (dynCall_iiiiid = Module["dynCall_iiiiid"] =
        Module["asm"]["dynCall_iiiiid"]).apply(null, arguments);
    });
    var dynCall_iiiiijj = (Module["dynCall_iiiiijj"] = function () {
      return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] =
        Module["asm"]["dynCall_iiiiijj"]).apply(null, arguments);
    });
    var dynCall_iiiiiijj = (Module["dynCall_iiiiiijj"] = function () {
      return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] =
        Module["asm"]["dynCall_iiiiiijj"]).apply(null, arguments);
    });
    var dynCall_vffff = (Module["dynCall_vffff"] = function () {
      return (dynCall_vffff = Module["dynCall_vffff"] =
        Module["asm"]["dynCall_vffff"]).apply(null, arguments);
    });
    var dynCall_vf = (Module["dynCall_vf"] = function () {
      return (dynCall_vf = Module["dynCall_vf"] =
        Module["asm"]["dynCall_vf"]).apply(null, arguments);
    });
    var dynCall_viiiiiiii = (Module["dynCall_viiiiiiii"] = function () {
      return (dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] =
        Module["asm"]["dynCall_viiiiiiii"]).apply(null, arguments);
    });
    var dynCall_viiiiiiiii = (Module["dynCall_viiiiiiiii"] = function () {
      return (dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] =
        Module["asm"]["dynCall_viiiiiiiii"]).apply(null, arguments);
    });
    var dynCall_vff = (Module["dynCall_vff"] = function () {
      return (dynCall_vff = Module["dynCall_vff"] =
        Module["asm"]["dynCall_vff"]).apply(null, arguments);
    });
    var dynCall_viiiiiii = (Module["dynCall_viiiiiii"] = function () {
      return (dynCall_viiiiiii = Module["dynCall_viiiiiii"] =
        Module["asm"]["dynCall_viiiiiii"]).apply(null, arguments);
    });
    var dynCall_vfi = (Module["dynCall_vfi"] = function () {
      return (dynCall_vfi = Module["dynCall_vfi"] =
        Module["asm"]["dynCall_vfi"]).apply(null, arguments);
    });
    var dynCall_viff = (Module["dynCall_viff"] = function () {
      return (dynCall_viff = Module["dynCall_viff"] =
        Module["asm"]["dynCall_viff"]).apply(null, arguments);
    });
    var dynCall_vifff = (Module["dynCall_vifff"] = function () {
      return (dynCall_vifff = Module["dynCall_vifff"] =
        Module["asm"]["dynCall_vifff"]).apply(null, arguments);
    });
    var dynCall_viffff = (Module["dynCall_viffff"] = function () {
      return (dynCall_viffff = Module["dynCall_viffff"] =
        Module["asm"]["dynCall_viffff"]).apply(null, arguments);
    });
    Module["asm"] = asm;
    Module["cwrap"] = cwrap;
    Module["UTF8ToString"] = UTF8ToString;
    var calledRun;
    Module["then"] = function (func) {
      if (calledRun) {
        func(Module);
      } else {
        var old = Module["onRuntimeInitialized"];
        Module["onRuntimeInitialized"] = function () {
          if (old) old();
          func(Module);
        };
      }
      return Module;
    };
    function ExitStatus(status) {
      this.name = "ExitStatus";
      this.message = "Program terminated with exit(" + status + ")";
      this.status = status;
    }
    dependenciesFulfilled = function runCaller() {
      if (!calledRun) run();
      if (!calledRun) dependenciesFulfilled = runCaller;
    };
    function run(args) {
      args = args || arguments_;
      if (runDependencies > 0) {
        return;
      }
      preRun();
      if (runDependencies > 0) return;
      function doRun() {
        if (calledRun) return;
        calledRun = true;
        Module["calledRun"] = true;
        if (ABORT) return;
        initRuntime();
        preMain();
        if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
        postRun();
      }
      if (Module["setStatus"]) {
        Module["setStatus"]("Running...");
        setTimeout(function () {
          setTimeout(function () {
            Module["setStatus"]("");
          }, 1);
          doRun();
        }, 1);
      } else {
        doRun();
      }
    }
    Module["run"] = run;
    if (Module["preInit"]) {
      if (typeof Module["preInit"] == "function")
        Module["preInit"] = [Module["preInit"]];
      while (Module["preInit"].length > 0) {
        Module["preInit"].pop()();
      }
    }
    noExitRuntime = true;
    run();
    Module["GL"] = GL;

    return effekseer_native;
  };
})();
if (typeof exports === "object" && typeof module === "object")
  module.exports = effekseer_native;
else if (typeof define === "function" && define["amd"])
  define([], function () {
    return effekseer_native;
  });
else if (typeof exports === "object")
  exports["effekseer_native"] = effekseer_native;
("use strict");
var _typeof =
  typeof Symbol === "function" && typeof Symbol.iterator === "symbol"
    ? function (obj) {
        return typeof obj;
      }
    : function (obj) {
        return obj &&
          typeof Symbol === "function" &&
          obj.constructor === Symbol &&
          obj !== Symbol.prototype
          ? "symbol"
          : typeof obj;
      };
var _createClass = (function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }
  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
})();
function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
var effekseer = (function () {
  var Module = {};
  var Core = {};
  var _imageCrossOrigin = "";
  var _onloadAssembly = function _onloadAssembly() {};
  var _onerrorAssembly = function _onerrorAssembly() {};
  var _is_runtime_initialized = false;
  var _onRuntimeInitialized = function _onRuntimeInitialized() {
    Core = {
      Init: Module.cwrap("EffekseerInit", "number", [
        "number",
        "number",
        "number",
      ]),
      Terminate: Module.cwrap("EffekseerTerminate", "void", ["number"]),
      Update: Module.cwrap("EffekseerUpdate", "void", ["number", "number"]),
      BeginUpdate: Module.cwrap("EffekseerBeginUpdate", "void", ["number"]),
      EndUpdate: Module.cwrap("EffekseerEndUpdate", "void", ["number"]),
      UpdateHandle: Module.cwrap("EffekseerUpdateHandle", "void", [
        "number",
        "number",
        "number",
      ]),
      Draw: Module.cwrap("EffekseerDraw", "void", ["number"]),
      BeginDraw: Module.cwrap("EffekseerBeginDraw", "void", ["number"]),
      EndDraw: Module.cwrap("EffekseerEndDraw", "void", ["number"]),
      DrawHandle: Module.cwrap("EffekseerDrawHandle", "void", [
        "number",
        "number",
      ]),
      SetProjectionMatrix: Module.cwrap(
        "EffekseerSetProjectionMatrix",
        "void",
        ["number", "number"]
      ),
      SetProjectionPerspective: Module.cwrap(
        "EffekseerSetProjectionPerspective",
        "void",
        ["number", "number", "number", "number", "number"]
      ),
      SetProjectionOrthographic: Module.cwrap(
        "EffekseerSetProjectionOrthographic",
        "void",
        ["number", "number", "number", "number", "number"]
      ),
      SetCameraMatrix: Module.cwrap("EffekseerSetCameraMatrix", "void", [
        "number",
        "number",
      ]),
      SetCameraLookAt: Module.cwrap("EffekseerSetCameraLookAt", "void", [
        "number",
        "number",
        "number",
        "number",
        "number",
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      LoadEffect: Module.cwrap("EffekseerLoadEffect", "number", [
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      ReleaseEffect: Module.cwrap("EffekseerReleaseEffect", "void", [
        "number",
        "number",
      ]),
      ReloadResources: Module.cwrap("EffekseerReloadResources", "void", [
        "number",
        "number",
      ]),
      StopAllEffects: Module.cwrap("EffekseerStopAllEffects", "void", [
        "number",
      ]),
      PlayEffect: Module.cwrap("EffekseerPlayEffect", "number", [
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      StopEffect: Module.cwrap("EffekseerStopEffect", "void", [
        "number",
        "number",
      ]),
      StopRoot: Module.cwrap("EffekseerStopRoot", "void", ["number", "number"]),
      Exists: Module.cwrap("EffekseerExists", "number", ["number", "number"]),
      SetFrame: Module.cwrap("EffekseerSetFrame", "void", [
        "number",
        "number",
        "number",
      ]),
      SetLocation: Module.cwrap("EffekseerSetLocation", "void", [
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      SetRotation: Module.cwrap("EffekseerSetRotation", "void", [
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      SetScale: Module.cwrap("EffekseerSetScale", "void", [
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      SetMatrix: Module.cwrap("EffekseerSetMatrix", "void", [
        "number",
        "number",
        "number",
      ]),
      SetAllColor: Module.cwrap("EffekseerSetAllColor", "void", [
        "number",
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      SetTargetLocation: Module.cwrap("EffekseerSetTargetLocation", "void", [
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      GetDynamicInput: Module.cwrap("EffekseerGetDynamicInput", "number", [
        "number",
        "number",
        "number",
      ]),
      SetDynamicInput: Module.cwrap("EffekseerSetDynamicInput", "void", [
        "number",
        "number",
        "number",
        "number",
      ]),
      SendTrigger: Module.cwrap("EffekseerSendTrigger", "void", [
        "number",
        "number",
        "number",
      ]),
      SetPaused: Module.cwrap("EffekseerSetPaused", "void", [
        "number",
        "number",
        "number",
      ]),
      SetShown: Module.cwrap("EffekseerSetShown", "void", [
        "number",
        "number",
        "number",
      ]),
      SetSpeed: Module.cwrap("EffekseerSetSpeed", "void", [
        "number",
        "number",
        "number",
      ]),
      SetRandomSeed: Module.cwrap("EffekseerSetRandomSeed", "void", [
        "number",
        "number",
        "number",
      ]),
      GetRestInstancesCount: Module.cwrap(
        "EffekseerGetRestInstancesCount",
        "number",
        ["number"]
      ),
      GetUpdateTime: Module.cwrap("EffekseerGetUpdateTime", "number", [
        "number",
      ]),
      GetDrawTime: Module.cwrap("EffekseerGetDrawTime", "number", ["number"]),
      IsVertexArrayObjectSupported: Module.cwrap(
        "EffekseerIsVertexArrayObjectSupported",
        "number",
        ["number"]
      ),
      SetRestorationOfStatesFlag: Module.cwrap(
        "EffekseerSetRestorationOfStatesFlag",
        "void",
        ["number", "number"]
      ),
      CaptureBackground: Module.cwrap("EffekseerCaptureBackground", "void", [
        "number",
        "number",
        "number",
        "number",
        "number",
      ]),
      ResetBackground: Module.cwrap("EffekseerResetBackground", "void", [
        "number",
      ]),
      SetLogEnabled: Module.cwrap("EffekseerSetLogEnabled", "void", ["number"]),
    };
    Module.resourcesMap = {};
    Module._isPowerOfTwo = function (img) {
      return _isImagePowerOfTwo(img);
    };
    Module._loadImage = function (path) {
      var effect = loadingEffect;
      effect.context._makeContextCurrent();
      {
        var _res = effect.resources.find(function (res) {
          return res.path == path;
        });
        if (_res) {
          return _res.isLoaded ? _res.image : null;
        }
      }
      var res = { path: path, isLoaded: false, image: null, isRequired: true };
      effect.resources.push(res);
      var path = effect.baseDir + path;
      if (effect.redirect) {
        path = effect.redirect(path);
      }
      {
        var arrayBuffer = Module.resourcesMap[path];
        if (arrayBuffer != null) {
          var arrayBufferView = new Uint8Array(arrayBuffer);
          Promise.resolve(new Blob([arrayBufferView], { type: "image/png" }))
            .then(function (blob) {
              return Promise.resolve(URL.createObjectURL(blob));
            })
            .then(function (url) {
              var img = new Image();
              img.onload = function () {
                res.image = img;
                res.isLoaded = true;
                effect._update();
              };
              img.src = url;
            });
        } else {
          _loadResource(
            path,
            function (image) {
              res.image = image;
              res.isLoaded = true;
              effect._update();
            },
            effect.onerror
          );
        }
      }
      return null;
    };
    Module._loadBinary = function (path, isRequired) {
      var effect = loadingEffect;
      effect.context._makeContextCurrent();
      var res = effect.resources.find(function (res) {
        return res.path == path;
      });
      if (res) {
        return res.isLoaded ? res.buffer : null;
      }
      var res = {
        path: path,
        isLoaded: false,
        buffer: null,
        isRequired: isRequired,
      };
      effect.resources.push(res);
      var path = effect.baseDir + path;
      if (effect.redirect) {
        path = effect.redirect(path);
      }
      var arrayBuffer = Module.resourcesMap[path];
      if (arrayBuffer != null) {
        res.buffer = arrayBuffer;
        res.isLoaded = true;
        effect._update();
      } else {
        _loadResource(
          path,
          function (buffer) {
            res.buffer = buffer;
            res.isLoaded = true;
            effect._update();
          },
          effect.onerror
        );
      }
      return null;
    };
    _is_runtime_initialized = true;
    _onloadAssembly();
  };
  var _initalize_wasm = function _initalize_wasm(url) {
    var xhr = new XMLHttpRequest();
    xhr.open("GET", url, true);
    xhr.responseType = "arraybuffer";
    xhr.onload = function () {
      var params = {};
      params.wasmBinary = xhr.response;
      effekseer_native(params).then(function (module) {
        Module = module;
        _onRuntimeInitialized();
      });
    };
    xhr.onerror = function () {
      _onerrorAssembly();
    };
    xhr.send(null);
  };
  if (typeof effekseer_native === "undefined") {
    moduleOrPromise = effekseer();
    if (moduleOrPromise instanceof Promise) {
      moduleOrPromise.then(function (module) {
        Module = module;
        _onRuntimeInitialized();
      });
    } else {
      Module = moduleOrPromise;
      _onRuntimeInitialized();
    }
  }
  var EffekseerEffect = (function () {
    function EffekseerEffect(context) {
      _classCallCheck(this, EffekseerEffect);
      this.context = context;
      this.nativeptr = 0;
      this.baseDir = "";
      this.isLoaded = false;
      this.scale = 1.0;
      this.resources = [];
      this.main_buffer = null;
    }
    _createClass(EffekseerEffect, [
      {
        key: "_load",
        value: function _load(buffer) {
          loadingEffect = this;
          this.main_buffer = buffer;
          var memptr = Module._malloc(buffer.byteLength);
          Module.HEAP8.set(new Uint8Array(buffer), memptr);
          this.nativeptr = Core.LoadEffect(
            this.context.nativeptr,
            memptr,
            buffer.byteLength,
            this.scale
          );
          Module._free(memptr);
          loadingEffect = null;
          this._update();
        },
      },
      {
        key: "_loadFromPackage",
        value: async function _loadFromPackage(buffer, Unzip) {
          var unzip = new Unzip(new Uint8Array(buffer));
          var meta_buffer = unzip.decompress("metafile.json");
          var textDecoder = new TextDecoder();
          var text = textDecoder.decode(meta_buffer);
          var json = JSON.parse(text);
          var efkFile = void 0;
          var dependencies = [];
          for (var key in json.files) {
            var val = json.files[key];
            if (val.type === "Effect") {
              efkFile = key;
              Array.prototype.push.apply(dependencies, val.dependencies);
            }
          }
          var _iteratorNormalCompletion = true;
          var _didIteratorError = false;
          var _iteratorError = undefined;
          try {
            for (
              var _iterator = dependencies[Symbol.iterator](), _step;
              !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
              _iteratorNormalCompletion = true
            ) {
              var dep = _step.value;
              var _buffer = unzip.decompress(dep);
              Module.resourcesMap[dep] = _buffer.buffer;
            }
          } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
              }
            } finally {
              if (_didIteratorError) {
                throw _iteratorError;
              }
            }
          }
          var efk_buffer = unzip.decompress(efkFile);
          this._load(efk_buffer.buffer);
        },
      },
      {
        key: "_reload",
        value: function _reload() {
          loadingEffect = this;
          var buffer = this.main_buffer;
          var memptr = Module._malloc(buffer.byteLength);
          Module.HEAP8.set(new Uint8Array(buffer), memptr);
          Core.ReloadResources(
            this.context.nativeptr,
            this.nativeptr,
            memptr,
            buffer.byteLength
          );
          Module._free(memptr);
          loadingEffect = null;
        },
      },
      {
        key: "_update",
        value: function _update() {
          var loaded = this.nativeptr != 0;
          if (this.resources.length > 0) {
            for (var i = 0; i < this.resources.length; i++) {
              if (!this.resources[i].isLoaded && this.resources[i].isRequired) {
                loaded = false;
                break;
              }
            }
            if (loaded) {
              this.context._makeContextCurrent();
              this.context.contextStates.save();
              this._reload();
              this.context.contextStates.restore();
            }
          }
          if (!this.isLoaded && loaded) {
            this.isLoaded = true;
            if (this.onload) this.onload();
          }
        },
      },
    ]);
    return EffekseerEffect;
  })();
  var EffekseerHandle = (function () {
    function EffekseerHandle(context, native) {
      _classCallCheck(this, EffekseerHandle);
      this.context = context;
      this.native = native;
    }
    _createClass(EffekseerHandle, [
      {
        key: "stop",
        value: function stop() {
          Core.StopEffect(this.context.nativeptr, this.native);
        },
      },
      {
        key: "stopRoot",
        value: function stopRoot() {
          Core.StopRoot(this.context.nativeptr, this.native);
        },
      },
      {
        key: "setFrame",
        value: function setFrame(frame) {
          Core.SetFrame(this.context.nativeptr, this.native, frame);
        },
      },
      {
        key: "setLocation",
        value: function setLocation(x, y, z) {
          Core.SetLocation(this.context.nativeptr, this.native, x, y, z);
        },
      },
      {
        key: "setRotation",
        value: function setRotation(x, y, z) {
          Core.SetRotation(this.context.nativeptr, this.native, x, y, z);
        },
      },
      {
        key: "setScale",
        value: function setScale(x, y, z) {
          Core.SetScale(this.context.nativeptr, this.native, x, y, z);
        },
      },
      {
        key: "setMatrix",
        value: function setMatrix(matrixArray) {
          var stack = Module.stackSave();
          var arrmem = Module.stackAlloc(4 * 16);
          Module.HEAPF32.set(matrixArray, arrmem >> 2);
          Core.SetMatrix(this.context.nativeptr, this.native, arrmem);
          Module.stackRestore(stack);
        },
      },
      {
        key: "setAllColor",
        value: function setAllColor(r, g, b, a) {
          Core.SetAllColor(this.context.nativeptr, this.native, r, g, b, a);
        },
      },
      {
        key: "setTargetLocation",
        value: function setTargetLocation(x, y, z) {
          Core.SetTargetLocation(this.context.nativeptr, this.native, x, y, z);
        },
      },
      {
        key: "getDynamicInput",
        value: function getDynamicInput(index) {
          return Core.GetDynamicInput(
            this.context.nativeptr,
            this.native,
            index
          );
        },
      },
      {
        key: "setDynamicInput",
        value: function setDynamicInput(index, value) {
          Core.SetDynamicInput(
            this.context.nativeptr,
            this.native,
            index,
            value
          );
        },
      },
      {
        key: "sendTrigger",
        value: function sendTrigger(index) {
          Core.SendTrigger(this.context.nativeptr, this.native, index);
        },
      },
      {
        key: "setPaused",
        value: function setPaused(paused) {
          Core.SetPaused(this.context.nativeptr, this.native, paused);
        },
      },
      {
        key: "setShown",
        value: function setShown(shown) {
          Core.SetShown(this.context.nativeptr, this.native, shown);
        },
      },
      {
        key: "setSpeed",
        value: function setSpeed(speed) {
          Core.SetSpeed(this.context.nativeptr, this.native, speed);
        },
      },
      {
        key: "setRandomSeed",
        value: function setRandomSeed(seed) {
          Core.SetRandomSeed(this.context.nativeptr, this.native, seed);
        },
      },
      {
        key: "exists",
        get: function get() {
          return !!Core.Exists(this.context.nativeptr, this.native);
        },
      },
    ]);
    return EffekseerHandle;
  })();
  var _isImagePowerOfTwo = function _isImagePowerOfTwo(image) {
    return (
      !(image.width & (image.width - 1)) && !(image.height & (image.height - 1))
    );
  };
  var calcNextPowerOfTwo = function calcNextPowerOfTwo(v) {
    var sizes = [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048];
    var foundInd = -1;
    for (var i = 0; i < sizes.length; i++) {
      if (sizes[i] >= v) {
        return sizes[i];
      }
    }
    for (var i = sizes.length - 1; i >= 0; i--) {
      if (sizes[i] <= v) {
        return sizes[i];
      }
    }
    return 1;
  };
  var _convertPowerOfTwoImage = function _convertPowerOfTwoImage(image) {
    if (!_isImagePowerOfTwo(image)) {
      var canvas = document.createElement("canvas");
      canvas.width = calcNextPowerOfTwo(image.width);
      canvas.height = calcNextPowerOfTwo(image.height);
      var context2d = canvas.getContext("2d");
      context2d.drawImage(
        image,
        0,
        0,
        image.width,
        image.height,
        0,
        0,
        canvas.width,
        canvas.height
      );
      image = canvas;
    }
    return image;
  };
  var _loadBinFile = function _loadBinFile(url, onload, onerror) {
    var xhr = new XMLHttpRequest();
    xhr.open("GET", url, true);
    xhr.responseType = "arraybuffer";
    xhr.onload = function () {
      onload(xhr.response);
    };
    xhr.onerror = function () {
      if (!(typeof onerror === "undefined")) onerror("not found", url);
    };
    xhr.send(null);
  };
  var _loadResource = function _loadResource(path, onload, onerror) {
    splitted_path = path.split("?");
    var ext_path = path;
    if (splitted_path.length >= 2) {
      ext_path = splitted_path[0];
    }
    var extindex = ext_path.lastIndexOf(".");
    var ext = extindex >= 0 ? ext_path.slice(extindex) : "";
    if (ext == ".png" || ext == ".jpg") {
      var image = new Image();
      image.onload = function () {
        var converted_image = _convertPowerOfTwoImage(image);
        onload(converted_image);
      };
      image.onerror = function () {
        if (!(typeof onerror === "undefined")) onerror("not found", path);
      };
      image.crossOrigin = _imageCrossOrigin;
      image.src = path;
    } else if (ext == ".tga") {
      if (!(typeof onerror === "undefined")) onerror("not supported", path);
    } else {
      _loadBinFile(
        path,
        function (buffer) {
          onload(buffer);
        },
        onerror
      );
    }
  };
  var loadingEffect = null;
  var ContextStates = (function () {
    function ContextStates(gl) {
      _classCallCheck(this, ContextStates);
      this.restore_texture_slot_max = 8;
      this._gl = gl;
      this.ext_vao = null;
      this.isWebGL2VAOEnabled = false;
      this.effekseer_vao = null;
      this.current_vao = null;
      this.current_vbo = null;
      this.current_ibo = null;
      this.current_textures = [];
      this.current_textures.length = this.restore_texture_slot_max;
      this.current_active_texture_id = null;
      this.ext_vao = this._gl.getExtension("OES_vertex_array_object");
      if (this.ext_vao != null) {
        this.effekseer_vao = this.ext_vao.createVertexArrayOES();
      } else if ("createVertexArray" in this._gl) {
        this.isWebGL2VAOEnabled = true;
        this.effekseer_vao = this._gl.createVertexArray();
      }
    }
    _createClass(ContextStates, [
      {
        key: "release",
        value: function release() {
          if (this.effekseer_vao) {
            if (this.ext_vao) {
              this.ext_vao.deleteVertexArrayOES(this.effekseer_vao);
            } else if (this.isWebGL2VAOEnabled) {
              this._gl.deleteVertexArray(this.effekseer_vao);
            }
            this.effekseer_vao = null;
          }
          this._gl = null;
        },
      },
      {
        key: "save",
        value: function save() {
          this.current_vbo = this._gl.getParameter(
            this._gl.ARRAY_BUFFER_BINDING
          );
          this.current_ibo = this._gl.getParameter(
            this._gl.ELEMENT_ARRAY_BUFFER_BINDING
          );
          if (this.ext_vao != null) {
            this.current_vao = this._gl.getParameter(
              this.ext_vao.VERTEX_ARRAY_BINDING_OES
            );
            this.ext_vao.bindVertexArrayOES(this.effekseer_vao);
          } else if (this.isWebGL2VAOEnabled) {
            this.current_vao = this._gl.getParameter(
              this._gl.VERTEX_ARRAY_BINDING
            );
            this._gl.bindVertexArray(this.effekseer_vao);
          }
          this.current_active_texture_id = this._gl.getParameter(
            this._gl.ACTIVE_TEXTURE
          );
          for (var i = 0; i < this.restore_texture_slot_max; i++) {
            this._gl.activeTexture(this._gl.TEXTURE0 + i);
            this.current_textures[i] = this._gl.getParameter(
              this._gl.TEXTURE_BINDING_2D
            );
          }
        },
      },
      {
        key: "restore",
        value: function restore() {
          for (var i = 0; i < this.restore_texture_slot_max; i++) {
            this._gl.activeTexture(this._gl.TEXTURE0 + i);
            this._gl.bindTexture(this._gl.TEXTURE_2D, this.current_textures[i]);
          }
          this._gl.activeTexture(this.current_active_texture_id);
          if (this.ext_vao != null) {
            this.ext_vao.bindVertexArrayOES(this.current_vao);
          } else if (this.isWebGL2VAOEnabled) {
            this._gl.bindVertexArray(this.current_vao);
          }
          this._gl.bindBuffer(this._gl.ARRAY_BUFFER, this.current_vbo);
          this._gl.bindBuffer(this._gl.ELEMENT_ARRAY_BUFFER, this.current_ibo);
        },
      },
      {
        key: "disableVAO",
        value: function disableVAO() {
          if (this.ext_vao != null) {
            this.ext_vao.bindVertexArrayOES(null);
          } else if (this.isWebGL2VAOEnabled) {
            this._gl.bindVertexArray(null);
          }
        },
      },
    ]);
    return ContextStates;
  })();
  var EffekseerContext = (function () {
    function EffekseerContext() {
      _classCallCheck(this, EffekseerContext);
    }
    _createClass(EffekseerContext, [
      {
        key: "_makeContextCurrent",
        value: function _makeContextCurrent() {
          Module.GL.makeContextCurrent(this.ctx);
        },
      },
      {
        key: "init",
        value: function init(webglContext, settings) {
          this._gl = webglContext;
          this.contextStates = new ContextStates(this._gl);
          var instanceMaxCount = 4000;
          var squareMaxCount = 10000;
          var enableExtensionsByDefault = true;
          if (settings) {
            if ("instanceMaxCount" in settings) {
              instanceMaxCount = settings.instanceMaxCount;
            }
            if ("squareMaxCount" in settings) {
              squareMaxCount = settings.squareMaxCount;
            }
            if ("enableExtensionsByDefault" in settings) {
              enableExtensionsByDefault = settings.enableExtensionsByDefault;
            }
          }
          window.gl = this._gl;
          this.ctx = Module.GL.registerContext(webglContext, {
            majorVersion: 1,
            minorVersion: 0,
            enableExtensionsByDefault: enableExtensionsByDefault,
          });
          this._makeContextCurrent();
          this._restorationOfStatesFlag = true;
          this.contextStates.save();
          this.nativeptr = Core.Init(
            instanceMaxCount,
            squareMaxCount,
            enableExtensionsByDefault
          );
          this.contextStates.restore();
        },
      },
      {
        key: "update",
        value: function update(deltaFrames) {
          if (!deltaFrames) deltaFrames = 1.0;
          Core.Update(this.nativeptr, deltaFrames);
        },
      },
      {
        key: "beginUpdate",
        value: function beginUpdate() {
          Core.BeginUpdate(this.nativeptr);
        },
      },
      {
        key: "endUpdate",
        value: function endUpdate() {
          Core.EndUpdate(this.nativeptr);
        },
      },
      {
        key: "updateHandle",
        value: function updateHandle(handle, deltaFrames) {
          Core.UpdateHandle(this.nativeptr, handle.native, deltaFrames);
        },
      },
      {
        key: "draw",
        value: function draw() {
          this._makeContextCurrent();
          var program = null;
          if (this._restorationOfStatesFlag) {
            program = this._gl.getParameter(this._gl.CURRENT_PROGRAM);
            this.contextStates.save();
          } else {
            this.contextStates.disableVAO();
          }
          Core.Draw(this.nativeptr);
          if (this._restorationOfStatesFlag) {
            this.contextStates.restore();
            this._gl.useProgram(program);
          }
        },
      },
      {
        key: "beginDraw",
        value: function beginDraw() {
          if (this._restorationOfStatesFlag) {
            this.contextStates.save();
          } else {
            this.contextStates.disableVAO();
          }
          Core.BeginDraw(this.nativeptr);
        },
      },
      {
        key: "endDraw",
        value: function endDraw() {
          Core.EndDraw(this.nativeptr);
          if (this._restorationOfStatesFlag) {
            this.contextStates.restore();
          }
        },
      },
      {
        key: "drawHandle",
        value: function drawHandle(handle) {
          Core.DrawHandle(this.nativeptr, handle.native);
        },
      },
      {
        key: "setProjectionMatrix",
        value: function setProjectionMatrix(matrixArray) {
          var stack = Module.stackSave();
          var arrmem = Module.stackAlloc(4 * 16);
          Module.HEAPF32.set(matrixArray, arrmem >> 2);
          Core.SetProjectionMatrix(this.nativeptr, arrmem);
          Module.stackRestore(stack);
        },
      },
      {
        key: "setProjectionPerspective",
        value: function setProjectionPerspective(fov, aspect, near, far) {
          Core.SetProjectionPerspective(this.nativeptr, fov, aspect, near, far);
        },
      },
      {
        key: "setProjectionOrthographic",
        value: function setProjectionOrthographic(width, height, near, far) {
          Core.SetProjectionOrthographic(
            this.nativeptr,
            width,
            height,
            near,
            far
          );
        },
      },
      {
        key: "setCameraMatrix",
        value: function setCameraMatrix(matrixArray) {
          var stack = Module.stackSave();
          var arrmem = Module.stackAlloc(4 * 16);
          Module.HEAPF32.set(matrixArray, arrmem >> 2);
          Core.SetCameraMatrix(this.nativeptr, arrmem);
          Module.stackRestore(stack);
        },
      },
      {
        key: "setCameraLookAt",
        value: function setCameraLookAt(
          positionX,
          positionY,
          positionZ,
          targetX,
          targetY,
          targetZ,
          upvecX,
          upvecY,
          upvecZ
        ) {
          Core.SetCameraLookAt(
            this.nativeptr,
            positionX,
            positionY,
            positionZ,
            targetX,
            targetY,
            targetZ,
            upvecX,
            upvecY,
            upvecZ
          );
        },
      },
      {
        key: "setCameraLookAtFromVector",
        value: function setCameraLookAtFromVector(position, target, upvec) {
          upvecVector =
            (typeof upvecVector === "undefined"
              ? "undefined"
              : _typeof(upvecVector)) === "object"
              ? upvecVector
              : { x: 0, y: 1, z: 0 };
          Core.SetCameraLookAt(
            this.nativeptr,
            position.x,
            position.y,
            position.z,
            target.x,
            target.y,
            target.z,
            upvec.x,
            upvec.y,
            upvec.z
          );
        },
      },
      {
        key: "loadEffect",
        value: function loadEffect(data) {
          var scale =
            arguments.length > 1 && arguments[1] !== undefined
              ? arguments[1]
              : 1.0;
          var onload = arguments[2];
          var onerror = arguments[3];
          var redirect = arguments[4];
          this._makeContextCurrent();
          var effect = new EffekseerEffect(this);
          if (typeof scale === "function") {
            console.log("Error : second arguments is number from version 1.5");
            effect.scale = 1.0;
            effect.onload = scale;
            effect.onerror = onload;
            effect.redirect = redirect;
          } else {
            effect.scale = scale;
            effect.onload = onload;
            effect.onerror = onerror;
            effect.redirect = redirect;
          }
          if (typeof data === "string") {
            var dirIndex = data.lastIndexOf("/");
            effect.baseDir = dirIndex >= 0 ? data.slice(0, dirIndex + 1) : "";
            _loadBinFile(
              data,
              function (buffer) {
                effect._load(buffer);
              },
              effect.onerror
            );
          } else if (data instanceof ArrayBuffer) {
            var buffer = data;
            effect._load(buffer);
          }
          return effect;
        },
      },
      {
        key: "loadEffectPackage",
        value: function loadEffectPackage(path, Unzip) {
          var scale =
            arguments.length > 2 && arguments[2] !== undefined
              ? arguments[2]
              : 1.0;
          var onload = arguments[3];
          var onerror = arguments[4];
          if (Unzip == null) this._makeContextCurrent();
          var effect = new EffekseerEffect(this);
          effect.scale = scale;
          effect.onload = onload;
          effect.onerror = onerror;
          if (typeof path === "string") {
            var dirIndex = path.lastIndexOf("/");
            effect.baseDir = dirIndex >= 0 ? path.slice(0, dirIndex + 1) : "";
            _loadBinFile(
              path,
              function (buffer) {
                effect._loadFromPackage(buffer, Unzip);
              },
              effect.onerror
            );
          } else if (path instanceof ArrayBuffer) {
            var buffer = path;
            effect._loadFromPackage(buffer, Unzip);
          }
          return effect;
        },
      },
      {
        key: "releaseEffect",
        value: function releaseEffect(effect) {
          this._makeContextCurrent();
          if (effect == null) {
            console.warn("the effect is null.");
            return;
          }
          if (!effect.isLoaded) {
            console.warn("the effect has not be loaded yet.");
            return;
          }
          if (effect.nativeptr == null) {
            console.warn("the effect has been released.");
            return;
          }
          Core.ReleaseEffect(this.nativeptr, effect.nativeptr);
          effect.nativeptr = null;
        },
      },
      {
        key: "play",
        value: function play(effect, x, y, z) {
          if (!effect || !effect.isLoaded) {
            return null;
          }
          if (x === undefined) x = 0;
          if (y === undefined) y = 0;
          if (z === undefined) z = 0;
          var handle = Core.PlayEffect(
            this.nativeptr,
            effect.nativeptr,
            x,
            y,
            z
          );
          return handle >= 0 ? new EffekseerHandle(this, handle) : null;
        },
      },
      {
        key: "stopAll",
        value: function stopAll() {
          Core.StopAllEffects(this.nativeptr);
        },
      },
      {
        key: "setResourceLoader",
        value: function setResourceLoader(loader) {
          _loadResource = loader;
        },
      },
      {
        key: "getRestInstancesCount",
        value: function getRestInstancesCount() {
          return Core.GetRestInstancesCount(this.nativeptr);
        },
      },
      {
        key: "getUpdateTime",
        value: function getUpdateTime() {
          return Core.GetUpdateTime(this.nativeptr);
        },
      },
      {
        key: "getDrawTime",
        value: function getDrawTime() {
          return Core.GetDrawTime(this.nativeptr);
        },
      },
      {
        key: "isVertexArrayObjectSupported",
        value: function isVertexArrayObjectSupported() {
          return Core.IsVertexArrayObjectSupported(this.nativeptr);
        },
      },
      {
        key: "setRestorationOfStatesFlag",
        value: function setRestorationOfStatesFlag(flag) {
          this._restorationOfStatesFlag = flag;
          Core.SetRestorationOfStatesFlag(this.nativeptr, flag);
        },
      },
      {
        key: "captureBackground",
        value: function captureBackground(x, y, width, height) {
          return Core.CaptureBackground(this.nativeptr, x, y, width, height);
        },
      },
      {
        key: "resetBackground",
        value: function resetBackground() {
          return Core.ResetBackground(this.nativeptr);
        },
      },
    ]);
    return EffekseerContext;
  })();
  var Effekseer = (function () {
    function Effekseer() {
      _classCallCheck(this, Effekseer);
    }
    _createClass(Effekseer, [
      {
        key: "initRuntime",
        value: function initRuntime(path, onload, onerror) {
          if (typeof effekseer_native === "undefined") {
            onload();
            return;
          }
          _onloadAssembly = onload;
          _onerrorAssembly = onerror;
          _initalize_wasm(path);
        },
      },
      {
        key: "createContext",
        value: function createContext() {
          if (!_is_runtime_initialized) {
            return null;
          }
          return new EffekseerContext();
        },
      },
      {
        key: "releaseContext",
        value: function releaseContext(context) {
          if (context.contextStates) {
            context.contextStates.release();
          }
          if (context._gl) {
            context._gl = null;
          }
          if (context.nativeptr == null) {
            return;
          }
          Core.Terminate(context.nativeptr);
          context.nativeptr = null;
        },
      },
      {
        key: "setLogEnabled",
        value: function setLogEnabled(flag) {
          Core.SetLogEnabled(flag);
        },
      },
      {
        key: "setImageCrossOrigin",
        value: function setImageCrossOrigin(crossOrigin) {
          _imageCrossOrigin = crossOrigin;
        },
      },
      {
        key: "init",
        value: function init(webglContext, settings) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext = new EffekseerContext();
          this.defaultContext.init(webglContext, settings);
        },
      },
      {
        key: "update",
        value: function update(deltaFrames) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.update(deltaFrames);
        },
      },
      {
        key: "beginUpdate",
        value: function beginUpdate() {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.beginUpdate();
        },
      },
      {
        key: "endUpdate",
        value: function endUpdate() {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.endUpdate();
        },
      },
      {
        key: "updateHandle",
        value: function updateHandle(handle, deltaFrames) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.updateHandle(handle, deltaFrames);
        },
      },
      {
        key: "draw",
        value: function draw() {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.draw();
        },
      },
      {
        key: "beginDraw",
        value: function beginDraw() {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.beginDraw();
        },
      },
      {
        key: "endDraw",
        value: function endDraw() {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.endDraw();
        },
      },
      {
        key: "drawHandle",
        value: function drawHandle(handle) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.drawHandle(handle);
        },
      },
      {
        key: "setProjectionMatrix",
        value: function setProjectionMatrix(matrixArray) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.setProjectionMatrix(matrixArray);
        },
      },
      {
        key: "setProjectionPerspective",
        value: function setProjectionPerspective(fov, aspect, near, far) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.SetProjectionPerspective(fov, aspect, near, far);
        },
      },
      {
        key: "setProjectionOrthographic",
        value: function setProjectionOrthographic(width, height, near, far) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.setProjectionOrthographic(
            width,
            height,
            near,
            far
          );
        },
      },
      {
        key: "setCameraMatrix",
        value: function setCameraMatrix(matrixArray) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.setCameraMatrix(matrixArray);
        },
      },
      {
        key: "setCameraLookAt",
        value: function setCameraLookAt(
          positionX,
          positionY,
          positionZ,
          targetX,
          targetY,
          targetZ,
          upvecX,
          upvecY,
          upvecZ
        ) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.setCameraLookAt(
            positionX,
            positionY,
            positionZ,
            targetX,
            targetY,
            targetZ,
            upvecX,
            upvecY,
            upvecZ
          );
        },
      },
      {
        key: "setCameraLookAtFromVector",
        value: function setCameraLookAtFromVector(position, target, upvec) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.setCameraLookAtFromVector(
            position,
            target,
            upvec
          );
        },
      },
      {
        key: "loadEffect",
        value: function loadEffect(path) {
          var scale =
            arguments.length > 1 && arguments[1] !== undefined
              ? arguments[1]
              : 1.0;
          var onload = arguments[2];
          var onerror = arguments[3];
          console.warn("deprecated : please use through createContext.");
          return this.defaultContext.loadEffect(path, scale, onload, onerror);
        },
      },
      {
        key: "releaseEffect",
        value: function releaseEffect(effect) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.releaseEffect(effect);
        },
      },
      {
        key: "play",
        value: function play(effect, x, y, z) {
          console.warn("deprecated : please use through createContext.");
          return this.defaultContext.play(effect, x, y, z);
        },
      },
      {
        key: "stopAll",
        value: function stopAll() {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.stopAll();
        },
      },
      {
        key: "setResourceLoader",
        value: function setResourceLoader(loader) {
          console.warn("deprecated : please use through createContext.");
          this.defaultContext.setResourceLoader(loader);
        },
      },
      {
        key: "isVertexArrayObjectSupported",
        value: function isVertexArrayObjectSupported() {
          console.warn("deprecated : please use through createContext.");
          return this.defaultContext.isVertexArrayObjectSupported();
        },
      },
    ]);
    return Effekseer;
  })();
  return new Effekseer();
})();
if (typeof exports !== "undefined") {
  exports = effekseer;
}