text: global_start = performance.now();
  
  
  // Support for growable heap + pthreads, where the buffer may change, so JS views
  // must be updated.
  function GROWABLE_HEAP_I8() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAP8;
  }
  function GROWABLE_HEAP_U8() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAPU8;
  }
  function GROWABLE_HEAP_I16() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAP16;
  }
  function GROWABLE_HEAP_U16() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAPU16;
  }
  function GROWABLE_HEAP_I32() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAP32;
  }
  function GROWABLE_HEAP_U32() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAPU32;
  }
  function GROWABLE_HEAP_F32() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAPF32;
  }
  function GROWABLE_HEAP_F64() {
    if (wasmMemory.buffer != buffer) {
      updateGlobalBufferAndViews(wasmMemory.buffer);
    }
    return HEAPF64;
  }
  
  var Module = typeof Module != "undefined" ? Module : {};
  
  var moduleOverrides = Object.assign({}, Module);
  
  var arguments_ = [];
  
  var thisProgram = "./this.program";
  
  var quit_ = (status, toThrow) => {
   throw toThrow;
  };
  
  var ENVIRONMENT_IS_WEB = typeof window == "object";
  
  var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
  
  var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
  
  var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
  
  if (Module["ENVIRONMENT"]) {
   throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)");
  }
  
  var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false;
  
  var _scriptDir = typeof document != "undefined" && document.currentScript ? document.currentScript.src : undefined;
  
  if (ENVIRONMENT_IS_WORKER) {
   _scriptDir = self.location.href;
  } else if (ENVIRONMENT_IS_NODE) {
   _scriptDir = __filename;
  }
  
  var scriptDirectory = "";
  
  function locateFile(path) {
   if (Module["locateFile"]) {
    return Module["locateFile"](path, scriptDirectory);
   }
   return scriptDirectory + path;
  }
  
  var read_, readAsync, readBinary, setWindowTitle;
  
  function logExceptionOnExit(e) {
   if (e instanceof ExitStatus) return;
   let toLog = e;
   if (e && typeof e == "object" && e.stack) {
    toLog = [ e, e.stack ];
   }
   err("exiting due to exception: " + toLog);
  }
  
  var fs;
  
  var nodePath;
  
  var requireNodeFS;
  
  if (ENVIRONMENT_IS_NODE) {
   if (!(typeof process == "object" && typeof require == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
   if (ENVIRONMENT_IS_WORKER) {
    scriptDirectory = require("path").dirname(scriptDirectory) + "/";
   } else {
    scriptDirectory = __dirname + "/";
   }
   requireNodeFS = (() => {
    if (!nodePath) {
     fs = require("fs");
     nodePath = require("path");
    }
   });
   read_ = function shell_read(filename, binary) {
    requireNodeFS();
    filename = nodePath["normalize"](filename);
    return fs.readFileSync(filename, binary ? undefined : "utf8");
   };
   readBinary = (filename => {
    var ret = read_(filename, true);
    if (!ret.buffer) {
     ret = new Uint8Array(ret);
    }
    assert(ret.buffer);
    return ret;
   });
   readAsync = ((filename, onload, onerror) => {
    requireNodeFS();
    filename = nodePath["normalize"](filename);
    fs.readFile(filename, function(err, data) {
     if (err) onerror(err); else onload(data.buffer);
    });
   });
   if (process["argv"].length > 1) {
    thisProgram = process["argv"][1].replace(/\\/g, "/");
   }
   arguments_ = process["argv"].slice(2);
   if (typeof module != "undefined") {
    module["exports"] = Module;
   }
   process["on"]("uncaughtException", function(ex) {
    if (!(ex instanceof ExitStatus)) {
     throw ex;
    }
   });
   process["on"]("unhandledRejection", function(reason) {
    throw reason;
   });
   quit_ = ((status, toThrow) => {
    if (keepRuntimeAlive()) {
     process["exitCode"] = status;
     throw toThrow;
    }
    logExceptionOnExit(toThrow);
    process["exit"](status);
   });
   Module["inspect"] = function() {
    return "[Emscripten Module object]";
   };
   let nodeWorkerThreads;
   try {
    nodeWorkerThreads = require("worker_threads");
   } catch (e) {
    console.error('The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?');
    throw e;
   }
   global.Worker = nodeWorkerThreads.Worker;
  } else if (ENVIRONMENT_IS_SHELL) {
   if (typeof process == "object" && typeof require === "function" || typeof window == "object" || typeof importScripts == "function") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
   if (typeof read != "undefined") {
    read_ = function shell_read(f) {
     return read(f);
    };
   }
   readBinary = function readBinary(f) {
    let data;
    if (typeof readbuffer == "function") {
     return new Uint8Array(readbuffer(f));
    }
    data = read(f, "binary");
    assert(typeof data == "object");
    return data;
   };
   readAsync = function readAsync(f, onload, onerror) {
    setTimeout(() => onload(readBinary(f)), 0);
   };
   if (typeof scriptArgs != "undefined") {
    arguments_ = scriptArgs;
   } else if (typeof arguments != "undefined") {
    arguments_ = arguments;
   }
   if (typeof quit == "function") {
    quit_ = ((status, toThrow) => {
     logExceptionOnExit(toThrow);
     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 (typeof document != "undefined" && document.currentScript) {
    scriptDirectory = document.currentScript.src;
   }
   if (scriptDirectory.indexOf("blob:") !== 0) {
    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
   } else {
    scriptDirectory = "";
   }
   if (!(typeof window == "object" || typeof importScripts == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
   if (!ENVIRONMENT_IS_NODE) {
    read_ = (url => {
     var xhr = new XMLHttpRequest();
     xhr.open("GET", url, false);
     xhr.send(null);
     return xhr.responseText;
    });
    if (ENVIRONMENT_IS_WORKER) {
     readBinary = (url => {
      var xhr = new XMLHttpRequest();
      xhr.open("GET", url, false);
      xhr.responseType = "arraybuffer";
      xhr.send(null);
      return new Uint8Array(xhr.response);
     });
    }
    readAsync = ((url, onload, onerror) => {
     var xhr = new XMLHttpRequest();
     xhr.open("GET", url, true);
     xhr.responseType = "arraybuffer";
     xhr.onload = (() => {
      if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
       onload(xhr.response);
       return;
      }
      onerror();
     });
     xhr.onerror = onerror;
     xhr.send(null);
    });
   }
   setWindowTitle = (title => document.title = title);
  } else {
   throw new Error("environment detection error");
  }
  
  if (ENVIRONMENT_IS_NODE) {
   if (typeof performance == "undefined") {
    global.performance = require("perf_hooks").performance;
   }
  }
  
  var defaultPrint = console.log.bind(console);
  
  var defaultPrintErr = console.warn.bind(console);
  
  if (ENVIRONMENT_IS_NODE) {
   requireNodeFS();
   defaultPrint = (str => fs.writeSync(1, str + "\n"));
   defaultPrintErr = (str => fs.writeSync(2, str + "\n"));
  }
  
  var out = Module["print"] || defaultPrint;
  
  var err = Module["printErr"] || defaultPrintErr;
  
  Object.assign(Module, moduleOverrides);
  
  moduleOverrides = null;
  
  if (Module["arguments"]) arguments_ = Module["arguments"];
  
  if (!Object.getOwnPropertyDescriptor(Module, "arguments")) {
   Object.defineProperty(Module, "arguments", {
    configurable: true,
    get: function() {
     abort("Module.arguments has been replaced with plain arguments_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
  
  if (!Object.getOwnPropertyDescriptor(Module, "thisProgram")) {
   Object.defineProperty(Module, "thisProgram", {
    configurable: true,
    get: function() {
     abort("Module.thisProgram has been replaced with plain thisProgram (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  if (Module["quit"]) quit_ = Module["quit"];
  
  if (!Object.getOwnPropertyDescriptor(Module, "quit")) {
   Object.defineProperty(Module, "quit", {
    configurable: true,
    get: function() {
     abort("Module.quit has been replaced with plain quit_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
  
  assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
  
  assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
  
  assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
  
  assert(typeof Module["read"] == "undefined", "Module.read option was removed (modify read_ in JS)");
  
  assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
  
  assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
  
  assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify setWindowTitle in JS)");
  
  assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
  
  if (!Object.getOwnPropertyDescriptor(Module, "read")) {
   Object.defineProperty(Module, "read", {
    configurable: true,
    get: function() {
     abort("Module.read has been replaced with plain read_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  if (!Object.getOwnPropertyDescriptor(Module, "readAsync")) {
   Object.defineProperty(Module, "readAsync", {
    configurable: true,
    get: function() {
     abort("Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  if (!Object.getOwnPropertyDescriptor(Module, "readBinary")) {
   Object.defineProperty(Module, "readBinary", {
    configurable: true,
    get: function() {
     abort("Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  if (!Object.getOwnPropertyDescriptor(Module, "setWindowTitle")) {
   Object.defineProperty(Module, "setWindowTitle", {
    configurable: true,
    get: function() {
     abort("Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";
  
  var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";
  
  var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
  
  var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";
  
  function alignMemory() {
   abort("`alignMemory` is now a library function and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line");
  }
  
  assert(ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_NODE, "Pthreads do not work in this environment yet (need Web Workers, or an alternative to them)");
  
  assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add 'shell' to `-s ENVIRONMENT` to enable.");
  
  var STACK_ALIGN = 16;
  
  var POINTER_SIZE = 4;
  
  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 POINTER_SIZE;
     } else if (type[0] === "i") {
      const 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 getEmptyTableSlot() {
   if (freeTableIndexes.length) {
    return freeTableIndexes.pop();
   }
   try {
    wasmTable.grow(1);
   } catch (err) {
    if (!(err instanceof RangeError)) {
     throw err;
    }
    throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
   }
   return wasmTable.length - 1;
  }
  
  function updateTableMap(offset, count) {
   for (var i = offset; i < offset + count; i++) {
    var item = getWasmTableEntry(i);
    if (item) {
     functionsInTableMap.set(item, i);
    }
   }
  }
  
  function addFunction(func, sig) {
   assert(typeof func != "undefined");
   if (!functionsInTableMap) {
    functionsInTableMap = new WeakMap();
    updateTableMap(0, wasmTable.length);
   }
   if (functionsInTableMap.has(func)) {
    return functionsInTableMap.get(func);
   }
   var ret = getEmptyTableSlot();
   try {
    setWasmTableEntry(ret, func);
   } catch (err) {
    if (!(err instanceof TypeError)) {
     throw err;
    }
    assert(typeof sig != "undefined", "Missing signature argument to addFunction: " + func);
    var wrapped = convertJsFunctionToWasm(func, sig);
    setWasmTableEntry(ret, wrapped);
   }
   functionsInTableMap.set(func, ret);
   return ret;
  }
  
  function removeFunction(index) {
   functionsInTableMap.delete(getWasmTableEntry(index));
   freeTableIndexes.push(index);
  }
  
  var tempRet0 = 0;
  
  var setTempRet0 = value => {
   tempRet0 = value;
  };
  
  var getTempRet0 = () => tempRet0;
  
  var Atomics_load = Atomics.load;
  
  var Atomics_store = Atomics.store;
  
  var Atomics_compareExchange = Atomics.compareExchange;
  
  var wasmBinary;
  
  if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
  
  if (!Object.getOwnPropertyDescriptor(Module, "wasmBinary")) {
   Object.defineProperty(Module, "wasmBinary", {
    configurable: true,
    get: function() {
     abort("Module.wasmBinary has been replaced with plain wasmBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  var noExitRuntime = Module["noExitRuntime"] || true;
  
  if (!Object.getOwnPropertyDescriptor(Module, "noExitRuntime")) {
   Object.defineProperty(Module, "noExitRuntime", {
    configurable: true,
    get: function() {
     abort("Module.noExitRuntime has been replaced with plain noExitRuntime (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  if (typeof WebAssembly != "object") {
   abort("no native wasm support detected");
  }
  
  function setValue(ptr, value, type = "i8", noSafe) {
   if (type.charAt(type.length - 1) === "*") type = "i32";
   switch (type) {
   case "i1":
    GROWABLE_HEAP_I8()[ptr >> 0] = value;
    break;
  
   case "i8":
    GROWABLE_HEAP_I8()[ptr >> 0] = value;
    break;
  
   case "i16":
    GROWABLE_HEAP_I16()[ptr >> 1] = value;
    break;
  
   case "i32":
    GROWABLE_HEAP_I32()[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) ], 
    GROWABLE_HEAP_I32()[ptr >> 2] = tempI64[0], GROWABLE_HEAP_I32()[ptr + 4 >> 2] = tempI64[1];
    break;
  
   case "float":
    GROWABLE_HEAP_F32()[ptr >> 2] = value;
    break;
  
   case "double":
    GROWABLE_HEAP_F64()[ptr >> 3] = value;
    break;
  
   default:
    abort("invalid type for setValue: " + type);
   }
  }
  
  function getValue(ptr, type = "i8", noSafe) {
   if (type.charAt(type.length - 1) === "*") type = "i32";
   switch (type) {
   case "i1":
    return GROWABLE_HEAP_I8()[ptr >> 0];
  
   case "i8":
    return GROWABLE_HEAP_I8()[ptr >> 0];
  
   case "i16":
    return GROWABLE_HEAP_I16()[ptr >> 1];
  
   case "i32":
    return GROWABLE_HEAP_I32()[ptr >> 2];
  
   case "i64":
    return GROWABLE_HEAP_I32()[ptr >> 2];
  
   case "float":
    return GROWABLE_HEAP_F32()[ptr >> 2];
  
   case "double":
    return Number(GROWABLE_HEAP_F64()[ptr >> 3]);
  
   default:
    abort("invalid type for getValue: " + type);
   }
   return null;
  }
  
  var wasmMemory;
  
  var wasmModule;
  
  var ABORT = false;
  
  var EXITSTATUS;
  
  function assert(condition, text) {
   if (!condition) {
    abort("Assertion failed" + (text ? ": " + 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;
   assert(returnType !== "array", 'Return type should not be "array".');
   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);
   function onDone(ret) {
    if (stack !== 0) stackRestore(stack);
    return convertReturnValue(ret);
   }
   ret = onDone(ret);
   return ret;
  }
  
  function cwrap(ident, returnType, argTypes, opts) {
   return function() {
    return ccall(ident, returnType, argTypes, arguments, opts);
   };
  }
  
  var ALLOC_NORMAL = 0;
  
  var ALLOC_STACK = 1;
  
  function allocate(slab, allocator) {
   var ret;
   assert(typeof allocator == "number", "allocate no longer takes a type argument");
   assert(typeof slab != "number", "allocate no longer takes a number as arg0");
   if (allocator == ALLOC_STACK) {
    ret = stackAlloc(slab.length);
   } else {
    ret = _malloc(slab.length);
   }
   if (!slab.subarray && !slab.slice) {
    slab = new Uint8Array(slab);
   }
   GROWABLE_HEAP_U8().set(slab, ret);
   return ret;
  }
  
  function TextDecoderWrapper(encoding) {
   var textDecoder = new TextDecoder(encoding);
   this.decode = (data => {
    assert(data instanceof Uint8Array);
    if (data.buffer instanceof SharedArrayBuffer) {
     data = new Uint8Array(data);
    }
    return textDecoder.decode.call(textDecoder, data);
   });
  }
  
  var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoderWrapper("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 {
      if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte 0x" + u0.toString(16) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
      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(GROWABLE_HEAP_U8(), 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;
     if (u > 1114111) warnOnce("Invalid Unicode code point 0x" + u.toString(16) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");
     heap[outIdx++] = 240 | u >> 18;
     heap[outIdx++] = 128 | u >> 12 & 63;
     heap[outIdx++] = 128 | u >> 6 & 63;
     heap[outIdx++] = 128 | u & 63;
    }
   }
   heap[outIdx] = 0;
   return outIdx - startIdx;
  }
  
  function stringToUTF8(str, outPtr, maxBytesToWrite) {
   assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
   return stringToUTF8Array(str, GROWABLE_HEAP_U8(), 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;
  }
  
  function AsciiToString(ptr) {
   var str = "";
   while (1) {
    var ch = GROWABLE_HEAP_U8()[ptr++ >> 0];
    if (!ch) return str;
    str += String.fromCharCode(ch);
   }
  }
  
  function stringToAscii(str, outPtr) {
   return writeAsciiToMemory(str, outPtr, false);
  }
  
  var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoderWrapper("utf-16le") : undefined;
  
  function UTF16ToString(ptr, maxBytesToRead) {
   assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!");
   var endPtr = ptr;
   var idx = endPtr >> 1;
   var maxIdx = idx + maxBytesToRead / 2;
   while (!(idx >= maxIdx) && GROWABLE_HEAP_U16()[idx]) ++idx;
   endPtr = idx << 1;
   if (endPtr - ptr > 32 && UTF16Decoder) {
    return UTF16Decoder.decode(GROWABLE_HEAP_U8().subarray(ptr, endPtr));
   } else {
    var str = "";
    for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
     var codeUnit = GROWABLE_HEAP_I16()[ptr + i * 2 >> 1];
     if (codeUnit == 0) break;
     str += String.fromCharCode(codeUnit);
    }
    return str;
   }
  }
  
  function stringToUTF16(str, outPtr, maxBytesToWrite) {
   assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!");
   assert(typeof maxBytesToWrite == "number", "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
   if (maxBytesToWrite === undefined) {
    maxBytesToWrite = 2147483647;
   }
   if (maxBytesToWrite < 2) return 0;
   maxBytesToWrite -= 2;
   var startPtr = outPtr;
   var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
   for (var i = 0; i < numCharsToWrite; ++i) {
    var codeUnit = str.charCodeAt(i);
    GROWABLE_HEAP_I16()[outPtr >> 1] = codeUnit;
    outPtr += 2;
   }
   GROWABLE_HEAP_I16()[outPtr >> 1] = 0;
   return outPtr - startPtr;
  }
  
  function lengthBytesUTF16(str) {
   return str.length * 2;
  }
  
  function UTF32ToString(ptr, maxBytesToRead) {
   assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!");
   var i = 0;
   var str = "";
   while (!(i >= maxBytesToRead / 4)) {
    var utf32 = GROWABLE_HEAP_I32()[ptr + i * 4 >> 2];
    if (utf32 == 0) break;
    ++i;
    if (utf32 >= 65536) {
     var ch = utf32 - 65536;
     str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
    } else {
     str += String.fromCharCode(utf32);
    }
   }
   return str;
  }
  
  function stringToUTF32(str, outPtr, maxBytesToWrite) {
   assert(outPtr % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!");
   assert(typeof maxBytesToWrite == "number", "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
   if (maxBytesToWrite === undefined) {
    maxBytesToWrite = 2147483647;
   }
   if (maxBytesToWrite < 4) return 0;
   var startPtr = outPtr;
   var endPtr = startPtr + maxBytesToWrite - 4;
   for (var i = 0; i < str.length; ++i) {
    var codeUnit = str.charCodeAt(i);
    if (codeUnit >= 55296 && codeUnit <= 57343) {
     var trailSurrogate = str.charCodeAt(++i);
     codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
    }
    GROWABLE_HEAP_I32()[outPtr >> 2] = codeUnit;
    outPtr += 4;
    if (outPtr + 4 > endPtr) break;
   }
   GROWABLE_HEAP_I32()[outPtr >> 2] = 0;
   return outPtr - startPtr;
  }
  
  function lengthBytesUTF32(str) {
   var len = 0;
   for (var i = 0; i < str.length; ++i) {
    var codeUnit = str.charCodeAt(i);
    if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
    len += 4;
   }
   return len;
  }
  
  function allocateUTF8(str) {
   var size = lengthBytesUTF8(str) + 1;
   var ret = _malloc(size);
   if (ret) stringToUTF8Array(str, GROWABLE_HEAP_I8(), ret, size);
   return ret;
  }
  
  function allocateUTF8OnStack(str) {
   var size = lengthBytesUTF8(str) + 1;
   var ret = stackAlloc(size);
   stringToUTF8Array(str, GROWABLE_HEAP_I8(), ret, size);
   return ret;
  }
  
  function writeStringToMemory(string, buffer, dontAddNull) {
   warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");
   var lastChar, end;
   if (dontAddNull) {
    end = buffer + lengthBytesUTF8(string);
    lastChar = GROWABLE_HEAP_I8()[end];
   }
   stringToUTF8(string, buffer, Infinity);
   if (dontAddNull) GROWABLE_HEAP_I8()[end] = lastChar;
  }
  
  function writeArrayToMemory(array, buffer) {
   assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
   GROWABLE_HEAP_I8().set(array, buffer);
  }
  
  function writeAsciiToMemory(str, buffer, dontAddNull) {
   for (var i = 0; i < str.length; ++i) {
    assert(str.charCodeAt(i) === (str.charCodeAt(i) & 255));
    GROWABLE_HEAP_I8()[buffer++ >> 0] = str.charCodeAt(i);
   }
   if (!dontAddNull) GROWABLE_HEAP_I8()[buffer >> 0] = 0;
  }
  
  function alignUp(x, multiple) {
   if (x % multiple > 0) {
    x += multiple - x % multiple;
   }
   return x;
  }
  
  var HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
  
  if (ENVIRONMENT_IS_PTHREAD) {
   buffer = Module["buffer"];
  }
  
  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 TOTAL_STACK = 5242880;
  
  if (Module["TOTAL_STACK"]) assert(TOTAL_STACK === Module["TOTAL_STACK"], "the stack size can no longer be determined at runtime");
  
  var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
  
  if (!Object.getOwnPropertyDescriptor(Module, "INITIAL_MEMORY")) {
   Object.defineProperty(Module, "INITIAL_MEMORY", {
    configurable: true,
    get: function() {
     abort("Module.INITIAL_MEMORY has been replaced with plain INITIAL_MEMORY (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
    }
   });
  }
  
  assert(INITIAL_MEMORY >= TOTAL_STACK, "INITIAL_MEMORY should be larger than TOTAL_STACK, was " + INITIAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
  
  assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support");
  
  if (ENVIRONMENT_IS_PTHREAD) {
   wasmMemory = Module["wasmMemory"];
   buffer = Module["buffer"];
  } else {
   if (Module["wasmMemory"]) {
    wasmMemory = Module["wasmMemory"];
   } else {
    wasmMemory = new WebAssembly.Memory({
     "initial": INITIAL_MEMORY / 65536,
     "maximum": 2147483648 / 65536,
     "shared": true
    });
    if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
     err("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag");
     if (ENVIRONMENT_IS_NODE) {
      console.log("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and also use a recent version)");
     }
     throw Error("bad memory");
    }
   }
  }
  
  if (wasmMemory) {
   buffer = wasmMemory.buffer;
  }
  
  INITIAL_MEMORY = buffer.byteLength;
  
  assert(INITIAL_MEMORY % 65536 === 0);
  
  updateGlobalBufferAndViews(buffer);
  
  var wasmTable;
  
  function writeStackCookie() {
   var max = _emscripten_stack_get_end();
   assert((max & 3) == 0);
   GROWABLE_HEAP_I32()[max + 4 >> 2] = 34821223;
   GROWABLE_HEAP_I32()[max + 8 >> 2] = 2310721022;
   GROWABLE_HEAP_I32()[0] = 1668509029;
  }
  
  function checkStackCookie() {
   if (ABORT) return;
   var max = _emscripten_stack_get_end();
   var cookie1 = GROWABLE_HEAP_U32()[max + 4 >> 2];
   var cookie2 = GROWABLE_HEAP_U32()[max + 8 >> 2];
   if (cookie1 != 34821223 || cookie2 != 2310721022) {
    abort("Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x" + cookie2.toString(16) + " 0x" + cookie1.toString(16));
   }
   if (GROWABLE_HEAP_I32()[0] !== 1668509029) abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
  }
  
  (function() {
   var h16 = new Int16Array(1);
   var h8 = new Int8Array(h16.buffer);
   h16[0] = 25459;
   if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -s SUPPORT_BIG_ENDIAN=1 to bypass)";
  })();
  
  var __ATPRERUN__ = [];
  
  var __ATINIT__ = [];
  
  var __ATMAIN__ = [];
  
  var __ATEXIT__ = [];
  
  var __ATPOSTRUN__ = [];
  
  var runtimeInitialized = false;
  
  var runtimeExited = false;
  
  var runtimeKeepaliveCounter = 0;
  
  function keepRuntimeAlive() {
   return noExitRuntime || runtimeKeepaliveCounter > 0;
  }
  
  function preRun() {
   assert(!ENVIRONMENT_IS_PTHREAD);
   if (Module["preRun"]) {
    if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
    while (Module["preRun"].length) {
     addOnPreRun(Module["preRun"].shift());
    }
   }
   callRuntimeCallbacks(__ATPRERUN__);
  }
  
  function initRuntime() {
   checkStackCookie();
   assert(!runtimeInitialized);
   runtimeInitialized = true;
   if (ENVIRONMENT_IS_PTHREAD) return;
   callRuntimeCallbacks(__ATINIT__);
  }
  
  function preMain() {
   checkStackCookie();
   if (ENVIRONMENT_IS_PTHREAD) return;
   callRuntimeCallbacks(__ATMAIN__);
  }
  
  function exitRuntime() {
   checkStackCookie();
   if (ENVIRONMENT_IS_PTHREAD) return;
   PThread.terminateAllThreads();
   runtimeExited = true;
  }
  
  function postRun() {
   checkStackCookie();
   if (ENVIRONMENT_IS_PTHREAD) return;
   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 addOnInit(cb) {
   __ATINIT__.unshift(cb);
  }
  
  function addOnPreMain(cb) {
   __ATMAIN__.unshift(cb);
  }
  
  function addOnExit(cb) {}
  
  function addOnPostRun(cb) {
   __ATPOSTRUN__.unshift(cb);
  }
  
  assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
  
  assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
  
  assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
  
  assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
  
  var runDependencies = 0;
  
  var runDependencyWatcher = null;
  
  var dependenciesFulfilled = null;
  
  var runDependencyTracking = {};
  
  function getUniqueRunDependency(id) {
   var orig = id;
   while (1) {
    if (!runDependencyTracking[id]) return id;
    id = orig + Math.random();
   }
  }
  
  function addRunDependency(id) {
   runDependencies++;
   if (Module["monitorRunDependencies"]) {
    Module["monitorRunDependencies"](runDependencies);
   }
   if (id) {
    assert(!runDependencyTracking[id]);
    runDependencyTracking[id] = 1;
    if (runDependencyWatcher === null && typeof setInterval != "undefined") {
     runDependencyWatcher = setInterval(function() {
      if (ABORT) {
       clearInterval(runDependencyWatcher);
       runDependencyWatcher = null;
       return;
      }
      var shown = false;
      for (var dep in runDependencyTracking) {
       if (!shown) {
        shown = true;
        err("still waiting on run dependencies:");
       }
       err("dependency: " + dep);
      }
      if (shown) {
       err("(end of list)");
      }
     }, 1e4);
    }
   } else {
    err("warning: run dependency added without ID");
   }
  }
  
  function removeRunDependency(id) {
   runDependencies--;
   if (Module["monitorRunDependencies"]) {
    Module["monitorRunDependencies"](runDependencies);
   }
   if (id) {
    assert(runDependencyTracking[id]);
    delete runDependencyTracking[id];
   } else {
    err("warning: run dependency removed without ID");
   }
   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 (ENVIRONMENT_IS_PTHREAD) {
    postMessage({
     "cmd": "onAbort",
     "arg": what
    });
   } else {
    if (Module["onAbort"]) {
     Module["onAbort"](what);
    }
   }
   what = "Aborted(" + what + ")";
   err(what);
   ABORT = true;
   EXITSTATUS = 1;
   var e = new WebAssembly.RuntimeError(what);
   throw e;
  }
  
  var FS = {
   error: function() {
    abort("Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with  -s FORCE_FILESYSTEM=1");
   },
   init: function() {
    FS.error();
   },
   createDataFile: function() {
    FS.error();
   },
   createPreloadedFile: function() {
    FS.error();
   },
   createLazyFile: function() {
    FS.error();
   },
   open: function() {
    FS.error();
   },
   mkdev: function() {
    FS.error();
   },
   registerDevice: function() {
    FS.error();
   },
   analyzePath: function() {
    FS.error();
   },
   loadFilesFromDB: function() {
    FS.error();
   },
   ErrnoError: function ErrnoError() {
    FS.error();
   }
  };
  
  Module["FS_createDataFile"] = FS.createDataFile;
  
  Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
  
  var dataURIPrefix = "data:application/octet-stream;base64,";
  
  function isDataURI(filename) {
   return filename.startsWith(dataURIPrefix);
  }
  
  function isFileURI(filename) {
   return filename.startsWith("file://");
  }
  
  function createExportWrapper(name, fixedasm) {
   return function() {
    var displayName = name;
    var asm = fixedasm;
    if (!fixedasm) {
     asm = Module["asm"];
    }
    assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization");
    assert(!runtimeExited, "native function `" + displayName + "` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)");
    if (!asm[name]) {
     assert(asm[name], "exported native function `" + displayName + "` not found");
    }
    return asm[name].apply(null, arguments);
   };
  }
  
  var wasmBinaryFile;
  
  wasmBinaryFile = "return_0.wasm";
  
  if (!isDataURI(wasmBinaryFile)) {
   wasmBinaryFile = locateFile(wasmBinaryFile);
  }
  
  function getBinary(file) {
   try {
    if (file == wasmBinaryFile && wasmBinary) {
     return new Uint8Array(wasmBinary);
    }
    if (readBinary) {
     return readBinary(file);
    } 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)) {
    if (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(wasmBinaryFile);
     });
    } else {
     if (readAsync) {
      return new Promise(function(resolve, reject) {
       readAsync(wasmBinaryFile, function(response) {
        resolve(new Uint8Array(response));
       }, reject);
      });
     }
    }
   }
   return Promise.resolve().then(function() {
    return getBinary(wasmBinaryFile);
   });
  }
  
  function createWasm() {
   var info = {
    "env": asmLibraryArg,
    "wasi_snapshot_preview1": asmLibraryArg
   };
   function receiveInstance(instance, module) {
    var exports = instance.exports;
    Module["asm"] = exports;
    registerTlsInit(Module["asm"]["emscripten_tls_init"]);
    wasmTable = Module["asm"]["__indirect_function_table"];
    assert(wasmTable, "table not found in wasm exports");
    addOnInit(Module["asm"]["__wasm_call_ctors"]);
    wasmModule = module;
    if (!ENVIRONMENT_IS_PTHREAD) {
     var numWorkersToLoad = PThread.unusedWorkers.length;
     PThread.unusedWorkers.forEach(function(w) {
      PThread.loadWasmModuleToWorker(w, function() {
       if (!--numWorkersToLoad) removeRunDependency("wasm-instantiate");
      });
     });
    }
   }
   if (!ENVIRONMENT_IS_PTHREAD) {
    addRunDependency("wasm-instantiate");
   }
   var trueModule = Module;
   function receiveInstantiationResult(result) {
    assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
    trueModule = null;
    receiveInstance(result["instance"], result["module"]);
   }
   function instantiateArrayBuffer(receiver) {
    return getBinaryPromise().then(function(binary) {
     return WebAssembly.instantiate(binary, info);
    }).then(function(instance) {
     return instance;
    }).then(receiver, function(reason) {
     err("failed to asynchronously prepare wasm: " + reason);
     if (isFileURI(wasmBinaryFile)) {
      err("warning: Loading from a file URI (" + wasmBinaryFile + ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing");
     }
     abort(reason);
    });
   }
   function instantiateAsync() {
    if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch == "function") {
     return fetch(wasmBinaryFile, {
      credentials: "same-origin"
     }).then(function(response) {
      var result = WebAssembly.instantiateStreaming(response, info);
      return result.then(receiveInstantiationResult, function(reason) {
       err("wasm streaming compile failed: " + reason);
       err("falling back to ArrayBuffer instantiation");
       return instantiateArrayBuffer(receiveInstantiationResult);
      });
     });
    } else {
     return instantiateArrayBuffer(receiveInstantiationResult);
    }
   }
   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 = {};
  
  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) {
      getWasmTableEntry(func)();
     } else {
      getWasmTableEntry(func)(callback.arg);
     }
    } else {
     func(callback.arg === undefined ? null : callback.arg);
    }
   }
  }
  
  function withStackSave(f) {
   var stack = stackSave();
   var ret = f();
   stackRestore(stack);
   return ret;
  }
  
  function demangle(func) {
   warnOnce("warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling");
   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 killThread(pthread_ptr) {
   assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! killThread() can only ever be called from main application thread!");
   assert(pthread_ptr, "Internal Error! Null pthread_ptr in killThread!");
   GROWABLE_HEAP_I32()[pthread_ptr >> 2] = 0;
   var pthread = PThread.pthreads[pthread_ptr];
   delete PThread.pthreads[pthread_ptr];
   pthread.worker.terminate();
   __emscripten_thread_free_data(pthread_ptr);
   PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(pthread.worker), 1);
   pthread.worker.pthread = undefined;
  }
  
  function cancelThread(pthread_ptr) {
   assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! cancelThread() can only ever be called from main application thread!");
   assert(pthread_ptr, "Internal Error! Null pthread_ptr in cancelThread!");
   var pthread = PThread.pthreads[pthread_ptr];
   pthread.worker.postMessage({
    "cmd": "cancel"
   });
  }
  
  function cleanupThread(pthread_ptr) {
   assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! cleanupThread() can only ever be called from main application thread!");
   assert(pthread_ptr, "Internal Error! Null pthread_ptr in cleanupThread!");
   var pthread = PThread.pthreads[pthread_ptr];
   if (pthread) {
    GROWABLE_HEAP_I32()[pthread_ptr >> 2] = 0;
    var worker = pthread.worker;
    PThread.returnWorkerToPool(worker);
   }
  }
  
  function zeroMemory(address, size) {
   GROWABLE_HEAP_U8().fill(0, address, address + size);
  }
  
  function ptrToString(ptr) {
   return "0x" + ptr.toString(16).padStart(8, "0");
  }
  
  function _exit(status) {
   exit(status);
  }
  
  function handleException(e) {
   if (e instanceof ExitStatus || e == "unwind") {
    return EXITSTATUS;
   }
   quit_(1, e);
  }
  
  var PThread = {
   unusedWorkers: [],
   runningWorkers: [],
   tlsInitFunctions: [],
   init: function() {
    if (ENVIRONMENT_IS_PTHREAD) {
     PThread.initWorker();
    } else {
     PThread.initMainThread();
    }
   },
   initMainThread: function() {
    var pthreadPoolSize = 13;
    for (var i = 0; i < pthreadPoolSize; ++i) {
     PThread.allocateUnusedWorker();
    }
   },
   initWorker: function() {
    noExitRuntime = false;
   },
   pthreads: {},
   setExitStatus: function(status) {
    EXITSTATUS = status;
   },
   terminateAllThreads: function() {
    assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! terminateAllThreads() can only ever be called from main application thread!");
    for (var t in PThread.pthreads) {
     var pthread = PThread.pthreads[t];
     if (pthread && pthread.worker) {
      PThread.returnWorkerToPool(pthread.worker);
     }
    }
    assert(Object.keys(PThread.pthreads).length === 0);
    assert(PThread.runningWorkers.length === 0);
    for (var i = 0; i < PThread.unusedWorkers.length; ++i) {
     var worker = PThread.unusedWorkers[i];
     assert(!worker.pthread);
     worker.terminate();
    }
    PThread.unusedWorkers = [];
   },
   returnWorkerToPool: function(worker) {
    PThread.runWithoutMainThreadQueuedCalls(function() {
     delete PThread.pthreads[worker.pthread.threadInfoStruct];
     PThread.unusedWorkers.push(worker);
     PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);
     __emscripten_thread_free_data(worker.pthread.threadInfoStruct);
     worker.pthread = undefined;
    });
   },
   runWithoutMainThreadQueuedCalls: function(func) {
    assert(PThread.mainRuntimeThread, "runWithoutMainThreadQueuedCalls must be done on the main runtime thread");
    assert(__emscripten_allow_main_runtime_queued_calls);
    GROWABLE_HEAP_I32()[__emscripten_allow_main_runtime_queued_calls >> 2] = 0;
    try {
     func();
    } finally {
     GROWABLE_HEAP_I32()[__emscripten_allow_main_runtime_queued_calls >> 2] = 1;
    }
   },
   receiveObjectTransfer: function(data) {},
   threadInit: function() {
    for (var i in PThread.tlsInitFunctions) {
     PThread.tlsInitFunctions[i]();
    }
   },
   loadWasmModuleToWorker: function(worker, onFinishedLoading) {
    worker.onmessage = (e => {
     var d = e["data"];
     var cmd = d["cmd"];
     if (worker.pthread) PThread.currentProxiedOperationCallerThread = worker.pthread.threadInfoStruct;
     if (d["targetThread"] && d["targetThread"] != _pthread_self()) {
      var thread = PThread.pthreads[d.targetThread];
      if (thread) {
       thread.worker.postMessage(d, d["transferList"]);
      } else {
       err('Internal error! Worker sent a message "' + cmd + '" to target pthread ' + d["targetThread"] + ", but that thread no longer exists!");
      }
      PThread.currentProxiedOperationCallerThread = undefined;
      return;
     }
     if (cmd === "processQueuedMainThreadWork") {
      _emscripten_main_thread_process_queued_calls();
     } else if (cmd === "spawnThread") {
      spawnThread(d);
     } else if (cmd === "cleanupThread") {
      cleanupThread(d["thread"]);
     } else if (cmd === "killThread") {
      killThread(d["thread"]);
     } else if (cmd === "cancelThread") {
      cancelThread(d["thread"]);
     } else if (cmd === "loaded") {
      worker.loaded = true;
      if (onFinishedLoading) onFinishedLoading(worker);
      if (worker.runPthread) {
       worker.runPthread();
       delete worker.runPthread;
      }
     } else if (cmd === "print") {
      out("Thread " + d["threadId"] + ": " + d["text"]);
     } else if (cmd === "printErr") {
      err("Thread " + d["threadId"] + ": " + d["text"]);
     } else if (cmd === "alert") {
      alert("Thread " + d["threadId"] + ": " + d["text"]);
     } else if (d.target === "setimmediate") {
      worker.postMessage(d);
     } else if (cmd === "onAbort") {
      if (Module["onAbort"]) {
       Module["onAbort"](d["arg"]);
      }
     } else {
      err("worker sent an unknown command " + cmd);
     }
     PThread.currentProxiedOperationCallerThread = undefined;
    });
    worker.onerror = (e => {
     var message = "worker sent an error!";
     if (worker.pthread) {
      var pthread_ptr = worker.pthread.threadInfoStruct;
      if (pthread_ptr) {
       message = "Pthread " + ptrToString(pthread_ptr) + " sent an error!";
      }
     }
     err(message + " " + e.filename + ":" + e.lineno + ": " + e.message);
     throw e;
    });
    if (ENVIRONMENT_IS_NODE) {
     worker.on("message", function(data) {
      worker.onmessage({
       data: data
      });
     });
     worker.on("error", function(e) {
      worker.onerror(e);
     });
     worker.on("detachedExit", function() {});
    }
    assert(wasmMemory instanceof WebAssembly.Memory, "WebAssembly memory should have been loaded by now!");
    assert(wasmModule instanceof WebAssembly.Module, "WebAssembly Module should have been loaded by now!");
    worker.postMessage({
     "cmd": "load",
     "urlOrBlob": Module["mainScriptUrlOrBlob"] || _scriptDir,
     "wasmMemory": wasmMemory,
     "wasmModule": wasmModule
    });
   },
   allocateUnusedWorker: function() {
    var pthreadMainJs = locateFile("return_0.worker.js");
    PThread.unusedWorkers.push(new Worker(pthreadMainJs));
   },
   getNewWorker: function() {
    if (PThread.unusedWorkers.length == 0) {
     err("Tried to spawn a new thread, but the thread pool is exhausted.\n" + "This might result in a deadlock unless some threads eventually exit or the code explicitly breaks out to the event loop.\n" + "If you want to increase the pool size, use setting `-s PTHREAD_POOL_SIZE=...`." + "\nIf you want to throw an explicit error instead of the risk of deadlocking in those cases, use setting `-s PTHREAD_POOL_SIZE_STRICT=2`.");
     PThread.allocateUnusedWorker();
     PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
    }
    return PThread.unusedWorkers.pop();
   }
  };
  
  function establishStackSpace() {
   var pthread_ptr = _pthread_self();
   var stackTop = GROWABLE_HEAP_I32()[pthread_ptr + 44 >> 2];
   var stackSize = GROWABLE_HEAP_I32()[pthread_ptr + 48 >> 2];
   var stackMax = stackTop - stackSize;
   assert(stackTop != 0);
   assert(stackMax != 0);
   assert(stackTop > stackMax);
   _emscripten_stack_set_limits(stackTop, stackMax);
   stackRestore(stackTop);
   writeStackCookie();
  }
  
  Module["establishStackSpace"] = establishStackSpace;
  
  function exitOnMainThread(returnCode) {
   if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(1, 0, returnCode);
   try {
    _exit(returnCode);
   } catch (e) {
    handleException(e);
   }
  }
  
  var wasmTableMirror = [];
  
  function getWasmTableEntry(funcPtr) {
   var func = wasmTableMirror[funcPtr];
   if (!func) {
    if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
    wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
   }
   assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!");
   return func;
  }
  
  function invokeEntryPoint(ptr, arg) {
   return getWasmTableEntry(ptr)(arg);
  }
  
  Module["invokeEntryPoint"] = invokeEntryPoint;
  
  function jsStackTrace() {
   var error = new Error();
   if (!error.stack) {
    try {
     throw new Error();
    } catch (e) {
     error = e;
    }
    if (!error.stack) {
     return "(no stack trace available)";
    }
   }
   return error.stack.toString();
  }
  
  function registerTlsInit(tlsInitFunc) {
   PThread.tlsInitFunctions.push(tlsInitFunc);
  }
  
  function setWasmTableEntry(idx, func) {
   wasmTable.set(idx, func);
   wasmTableMirror[idx] = func;
  }
  
  function stackTrace() {
   var js = jsStackTrace();
   if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
   return demangleAll(js);
  }
  
  function ___assert_fail(condition, filename, line, func) {
   abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
  }
  
  var _emscripten_get_now;
  
  if (ENVIRONMENT_IS_NODE) {
   _emscripten_get_now = (() => {
    var t = process["hrtime"]();
    return t[0] * 1e3 + t[1] / 1e6;
   });
  } else if (ENVIRONMENT_IS_PTHREAD) {
   _emscripten_get_now = (() => performance.now() - Module["__performance_now_clock_drift"]);
  } else _emscripten_get_now = (() => performance.now());
  
  var _emscripten_get_now_is_monotonic = true;
  
  function setErrNo(value) {
   GROWABLE_HEAP_I32()[___errno_location() >> 2] = value;
   return value;
  }
  
  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;
   }
   GROWABLE_HEAP_I32()[tp >> 2] = now / 1e3 | 0;
   GROWABLE_HEAP_I32()[tp + 4 >> 2] = now % 1e3 * 1e3 * 1e3 | 0;
   return 0;
  }
  
  function ___clock_gettime(a0, a1) {
   return _clock_gettime(a0, a1);
  }
  
  function ___emscripten_init_main_thread_js(tb) {
   __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1, !ENVIRONMENT_IS_WEB);
   PThread.mainRuntimeThread = true;
   PThread.threadInit();
  }
  
  function ___emscripten_thread_cleanup(thread) {
   if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread); else postMessage({
    "cmd": "cleanupThread",
    "thread": thread
   });
  }
  
  function spawnThread(threadParams) {
   assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! spawnThread() can only ever be called from main application thread!");
   assert(threadParams.pthread_ptr, "Internal error, no pthread ptr!");
   var worker = PThread.getNewWorker();
   if (!worker) {
    return 6;
   }
   assert(!worker.pthread, "Internal error!");
   PThread.runningWorkers.push(worker);
   var pthread = PThread.pthreads[threadParams.pthread_ptr] = {
    worker: worker,
    threadInfoStruct: threadParams.pthread_ptr
   };
   worker.pthread = pthread;
   var msg = {
    "cmd": "run",
    "start_routine": threadParams.startRoutine,
    "arg": threadParams.arg,
    "threadInfoStruct": threadParams.pthread_ptr
   };
   worker.runPthread = (() => {
    msg.time = performance.now();
    worker.postMessage(msg, threadParams.transferList);
   });
   if (worker.loaded) {
    worker.runPthread();
    delete worker.runPthread;
   }
   return 0;
  }
  
  function ___pthread_create_js(pthread_ptr, attr, start_routine, arg) {
   if (typeof SharedArrayBuffer == "undefined") {
    err("Current environment does not support SharedArrayBuffer, pthreads are not available!");
    return 6;
   }
   var transferList = [];
   var error = 0;
   if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
    return _emscripten_sync_run_in_main_thread_4(687865856, pthread_ptr, attr, start_routine, arg);
   }
   if (error) return error;
   var threadParams = {
    startRoutine: start_routine,
    pthread_ptr: pthread_ptr,
    arg: arg,
    transferList: transferList
   };
   if (ENVIRONMENT_IS_PTHREAD) {
    threadParams.cmd = "spawnThread";
    postMessage(threadParams, transferList);
    return 0;
   }
   return spawnThread(threadParams);
  }
  
  function __emscripten_notify_thread_queue(targetThreadId, mainThreadId) {
   if (targetThreadId == mainThreadId) {
    postMessage({
     "cmd": "processQueuedMainThreadWork"
    });
   } else if (ENVIRONMENT_IS_PTHREAD) {
    postMessage({
     "targetThread": targetThreadId,
     "cmd": "processThreadQueue"
    });
   } else {
    var pthread = PThread.pthreads[targetThreadId];
    var worker = pthread && pthread.worker;
    if (!worker) {
     err("Cannot send message to thread with ID " + targetThreadId + ", unknown thread ID!");
     return;
    }
    worker.postMessage({
     "cmd": "processThreadQueue"
    });
   }
   return 1;
  }
  
  function _emscripten_proxy_to_main_thread_js(index, sync) {
   var numCallArgs = arguments.length - 2;
   var outerArgs = arguments;
   if (numCallArgs > 20 - 1) throw "emscripten_proxy_to_main_thread_js: Too many arguments " + numCallArgs + " to proxied function idx=" + index + ", maximum supported is " + (20 - 1) + "!";
   return withStackSave(function() {
    var serializedNumCallArgs = numCallArgs;
    var args = stackAlloc(serializedNumCallArgs * 8);
    var b = args >> 3;
    for (var i = 0; i < numCallArgs; i++) {
     var arg = outerArgs[2 + i];
     GROWABLE_HEAP_F64()[b + i] = arg;
    }
    return _emscripten_run_in_main_runtime_thread_js(index, serializedNumCallArgs, args, sync);
   });
  }
  
  var _emscripten_receive_on_main_thread_js_callArgs = [];
  
  function _emscripten_receive_on_main_thread_js(index, numCallArgs, args) {
   _emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs;
   var b = args >> 3;
   for (var i = 0; i < numCallArgs; i++) {
    _emscripten_receive_on_main_thread_js_callArgs[i] = GROWABLE_HEAP_F64()[b + i];
   }
   var isEmAsmConst = index < 0;
   var func = !isEmAsmConst ? proxiedFunctionTable[index] : ASM_CONSTS[-index - 1];
   assert(func.length == numCallArgs, "Call args mismatch in emscripten_receive_on_main_thread_js");
   return func.apply(null, _emscripten_receive_on_main_thread_js_callArgs);
  }
  
  function _emscripten_get_heap_max() {
   return 2147483648;
  }
  
  function emscripten_realloc_buffer(size) {
   try {
    wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
    updateGlobalBufferAndViews(wasmMemory.buffer);
    return 1;
   } catch (e) {
    err("emscripten_realloc_buffer: Attempted to grow heap from " + buffer.byteLength + " bytes to " + size + " bytes, but got error: " + e);
   }
  }
  
  function _emscripten_resize_heap(requestedSize) {
   var oldSize = GROWABLE_HEAP_U8().length;
   requestedSize = requestedSize >>> 0;
   if (requestedSize <= oldSize) {
    return false;
   }
   var maxHeapSize = _emscripten_get_heap_max();
   if (requestedSize > maxHeapSize) {
    err("Cannot enlarge memory, asked to go up to " + requestedSize + " bytes, but the limit is " + maxHeapSize + " bytes!");
    return false;
   }
   for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
    var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
    overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
    var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
    var replacement = emscripten_realloc_buffer(newSize);
    if (replacement) {
     return true;
    }
   }
   err("Failed to grow the heap from " + oldSize + " bytes to " + newSize + " bytes, not enough memory!");
   return false;
  }
  
  var JSEvents = {
   inEventHandler: 0,
   removeAllEventListeners: function() {
    for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) {
     JSEvents._removeHandler(i);
    }
    JSEvents.eventHandlers = [];
    JSEvents.deferredCalls = [];
   },
   registerRemoveEventListeners: function() {
    if (!JSEvents.removeEventListenersRegistered) {
     __ATEXIT__.push(JSEvents.removeAllEventListeners);
     JSEvents.removeEventListenersRegistered = true;
    }
   },
   deferredCalls: [],
   deferCall: function(targetFunction, precedence, argsList) {
    function arraysHaveEqualContent(arrA, arrB) {
     if (arrA.length != arrB.length) return false;
     for (var i in arrA) {
      if (arrA[i] != arrB[i]) return false;
     }
     return true;
    }
    for (var i in JSEvents.deferredCalls) {
     var call = JSEvents.deferredCalls[i];
     if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
      return;
     }
    }
    JSEvents.deferredCalls.push({
     targetFunction: targetFunction,
     precedence: precedence,
     argsList: argsList
    });
    JSEvents.deferredCalls.sort(function(x, y) {
     return x.precedence < y.precedence;
    });
   },
   removeDeferredCalls: function(targetFunction) {
    for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
     if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
      JSEvents.deferredCalls.splice(i, 1);
      --i;
     }
    }
   },
   canPerformEventHandlerRequests: function() {
    return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
   },
   runDeferredCalls: function() {
    if (!JSEvents.canPerformEventHandlerRequests()) {
     return;
    }
    for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
     var call = JSEvents.deferredCalls[i];
     JSEvents.deferredCalls.splice(i, 1);
     --i;
     call.targetFunction.apply(null, call.argsList);
    }
   },
   eventHandlers: [],
   removeAllHandlersOnTarget: function(target, eventTypeString) {
    for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
     if (JSEvents.eventHandlers[i].target == target && (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
      JSEvents._removeHandler(i--);
     }
    }
   },
   _removeHandler: function(i) {
    var h = JSEvents.eventHandlers[i];
    h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
    JSEvents.eventHandlers.splice(i, 1);
   },
   registerOrRemoveHandler: function(eventHandler) {
    var jsEventHandler = function jsEventHandler(event) {
     ++JSEvents.inEventHandler;
     JSEvents.currentEventHandler = eventHandler;
     JSEvents.runDeferredCalls();
     eventHandler.handlerFunc(event);
     JSEvents.runDeferredCalls();
     --JSEvents.inEventHandler;
    };
    if (eventHandler.callbackfunc) {
     eventHandler.eventListenerFunc = jsEventHandler;
     eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
     JSEvents.eventHandlers.push(eventHandler);
     JSEvents.registerRemoveEventListeners();
    } else {
     for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
      if (JSEvents.eventHandlers[i].target == eventHandler.target && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
       JSEvents._removeHandler(i--);
      }
     }
    }
   },
   queueEventHandlerOnThread_iiii: function(targetThread, eventHandlerFunc, eventTypeId, eventData, userData) {
    withStackSave(function() {
     var varargs = stackAlloc(12);
     GROWABLE_HEAP_I32()[varargs >> 2] = eventTypeId;
     GROWABLE_HEAP_I32()[varargs + 4 >> 2] = eventData;
     GROWABLE_HEAP_I32()[varargs + 8 >> 2] = userData;
     _emscripten_dispatch_to_thread_(targetThread, 637534208, eventHandlerFunc, eventData, varargs);
    });
   },
   getTargetThreadForEventCallback: function(targetThread) {
    switch (targetThread) {
    case 1:
     return 0;
  
    case 2:
     return PThread.currentProxiedOperationCallerThread;
  
    default:
     return targetThread;
    }
   },
   getNodeNameForTarget: function(target) {
    if (!target) return "";
    if (target == window) return "#window";
    if (target == screen) return "#screen";
    return target && target.nodeName ? target.nodeName : "";
   },
   fullscreenEnabled: function() {
    return document.fullscreenEnabled || document.webkitFullscreenEnabled;
   }
  };
  
  function stringToNewUTF8(jsString) {
   var length = lengthBytesUTF8(jsString) + 1;
   var cString = _malloc(length);
   stringToUTF8(jsString, cString, length);
   return cString;
  }
  
  function _emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height) {
   withStackSave(function() {
    var varargs = stackAlloc(12);
    var targetCanvasPtr = 0;
    if (targetCanvas) {
     targetCanvasPtr = stringToNewUTF8(targetCanvas);
    }
    GROWABLE_HEAP_I32()[varargs >> 2] = targetCanvasPtr;
    GROWABLE_HEAP_I32()[varargs + 4 >> 2] = width;
    GROWABLE_HEAP_I32()[varargs + 8 >> 2] = height;
    _emscripten_dispatch_to_thread_(targetThread, 657457152, 0, targetCanvasPtr, varargs);
   });
  }
  
  function _emscripten_set_offscreencanvas_size_on_target_thread(targetThread, targetCanvas, width, height) {
   targetCanvas = targetCanvas ? UTF8ToString(targetCanvas) : "";
   _emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height);
  }
  
  function maybeCStringToJsString(cString) {
   return cString > 2 ? UTF8ToString(cString) : cString;
  }
  
  var specialHTMLTargets = [ 0, typeof document != "undefined" ? document : 0, typeof window != "undefined" ? window : 0 ];
  
  function findEventTarget(target) {
   target = maybeCStringToJsString(target);
   var domElement = specialHTMLTargets[target] || (typeof document != "undefined" ? document.querySelector(target) : undefined);
   return domElement;
  }
  
  function findCanvasEventTarget(target) {
   return findEventTarget(target);
  }
  
  function _emscripten_set_canvas_element_size_calling_thread(target, width, height) {
   var canvas = findCanvasEventTarget(target);
   if (!canvas) return -4;
   if (canvas.canvasSharedPtr) {
    GROWABLE_HEAP_I32()[canvas.canvasSharedPtr >> 2] = width;
    GROWABLE_HEAP_I32()[canvas.canvasSharedPtr + 4 >> 2] = height;
   }
   if (canvas.offscreenCanvas || !canvas.controlTransferredOffscreen) {
    if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas;
    var autoResizeViewport = false;
    if (canvas.GLctxObject && canvas.GLctxObject.GLctx) {
     var prevViewport = canvas.GLctxObject.GLctx.getParameter(2978);
     autoResizeViewport = prevViewport[0] === 0 && prevViewport[1] === 0 && prevViewport[2] === canvas.width && prevViewport[3] === canvas.height;
    }
    canvas.width = width;
    canvas.height = height;
    if (autoResizeViewport) {
     canvas.GLctxObject.GLctx.viewport(0, 0, width, height);
    }
   } else if (canvas.canvasSharedPtr) {
    var targetThread = GROWABLE_HEAP_I32()[canvas.canvasSharedPtr + 8 >> 2];
    _emscripten_set_offscreencanvas_size_on_target_thread(targetThread, target, width, height);
    return 1;
   } else {
    return -4;
   }
   return 0;
  }
  
  function _emscripten_set_canvas_element_size_main_thread(target, width, height) {
   if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(2, 1, target, width, height);
   return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
  }
  
  function _emscripten_set_canvas_element_size(target, width, height) {
   var canvas = findCanvasEventTarget(target);
   if (canvas) {
    return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
   } else {
    return _emscripten_set_canvas_element_size_main_thread(target, width, height);
   }
  }
  
  function _emscripten_unwind_to_js_event_loop() {
   throw "unwind";
  }
  
  function __webgl_enable_ANGLE_instanced_arrays(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);
    };
    return 1;
   }
  }
  
  function __webgl_enable_OES_vertex_array_object(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);
    };
    return 1;
   }
  }
  
  function __webgl_enable_WEBGL_draw_buffers(ctx) {
   var ext = ctx.getExtension("WEBGL_draw_buffers");
   if (ext) {
    ctx["drawBuffers"] = function(n, bufs) {
     ext["drawBuffersWEBGL"](n, bufs);
    };
    return 1;
   }
  }
  
  function __webgl_enable_WEBGL_multi_draw(ctx) {
   return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw"));
  }
  
  var GL = {
   counter: 1,
   buffers: [],
   programs: [],
   framebuffers: [],
   renderbuffers: [],
   textures: [],
   shaders: [],
   vaos: [],
   contexts: {},
   offscreenCanvases: {},
   queries: [],
   stringCache: {},
   unpackAlignment: 4,
   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;
   },
   getSource: function(shader, count, string, length) {
    var source = "";
    for (var i = 0; i < count; ++i) {
     var len = length ? GROWABLE_HEAP_I32()[length + i * 4 >> 2] : -1;
     source += UTF8ToString(GROWABLE_HEAP_I32()[string + i * 4 >> 2], len < 0 ? undefined : len);
    }
    return source;
   },
   createContext: function(canvas, webGLContextAttributes) {
    if (!canvas.getContextSafariWebGL2Fixed) {
     canvas.getContextSafariWebGL2Fixed = canvas.getContext;
     function fixedGetContext(ver, attrs) {
      var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
      return ver == "webgl" == gl instanceof WebGLRenderingContext ? gl : null;
     }
     canvas.getContext = fixedGetContext;
    }
    var ctx = canvas.getContext("webgl", webGLContextAttributes);
    if (!ctx) return 0;
    var handle = GL.registerContext(ctx, webGLContextAttributes);
    return handle;
   },
   registerContext: function(ctx, webGLContextAttributes) {
    var handle = _malloc(8);
    GROWABLE_HEAP_I32()[handle + 4 >> 2] = _pthread_self();
    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;
    _free(GL.contexts[contextHandle].handle);
    GL.contexts[contextHandle] = null;
   },
   initExtensions: function(context) {
    if (!context) context = GL.currentContext;
    if (context.initExtensionsDone) return;
    context.initExtensionsDone = true;
    var GLctx = context.GLctx;
    __webgl_enable_ANGLE_instanced_arrays(GLctx);
    __webgl_enable_OES_vertex_array_object(GLctx);
    __webgl_enable_WEBGL_draw_buffers(GLctx);
    {
     GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
    }
    __webgl_enable_WEBGL_multi_draw(GLctx);
    var exts = GLctx.getSupportedExtensions() || [];
    exts.forEach(function(ext) {
     if (!ext.includes("lose_context") && !ext.includes("debug")) {
      GLctx.getExtension(ext);
     }
    });
   }
  };
  
  var __emscripten_webgl_power_preferences = [ "default", "low-power", "high-performance" ];
  
  function _emscripten_webgl_do_create_context(target, attributes) {
   assert(attributes);
   var a = attributes >> 2;
   var powerPreference = GROWABLE_HEAP_I32()[a + (24 >> 2)];
   var contextAttributes = {
    "alpha": !!GROWABLE_HEAP_I32()[a + (0 >> 2)],
    "depth": !!GROWABLE_HEAP_I32()[a + (4 >> 2)],
    "stencil": !!GROWABLE_HEAP_I32()[a + (8 >> 2)],
    "antialias": !!GROWABLE_HEAP_I32()[a + (12 >> 2)],
    "premultipliedAlpha": !!GROWABLE_HEAP_I32()[a + (16 >> 2)],
    "preserveDrawingBuffer": !!GROWABLE_HEAP_I32()[a + (20 >> 2)],
    "powerPreference": __emscripten_webgl_power_preferences[powerPreference],
    "failIfMajorPerformanceCaveat": !!GROWABLE_HEAP_I32()[a + (28 >> 2)],
    majorVersion: GROWABLE_HEAP_I32()[a + (32 >> 2)],
    minorVersion: GROWABLE_HEAP_I32()[a + (36 >> 2)],
    enableExtensionsByDefault: GROWABLE_HEAP_I32()[a + (40 >> 2)],
    explicitSwapControl: GROWABLE_HEAP_I32()[a + (44 >> 2)],
    proxyContextToMainThread: GROWABLE_HEAP_I32()[a + (48 >> 2)],
    renderViaOffscreenBackBuffer: GROWABLE_HEAP_I32()[a + (52 >> 2)]
   };
   var canvas = findCanvasEventTarget(target);
   if (!canvas) {
    return 0;
   }
   if (contextAttributes.explicitSwapControl) {
    return 0;
   }
   var contextHandle = GL.createContext(canvas, contextAttributes);
   return contextHandle;
  }
  
  function _emscripten_webgl_create_context(a0, a1) {
   return _emscripten_webgl_do_create_context(a0, a1);
  }
  
  function flush_NO_FILESYSTEM() {
   ___stdio_exit();
   var buffers = SYSCALLS.buffers;
   if (buffers[1].length) SYSCALLS.printChar(1, 10);
   if (buffers[2].length) SYSCALLS.printChar(2, 10);
  }
  
  var SYSCALLS = {
   buffers: [ null, [], [] ],
   printChar: function(stream, curr) {
    var buffer = SYSCALLS.buffers[stream];
    assert(buffer);
    if (curr === 0 || curr === 10) {
     (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
     buffer.length = 0;
    } else {
     buffer.push(curr);
    }
   },
   varargs: undefined,
   get: function() {
    assert(SYSCALLS.varargs != undefined);
    SYSCALLS.varargs += 4;
    var ret = GROWABLE_HEAP_I32()[SYSCALLS.varargs - 4 >> 2];
    return ret;
   },
   getStr: function(ptr) {
    var ret = UTF8ToString(ptr);
    return ret;
   },
   get64: function(low, high) {
    if (low >= 0) assert(high === 0); else assert(high === -1);
    return low;
   }
  };
  
  function _fd_write(fd, iov, iovcnt, pnum) {
   if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(3, 1, fd, iov, iovcnt, pnum);
   var num = 0;
   for (var i = 0; i < iovcnt; i++) {
    var ptr = GROWABLE_HEAP_I32()[iov >> 2];
    var len = GROWABLE_HEAP_I32()[iov + 4 >> 2];
    iov += 8;
    for (var j = 0; j < len; j++) {
     SYSCALLS.printChar(fd, GROWABLE_HEAP_U8()[ptr + j]);
    }
    num += len;
   }
   GROWABLE_HEAP_I32()[pnum >> 2] = num;
   return 0;
  }
  
  function _setTempRet0(val) {
   setTempRet0(val);
  }
  
  PThread.init();
  
  var GLctx;
  
  var proxiedFunctionTable = [ null, exitOnMainThread, _emscripten_set_canvas_element_size_main_thread, _fd_write ];
  
  var ASSERTIONS = true;
  
  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;
  }
  
  function intArrayToString(array) {
   var ret = [];
   for (var i = 0; i < array.length; i++) {
    var chr = array[i];
    if (chr > 255) {
     if (ASSERTIONS) {
      assert(false, "Character code " + chr + " (" + String.fromCharCode(chr) + ")  at offset " + i + " not in 0x00-0xFF.");
     }
     chr &= 255;
    }
    ret.push(String.fromCharCode(chr));
   }
   return ret.join("");
  }
  
  var asmLibraryArg = {
   "__assert_fail": ___assert_fail,
   "__clock_gettime": ___clock_gettime,
   "__emscripten_init_main_thread_js": ___emscripten_init_main_thread_js,
   "__emscripten_thread_cleanup": ___emscripten_thread_cleanup,
   "__pthread_create_js": ___pthread_create_js,
   "_emscripten_notify_thread_queue": __emscripten_notify_thread_queue,
   "emscripten_get_now": _emscripten_get_now,
   "emscripten_receive_on_main_thread_js": _emscripten_receive_on_main_thread_js,
   "emscripten_resize_heap": _emscripten_resize_heap,
   "emscripten_set_canvas_element_size": _emscripten_set_canvas_element_size,
   "emscripten_unwind_to_js_event_loop": _emscripten_unwind_to_js_event_loop,
   "emscripten_webgl_create_context": _emscripten_webgl_create_context,
   "exit": _exit,
   "fd_write": _fd_write,
   "memory": wasmMemory,
   "setTempRet0": _setTempRet0
  };
  
  var asm = createWasm();
  
  var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors");
  
  var _main = Module["_main"] = createExportWrapper("main");
  
  var _emscripten_tls_init = Module["_emscripten_tls_init"] = createExportWrapper("emscripten_tls_init");
  
  var _emscripten_builtin_memalign = Module["_emscripten_builtin_memalign"] = createExportWrapper("emscripten_builtin_memalign");
  
  var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location");
  
  var ___stdio_exit = Module["___stdio_exit"] = createExportWrapper("__stdio_exit");
  
  var __emscripten_thread_crashed = Module["__emscripten_thread_crashed"] = createExportWrapper("_emscripten_thread_crashed");
  
  var __emscripten_thread_init = Module["__emscripten_thread_init"] = createExportWrapper("_emscripten_thread_init");
  
  var _emscripten_current_thread_process_queued_calls = Module["_emscripten_current_thread_process_queued_calls"] = createExportWrapper("emscripten_current_thread_process_queued_calls");
  
  var _emscripten_main_browser_thread_id = Module["_emscripten_main_browser_thread_id"] = createExportWrapper("emscripten_main_browser_thread_id");
  
  var _emscripten_sync_run_in_main_thread_2 = Module["_emscripten_sync_run_in_main_thread_2"] = createExportWrapper("emscripten_sync_run_in_main_thread_2");
  
  var _emscripten_sync_run_in_main_thread_4 = Module["_emscripten_sync_run_in_main_thread_4"] = createExportWrapper("emscripten_sync_run_in_main_thread_4");
  
  var _emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = createExportWrapper("emscripten_main_thread_process_queued_calls");
  
  var _emscripten_run_in_main_runtime_thread_js = Module["_emscripten_run_in_main_runtime_thread_js"] = createExportWrapper("emscripten_run_in_main_runtime_thread_js");
  
  var _emscripten_dispatch_to_thread_ = Module["_emscripten_dispatch_to_thread_"] = createExportWrapper("emscripten_dispatch_to_thread_");
  
  var __emscripten_thread_free_data = Module["__emscripten_thread_free_data"] = createExportWrapper("_emscripten_thread_free_data");
  
  var __emscripten_thread_exit = Module["__emscripten_thread_exit"] = createExportWrapper("_emscripten_thread_exit");
  
  var _pthread_self = Module["_pthread_self"] = createExportWrapper("pthread_self");
  
  var _malloc = Module["_malloc"] = createExportWrapper("malloc");
  
  var _free = Module["_free"] = createExportWrapper("free");
  
  var _emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = function() {
   return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments);
  };
  
  var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() {
   return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments);
  };
  
  var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() {
   return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments);
  };
  
  var _emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = function() {
   return (_emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = Module["asm"]["emscripten_stack_set_limits"]).apply(null, arguments);
  };
  
  var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() {
   return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments);
  };
  
  var stackSave = Module["stackSave"] = createExportWrapper("stackSave");
  
  var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore");
  
  var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc");
  
  var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji");
  
  var __emscripten_allow_main_runtime_queued_calls = Module["__emscripten_allow_main_runtime_queued_calls"] = 2136;
  
  if (!Object.getOwnPropertyDescriptor(Module, "intArrayFromString")) Module["intArrayFromString"] = (() => abort("'intArrayFromString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "intArrayToString")) Module["intArrayToString"] = (() => abort("'intArrayToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "ccall")) Module["ccall"] = (() => abort("'ccall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "cwrap")) Module["cwrap"] = (() => abort("'cwrap' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setValue")) Module["setValue"] = (() => abort("'setValue' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getValue")) Module["getValue"] = (() => abort("'getValue' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "allocate")) Module["allocate"] = (() => abort("'allocate' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString")) Module["UTF8ArrayToString"] = (() => abort("'UTF8ArrayToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString")) Module["UTF8ToString"] = (() => abort("'UTF8ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = (() => abort("'stringToUTF8Array' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8")) Module["stringToUTF8"] = (() => abort("'stringToUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8")) Module["lengthBytesUTF8"] = (() => abort("'lengthBytesUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = (() => abort("'stackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun")) Module["addOnPreRun"] = (() => abort("'addOnPreRun' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "addOnInit")) Module["addOnInit"] = (() => abort("'addOnInit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain")) Module["addOnPreMain"] = (() => abort("'addOnPreMain' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "addOnExit")) Module["addOnExit"] = (() => abort("'addOnExit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun")) Module["addOnPostRun"] = (() => abort("'addOnPostRun' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory")) Module["writeStringToMemory"] = (() => abort("'writeStringToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeArrayToMemory")) Module["writeArrayToMemory"] = (() => abort("'writeArrayToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory")) Module["writeAsciiToMemory"] = (() => abort("'writeAsciiToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "addRunDependency")) Module["addRunDependency"] = (() => abort("'addRunDependency' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "removeRunDependency")) Module["removeRunDependency"] = (() => abort("'removeRunDependency' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_createFolder")) Module["FS_createFolder"] = (() => abort("'FS_createFolder' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_createPath")) Module["FS_createPath"] = (() => abort("'FS_createPath' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_createDataFile")) Module["FS_createDataFile"] = (() => abort("'FS_createDataFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_createPreloadedFile")) Module["FS_createPreloadedFile"] = (() => abort("'FS_createPreloadedFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_createLazyFile")) Module["FS_createLazyFile"] = (() => abort("'FS_createLazyFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_createLink")) Module["FS_createLink"] = (() => abort("'FS_createLink' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_createDevice")) Module["FS_createDevice"] = (() => abort("'FS_createDevice' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS_unlink")) Module["FS_unlink"] = (() => abort("'FS_unlink' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getLEB")) Module["getLEB"] = (() => abort("'getLEB' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables")) Module["getFunctionTables"] = (() => abort("'getFunctionTables' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables")) Module["alignFunctionTables"] = (() => abort("'alignFunctionTables' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions")) Module["registerFunctions"] = (() => abort("'registerFunctions' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "addFunction")) Module["addFunction"] = (() => abort("'addFunction' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "removeFunction")) Module["removeFunction"] = (() => abort("'removeFunction' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = (() => abort("'getFuncWrapper' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint")) Module["prettyPrint"] = (() => abort("'prettyPrint' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = (() => abort("'dynCall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting")) Module["getCompilerSetting"] = (() => abort("'getCompilerSetting' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "print")) Module["print"] = (() => abort("'print' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "printErr")) Module["printErr"] = (() => abort("'printErr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0")) Module["getTempRet0"] = (() => abort("'getTempRet0' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0")) Module["setTempRet0"] = (() => abort("'setTempRet0' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "callMain")) Module["callMain"] = (() => abort("'callMain' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "abort")) Module["abort"] = (() => abort("'abort' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  Module["keepRuntimeAlive"] = keepRuntimeAlive;
  
  if (!Object.getOwnPropertyDescriptor(Module, "zeroMemory")) Module["zeroMemory"] = (() => abort("'zeroMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stringToNewUTF8")) Module["stringToNewUTF8"] = (() => abort("'stringToNewUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "emscripten_realloc_buffer")) Module["emscripten_realloc_buffer"] = (() => abort("'emscripten_realloc_buffer' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "ENV")) Module["ENV"] = (() => abort("'ENV' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "withStackSave")) Module["withStackSave"] = (() => abort("'withStackSave' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_CODES")) Module["ERRNO_CODES"] = (() => abort("'ERRNO_CODES' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_MESSAGES")) Module["ERRNO_MESSAGES"] = (() => abort("'ERRNO_MESSAGES' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setErrNo")) Module["setErrNo"] = (() => abort("'setErrNo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "inetPton4")) Module["inetPton4"] = (() => abort("'inetPton4' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "inetNtop4")) Module["inetNtop4"] = (() => abort("'inetNtop4' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "inetPton6")) Module["inetPton6"] = (() => abort("'inetPton6' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "inetNtop6")) Module["inetNtop6"] = (() => abort("'inetNtop6' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "readSockaddr")) Module["readSockaddr"] = (() => abort("'readSockaddr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeSockaddr")) Module["writeSockaddr"] = (() => abort("'writeSockaddr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "DNS")) Module["DNS"] = (() => abort("'DNS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getHostByName")) Module["getHostByName"] = (() => abort("'getHostByName' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "Protocols")) Module["Protocols"] = (() => abort("'Protocols' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "Sockets")) Module["Sockets"] = (() => abort("'Sockets' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getRandomDevice")) Module["getRandomDevice"] = (() => abort("'getRandomDevice' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "traverseStack")) Module["traverseStack"] = (() => abort("'traverseStack' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "convertFrameToPC")) Module["convertFrameToPC"] = (() => abort("'convertFrameToPC' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "UNWIND_CACHE")) Module["UNWIND_CACHE"] = (() => abort("'UNWIND_CACHE' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "saveInUnwindCache")) Module["saveInUnwindCache"] = (() => abort("'saveInUnwindCache' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "convertPCtoSourceLocation")) Module["convertPCtoSourceLocation"] = (() => abort("'convertPCtoSourceLocation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgsArray")) Module["readAsmConstArgsArray"] = (() => abort("'readAsmConstArgsArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgs")) Module["readAsmConstArgs"] = (() => abort("'readAsmConstArgs' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "mainThreadEM_ASM")) Module["mainThreadEM_ASM"] = (() => abort("'mainThreadEM_ASM' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "jstoi_q")) Module["jstoi_q"] = (() => abort("'jstoi_q' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "jstoi_s")) Module["jstoi_s"] = (() => abort("'jstoi_s' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getExecutableName")) Module["getExecutableName"] = (() => abort("'getExecutableName' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "listenOnce")) Module["listenOnce"] = (() => abort("'listenOnce' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "autoResumeAudioContext")) Module["autoResumeAudioContext"] = (() => abort("'autoResumeAudioContext' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "dynCallLegacy")) Module["dynCallLegacy"] = (() => abort("'dynCallLegacy' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getDynCaller")) Module["getDynCaller"] = (() => abort("'getDynCaller' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = (() => abort("'dynCall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "callRuntimeCallbacks")) Module["callRuntimeCallbacks"] = (() => abort("'callRuntimeCallbacks' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "wasmTableMirror")) Module["wasmTableMirror"] = (() => abort("'wasmTableMirror' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setWasmTableEntry")) Module["setWasmTableEntry"] = (() => abort("'setWasmTableEntry' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getWasmTableEntry")) Module["getWasmTableEntry"] = (() => abort("'getWasmTableEntry' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "handleException")) Module["handleException"] = (() => abort("'handleException' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePush")) Module["runtimeKeepalivePush"] = (() => abort("'runtimeKeepalivePush' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePop")) Module["runtimeKeepalivePop"] = (() => abort("'runtimeKeepalivePop' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "callUserCallback")) Module["callUserCallback"] = (() => abort("'callUserCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "maybeExit")) Module["maybeExit"] = (() => abort("'maybeExit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "safeSetTimeout")) Module["safeSetTimeout"] = (() => abort("'safeSetTimeout' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "asmjsMangle")) Module["asmjsMangle"] = (() => abort("'asmjsMangle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "asyncLoad")) Module["asyncLoad"] = (() => abort("'asyncLoad' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "alignMemory")) Module["alignMemory"] = (() => abort("'alignMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "mmapAlloc")) Module["mmapAlloc"] = (() => abort("'mmapAlloc' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "reallyNegative")) Module["reallyNegative"] = (() => abort("'reallyNegative' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "unSign")) Module["unSign"] = (() => abort("'unSign' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "reSign")) Module["reSign"] = (() => abort("'reSign' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "formatString")) Module["formatString"] = (() => abort("'formatString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "PATH")) Module["PATH"] = (() => abort("'PATH' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "PATH_FS")) Module["PATH_FS"] = (() => abort("'PATH_FS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "SYSCALLS")) Module["SYSCALLS"] = (() => abort("'SYSCALLS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getSocketFromFD")) Module["getSocketFromFD"] = (() => abort("'getSocketFromFD' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getSocketAddress")) Module["getSocketAddress"] = (() => abort("'getSocketAddress' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "JSEvents")) Module["JSEvents"] = (() => abort("'JSEvents' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerKeyEventCallback")) Module["registerKeyEventCallback"] = (() => abort("'registerKeyEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "specialHTMLTargets")) Module["specialHTMLTargets"] = (() => abort("'specialHTMLTargets' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "maybeCStringToJsString")) Module["maybeCStringToJsString"] = (() => abort("'maybeCStringToJsString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "findEventTarget")) Module["findEventTarget"] = (() => abort("'findEventTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "findCanvasEventTarget")) Module["findCanvasEventTarget"] = (() => abort("'findCanvasEventTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getBoundingClientRect")) Module["getBoundingClientRect"] = (() => abort("'getBoundingClientRect' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillMouseEventData")) Module["fillMouseEventData"] = (() => abort("'fillMouseEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerMouseEventCallback")) Module["registerMouseEventCallback"] = (() => abort("'registerMouseEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerWheelEventCallback")) Module["registerWheelEventCallback"] = (() => abort("'registerWheelEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerUiEventCallback")) Module["registerUiEventCallback"] = (() => abort("'registerUiEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerFocusEventCallback")) Module["registerFocusEventCallback"] = (() => abort("'registerFocusEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceOrientationEventData")) Module["fillDeviceOrientationEventData"] = (() => abort("'fillDeviceOrientationEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceOrientationEventCallback")) Module["registerDeviceOrientationEventCallback"] = (() => abort("'registerDeviceOrientationEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceMotionEventData")) Module["fillDeviceMotionEventData"] = (() => abort("'fillDeviceMotionEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceMotionEventCallback")) Module["registerDeviceMotionEventCallback"] = (() => abort("'registerDeviceMotionEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "screenOrientation")) Module["screenOrientation"] = (() => abort("'screenOrientation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillOrientationChangeEventData")) Module["fillOrientationChangeEventData"] = (() => abort("'fillOrientationChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerOrientationChangeEventCallback")) Module["registerOrientationChangeEventCallback"] = (() => abort("'registerOrientationChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillFullscreenChangeEventData")) Module["fillFullscreenChangeEventData"] = (() => abort("'fillFullscreenChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerFullscreenChangeEventCallback")) Module["registerFullscreenChangeEventCallback"] = (() => abort("'registerFullscreenChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerRestoreOldStyle")) Module["registerRestoreOldStyle"] = (() => abort("'registerRestoreOldStyle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "hideEverythingExceptGivenElement")) Module["hideEverythingExceptGivenElement"] = (() => abort("'hideEverythingExceptGivenElement' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "restoreHiddenElements")) Module["restoreHiddenElements"] = (() => abort("'restoreHiddenElements' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setLetterbox")) Module["setLetterbox"] = (() => abort("'setLetterbox' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "currentFullscreenStrategy")) Module["currentFullscreenStrategy"] = (() => abort("'currentFullscreenStrategy' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "restoreOldWindowedStyle")) Module["restoreOldWindowedStyle"] = (() => abort("'restoreOldWindowedStyle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "softFullscreenResizeWebGLRenderTarget")) Module["softFullscreenResizeWebGLRenderTarget"] = (() => abort("'softFullscreenResizeWebGLRenderTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "doRequestFullscreen")) Module["doRequestFullscreen"] = (() => abort("'doRequestFullscreen' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillPointerlockChangeEventData")) Module["fillPointerlockChangeEventData"] = (() => abort("'fillPointerlockChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockChangeEventCallback")) Module["registerPointerlockChangeEventCallback"] = (() => abort("'registerPointerlockChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockErrorEventCallback")) Module["registerPointerlockErrorEventCallback"] = (() => abort("'registerPointerlockErrorEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "requestPointerLock")) Module["requestPointerLock"] = (() => abort("'requestPointerLock' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillVisibilityChangeEventData")) Module["fillVisibilityChangeEventData"] = (() => abort("'fillVisibilityChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerVisibilityChangeEventCallback")) Module["registerVisibilityChangeEventCallback"] = (() => abort("'registerVisibilityChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerTouchEventCallback")) Module["registerTouchEventCallback"] = (() => abort("'registerTouchEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillGamepadEventData")) Module["fillGamepadEventData"] = (() => abort("'fillGamepadEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerGamepadEventCallback")) Module["registerGamepadEventCallback"] = (() => abort("'registerGamepadEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerBeforeUnloadEventCallback")) Module["registerBeforeUnloadEventCallback"] = (() => abort("'registerBeforeUnloadEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "fillBatteryEventData")) Module["fillBatteryEventData"] = (() => abort("'fillBatteryEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "battery")) Module["battery"] = (() => abort("'battery' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerBatteryEventCallback")) Module["registerBatteryEventCallback"] = (() => abort("'registerBatteryEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setCanvasElementSize")) Module["setCanvasElementSize"] = (() => abort("'setCanvasElementSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getCanvasElementSize")) Module["getCanvasElementSize"] = (() => abort("'getCanvasElementSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "demangle")) Module["demangle"] = (() => abort("'demangle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "demangleAll")) Module["demangleAll"] = (() => abort("'demangleAll' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "jsStackTrace")) Module["jsStackTrace"] = (() => abort("'jsStackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = (() => abort("'stackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getEnvStrings")) Module["getEnvStrings"] = (() => abort("'getEnvStrings' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "checkWasiClock")) Module["checkWasiClock"] = (() => abort("'checkWasiClock' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "flush_NO_FILESYSTEM")) Module["flush_NO_FILESYSTEM"] = (() => abort("'flush_NO_FILESYSTEM' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64")) Module["writeI53ToI64"] = (() => abort("'writeI53ToI64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Clamped")) Module["writeI53ToI64Clamped"] = (() => abort("'writeI53ToI64Clamped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Signaling")) Module["writeI53ToI64Signaling"] = (() => abort("'writeI53ToI64Signaling' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Clamped")) Module["writeI53ToU64Clamped"] = (() => abort("'writeI53ToU64Clamped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Signaling")) Module["writeI53ToU64Signaling"] = (() => abort("'writeI53ToU64Signaling' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "readI53FromI64")) Module["readI53FromI64"] = (() => abort("'readI53FromI64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "readI53FromU64")) Module["readI53FromU64"] = (() => abort("'readI53FromU64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "convertI32PairToI53")) Module["convertI32PairToI53"] = (() => abort("'convertI32PairToI53' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "convertU32PairToI53")) Module["convertU32PairToI53"] = (() => abort("'convertU32PairToI53' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setImmediateWrapped")) Module["setImmediateWrapped"] = (() => abort("'setImmediateWrapped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "clearImmediateWrapped")) Module["clearImmediateWrapped"] = (() => abort("'clearImmediateWrapped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "polyfillSetImmediate")) Module["polyfillSetImmediate"] = (() => abort("'polyfillSetImmediate' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "uncaughtExceptionCount")) Module["uncaughtExceptionCount"] = (() => abort("'uncaughtExceptionCount' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "exceptionLast")) Module["exceptionLast"] = (() => abort("'exceptionLast' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "exceptionCaught")) Module["exceptionCaught"] = (() => abort("'exceptionCaught' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "ExceptionInfo")) Module["ExceptionInfo"] = (() => abort("'ExceptionInfo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "CatchInfo")) Module["CatchInfo"] = (() => abort("'CatchInfo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "exception_addRef")) Module["exception_addRef"] = (() => abort("'exception_addRef' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "exception_decRef")) Module["exception_decRef"] = (() => abort("'exception_decRef' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "Browser")) Module["Browser"] = (() => abort("'Browser' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "funcWrappers")) Module["funcWrappers"] = (() => abort("'funcWrappers' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = (() => abort("'getFuncWrapper' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "setMainLoop")) Module["setMainLoop"] = (() => abort("'setMainLoop' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "wget")) Module["wget"] = (() => abort("'wget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "tempFixedLengthArray")) Module["tempFixedLengthArray"] = (() => abort("'tempFixedLengthArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "miniTempWebGLFloatBuffers")) Module["miniTempWebGLFloatBuffers"] = (() => abort("'miniTempWebGLFloatBuffers' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "heapObjectForWebGLType")) Module["heapObjectForWebGLType"] = (() => abort("'heapObjectForWebGLType' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "heapAccessShiftForWebGLHeap")) Module["heapAccessShiftForWebGLHeap"] = (() => abort("'heapAccessShiftForWebGLHeap' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "GL")) Module["GL"] = (() => abort("'GL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGet")) Module["emscriptenWebGLGet"] = (() => abort("'emscriptenWebGLGet' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "computeUnpackAlignedImageSize")) Module["computeUnpackAlignedImageSize"] = (() => abort("'computeUnpackAlignedImageSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetTexPixelData")) Module["emscriptenWebGLGetTexPixelData"] = (() => abort("'emscriptenWebGLGetTexPixelData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetUniform")) Module["emscriptenWebGLGetUniform"] = (() => abort("'emscriptenWebGLGetUniform' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "webglGetUniformLocation")) Module["webglGetUniformLocation"] = (() => abort("'webglGetUniformLocation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "webglPrepareUniformLocationsBeforeFirstUse")) Module["webglPrepareUniformLocationsBeforeFirstUse"] = (() => abort("'webglPrepareUniformLocationsBeforeFirstUse' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "webglGetLeftBracePos")) Module["webglGetLeftBracePos"] = (() => abort("'webglGetLeftBracePos' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetVertexAttrib")) Module["emscriptenWebGLGetVertexAttrib"] = (() => abort("'emscriptenWebGLGetVertexAttrib' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "writeGLArray")) Module["writeGLArray"] = (() => abort("'writeGLArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "FS")) Module["FS"] = (() => abort("'FS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "MEMFS")) Module["MEMFS"] = (() => abort("'MEMFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "TTY")) Module["TTY"] = (() => abort("'TTY' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "PIPEFS")) Module["PIPEFS"] = (() => abort("'PIPEFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "SOCKFS")) Module["SOCKFS"] = (() => abort("'SOCKFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "_setNetworkCallback")) Module["_setNetworkCallback"] = (() => abort("'_setNetworkCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "AL")) Module["AL"] = (() => abort("'AL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "SDL_unicode")) Module["SDL_unicode"] = (() => abort("'SDL_unicode' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "SDL_ttfContext")) Module["SDL_ttfContext"] = (() => abort("'SDL_ttfContext' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "SDL_audio")) Module["SDL_audio"] = (() => abort("'SDL_audio' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "SDL")) Module["SDL"] = (() => abort("'SDL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "SDL_gfx")) Module["SDL_gfx"] = (() => abort("'SDL_gfx' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "GLUT")) Module["GLUT"] = (() => abort("'GLUT' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "EGL")) Module["EGL"] = (() => abort("'EGL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "GLFW_Window")) Module["GLFW_Window"] = (() => abort("'GLFW_Window' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "GLFW")) Module["GLFW"] = (() => abort("'GLFW' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "GLEW")) Module["GLEW"] = (() => abort("'GLEW' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "IDBStore")) Module["IDBStore"] = (() => abort("'IDBStore' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "runAndAbortIfError")) Module["runAndAbortIfError"] = (() => abort("'runAndAbortIfError' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  Module["PThread"] = PThread;
  
  if (!Object.getOwnPropertyDescriptor(Module, "ptrToString")) Module["ptrToString"] = (() => abort("'ptrToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "killThread")) Module["killThread"] = (() => abort("'killThread' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "cleanupThread")) Module["cleanupThread"] = (() => abort("'cleanupThread' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "registerTlsInit")) Module["registerTlsInit"] = (() => abort("'registerTlsInit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "cancelThread")) Module["cancelThread"] = (() => abort("'cancelThread' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "spawnThread")) Module["spawnThread"] = (() => abort("'spawnThread' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "exitOnMainThread")) Module["exitOnMainThread"] = (() => abort("'exitOnMainThread' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "establishStackSpace")) Module["establishStackSpace"] = (() => abort("'establishStackSpace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "invokeEntryPoint")) Module["invokeEntryPoint"] = (() => abort("'invokeEntryPoint' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "warnOnce")) Module["warnOnce"] = (() => abort("'warnOnce' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stackSave")) Module["stackSave"] = (() => abort("'stackSave' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stackRestore")) Module["stackRestore"] = (() => abort("'stackRestore' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc")) Module["stackAlloc"] = (() => abort("'stackAlloc' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString")) Module["AsciiToString"] = (() => abort("'AsciiToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii")) Module["stringToAscii"] = (() => abort("'stringToAscii' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "UTF16ToString")) Module["UTF16ToString"] = (() => abort("'UTF16ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF16")) Module["stringToUTF16"] = (() => abort("'stringToUTF16' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16")) Module["lengthBytesUTF16"] = (() => abort("'lengthBytesUTF16' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString")) Module["UTF32ToString"] = (() => abort("'UTF32ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32")) Module["stringToUTF32"] = (() => abort("'stringToUTF32' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32")) Module["lengthBytesUTF32"] = (() => abort("'lengthBytesUTF32' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8")) Module["allocateUTF8"] = (() => abort("'allocateUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8OnStack")) Module["allocateUTF8OnStack"] = (() => abort("'allocateUTF8OnStack' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"));
  
  Module["writeStackCookie"] = writeStackCookie;
  
  Module["checkStackCookie"] = checkStackCookie;
  
  Module["PThread"] = PThread;
  
  Module["wasmMemory"] = wasmMemory;
  
  Module["ExitStatus"] = ExitStatus;
  
  if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NORMAL")) Object.defineProperty(Module, "ALLOC_NORMAL", {
   configurable: true,
   get: function() {
    abort("'ALLOC_NORMAL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
   }
  });
  
  if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_STACK")) Object.defineProperty(Module, "ALLOC_STACK", {
   configurable: true,
   get: function() {
    abort("'ALLOC_STACK' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)");
   }
  });
  
  var calledRun;
  
  function ExitStatus(status) {
   this.name = "ExitStatus";
   this.message = "Program terminated with exit(" + status + ")";
   this.status = status;
  }
  
  var calledMain = false;
  
  dependenciesFulfilled = function runCaller() {
   if (!calledRun) run();
   if (!calledRun) dependenciesFulfilled = runCaller;
  };
  
  function callMain(args) {
   assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');
   assert(__ATPRERUN__.length == 0, "cannot call main when preRun functions remain to be called");
   var entryFunction = Module["_main"];
   args = args || [];
   var argc = args.length + 1;
   var argv = stackAlloc((argc + 1) * 4);
   GROWABLE_HEAP_I32()[argv >> 2] = allocateUTF8OnStack(thisProgram);
   for (var i = 1; i < argc; i++) {
    GROWABLE_HEAP_I32()[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]);
   }
   GROWABLE_HEAP_I32()[(argv >> 2) + argc] = 0;
   try {
    var ret = entryFunction(argc, argv);
    exit(ret, true);
    return ret;
   } catch (e) {
    return handleException(e);
   } finally {
    calledMain = true;
   }
  }
  
  function stackCheckInit() {
   _emscripten_stack_init();
   writeStackCookie();
  }
  
  function run(args) {
   args = args || arguments_;
   if (runDependencies > 0) {
    return;
   }
   stackCheckInit();
   if (ENVIRONMENT_IS_PTHREAD) {
    initRuntime();
    postMessage({
     "cmd": "loaded"
    });
    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"]();
    if (shouldRunNow) callMain(args);
    postRun();
   }
   if (Module["setStatus"]) {
    Module["setStatus"]("Running...");
    setTimeout(function() {
     setTimeout(function() {
      Module["setStatus"]("");
     }, 1);
     doRun();
    }, 1);
   } else {
    doRun();
   }
   checkStackCookie();
  }
  
  Module["run"] = run;
  
  function checkUnflushedContent() {
   var oldOut = out;
   var oldErr = err;
   var has = false;
   out = err = (x => {
    has = true;
   });
   try {
    var flush = flush_NO_FILESYSTEM;
    if (flush) flush();
   } catch (e) {}
   out = oldOut;
   err = oldErr;
   if (has) {
    warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.");
    warnOnce("(this may also be due to not including full filesystem support - try building with -s FORCE_FILESYSTEM=1)");
   }
  }
  
  function exit(status, implicit) {
   EXITSTATUS = status;
   if (!runtimeKeepaliveCounter) {
    checkUnflushedContent();
   }
   if (!implicit) {
    if (ENVIRONMENT_IS_PTHREAD) {
     exitOnMainThread(status);
     throw "unwind";
    } else {}
   }
   if (keepRuntimeAlive()) {
    if (!implicit) {
     var msg = "program exited (with status: " + status + "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)";
     err(msg);
    }
   } else {
    exitRuntime();
   }
   procExit(status);
  }
  
  function procExit(code) {
   EXITSTATUS = code;
   if (!keepRuntimeAlive()) {
    PThread.terminateAllThreads();
    if (Module["onExit"]) Module["onExit"](code);
    ABORT = true;
   }
   quit_(code, new ExitStatus(code));
  }
  
  if (Module["preInit"]) {
   if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
   while (Module["preInit"].length > 0) {
    Module["preInit"].pop()();
   }
  }
  
  var shouldRunNow = false;
  
  if (Module["noInitialRun"]) shouldRunNow = false;
  
  run();
  