lkarch.org/tools/sm64/sm64.us.f3dex2e.js

// Copyright 2010 The Emscripten Authors.  All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License.  Both these licenses can be
// found in the LICENSE file.

// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(Module) { ..generated code.. }
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define   var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = typeof Module !== "undefined" ? Module : {};

// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
// {{PRE_JSES}}

// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = {};
var key;
for (key in Module) {
  if (Module.hasOwnProperty(key)) {
    moduleOverrides[key] = Module[key];
  }
}

var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = function (status, toThrow) {
  throw toThrow;
};

// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).

var ENVIRONMENT_IS_WEB = false;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
ENVIRONMENT_IS_WEB = typeof window === "object";
ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
// N.b. Electron.js environment is simultaneously a NODE-environment, but
// also a web environment.
ENVIRONMENT_IS_NODE =
  typeof process === "object" &&
  typeof process.versions === "object" &&
  typeof process.versions.node === "string";
ENVIRONMENT_IS_SHELL =
  !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

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)"
  );
}

// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = "";
function locateFile(path) {
  if (Module["locateFile"]) {
    return Module["locateFile"](path, scriptDirectory);
  }
  return scriptDirectory + path;
}

// Hooks that are implemented differently in different runtime environments.
var read_, readAsync, readBinary, setWindowTitle;

var nodeFS;
var nodePath;

if (ENVIRONMENT_IS_NODE) {
  if (ENVIRONMENT_IS_WORKER) {
    scriptDirectory = require("path").dirname(scriptDirectory) + "/";
  } else {
    scriptDirectory = __dirname + "/";
  }

  read_ = function shell_read(filename, binary) {
    if (!nodeFS) nodeFS = require("fs");
    if (!nodePath) nodePath = require("path");
    filename = nodePath["normalize"](filename);
    return nodeFS["readFileSync"](filename, binary ? null : "utf8");
  };

  readBinary = function readBinary(filename) {
    var ret = read_(filename, true);
    if (!ret.buffer) {
      ret = new Uint8Array(ret);
    }
    assert(ret.buffer);
    return ret;
  };

  if (process["argv"].length > 1) {
    thisProgram = process["argv"][1].replace(/\\/g, "/");
  }

  arguments_ = process["argv"].slice(2);

  if (typeof module !== "undefined") {
    module["exports"] = Module;
  }

  process["on"]("uncaughtException", function (ex) {
    // suppress ExitStatus exceptions from showing an error
    if (!(ex instanceof ExitStatus)) {
      throw ex;
    }
  });

  process["on"]("unhandledRejection", abort);

  quit_ = function (status) {
    process["exit"](status);
  };

  Module["inspect"] = function () {
    return "[Emscripten Module object]";
  };
} else if (ENVIRONMENT_IS_SHELL) {
  if (typeof read != "undefined") {
    read_ = function shell_read(f) {
      return read(f);
    };
  }

  readBinary = function readBinary(f) {
    var data;
    if (typeof readbuffer === "function") {
      return new Uint8Array(readbuffer(f));
    }
    data = read(f, "binary");
    assert(typeof data === "object");
    return data;
  };

  if (typeof scriptArgs != "undefined") {
    arguments_ = scriptArgs;
  } else if (typeof arguments != "undefined") {
    arguments_ = arguments;
  }

  if (typeof quit === "function") {
    quit_ = function (status) {
      quit(status);
    };
  }

  if (typeof print !== "undefined") {
    // Prefer to use print/printErr where they exist, as they usually work better.
    if (typeof console === "undefined") console = /** @type{!Console} */ ({});
    console.log = /** @type{!function(this:Console, ...*): undefined} */ (
      print
    );
    console.warn = console.error =
      /** @type{!function(this:Console, ...*): undefined} */ (
        typeof printErr !== "undefined" ? printErr : print
      );
  }
}

// Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  if (ENVIRONMENT_IS_WORKER) {
    // Check worker, not web, since window could be polyfilled
    scriptDirectory = self.location.href;
  } else if (document.currentScript) {
    // web
    scriptDirectory = document.currentScript.src;
  }
  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
  // otherwise, slice off the final part of the url to find the script directory.
  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
  // and scriptDirectory will correctly be replaced with an empty string.
  if (scriptDirectory.indexOf("blob:") !== 0) {
    scriptDirectory = scriptDirectory.substr(
      0,
      scriptDirectory.lastIndexOf("/") + 1
    );
  } else {
    scriptDirectory = "";
  }

  // Differentiate the Web Worker from the Node Worker case, as reading must
  // be done differently.
  {
    read_ = function shell_read(url) {
      var xhr = new XMLHttpRequest();
      xhr.open("GET", url, false);
      xhr.send(null);
      return xhr.responseText;
    };

    if (ENVIRONMENT_IS_WORKER) {
      readBinary = function readBinary(url) {
        var xhr = new XMLHttpRequest();
        xhr.open("GET", url, false);
        xhr.responseType = "arraybuffer";
        xhr.send(null);
        return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response));
      };
    }

    readAsync = function readAsync(url, onload, onerror) {
      var xhr = new XMLHttpRequest();
      xhr.open("GET", url, true);
      xhr.responseType = "arraybuffer";
      xhr.onload = function xhr_onload() {
        if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
          // file URLs can return 0
          onload(xhr.response);
          return;
        }
        onerror();
      };
      xhr.onerror = onerror;
      xhr.send(null);
    };
  }

  setWindowTitle = function (title) {
    document.title = title;
  };
} else {
  throw new Error("environment detection error");
}

// Set up the out() and err() hooks, which are how we can print to stdout or
// stderr, respectively.
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.warn.bind(console);

// Merge back in the overrides
for (key in moduleOverrides) {
  if (moduleOverrides.hasOwnProperty(key)) {
    Module[key] = moduleOverrides[key];
  }
}
// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
moduleOverrides = null;

// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.
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_");
    },
  });
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");
    },
  });
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_");
    },
  });

// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Assertions on removed incoming Module JS APIs.
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_");
    },
  });
if (!Object.getOwnPropertyDescriptor(Module, "readAsync"))
  Object.defineProperty(Module, "readAsync", {
    configurable: true,
    get: function () {
      abort("Module.readAsync has been replaced with plain readAsync");
    },
  });
if (!Object.getOwnPropertyDescriptor(Module, "readBinary"))
  Object.defineProperty(Module, "readBinary", {
    configurable: true,
    get: function () {
      abort("Module.readBinary has been replaced with plain readBinary");
    },
  });
// TODO: add when SDL2 is fixed if (!Object.getOwnPropertyDescriptor(Module, 'setWindowTitle')) Object.defineProperty(Module, 'setWindowTitle', { configurable: true, get: function() { abort('Module.setWindowTitle has been replaced with plain setWindowTitle') } });
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";

// TODO remove when SDL2 is fixed (also see above)

// Copyright 2017 The Emscripten Authors.  All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License.  Both these licenses can be
// found in the LICENSE file.

// {{PREAMBLE_ADDITIONS}}

var STACK_ALIGN = 16;

// stack management, and other functionality that is provided by the compiled code,
// should not be used before it is ready

/** @suppress{duplicate} */
var stackSave;
/** @suppress{duplicate} */
var stackRestore;
/** @suppress{duplicate} */
var stackAlloc;

stackSave =
  stackRestore =
  stackAlloc =
    function () {
      abort(
        "cannot use the stack before compiled code is ready to run, and has provided stack access"
      );
    };

function staticAlloc(size) {
  abort(
    "staticAlloc is no longer available at runtime; instead, perform static allocations at compile time (using makeStaticAlloc)"
  );
}

function dynamicAlloc(size) {
  assert(DYNAMICTOP_PTR);
  var ret = HEAP32[DYNAMICTOP_PTR >> 2];
  var end = (ret + size + 15) & -16;
  assert(
    end <= HEAP8.length,
    "failure to dynamicAlloc - memory growth etc. is not supported there, call malloc/sbrk directly"
  );
  HEAP32[DYNAMICTOP_PTR >> 2] = end;
  return ret;
}

function alignMemory(size, factor) {
  if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default
  return Math.ceil(size / factor) * factor;
}

function getNativeTypeSize(type) {
  switch (type) {
    case "i1":
    case "i8":
      return 1;
    case "i16":
      return 2;
    case "i32":
      return 4;
    case "i64":
      return 8;
    case "float":
      return 4;
    case "double":
      return 8;
    default: {
      if (type[type.length - 1] === "*") {
        return 4; // A pointer
      } else if (type[0] === "i") {
        var bits = Number(type.substr(1));
        assert(
          bits % 8 === 0,
          "getNativeTypeSize invalid bits " + bits + ", type " + type
        );
        return bits / 8;
      } else {
        return 0;
      }
    }
  }
}

function warnOnce(text) {
  if (!warnOnce.shown) warnOnce.shown = {};
  if (!warnOnce.shown[text]) {
    warnOnce.shown[text] = 1;
    err(text);
  }
}

// Wraps a JS function as a wasm function with a given signature.
function convertJsFunctionToWasm(func, sig) {
  // If the type reflection proposal is available, use the new
  // "WebAssembly.Function" constructor.
  // Otherwise, construct a minimal wasm module importing the JS function and
  // re-exporting it.
  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);
  }

  // The module is static, with the exception of the type section, which is
  // generated based on the signature passed in.
  var typeSection = [
    0x01, // id: section,
    0x00, // length: 0 (placeholder)
    0x01, // count: 1
    0x60, // form: func
  ];
  var sigRet = sig.slice(0, 1);
  var sigParam = sig.slice(1);
  var typeCodes = {
    i: 0x7f, // i32
    j: 0x7e, // i64
    f: 0x7d, // f32
    d: 0x7c, // f64
  };

  // Parameters, length + signatures
  typeSection.push(sigParam.length);
  for (var i = 0; i < sigParam.length; ++i) {
    typeSection.push(typeCodes[sigParam[i]]);
  }

  // Return values, length + signatures
  // With no multi-return in MVP, either 0 (void) or 1 (anything else)
  if (sigRet == "v") {
    typeSection.push(0x00);
  } else {
    typeSection = typeSection.concat([0x01, typeCodes[sigRet]]);
  }

  // Write the overall length of the type section back into the section header
  // (excepting the 2 bytes for the section id and length)
  typeSection[1] = typeSection.length - 2;

  // Rest of the module is static
  var bytes = new Uint8Array(
    [
      0x00,
      0x61,
      0x73,
      0x6d, // magic ("\0asm")
      0x01,
      0x00,
      0x00,
      0x00, // version: 1
    ].concat(typeSection, [
      0x02,
      0x07, // import section
      // (import "e" "f" (func 0 (type 0)))
      0x01,
      0x01,
      0x65,
      0x01,
      0x66,
      0x00,
      0x00,
      0x07,
      0x05, // export section
      // (export "f" (func 0 (type 0)))
      0x01,
      0x01,
      0x66,
      0x00,
      0x00,
    ])
  );

  // We can compile this wasm module synchronously because it is very small.
  // This accepts an import (at "e.f"), that it reroutes to an export (at "f")
  var module = new WebAssembly.Module(bytes);
  var instance = new WebAssembly.Instance(module, {
    e: {
      f: func,
    },
  });
  var wrappedFunc = instance.exports["f"];
  return wrappedFunc;
}

var freeTableIndexes = [];

// Add a wasm function to the table.
function addFunctionWasm(func, sig) {
  var table = wasmTable;
  var ret;
  // Reuse a free index if there is one, otherwise grow.
  if (freeTableIndexes.length) {
    ret = freeTableIndexes.pop();
  } else {
    ret = table.length;
    // Grow the table
    try {
      table.grow(1);
    } catch (err) {
      if (!(err instanceof RangeError)) {
        throw err;
      }
      throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
    }
  }

  // Set the new value.
  try {
    // Attempting to call this with JS function will cause of table.set() to fail
    table.set(ret, func);
  } catch (err) {
    if (!(err instanceof TypeError)) {
      throw err;
    }
    assert(
      typeof sig !== "undefined",
      "Missing signature argument to addFunction"
    );
    var wrapped = convertJsFunctionToWasm(func, sig);
    table.set(ret, wrapped);
  }

  return ret;
}

function removeFunctionWasm(index) {
  freeTableIndexes.push(index);
}

// 'sig' parameter is required for the llvm backend but only when func is not
// already a WebAssembly function.
function addFunction(func, sig) {
  assert(typeof func !== "undefined");

  return addFunctionWasm(func, sig);
}

function removeFunction(index) {
  removeFunctionWasm(index);
}

var funcWrappers = {};

function getFuncWrapper(func, sig) {
  if (!func) return; // on null pointer, return undefined
  assert(sig);
  if (!funcWrappers[sig]) {
    funcWrappers[sig] = {};
  }
  var sigCache = funcWrappers[sig];
  if (!sigCache[func]) {
    // optimize away arguments usage in common cases
    if (sig.length === 1) {
      sigCache[func] = function dynCall_wrapper() {
        return dynCall(sig, func);
      };
    } else if (sig.length === 2) {
      sigCache[func] = function dynCall_wrapper(arg) {
        return dynCall(sig, func, [arg]);
      };
    } else {
      // general case
      sigCache[func] = function dynCall_wrapper() {
        return dynCall(sig, func, Array.prototype.slice.call(arguments));
      };
    }
  }
  return sigCache[func];
}

function makeBigInt(low, high, unsigned) {
  return unsigned
    ? +(low >>> 0) + +(high >>> 0) * 4294967296.0
    : +(low >>> 0) + +(high | 0) * 4294967296.0;
}

/** @param {Array=} args */
function dynCall(sig, ptr, args) {
  if (args && args.length) {
    // j (64-bit integer) must be passed in as two numbers [low 32, high 32].
    assert(args.length === sig.substring(1).replace(/j/g, "--").length);
    assert(
      "dynCall_" + sig in Module,
      "bad function pointer type - no table for sig '" + sig + "'"
    );
    return Module["dynCall_" + sig].apply(null, [ptr].concat(args));
  } else {
    assert(sig.length == 1);
    assert(
      "dynCall_" + sig in Module,
      "bad function pointer type - no table for sig '" + sig + "'"
    );
    return Module["dynCall_" + sig].call(null, ptr);
  }
}

var tempRet0 = 0;

var setTempRet0 = function (value) {
  tempRet0 = value;
};

var getTempRet0 = function () {
  return tempRet0;
};

function getCompilerSetting(name) {
  throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for getCompilerSetting or emscripten_get_compiler_setting to work";
}

var Runtime = {
  // helpful errors
  getTempRet0: function () {
    abort(
      'getTempRet0() is now a top-level function, after removing the Runtime object. Remove "Runtime."'
    );
  },
  staticAlloc: function () {
    abort(
      'staticAlloc() is now a top-level function, after removing the Runtime object. Remove "Runtime."'
    );
  },
  stackAlloc: function () {
    abort(
      'stackAlloc() is now a top-level function, after removing the Runtime object. Remove "Runtime."'
    );
  },
};

// The address globals begin at. Very low in memory, for code size and optimization opportunities.
// Above 0 is static memory, starting with globals.
// Then the stack.
// Then 'dynamic' memory for sbrk.
var GLOBAL_BASE = 1024;

// === Preamble library stuff ===

// Documentation for the public APIs defined in this file must be updated in:
//    site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
//    site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html

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");
    },
  });
var noExitRuntime;
if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
if (!Object.getOwnPropertyDescriptor(Module, "noExitRuntime"))
  Object.defineProperty(Module, "noExitRuntime", {
    configurable: true,
    get: function () {
      abort("Module.noExitRuntime has been replaced with plain noExitRuntime");
    },
  });

if (typeof WebAssembly !== "object") {
  abort(
    "No WebAssembly support found. Build with -s WASM=0 to target JavaScript instead."
  );
}

// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.
// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)

/** @param {number} ptr
    @param {number} value
    @param {string} type
    @param {number|boolean=} noSafe */
function setValue(ptr, value, type, noSafe) {
  type = type || "i8";
  if (type.charAt(type.length - 1) === "*") type = "i32"; // pointers are 32-bit
  switch (type) {
    case "i1":
      HEAP8[ptr >> 0] = value;
      break;
    case "i8":
      HEAP8[ptr >> 0] = value;
      break;
    case "i16":
      HEAP16[ptr >> 1] = value;
      break;
    case "i32":
      HEAP32[ptr >> 2] = value;
      break;
    case "i64":
      (tempI64 = [
        value >>> 0,
        ((tempDouble = value),
        +Math_abs(tempDouble) >= 1.0
          ? tempDouble > 0.0
            ? (Math_min(+Math_floor(tempDouble / 4294967296.0), 4294967295.0) |
                0) >>>
              0
            : ~~+Math_ceil(
                (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
              ) >>> 0
          : 0),
      ]),
        (HEAP32[ptr >> 2] = tempI64[0]),
        (HEAP32[(ptr + 4) >> 2] = tempI64[1]);
      break;
    case "float":
      HEAPF32[ptr >> 2] = value;
      break;
    case "double":
      HEAPF64[ptr >> 3] = value;
      break;
    default:
      abort("invalid type for setValue: " + type);
  }
}

/** @param {number} ptr
    @param {string} type
    @param {number|boolean=} noSafe */
function getValue(ptr, type, noSafe) {
  type = type || "i8";
  if (type.charAt(type.length - 1) === "*") type = "i32"; // pointers are 32-bit
  switch (type) {
    case "i1":
      return HEAP8[ptr >> 0];
    case "i8":
      return HEAP8[ptr >> 0];
    case "i16":
      return HEAP16[ptr >> 1];
    case "i32":
      return HEAP32[ptr >> 2];
    case "i64":
      return HEAP32[ptr >> 2];
    case "float":
      return HEAPF32[ptr >> 2];
    case "double":
      return HEAPF64[ptr >> 3];
    default:
      abort("invalid type for getValue: " + type);
  }
  return null;
}

// Wasm globals

var wasmMemory;

// In fastcomp asm.js, we don't need a wasm Table at all.
// In the wasm backend, we polyfill the WebAssembly object,
// so this creates a (non-native-wasm) table for us.
var wasmTable = new WebAssembly.Table({
  initial: 1821,
  maximum: 1821 + 0,
  element: "anyfunc",
});

//========================================
// Runtime essentials
//========================================

// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;

// set by exit() and abort().  Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS = 0;

/** @type {function(*, string=)} */
function assert(condition, text) {
  if (!condition) {
    abort("Assertion failed: " + text);
  }
}

// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
function getCFunc(ident) {
  var func = Module["_" + ident]; // closure exported function
  assert(
    func,
    "Cannot call unknown function " + ident + ", make sure it is exported"
  );
  return func;
}

// C calling interface.
/** @param {Array=} argTypes
    @param {Arguments|Array=} args
    @param {Object=} opts */
function ccall(ident, returnType, argTypes, args, opts) {
  // For fast lookup of conversion functions
  var toC = {
    string: function (str) {
      var ret = 0;
      if (str !== null && str !== undefined && str !== 0) {
        // null string
        // at most 4 bytes per UTF-8 code point, +1 for the trailing '\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);

  ret = convertReturnValue(ret);
  if (stack !== 0) stackRestore(stack);
  return ret;
}

/** @param {Array=} argTypes
    @param {Object=} opts */
function cwrap(ident, returnType, argTypes, opts) {
  return function () {
    return ccall(ident, returnType, argTypes, arguments, opts);
  };
}

var ALLOC_NORMAL = 0; // Tries to use _malloc()
var ALLOC_STACK = 1; // Lives for the duration of the current function call
var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk
var ALLOC_NONE = 3; // Do not allocate

// allocate(): This is for internal use. You can use it yourself as well, but the interface
//             is a little tricky (see docs right below). The reason is that it is optimized
//             for multiple syntaxes to save space in generated code. So you should
//             normally not use allocate(), and instead allocate memory using _malloc(),
//             initialize it with setValue(), and so forth.
// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
//        in *bytes* (note that this is sometimes confusing: the next parameter does not
//        affect this!)
// @types: Either an array of types, one for each byte (or 0 if no type at that position),
//         or a single type which is used for the entire block. This only matters if there
//         is initial data - if @slab is a number, then this does not matter at all and is
//         ignored.
// @allocator: How to allocate memory, see ALLOC_*
/** @type {function((TypedArray|Array<number>|number), string, number, number=)} */
function allocate(slab, types, allocator, ptr) {
  var zeroinit, size;
  if (typeof slab === "number") {
    zeroinit = true;
    size = slab;
  } else {
    zeroinit = false;
    size = slab.length;
  }

  var singleType = typeof types === "string" ? types : null;

  var ret;
  if (allocator == ALLOC_NONE) {
    ret = ptr;
  } else {
    ret = [_malloc, stackAlloc, dynamicAlloc][allocator](
      Math.max(size, singleType ? 1 : types.length)
    );
  }

  if (zeroinit) {
    var stop;
    ptr = ret;
    assert((ret & 3) == 0);
    stop = ret + (size & ~3);
    for (; ptr < stop; ptr += 4) {
      HEAP32[ptr >> 2] = 0;
    }
    stop = ret + size;
    while (ptr < stop) {
      HEAP8[ptr++ >> 0] = 0;
    }
    return ret;
  }

  if (singleType === "i8") {
    if (slab.subarray || slab.slice) {
      HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret);
    } else {
      HEAPU8.set(new Uint8Array(slab), ret);
    }
    return ret;
  }

  var i = 0,
    type,
    typeSize,
    previousType;
  while (i < size) {
    var curr = slab[i];

    type = singleType || types[i];
    if (type === 0) {
      i++;
      continue;
    }
    assert(type, "Must know what type to store in allocate!");

    if (type == "i64") type = "i32"; // special case: we have one i32 here, and one i32 later

    setValue(ret + i, curr, type);

    // no need to look up size unless type changes, so cache it
    if (previousType !== type) {
      typeSize = getNativeTypeSize(type);
      previousType = type;
    }
    i += typeSize;
  }

  return ret;
}

// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready
function getMemory(size) {
  if (!runtimeInitialized) return dynamicAlloc(size);
  return _malloc(size);
}

// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.

// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
// a copy of that string as a Javascript String object.

var UTF8Decoder =
  typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;

/**
 * @param {number} idx
 * @param {number=} maxBytesToRead
 * @return {string}
 */
function UTF8ArrayToString(u8Array, idx, maxBytesToRead) {
  var endIdx = idx + maxBytesToRead;
  var endPtr = idx;
  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
  // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
  // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)
  while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr;

  if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
    return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
  } else {
    var str = "";
    // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that
    while (idx < endPtr) {
      // For UTF8 byte structure, see:
      // http://en.wikipedia.org/wiki/UTF-8#Description
      // https://www.ietf.org/rfc/rfc2279.txt
      // https://tools.ietf.org/html/rfc3629
      var u0 = u8Array[idx++];
      if (!(u0 & 0x80)) {
        str += String.fromCharCode(u0);
        continue;
      }
      var u1 = u8Array[idx++] & 63;
      if ((u0 & 0xe0) == 0xc0) {
        str += String.fromCharCode(((u0 & 31) << 6) | u1);
        continue;
      }
      var u2 = u8Array[idx++] & 63;
      if ((u0 & 0xf0) == 0xe0) {
        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
      } else {
        if ((u0 & 0xf8) != 0xf0)
          warnOnce(
            "Invalid UTF-8 leading byte 0x" +
              u0.toString(16) +
              " encountered when deserializing a UTF-8 string on the asm.js/wasm heap to a JS string!"
          );
        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (u8Array[idx++] & 63);
      }

      if (u0 < 0x10000) {
        str += String.fromCharCode(u0);
      } else {
        var ch = u0 - 0x10000;
        str += String.fromCharCode(0xd800 | (ch >> 10), 0xdc00 | (ch & 0x3ff));
      }
    }
  }
  return str;
}

// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
// copy of that string as a Javascript String object.
// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
//                 this parameter to scan the string until the first \0 byte. If maxBytesToRead is
//                 passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the
//                 middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
//                 not produce a string of exact length [ptr, ptr+maxBytesToRead[)
//                 N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
//                 throw JS JIT optimizations off, so it is worth to consider consistently using one
//                 style or the other.
/**
 * @param {number} ptr
 * @param {number=} maxBytesToRead
 * @return {string}
 */
function UTF8ToString(ptr, maxBytesToRead) {
  return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}

// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
//   str: the Javascript string to copy.
//   outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element.
//   outIdx: The starting offset in the array to begin the copying.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array.
//                    This count should include the null terminator,
//                    i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
//                    maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
  if (!(maxBytesToWrite > 0))
    // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
    return 0;

  var startIdx = outIdx;
  var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
    var u = str.charCodeAt(i); // possibly a lead surrogate
    if (u >= 0xd800 && u <= 0xdfff) {
      var u1 = str.charCodeAt(++i);
      u = (0x10000 + ((u & 0x3ff) << 10)) | (u1 & 0x3ff);
    }
    if (u <= 0x7f) {
      if (outIdx >= endIdx) break;
      outU8Array[outIdx++] = u;
    } else if (u <= 0x7ff) {
      if (outIdx + 1 >= endIdx) break;
      outU8Array[outIdx++] = 0xc0 | (u >> 6);
      outU8Array[outIdx++] = 0x80 | (u & 63);
    } else if (u <= 0xffff) {
      if (outIdx + 2 >= endIdx) break;
      outU8Array[outIdx++] = 0xe0 | (u >> 12);
      outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
      outU8Array[outIdx++] = 0x80 | (u & 63);
    } else {
      if (outIdx + 3 >= endIdx) break;
      if (u >= 0x200000)
        warnOnce(
          "Invalid Unicode code point 0x" +
            u.toString(16) +
            " encountered when serializing a JS string to an UTF-8 string on the asm.js/wasm heap! (Valid unicode code points should be in range 0-0x1FFFFF)."
        );
      outU8Array[outIdx++] = 0xf0 | (u >> 18);
      outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
      outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
      outU8Array[outIdx++] = 0x80 | (u & 63);
    }
  }
  // Null-terminate the pointer to the buffer.
  outU8Array[outIdx] = 0;
  return outIdx - startIdx;
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
// Returns the number of bytes written, EXCLUDING the null terminator.

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, HEAPU8, outPtr, maxBytesToWrite);
}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.
function lengthBytesUTF8(str) {
  var len = 0;
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    var u = str.charCodeAt(i); // possibly a lead surrogate
    if (u >= 0xd800 && u <= 0xdfff)
      u = (0x10000 + ((u & 0x3ff) << 10)) | (str.charCodeAt(++i) & 0x3ff);
    if (u <= 0x7f) ++len;
    else if (u <= 0x7ff) len += 2;
    else if (u <= 0xffff) len += 3;
    else len += 4;
  }
  return len;
}

// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime.

// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
// a copy of that string as a Javascript String object.

function AsciiToString(ptr) {
  var str = "";
  while (1) {
    var ch = HEAPU8[ptr++ >> 0];
    if (!ch) return str;
    str += String.fromCharCode(ch);
  }
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.

function stringToAscii(str, outPtr) {
  return writeAsciiToMemory(str, outPtr, false);
}

// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
// a copy of that string as a Javascript String object.

var UTF16Decoder =
  typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;

function UTF16ToString(ptr) {
  assert(
    ptr % 2 == 0,
    "Pointer passed to UTF16ToString must be aligned to two bytes!"
  );
  var endPtr = ptr;
  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
  // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
  var idx = endPtr >> 1;
  while (HEAP16[idx]) ++idx;
  endPtr = idx << 1;

  if (endPtr - ptr > 32 && UTF16Decoder) {
    return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
  } else {
    var i = 0;

    var str = "";
    while (1) {
      var codeUnit = HEAP16[(ptr + i * 2) >> 1];
      if (codeUnit == 0) return str;
      ++i;
      // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
      str += String.fromCharCode(codeUnit);
    }
  }
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
//   str: the Javascript string to copy.
//   outPtr: Byte address in Emscripten HEAP where to write the string to.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
//                    terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
//                    maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.

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!"
  );
  // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
  if (maxBytesToWrite === undefined) {
    maxBytesToWrite = 0x7fffffff;
  }
  if (maxBytesToWrite < 2) return 0;
  maxBytesToWrite -= 2; // Null terminator.
  var startPtr = outPtr;
  var numCharsToWrite =
    maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
  for (var i = 0; i < numCharsToWrite; ++i) {
    // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
    var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
    HEAP16[outPtr >> 1] = codeUnit;
    outPtr += 2;
  }
  // Null-terminate the pointer to the HEAP.
  HEAP16[outPtr >> 1] = 0;
  return outPtr - startPtr;
}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.

function lengthBytesUTF16(str) {
  return str.length * 2;
}

function UTF32ToString(ptr) {
  assert(
    ptr % 4 == 0,
    "Pointer passed to UTF32ToString must be aligned to four bytes!"
  );
  var i = 0;

  var str = "";
  while (1) {
    var utf32 = HEAP32[(ptr + i * 4) >> 2];
    if (utf32 == 0) return str;
    ++i;
    // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    if (utf32 >= 0x10000) {
      var ch = utf32 - 0x10000;
      str += String.fromCharCode(0xd800 | (ch >> 10), 0xdc00 | (ch & 0x3ff));
    } else {
      str += String.fromCharCode(utf32);
    }
  }
}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
//   str: the Javascript string to copy.
//   outPtr: Byte address in Emscripten HEAP where to write the string to.
//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
//                    terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
//                    maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.

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!"
  );
  // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
  if (maxBytesToWrite === undefined) {
    maxBytesToWrite = 0x7fffffff;
  }
  if (maxBytesToWrite < 4) return 0;
  var startPtr = outPtr;
  var endPtr = startPtr + maxBytesToWrite - 4;
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
    if (codeUnit >= 0xd800 && codeUnit <= 0xdfff) {
      var trailSurrogate = str.charCodeAt(++i);
      codeUnit =
        (0x10000 + ((codeUnit & 0x3ff) << 10)) | (trailSurrogate & 0x3ff);
    }
    HEAP32[outPtr >> 2] = codeUnit;
    outPtr += 4;
    if (outPtr + 4 > endPtr) break;
  }
  // Null-terminate the pointer to the HEAP.
  HEAP32[outPtr >> 2] = 0;
  return outPtr - startPtr;
}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.

function lengthBytesUTF32(str) {
  var len = 0;
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    var codeUnit = str.charCodeAt(i);
    if (codeUnit >= 0xd800 && codeUnit <= 0xdfff) ++i; // possibly a lead surrogate, so skip over the tail surrogate.
    len += 4;
  }

  return len;
}

// Allocate heap space for a JS string, and write it there.
// It is the responsibility of the caller to free() that memory.
function allocateUTF8(str) {
  var size = lengthBytesUTF8(str) + 1;
  var ret = _malloc(size);
  if (ret) stringToUTF8Array(str, HEAP8, ret, size);
  return ret;
}

// Allocate stack space for a JS string, and write it there.
function allocateUTF8OnStack(str) {
  var size = lengthBytesUTF8(str) + 1;
  var ret = stackAlloc(size);
  stringToUTF8Array(str, HEAP8, ret, size);
  return ret;
}

// Deprecated: This function should not be called because it is unsafe and does not provide
// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
// function stringToUTF8Array() instead, which takes in a maximum length that can be used
// to be secure from out of bounds writes.
/** @deprecated
    @param {boolean=} dontAddNull */
function writeStringToMemory(string, buffer, dontAddNull) {
  warnOnce(
    "writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!"
  );

  var /** @type {number} */ lastChar, /** @type {number} */ end;
  if (dontAddNull) {
    // stringToUTF8Array always appends null. If we don't want to do that, remember the
    // character that existed at the location where the null will be placed, and restore
    // that after the write (below).
    end = buffer + lengthBytesUTF8(string);
    lastChar = HEAP8[end];
  }
  stringToUTF8(string, buffer, Infinity);
  if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character.
}

function writeArrayToMemory(array, buffer) {
  assert(
    array.length >= 0,
    "writeArrayToMemory array must have a length (should be an array or typed array)"
  );
  HEAP8.set(array, buffer);
}

/** @param {boolean=} dontAddNull */
function writeAsciiToMemory(str, buffer, dontAddNull) {
  for (var i = 0; i < str.length; ++i) {
    assert((str.charCodeAt(i) === str.charCodeAt(i)) & 0xff);
    HEAP8[buffer++ >> 0] = str.charCodeAt(i);
  }
  // Null-terminate the pointer to the HEAP.
  if (!dontAddNull) HEAP8[buffer >> 0] = 0;
}

// Memory management

var PAGE_SIZE = 16384;
var WASM_PAGE_SIZE = 65536;
var ASMJS_PAGE_SIZE = 16777216;

function alignUp(x, multiple) {
  if (x % multiple > 0) {
    x += multiple - (x % multiple);
  }
  return x;
}

var HEAP,
  /** @type {ArrayBuffer} */
  buffer,
  /** @type {Int8Array} */
  HEAP8,
  /** @type {Uint8Array} */
  HEAPU8,
  /** @type {Int16Array} */
  HEAP16,
  /** @type {Uint16Array} */
  HEAPU16,
  /** @type {Int32Array} */
  HEAP32,
  /** @type {Uint32Array} */
  HEAPU32,
  /** @type {Float32Array} */
  HEAPF32,
  /** @type {Float64Array} */
  HEAPF64;

function updateGlobalBufferAndViews(buf) {
  buffer = buf;
  Module["HEAP8"] = HEAP8 = new Int8Array(buf);
  Module["HEAP16"] = HEAP16 = new Int16Array(buf);
  Module["HEAP32"] = HEAP32 = new Int32Array(buf);
  Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
  Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
  Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
  Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
  Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
}

var STATIC_BASE = 1024,
  STACK_BASE = 19593120,
  STACKTOP = STACK_BASE,
  STACK_MAX = 14350240,
  DYNAMIC_BASE = 19593120,
  DYNAMICTOP_PTR = 14350080;

assert(STACK_BASE % 16 === 0, "stack must start aligned");
assert(DYNAMIC_BASE % 16 === 0, "heap must start aligned");

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_INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 20971520;
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_INITIAL_MEMORY"
      );
    },
  });

assert(
  INITIAL_INITIAL_MEMORY >= TOTAL_STACK,
  "INITIAL_MEMORY should be larger than TOTAL_STACK, was " +
    INITIAL_INITIAL_MEMORY +
    "! (TOTAL_STACK=" +
    TOTAL_STACK +
    ")"
);

// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
assert(
  typeof Int32Array !== "undefined" &&
    typeof Float64Array !== "undefined" &&
    Int32Array.prototype.subarray !== undefined &&
    Int32Array.prototype.set !== undefined,
  "JS engine does not provide full typed array support"
);

// In standalone mode, the wasm creates the memory, and the user can't provide it.
// In non-standalone/normal mode, we create the memory here.

// Create the main memory. (Note: this isn't used in STANDALONE_WASM mode since the wasm
// memory is created in the wasm, not in JS.)

if (Module["wasmMemory"]) {
  wasmMemory = Module["wasmMemory"];
} else {
  wasmMemory = new WebAssembly.Memory({
    initial: INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE,
    maximum: INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE,
  });
}

if (wasmMemory) {
  buffer = wasmMemory.buffer;
}

// If the user provides an incorrect length, just use that length instead rather than providing the user to
// specifically provide the memory length with Module['INITIAL_MEMORY'].
INITIAL_INITIAL_MEMORY = buffer.byteLength;
assert(INITIAL_INITIAL_MEMORY % WASM_PAGE_SIZE === 0);
updateGlobalBufferAndViews(buffer);

HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;

// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie() {
  assert((STACK_MAX & 3) == 0);
  // The stack grows downwards
  HEAPU32[(STACK_MAX >> 2) + 1] = 0x2135467;
  HEAPU32[(STACK_MAX >> 2) + 2] = 0x89bacdfe;
  // Also test the global address 0 for integrity.
  // We don't do this with ASan because ASan does its own checks for this.
  HEAP32[0] = 0x63736d65; /* 'emsc' */
}

function checkStackCookie() {
  var cookie1 = HEAPU32[(STACK_MAX >> 2) + 1];
  var cookie2 = HEAPU32[(STACK_MAX >> 2) + 2];
  if (cookie1 != 0x2135467 || cookie2 != 0x89bacdfe) {
    abort(
      "Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x" +
        cookie2.toString(16) +
        " " +
        cookie1.toString(16)
    );
  }
  // Also test the global address 0 for integrity.
  // We don't do this with ASan because ASan does its own checks for this.
  if (HEAP32[0] !== 0x63736d65 /* 'emsc' */)
    abort(
      "Runtime error: The application has corrupted its heap memory area (address zero)!"
    );
}

function abortStackOverflow(allocSize) {
  abort(
    "Stack overflow! Attempted to allocate " +
      allocSize +
      " bytes on the stack, but stack has only " +
      (STACK_MAX - stackSave() + allocSize) +
      " bytes available!"
  );
}

// Endianness check (note: assumes compiler arch was little-endian)
(function () {
  var h16 = new Int16Array(1);
  var h8 = new Int8Array(h16.buffer);
  h16[0] = 0x6373;
  if (h8[0] !== 0x73 || h8[1] !== 0x63)
    throw "Runtime error: expected the system to be little-endian!";
})();

function abortFnPtrError(ptr, sig) {
  abort(
    "Invalid function pointer " +
      ptr +
      " called with signature '" +
      sig +
      "'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this). Build with ASSERTIONS=2 for more info."
  );
}

function callRuntimeCallbacks(callbacks) {
  while (callbacks.length > 0) {
    var callback = callbacks.shift();
    if (typeof callback == "function") {
      callback();
      continue;
    }
    var func = callback.func;
    if (typeof func === "number") {
      if (callback.arg === undefined) {
        Module["dynCall_v"](func);
      } else {
        Module["dynCall_vi"](func, callback.arg);
      }
    } else {
      func(callback.arg === undefined ? null : callback.arg);
    }
  }
}

var __ATPRERUN__ = []; // functions called before the runtime is initialized
var __ATINIT__ = []; // functions called during startup
var __ATMAIN__ = []; // functions called when main() is to be run
var __ATEXIT__ = []; // functions called during shutdown
var __ATPOSTRUN__ = []; // functions called after the main() is called

var runtimeInitialized = false;
var runtimeExited = false;

function preRun() {
  if (Module["preRun"]) {
    if (typeof Module["preRun"] == "function")
      Module["preRun"] = [Module["preRun"]];
    while (Module["preRun"].length) {
      addOnPreRun(Module["preRun"].shift());
    }
  }

  callRuntimeCallbacks(__ATPRERUN__);
}

function initRuntime() {
  checkStackCookie();
  assert(!runtimeInitialized);
  runtimeInitialized = true;
  if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
  TTY.init();
  callRuntimeCallbacks(__ATINIT__);
}

function preMain() {
  checkStackCookie();
  FS.ignorePermissions = false;
  callRuntimeCallbacks(__ATMAIN__);
}

function exitRuntime() {
  checkStackCookie();
  runtimeExited = true;
}

function postRun() {
  checkStackCookie();

  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);
}

/** @param {number|boolean=} ignore */
function unSign(value, bits, ignore) {
  if (value >= 0) {
    return value;
  }
  return bits <= 32
    ? 2 * Math.abs(1 << (bits - 1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
    : Math.pow(2, bits) + value;
}
/** @param {number|boolean=} ignore */
function reSign(value, bits, ignore) {
  if (value <= 0) {
    return value;
  }
  var half =
    bits <= 32
      ? Math.abs(1 << (bits - 1)) // abs is needed if bits == 32
      : Math.pow(2, bits - 1);
  if (value >= half && (bits <= 32 || value > half)) {
    // for huge values, we can hit the precision limit and always get true here. so don't do that
    // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
    // TODO: In i64 mode 1, resign the two parts separately and safely
    value = -2 * half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
  }
  return value;
}

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc

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 Math_abs = Math.abs;
var Math_cos = Math.cos;
var Math_sin = Math.sin;
var Math_tan = Math.tan;
var Math_acos = Math.acos;
var Math_asin = Math.asin;
var Math_atan = Math.atan;
var Math_atan2 = Math.atan2;
var Math_exp = Math.exp;
var Math_log = Math.log;
var Math_sqrt = Math.sqrt;
var Math_ceil = Math.ceil;
var Math_floor = Math.floor;
var Math_pow = Math.pow;
var Math_imul = Math.imul;
var Math_fround = Math.fround;
var Math_round = Math.round;
var Math_min = Math.min;
var Math_max = Math.max;
var Math_clz32 = Math.clz32;
var Math_trunc = Math.trunc;

// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
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") {
      // Check for missing dependencies every few seconds
      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)");
        }
      }, 10000);
    }
  } 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(); // can add another dependenciesFulfilled
    }
  }
}

Module["preloadedImages"] = {}; // maps url to image data
Module["preloadedAudios"] = {}; // maps url to audio data

/** @param {string|number=} what */
function abort(what) {
  if (Module["onAbort"]) {
    Module["onAbort"](what);
  }

  what += "";
  out(what);
  err(what);

  ABORT = true;
  EXITSTATUS = 1;

  var output = "abort(" + what + ") at " + stackTrace();
  what = output;

  // Throw a wasm runtime error, because a JS error might be seen as a foreign
  // exception, which means we'd run destructors on it. We need the error to
  // simply make the program stop.
  throw new WebAssembly.RuntimeError(what);
}

var memoryInitializer = null;

// Copyright 2017 The Emscripten Authors.  All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License.  Both these licenses can be
// found in the LICENSE file.

// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = "data:application/octet-stream;base64,";

// Indicates whether filename is a base64 data URI.
function isDataURI(filename) {
  return String.prototype.startsWith
    ? filename.startsWith(dataURIPrefix)
    : filename.indexOf(dataURIPrefix) === 0;
}

var wasmBinaryFile = "sm64.us.f3dex2e.wasm";
if (!isDataURI(wasmBinaryFile)) {
  wasmBinaryFile = locateFile(wasmBinaryFile);
}

function getBinary() {
  try {
    if (wasmBinary) {
      return new Uint8Array(wasmBinary);
    }

    if (readBinary) {
      return readBinary(wasmBinaryFile);
    } else {
      throw "both async and sync fetching of the wasm failed";
    }
  } catch (err) {
    abort(err);
  }
}

function getBinaryPromise() {
  // if we don't have the binary yet, and have the Fetch api, use that
  // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web
  if (
    !wasmBinary &&
    (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) &&
    typeof fetch === "function"
  ) {
    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();
      });
  }
  // Otherwise, getBinary should be able to get it synchronously
  return new Promise(function (resolve, reject) {
    resolve(getBinary());
  });
}

// Create the wasm instance.
// Receives the wasm imports, returns the exports.
function createWasm() {
  // prepare imports
  var info = {
    env: asmLibraryArg,
    wasi_snapshot_preview1: asmLibraryArg,
  };
  // Load the wasm module and create an instance of using native support in the JS engine.
  // handle a generated wasm instance, receiving its exports and
  // performing other necessary setup
  /** @param {WebAssembly.Module=} module*/
  function receiveInstance(instance, module) {
    var exports = instance.exports;
    Module["asm"] = exports;
    removeRunDependency("wasm-instantiate");
  }
  // we can't run yet (except in a pthread, where we have a custom sync instantiator)
  addRunDependency("wasm-instantiate");

  // Async compilation can be confusing when an error on the page overwrites Module
  // (for example, if the order of elements is wrong, and the one defining Module is
  // later), so we save Module and check it later.
  var trueModule = Module;
  function receiveInstantiatedSource(output) {
    // 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance.
    // receiveInstance() will swap in the exports (to Module.asm) so they can be called
    assert(
      Module === trueModule,
      "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"
    );
    trueModule = null;
    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
    // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
    receiveInstance(output["instance"]);
  }

  function instantiateArrayBuffer(receiver) {
    return getBinaryPromise()
      .then(function (binary) {
        return WebAssembly.instantiate(binary, info);
      })
      .then(receiver, function (reason) {
        err("failed to asynchronously prepare wasm: " + reason);
        abort(reason);
      });
  }

  // Prefer streaming instantiation if available.
  function instantiateAsync() {
    if (
      !wasmBinary &&
      typeof WebAssembly.instantiateStreaming === "function" &&
      !isDataURI(wasmBinaryFile) &&
      typeof fetch === "function"
    ) {
      fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (
        response
      ) {
        var result = WebAssembly.instantiateStreaming(response, info);
        return result.then(receiveInstantiatedSource, function (reason) {
          // We expect the most common failure cause to be a bad MIME type for the binary,
          // in which case falling back to ArrayBuffer instantiation should work.
          err("wasm streaming compile failed: " + reason);
          err("falling back to ArrayBuffer instantiation");
          instantiateArrayBuffer(receiveInstantiatedSource);
        });
      });
    } else {
      return instantiateArrayBuffer(receiveInstantiatedSource);
    }
  }
  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
  // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
  // to any other async startup actions they are performing.
  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 {}; // no exports yet; we'll fill them in later
}

// Globals used by JS i64 conversions
var tempDouble;
var tempI64;

// === Body ===

var ASM_CONSTS = {
  3069901: function ($0) {
    requestAnimationFrame(function (time) {
      dynCall("vd", $0, [time]);
    });
  },
  3069970: function ($0) {
    var s = localStorage.sm64_save_file;
    if (s && s.length === 684) {
      try {
        var binary = atob(s);
        if (binary.length === 512) {
          for (var i = 0; i < 512; i++) {
            HEAPU8[$0 + i] = binary.charCodeAt(i);
          }
          return 1;
        }
      } catch (e) {}
    }
    return 0;
  },
  3070210: function ($0) {
    var str = "";
    for (var i = 0; i < 512; i++) {
      str += String.fromCharCode(HEAPU8[$0 + i]);
    }
    localStorage.sm64_save_file = btoa(str);
  },
  8775252: function ($0, $1, $2) {
    var w = $0;
    var h = $1;
    var pixels = $2;
    if (!Module["SDL2"]) Module["SDL2"] = {};
    var SDL2 = Module["SDL2"];
    if (SDL2.ctxCanvas !== Module["canvas"]) {
      SDL2.ctx = Module["createContext"](Module["canvas"], false, true);
      SDL2.ctxCanvas = Module["canvas"];
    }
    if (SDL2.w !== w || SDL2.h !== h || SDL2.imageCtx !== SDL2.ctx) {
      SDL2.image = SDL2.ctx.createImageData(w, h);
      SDL2.w = w;
      SDL2.h = h;
      SDL2.imageCtx = SDL2.ctx;
    }
    var data = SDL2.image.data;
    var src = pixels >> 2;
    var dst = 0;
    var num;
    if (
      typeof CanvasPixelArray !== "undefined" &&
      data instanceof CanvasPixelArray
    ) {
      num = data.length;
      while (dst < num) {
        var val = HEAP32[src];
        data[dst] = val & 0xff;
        data[dst + 1] = (val >> 8) & 0xff;
        data[dst + 2] = (val >> 16) & 0xff;
        data[dst + 3] = 0xff;
        src++;
        dst += 4;
      }
    } else {
      if (SDL2.data32Data !== data) {
        SDL2.data32 = new Int32Array(data.buffer);
        SDL2.data8 = new Uint8Array(data.buffer);
      }
      var data32 = SDL2.data32;
      num = data32.length;
      data32.set(HEAP32.subarray(src, src + num));
      var data8 = SDL2.data8;
      var i = 3;
      var j = i + 4 * num;
      if (num % 8 == 0) {
        while (i < j) {
          data8[i] = 0xff;
          i = (i + 4) | 0;
          data8[i] = 0xff;
          i = (i + 4) | 0;
          data8[i] = 0xff;
          i = (i + 4) | 0;
          data8[i] = 0xff;
          i = (i + 4) | 0;
          data8[i] = 0xff;
          i = (i + 4) | 0;
          data8[i] = 0xff;
          i = (i + 4) | 0;
          data8[i] = 0xff;
          i = (i + 4) | 0;
          data8[i] = 0xff;
          i = (i + 4) | 0;
        }
      } else {
        while (i < j) {
          data8[i] = 0xff;
          i = (i + 4) | 0;
        }
      }
    }
    SDL2.ctx.putImageData(SDL2.image, 0, 0);
    return 0;
  },
  8776707: function ($0, $1, $2, $3, $4) {
    var w = $0;
    var h = $1;
    var hot_x = $2;
    var hot_y = $3;
    var pixels = $4;
    var canvas = document.createElement("canvas");
    canvas.width = w;
    canvas.height = h;
    var ctx = canvas.getContext("2d");
    var image = ctx.createImageData(w, h);
    var data = image.data;
    var src = pixels >> 2;
    var dst = 0;
    var num;
    if (
      typeof CanvasPixelArray !== "undefined" &&
      data instanceof CanvasPixelArray
    ) {
      num = data.length;
      while (dst < num) {
        var val = HEAP32[src];
        data[dst] = val & 0xff;
        data[dst + 1] = (val >> 8) & 0xff;
        data[dst + 2] = (val >> 16) & 0xff;
        data[dst + 3] = (val >> 24) & 0xff;
        src++;
        dst += 4;
      }
    } else {
      var data32 = new Int32Array(data.buffer);
      num = data32.length;
      data32.set(HEAP32.subarray(src, src + num));
    }
    ctx.putImageData(image, 0, 0);
    var url =
      hot_x === 0 && hot_y === 0
        ? "url(" + canvas.toDataURL() + "), auto"
        : "url(" + canvas.toDataURL() + ") " + hot_x + " " + hot_y + ", auto";
    var urlBuf = _malloc(url.length + 1);
    stringToUTF8(url, urlBuf, url.length + 1);
    return urlBuf;
  },
  8777696: function ($0) {
    if (Module["canvas"]) {
      Module["canvas"].style["cursor"] = UTF8ToString($0);
    }
    return 0;
  },
  8777789: function () {
    if (Module["canvas"]) {
      Module["canvas"].style["cursor"] = "none";
    }
  },
  8779014: function () {
    return screen.width;
  },
  8779041: function () {
    return screen.height;
  },
  8779069: function () {
    return window.innerWidth;
  },
  8779101: function () {
    return window.innerHeight;
  },
  8779179: function ($0) {
    if (typeof Module["setWindowTitle"] !== "undefined") {
      Module["setWindowTitle"](UTF8ToString($0));
    }
    return 0;
  },
  8779333: function () {
    if (typeof AudioContext !== "undefined") {
      return 1;
    } else if (typeof webkitAudioContext !== "undefined") {
      return 1;
    }
    return 0;
  },
  8779499: function () {
    if (
      typeof navigator.mediaDevices !== "undefined" &&
      typeof navigator.mediaDevices.getUserMedia !== "undefined"
    ) {
      return 1;
    } else if (typeof navigator.webkitGetUserMedia !== "undefined") {
      return 1;
    }
    return 0;
  },
  8779725: function ($0) {
    if (typeof Module["SDL2"] === "undefined") {
      Module["SDL2"] = {};
    }
    var SDL2 = Module["SDL2"];
    if (!$0) {
      SDL2.audio = {};
    } else {
      SDL2.capture = {};
    }
    if (!SDL2.audioContext) {
      if (typeof AudioContext !== "undefined") {
        SDL2.audioContext = new AudioContext();
      } else if (typeof webkitAudioContext !== "undefined") {
        SDL2.audioContext = new webkitAudioContext();
      }
    }
    return SDL2.audioContext === undefined ? -1 : 0;
  },
  8780208: function () {
    var SDL2 = Module["SDL2"];
    return SDL2.audioContext.sampleRate;
  },
  8780278: function ($0, $1, $2, $3) {
    var SDL2 = Module["SDL2"];
    var have_microphone = function (stream) {
      if (SDL2.capture.silenceTimer !== undefined) {
        clearTimeout(SDL2.capture.silenceTimer);
        SDL2.capture.silenceTimer = undefined;
      }
      SDL2.capture.mediaStreamNode =
        SDL2.audioContext.createMediaStreamSource(stream);
      SDL2.capture.scriptProcessorNode =
        SDL2.audioContext.createScriptProcessor($1, $0, 1);
      SDL2.capture.scriptProcessorNode.onaudioprocess = function (
        audioProcessingEvent
      ) {
        if (SDL2 === undefined || SDL2.capture === undefined) {
          return;
        }
        audioProcessingEvent.outputBuffer.getChannelData(0).fill(0.0);
        SDL2.capture.currentCaptureBuffer = audioProcessingEvent.inputBuffer;
        dynCall("vi", $2, [$3]);
      };
      SDL2.capture.mediaStreamNode.connect(SDL2.capture.scriptProcessorNode);
      SDL2.capture.scriptProcessorNode.connect(SDL2.audioContext.destination);
      SDL2.capture.stream = stream;
    };
    var no_microphone = function (error) {};
    SDL2.capture.silenceBuffer = SDL2.audioContext.createBuffer(
      $0,
      $1,
      SDL2.audioContext.sampleRate
    );
    SDL2.capture.silenceBuffer.getChannelData(0).fill(0.0);
    var silence_callback = function () {
      SDL2.capture.currentCaptureBuffer = SDL2.capture.silenceBuffer;
      dynCall("vi", $2, [$3]);
    };
    SDL2.capture.silenceTimer = setTimeout(
      silence_callback,
      ($1 / SDL2.audioContext.sampleRate) * 1000
    );
    if (
      navigator.mediaDevices !== undefined &&
      navigator.mediaDevices.getUserMedia !== undefined
    ) {
      navigator.mediaDevices
        .getUserMedia({ audio: true, video: false })
        .then(have_microphone)
        .catch(no_microphone);
    } else if (navigator.webkitGetUserMedia !== undefined) {
      navigator.webkitGetUserMedia(
        { audio: true, video: false },
        have_microphone,
        no_microphone
      );
    }
  },
  8781930: function ($0, $1, $2, $3) {
    var SDL2 = Module["SDL2"];
    SDL2.audio.scriptProcessorNode = SDL2.audioContext["createScriptProcessor"](
      $1,
      0,
      $0
    );
    SDL2.audio.scriptProcessorNode["onaudioprocess"] = function (e) {
      if (SDL2 === undefined || SDL2.audio === undefined) {
        return;
      }
      SDL2.audio.currentOutputBuffer = e["outputBuffer"];
      dynCall("vi", $2, [$3]);
    };
    SDL2.audio.scriptProcessorNode["connect"](SDL2.audioContext["destination"]);
  },
  8782340: function ($0, $1) {
    var SDL2 = Module["SDL2"];
    var numChannels = SDL2.capture.currentCaptureBuffer.numberOfChannels;
    for (var c = 0; c < numChannels; ++c) {
      var channelData = SDL2.capture.currentCaptureBuffer.getChannelData(c);
      if (channelData.length != $1) {
        throw (
          "Web Audio capture buffer length mismatch! Destination size: " +
          channelData.length +
          " samples vs expected " +
          $1 +
          " samples!"
        );
      }
      if (numChannels == 1) {
        for (var j = 0; j < $1; ++j) {
          setValue($0 + j * 4, channelData[j], "float");
        }
      } else {
        for (var j = 0; j < $1; ++j) {
          setValue($0 + (j * numChannels + c) * 4, channelData[j], "float");
        }
      }
    }
  },
  8782945: function ($0, $1) {
    var SDL2 = Module["SDL2"];
    var numChannels = SDL2.audio.currentOutputBuffer["numberOfChannels"];
    for (var c = 0; c < numChannels; ++c) {
      var channelData = SDL2.audio.currentOutputBuffer["getChannelData"](c);
      if (channelData.length != $1) {
        throw (
          "Web Audio output buffer length mismatch! Destination size: " +
          channelData.length +
          " samples vs expected " +
          $1 +
          " samples!"
        );
      }
      for (var j = 0; j < $1; ++j) {
        channelData[j] = HEAPF32[($0 + ((j * numChannels + c) << 2)) >> 2];
      }
    }
  },
  8783425: function ($0) {
    var SDL2 = Module["SDL2"];
    if ($0) {
      if (SDL2.capture.silenceTimer !== undefined) {
        clearTimeout(SDL2.capture.silenceTimer);
      }
      if (SDL2.capture.stream !== undefined) {
        var tracks = SDL2.capture.stream.getAudioTracks();
        for (var i = 0; i < tracks.length; i++) {
          SDL2.capture.stream.removeTrack(tracks[i]);
        }
        SDL2.capture.stream = undefined;
      }
      if (SDL2.capture.scriptProcessorNode !== undefined) {
        SDL2.capture.scriptProcessorNode.onaudioprocess = function (
          audioProcessingEvent
        ) {};
        SDL2.capture.scriptProcessorNode.disconnect();
        SDL2.capture.scriptProcessorNode = undefined;
      }
      if (SDL2.capture.mediaStreamNode !== undefined) {
        SDL2.capture.mediaStreamNode.disconnect();
        SDL2.capture.mediaStreamNode = undefined;
      }
      if (SDL2.capture.silenceBuffer !== undefined) {
        SDL2.capture.silenceBuffer = undefined;
      }
      SDL2.capture = undefined;
    } else {
      if (SDL2.audio.scriptProcessorNode != undefined) {
        SDL2.audio.scriptProcessorNode.disconnect();
        SDL2.audio.scriptProcessorNode = undefined;
      }
      SDL2.audio = undefined;
    }
    if (
      SDL2.audioContext !== undefined &&
      SDL2.audio === undefined &&
      SDL2.capture === undefined
    ) {
      SDL2.audioContext.close();
      SDL2.audioContext = undefined;
    }
  },
};

function _emscripten_asm_const_iii(code, sigPtr, argbuf) {
  var args = readAsmConstArgs(sigPtr, argbuf);
  return ASM_CONSTS[code].apply(null, args);
}

// STATICTOP = STATIC_BASE + 14349216;
/* global initializers */ __ATINIT__.push({
  func: function () {
    ___wasm_call_ctors();
  },
});

/* no memory initializer */
// {{PRE_LIBRARY}}

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 jsStackTrace() {
  var err = new Error();
  if (!err.stack) {
    // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
    // so try that as a special-case.
    try {
      throw new Error();
    } catch (e) {
      err = e;
    }
    if (!err.stack) {
      return "(no stack trace available)";
    }
  }
  return err.stack.toString();
}

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",
      ]
  );
}

function ___handle_stack_overflow() {
  abort("stack overflow");
}

function ___setErrNo(value) {
  if (Module["___errno_location"])
    HEAP32[Module["___errno_location"]() >> 2] = value;
  else err("failed to set errno from JS");
  return value;
}

var PATH = {
  splitPath: function (filename) {
    var splitPathRe =
      /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
    return splitPathRe.exec(filename).slice(1);
  },
  normalizeArray: function (parts, allowAboveRoot) {
    // if the path tries to go above the root, `up` ends up > 0
    var up = 0;
    for (var i = parts.length - 1; i >= 0; i--) {
      var last = parts[i];
      if (last === ".") {
        parts.splice(i, 1);
      } else if (last === "..") {
        parts.splice(i, 1);
        up++;
      } else if (up) {
        parts.splice(i, 1);
        up--;
      }
    }
    // if the path is allowed to go above the root, restore leading ..s
    if (allowAboveRoot) {
      for (; up; up--) {
        parts.unshift("..");
      }
    }
    return parts;
  },
  normalize: function (path) {
    var isAbsolute = path.charAt(0) === "/",
      trailingSlash = path.substr(-1) === "/";
    // Normalize the path
    path = PATH.normalizeArray(
      path.split("/").filter(function (p) {
        return !!p;
      }),
      !isAbsolute
    ).join("/");
    if (!path && !isAbsolute) {
      path = ".";
    }
    if (path && trailingSlash) {
      path += "/";
    }
    return (isAbsolute ? "/" : "") + path;
  },
  dirname: function (path) {
    var result = PATH.splitPath(path),
      root = result[0],
      dir = result[1];
    if (!root && !dir) {
      // No dirname whatsoever
      return ".";
    }
    if (dir) {
      // It has a dirname, strip trailing slash
      dir = dir.substr(0, dir.length - 1);
    }
    return root + dir;
  },
  basename: function (path) {
    // EMSCRIPTEN return '/'' for '/', not an empty string
    if (path === "/") return "/";
    var lastSlash = path.lastIndexOf("/");
    if (lastSlash === -1) return path;
    return path.substr(lastSlash + 1);
  },
  extname: function (path) {
    return PATH.splitPath(path)[3];
  },
  join: function () {
    var paths = Array.prototype.slice.call(arguments, 0);
    return PATH.normalize(paths.join("/"));
  },
  join2: function (l, r) {
    return PATH.normalize(l + "/" + r);
  },
};

var PATH_FS = {
  resolve: function () {
    var resolvedPath = "",
      resolvedAbsolute = false;
    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
      var path = i >= 0 ? arguments[i] : FS.cwd();
      // Skip empty and invalid entries
      if (typeof path !== "string") {
        throw new TypeError("Arguments to path.resolve must be strings");
      } else if (!path) {
        return ""; // an invalid portion invalidates the whole thing
      }
      resolvedPath = path + "/" + resolvedPath;
      resolvedAbsolute = path.charAt(0) === "/";
    }
    // At this point the path should be resolved to a full absolute path, but
    // handle relative paths to be safe (might happen when process.cwd() fails)
    resolvedPath = PATH.normalizeArray(
      resolvedPath.split("/").filter(function (p) {
        return !!p;
      }),
      !resolvedAbsolute
    ).join("/");
    return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
  },
  relative: function (from, to) {
    from = PATH_FS.resolve(from).substr(1);
    to = PATH_FS.resolve(to).substr(1);
    function trim(arr) {
      var start = 0;
      for (; start < arr.length; start++) {
        if (arr[start] !== "") break;
      }
      var end = arr.length - 1;
      for (; end >= 0; end--) {
        if (arr[end] !== "") break;
      }
      if (start > end) return [];
      return arr.slice(start, end - start + 1);
    }
    var fromParts = trim(from.split("/"));
    var toParts = trim(to.split("/"));
    var length = Math.min(fromParts.length, toParts.length);
    var samePartsLength = length;
    for (var i = 0; i < length; i++) {
      if (fromParts[i] !== toParts[i]) {
        samePartsLength = i;
        break;
      }
    }
    var outputParts = [];
    for (var i = samePartsLength; i < fromParts.length; i++) {
      outputParts.push("..");
    }
    outputParts = outputParts.concat(toParts.slice(samePartsLength));
    return outputParts.join("/");
  },
};

var TTY = {
  ttys: [],
  init: function () {
    // https://github.com/emscripten-core/emscripten/pull/1555
    // if (ENVIRONMENT_IS_NODE) {
    //   // currently, FS.init does not distinguish if process.stdin is a file or TTY
    //   // device, it always assumes it's a TTY device. because of this, we're forcing
    //   // process.stdin to UTF8 encoding to at least make stdin reading compatible
    //   // with text files until FS.init can be refactored.
    //   process['stdin']['setEncoding']('utf8');
    // }
  },
  shutdown: function () {
    // https://github.com/emscripten-core/emscripten/pull/1555
    // if (ENVIRONMENT_IS_NODE) {
    //   // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
    //   // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
    //   // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
    //   // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
    //   // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
    //   process['stdin']['pause']();
    // }
  },
  register: function (dev, ops) {
    TTY.ttys[dev] = { input: [], output: [], ops: ops };
    FS.registerDevice(dev, TTY.stream_ops);
  },
  stream_ops: {
    open: function (stream) {
      var tty = TTY.ttys[stream.node.rdev];
      if (!tty) {
        throw new FS.ErrnoError(43);
      }
      stream.tty = tty;
      stream.seekable = false;
    },
    close: function (stream) {
      // flush any pending line data
      stream.tty.ops.flush(stream.tty);
    },
    flush: function (stream) {
      stream.tty.ops.flush(stream.tty);
    },
    read: function (stream, buffer, offset, length, pos /* ignored */) {
      if (!stream.tty || !stream.tty.ops.get_char) {
        throw new FS.ErrnoError(60);
      }
      var bytesRead = 0;
      for (var i = 0; i < length; i++) {
        var result;
        try {
          result = stream.tty.ops.get_char(stream.tty);
        } catch (e) {
          throw new FS.ErrnoError(29);
        }
        if (result === undefined && bytesRead === 0) {
          throw new FS.ErrnoError(6);
        }
        if (result === null || result === undefined) break;
        bytesRead++;
        buffer[offset + i] = result;
      }
      if (bytesRead) {
        stream.node.timestamp = Date.now();
      }
      return bytesRead;
    },
    write: function (stream, buffer, offset, length, pos) {
      if (!stream.tty || !stream.tty.ops.put_char) {
        throw new FS.ErrnoError(60);
      }
      try {
        for (var i = 0; i < length; i++) {
          stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
        }
      } catch (e) {
        throw new FS.ErrnoError(29);
      }
      if (length) {
        stream.node.timestamp = Date.now();
      }
      return i;
    },
  },
  default_tty_ops: {
    get_char: function (tty) {
      if (!tty.input.length) {
        var result = null;
        if (ENVIRONMENT_IS_NODE) {
          // we will read data by chunks of BUFSIZE
          var BUFSIZE = 256;
          var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE);
          var bytesRead = 0;

          try {
            bytesRead = nodeFS.readSync(
              process.stdin.fd,
              buf,
              0,
              BUFSIZE,
              null
            );
          } catch (e) {
            // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes,
            // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0.
            if (e.toString().indexOf("EOF") != -1) bytesRead = 0;
            else throw e;
          }

          if (bytesRead > 0) {
            result = buf.slice(0, bytesRead).toString("utf-8");
          } else {
            result = null;
          }
        } else if (
          typeof window != "undefined" &&
          typeof window.prompt == "function"
        ) {
          // Browser.
          result = window.prompt("Input: "); // returns null on cancel
          if (result !== null) {
            result += "\n";
          }
        } else if (typeof readline == "function") {
          // Command line.
          result = readline();
          if (result !== null) {
            result += "\n";
          }
        }
        if (!result) {
          return null;
        }
        tty.input = intArrayFromString(result, true);
      }
      return tty.input.shift();
    },
    put_char: function (tty, val) {
      if (val === null || val === 10) {
        out(UTF8ArrayToString(tty.output, 0));
        tty.output = [];
      } else {
        if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle.
      }
    },
    flush: function (tty) {
      if (tty.output && tty.output.length > 0) {
        out(UTF8ArrayToString(tty.output, 0));
        tty.output = [];
      }
    },
  },
  default_tty1_ops: {
    put_char: function (tty, val) {
      if (val === null || val === 10) {
        err(UTF8ArrayToString(tty.output, 0));
        tty.output = [];
      } else {
        if (val != 0) tty.output.push(val);
      }
    },
    flush: function (tty) {
      if (tty.output && tty.output.length > 0) {
        err(UTF8ArrayToString(tty.output, 0));
        tty.output = [];
      }
    },
  },
};

var MEMFS = {
  ops_table: null,
  mount: function (mount) {
    return MEMFS.createNode(null, "/", 16384 | 511 /* 0777 */, 0);
  },
  createNode: function (parent, name, mode, dev) {
    if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
      // no supported
      throw new FS.ErrnoError(63);
    }
    if (!MEMFS.ops_table) {
      MEMFS.ops_table = {
        dir: {
          node: {
            getattr: MEMFS.node_ops.getattr,
            setattr: MEMFS.node_ops.setattr,
            lookup: MEMFS.node_ops.lookup,
            mknod: MEMFS.node_ops.mknod,
            rename: MEMFS.node_ops.rename,
            unlink: MEMFS.node_ops.unlink,
            rmdir: MEMFS.node_ops.rmdir,
            readdir: MEMFS.node_ops.readdir,
            symlink: MEMFS.node_ops.symlink,
          },
          stream: {
            llseek: MEMFS.stream_ops.llseek,
          },
        },
        file: {
          node: {
            getattr: MEMFS.node_ops.getattr,
            setattr: MEMFS.node_ops.setattr,
          },
          stream: {
            llseek: MEMFS.stream_ops.llseek,
            read: MEMFS.stream_ops.read,
            write: MEMFS.stream_ops.write,
            allocate: MEMFS.stream_ops.allocate,
            mmap: MEMFS.stream_ops.mmap,
            msync: MEMFS.stream_ops.msync,
          },
        },
        link: {
          node: {
            getattr: MEMFS.node_ops.getattr,
            setattr: MEMFS.node_ops.setattr,
            readlink: MEMFS.node_ops.readlink,
          },
          stream: {},
        },
        chrdev: {
          node: {
            getattr: MEMFS.node_ops.getattr,
            setattr: MEMFS.node_ops.setattr,
          },
          stream: FS.chrdev_stream_ops,
        },
      };
    }
    var node = FS.createNode(parent, name, mode, dev);
    if (FS.isDir(node.mode)) {
      node.node_ops = MEMFS.ops_table.dir.node;
      node.stream_ops = MEMFS.ops_table.dir.stream;
      node.contents = {};
    } else if (FS.isFile(node.mode)) {
      node.node_ops = MEMFS.ops_table.file.node;
      node.stream_ops = MEMFS.ops_table.file.stream;
      node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity.
      // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred
      // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size
      // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme.
      node.contents = null;
    } else if (FS.isLink(node.mode)) {
      node.node_ops = MEMFS.ops_table.link.node;
      node.stream_ops = MEMFS.ops_table.link.stream;
    } else if (FS.isChrdev(node.mode)) {
      node.node_ops = MEMFS.ops_table.chrdev.node;
      node.stream_ops = MEMFS.ops_table.chrdev.stream;
    }
    node.timestamp = Date.now();
    // add the new node to the parent
    if (parent) {
      parent.contents[name] = node;
    }
    return node;
  },
  getFileDataAsRegularArray: function (node) {
    if (node.contents && node.contents.subarray) {
      var arr = [];
      for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]);
      return arr; // Returns a copy of the original data.
    }
    return node.contents; // No-op, the file contents are already in a JS array. Return as-is.
  },
  getFileDataAsTypedArray: function (node) {
    if (!node.contents) return new Uint8Array(0);
    if (node.contents.subarray)
      return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes.
    return new Uint8Array(node.contents);
  },
  expandFileStorage: function (node, newCapacity) {
    var prevCapacity = node.contents ? node.contents.length : 0;
    if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough.
    // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity.
    // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to
    // avoid overshooting the allocation cap by a very large margin.
    var CAPACITY_DOUBLING_MAX = 1024 * 1024;
    newCapacity = Math.max(
      newCapacity,
      (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) | 0
    );
    if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding.
    var oldContents = node.contents;
    node.contents = new Uint8Array(newCapacity); // Allocate new storage.
    if (node.usedBytes > 0)
      node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage.
    return;
  },
  resizeFileStorage: function (node, newSize) {
    if (node.usedBytes == newSize) return;
    if (newSize == 0) {
      node.contents = null; // Fully decommit when requesting a resize to zero.
      node.usedBytes = 0;
      return;
    }
    if (!node.contents || node.contents.subarray) {
      // Resize a typed array if that is being used as the backing store.
      var oldContents = node.contents;
      node.contents = new Uint8Array(newSize); // Allocate new storage.
      if (oldContents) {
        node.contents.set(
          oldContents.subarray(0, Math.min(newSize, node.usedBytes))
        ); // Copy old data over to the new storage.
      }
      node.usedBytes = newSize;
      return;
    }
    // Backing with a JS array.
    if (!node.contents) node.contents = [];
    if (node.contents.length > newSize) node.contents.length = newSize;
    else while (node.contents.length < newSize) node.contents.push(0);
    node.usedBytes = newSize;
  },
  node_ops: {
    getattr: function (node) {
      var attr = {};
      // device numbers reuse inode numbers.
      attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
      attr.ino = node.id;
      attr.mode = node.mode;
      attr.nlink = 1;
      attr.uid = 0;
      attr.gid = 0;
      attr.rdev = node.rdev;
      if (FS.isDir(node.mode)) {
        attr.size = 4096;
      } else if (FS.isFile(node.mode)) {
        attr.size = node.usedBytes;
      } else if (FS.isLink(node.mode)) {
        attr.size = node.link.length;
      } else {
        attr.size = 0;
      }
      attr.atime = new Date(node.timestamp);
      attr.mtime = new Date(node.timestamp);
      attr.ctime = new Date(node.timestamp);
      // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
      //       but this is not required by the standard.
      attr.blksize = 4096;
      attr.blocks = Math.ceil(attr.size / attr.blksize);
      return attr;
    },
    setattr: function (node, attr) {
      if (attr.mode !== undefined) {
        node.mode = attr.mode;
      }
      if (attr.timestamp !== undefined) {
        node.timestamp = attr.timestamp;
      }
      if (attr.size !== undefined) {
        MEMFS.resizeFileStorage(node, attr.size);
      }
    },
    lookup: function (parent, name) {
      throw FS.genericErrors[44];
    },
    mknod: function (parent, name, mode, dev) {
      return MEMFS.createNode(parent, name, mode, dev);
    },
    rename: function (old_node, new_dir, new_name) {
      // if we're overwriting a directory at new_name, make sure it's empty.
      if (FS.isDir(old_node.mode)) {
        var new_node;
        try {
          new_node = FS.lookupNode(new_dir, new_name);
        } catch (e) {}
        if (new_node) {
          for (var i in new_node.contents) {
            throw new FS.ErrnoError(55);
          }
        }
      }
      // do the internal rewiring
      delete old_node.parent.contents[old_node.name];
      old_node.name = new_name;
      new_dir.contents[new_name] = old_node;
      old_node.parent = new_dir;
    },
    unlink: function (parent, name) {
      delete parent.contents[name];
    },
    rmdir: function (parent, name) {
      var node = FS.lookupNode(parent, name);
      for (var i in node.contents) {
        throw new FS.ErrnoError(55);
      }
      delete parent.contents[name];
    },
    readdir: function (node) {
      var entries = [".", ".."];
      for (var key in node.contents) {
        if (!node.contents.hasOwnProperty(key)) {
          continue;
        }
        entries.push(key);
      }
      return entries;
    },
    symlink: function (parent, newname, oldpath) {
      var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
      node.link = oldpath;
      return node;
    },
    readlink: function (node) {
      if (!FS.isLink(node.mode)) {
        throw new FS.ErrnoError(28);
      }
      return node.link;
    },
  },
  stream_ops: {
    read: function (stream, buffer, offset, length, position) {
      var contents = stream.node.contents;
      if (position >= stream.node.usedBytes) return 0;
      var size = Math.min(stream.node.usedBytes - position, length);
      assert(size >= 0);
      if (size > 8 && contents.subarray) {
        // non-trivial, and typed array
        buffer.set(contents.subarray(position, position + size), offset);
      } else {
        for (var i = 0; i < size; i++)
          buffer[offset + i] = contents[position + i];
      }
      return size;
    },
    write: function (stream, buffer, offset, length, position, canOwn) {
      // The data buffer should be a typed array view
      assert(!(buffer instanceof ArrayBuffer));

      if (!length) return 0;
      var node = stream.node;
      node.timestamp = Date.now();

      if (buffer.subarray && (!node.contents || node.contents.subarray)) {
        // This write is from a typed array to a typed array?
        if (canOwn) {
          assert(
            position === 0,
            "canOwn must imply no weird position inside the file"
          );
          node.contents = buffer.subarray(offset, offset + length);
          node.usedBytes = length;
          return length;
        } else if (node.usedBytes === 0 && position === 0) {
          // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data.
          node.contents = buffer.slice(offset, offset + length);
          node.usedBytes = length;
          return length;
        } else if (position + length <= node.usedBytes) {
          // Writing to an already allocated and used subrange of the file?
          node.contents.set(buffer.subarray(offset, offset + length), position);
          return length;
        }
      }

      // Appending to an existing file and we need to reallocate, or source data did not come as a typed array.
      MEMFS.expandFileStorage(node, position + length);
      if (node.contents.subarray && buffer.subarray)
        node.contents.set(
          buffer.subarray(offset, offset + length),
          position
        ); // Use typed array write if available.
      else {
        for (var i = 0; i < length; i++) {
          node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not.
        }
      }
      node.usedBytes = Math.max(node.usedBytes, position + length);
      return length;
    },
    llseek: function (stream, offset, whence) {
      var position = offset;
      if (whence === 1) {
        position += stream.position;
      } else if (whence === 2) {
        if (FS.isFile(stream.node.mode)) {
          position += stream.node.usedBytes;
        }
      }
      if (position < 0) {
        throw new FS.ErrnoError(28);
      }
      return position;
    },
    allocate: function (stream, offset, length) {
      MEMFS.expandFileStorage(stream.node, offset + length);
      stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
    },
    mmap: function (stream, buffer, offset, length, position, prot, flags) {
      // The data buffer should be a typed array view
      assert(!(buffer instanceof ArrayBuffer));
      if (!FS.isFile(stream.node.mode)) {
        throw new FS.ErrnoError(43);
      }
      var ptr;
      var allocated;
      var contents = stream.node.contents;
      // Only make a new copy when MAP_PRIVATE is specified.
      if (!(flags & 2) && contents.buffer === buffer.buffer) {
        // We can't emulate MAP_SHARED when the file is not backed by the buffer
        // we're mapping to (e.g. the HEAP buffer).
        allocated = false;
        ptr = contents.byteOffset;
      } else {
        // Try to avoid unnecessary slices.
        if (position > 0 || position + length < contents.length) {
          if (contents.subarray) {
            contents = contents.subarray(position, position + length);
          } else {
            contents = Array.prototype.slice.call(
              contents,
              position,
              position + length
            );
          }
        }
        allocated = true;
        // malloc() can lead to growing the heap. If targeting the heap, we need to
        // re-acquire the heap buffer object in case growth had occurred.
        var fromHeap = buffer.buffer == HEAP8.buffer;
        ptr = _malloc(length);
        if (!ptr) {
          throw new FS.ErrnoError(48);
        }
        (fromHeap ? HEAP8 : buffer).set(contents, ptr);
      }
      return { ptr: ptr, allocated: allocated };
    },
    msync: function (stream, buffer, offset, length, mmapFlags) {
      if (!FS.isFile(stream.node.mode)) {
        throw new FS.ErrnoError(43);
      }
      if (mmapFlags & 2) {
        // MAP_PRIVATE calls need not to be synced back to underlying fs
        return 0;
      }

      var bytesWritten = MEMFS.stream_ops.write(
        stream,
        buffer,
        0,
        length,
        offset,
        false
      );
      // should we check if bytesWritten and length are the same?
      return 0;
    },
  },
};

var ERRNO_MESSAGES = {
  0: "Success",
  1: "Arg list too long",
  2: "Permission denied",
  3: "Address already in use",
  4: "Address not available",
  5: "Address family not supported by protocol family",
  6: "No more processes",
  7: "Socket already connected",
  8: "Bad file number",
  9: "Trying to read unreadable message",
  10: "Mount device busy",
  11: "Operation canceled",
  12: "No children",
  13: "Connection aborted",
  14: "Connection refused",
  15: "Connection reset by peer",
  16: "File locking deadlock error",
  17: "Destination address required",
  18: "Math arg out of domain of func",
  19: "Quota exceeded",
  20: "File exists",
  21: "Bad address",
  22: "File too large",
  23: "Host is unreachable",
  24: "Identifier removed",
  25: "Illegal byte sequence",
  26: "Connection already in progress",
  27: "Interrupted system call",
  28: "Invalid argument",
  29: "I/O error",
  30: "Socket is already connected",
  31: "Is a directory",
  32: "Too many symbolic links",
  33: "Too many open files",
  34: "Too many links",
  35: "Message too long",
  36: "Multihop attempted",
  37: "File or path name too long",
  38: "Network interface is not configured",
  39: "Connection reset by network",
  40: "Network is unreachable",
  41: "Too many open files in system",
  42: "No buffer space available",
  43: "No such device",
  44: "No such file or directory",
  45: "Exec format error",
  46: "No record locks available",
  47: "The link has been severed",
  48: "Not enough core",
  49: "No message of desired type",
  50: "Protocol not available",
  51: "No space left on device",
  52: "Function not implemented",
  53: "Socket is not connected",
  54: "Not a directory",
  55: "Directory not empty",
  56: "State not recoverable",
  57: "Socket operation on non-socket",
  59: "Not a typewriter",
  60: "No such device or address",
  61: "Value too large for defined data type",
  62: "Previous owner died",
  63: "Not super-user",
  64: "Broken pipe",
  65: "Protocol error",
  66: "Unknown protocol",
  67: "Protocol wrong type for socket",
  68: "Math result not representable",
  69: "Read only file system",
  70: "Illegal seek",
  71: "No such process",
  72: "Stale file handle",
  73: "Connection timed out",
  74: "Text file busy",
  75: "Cross-device link",
  100: "Device not a stream",
  101: "Bad font file fmt",
  102: "Invalid slot",
  103: "Invalid request code",
  104: "No anode",
  105: "Block device required",
  106: "Channel number out of range",
  107: "Level 3 halted",
  108: "Level 3 reset",
  109: "Link number out of range",
  110: "Protocol driver not attached",
  111: "No CSI structure available",
  112: "Level 2 halted",
  113: "Invalid exchange",
  114: "Invalid request descriptor",
  115: "Exchange full",
  116: "No data (for no delay io)",
  117: "Timer expired",
  118: "Out of streams resources",
  119: "Machine is not on the network",
  120: "Package not installed",
  121: "The object is remote",
  122: "Advertise error",
  123: "Srmount error",
  124: "Communication error on send",
  125: "Cross mount point (not really error)",
  126: "Given log. name not unique",
  127: "f.d. invalid for this operation",
  128: "Remote address changed",
  129: "Can   access a needed shared lib",
  130: "Accessing a corrupted shared lib",
  131: ".lib section in a.out corrupted",
  132: "Attempting to link in too many libs",
  133: "Attempting to exec a shared library",
  135: "Streams pipe error",
  136: "Too many users",
  137: "Socket type not supported",
  138: "Not supported",
  139: "Protocol family not supported",
  140: "Can't send after socket shutdown",
  141: "Too many references",
  142: "Host is down",
  148: "No medium (in tape drive)",
  156: "Level 2 not synchronized",
};

var ERRNO_CODES = {
  EPERM: 63,
  ENOENT: 44,
  ESRCH: 71,
  EINTR: 27,
  EIO: 29,
  ENXIO: 60,
  E2BIG: 1,
  ENOEXEC: 45,
  EBADF: 8,
  ECHILD: 12,
  EAGAIN: 6,
  EWOULDBLOCK: 6,
  ENOMEM: 48,
  EACCES: 2,
  EFAULT: 21,
  ENOTBLK: 105,
  EBUSY: 10,
  EEXIST: 20,
  EXDEV: 75,
  ENODEV: 43,
  ENOTDIR: 54,
  EISDIR: 31,
  EINVAL: 28,
  ENFILE: 41,
  EMFILE: 33,
  ENOTTY: 59,
  ETXTBSY: 74,
  EFBIG: 22,
  ENOSPC: 51,
  ESPIPE: 70,
  EROFS: 69,
  EMLINK: 34,
  EPIPE: 64,
  EDOM: 18,
  ERANGE: 68,
  ENOMSG: 49,
  EIDRM: 24,
  ECHRNG: 106,
  EL2NSYNC: 156,
  EL3HLT: 107,
  EL3RST: 108,
  ELNRNG: 109,
  EUNATCH: 110,
  ENOCSI: 111,
  EL2HLT: 112,
  EDEADLK: 16,
  ENOLCK: 46,
  EBADE: 113,
  EBADR: 114,
  EXFULL: 115,
  ENOANO: 104,
  EBADRQC: 103,
  EBADSLT: 102,
  EDEADLOCK: 16,
  EBFONT: 101,
  ENOSTR: 100,
  ENODATA: 116,
  ETIME: 117,
  ENOSR: 118,
  ENONET: 119,
  ENOPKG: 120,
  EREMOTE: 121,
  ENOLINK: 47,
  EADV: 122,
  ESRMNT: 123,
  ECOMM: 124,
  EPROTO: 65,
  EMULTIHOP: 36,
  EDOTDOT: 125,
  EBADMSG: 9,
  ENOTUNIQ: 126,
  EBADFD: 127,
  EREMCHG: 128,
  ELIBACC: 129,
  ELIBBAD: 130,
  ELIBSCN: 131,
  ELIBMAX: 132,
  ELIBEXEC: 133,
  ENOSYS: 52,
  ENOTEMPTY: 55,
  ENAMETOOLONG: 37,
  ELOOP: 32,
  EOPNOTSUPP: 138,
  EPFNOSUPPORT: 139,
  ECONNRESET: 15,
  ENOBUFS: 42,
  EAFNOSUPPORT: 5,
  EPROTOTYPE: 67,
  ENOTSOCK: 57,
  ENOPROTOOPT: 50,
  ESHUTDOWN: 140,
  ECONNREFUSED: 14,
  EADDRINUSE: 3,
  ECONNABORTED: 13,
  ENETUNREACH: 40,
  ENETDOWN: 38,
  ETIMEDOUT: 73,
  EHOSTDOWN: 142,
  EHOSTUNREACH: 23,
  EINPROGRESS: 26,
  EALREADY: 7,
  EDESTADDRREQ: 17,
  EMSGSIZE: 35,
  EPROTONOSUPPORT: 66,
  ESOCKTNOSUPPORT: 137,
  EADDRNOTAVAIL: 4,
  ENETRESET: 39,
  EISCONN: 30,
  ENOTCONN: 53,
  ETOOMANYREFS: 141,
  EUSERS: 136,
  EDQUOT: 19,
  ESTALE: 72,
  ENOTSUP: 138,
  ENOMEDIUM: 148,
  EILSEQ: 25,
  EOVERFLOW: 61,
  ECANCELED: 11,
  ENOTRECOVERABLE: 56,
  EOWNERDEAD: 62,
  ESTRPIPE: 135,
};
var FS = {
  root: null,
  mounts: [],
  devices: {},
  streams: [],
  nextInode: 1,
  nameTable: null,
  currentPath: "/",
  initialized: false,
  ignorePermissions: true,
  trackingDelegate: {},
  tracking: { openFlags: { READ: 1, WRITE: 2 } },
  ErrnoError: null,
  genericErrors: {},
  filesystems: null,
  syncFSRequests: 0,
  handleFSError: function (e) {
    if (!(e instanceof FS.ErrnoError)) throw e + " : " + stackTrace();
    return ___setErrNo(e.errno);
  },
  lookupPath: function (path, opts) {
    path = PATH_FS.resolve(FS.cwd(), path);
    opts = opts || {};

    if (!path) return { path: "", node: null };

    var defaults = {
      follow_mount: true,
      recurse_count: 0,
    };
    for (var key in defaults) {
      if (opts[key] === undefined) {
        opts[key] = defaults[key];
      }
    }

    if (opts.recurse_count > 8) {
      // max recursive lookup of 8
      throw new FS.ErrnoError(32);
    }

    // split the path
    var parts = PATH.normalizeArray(
      path.split("/").filter(function (p) {
        return !!p;
      }),
      false
    );

    // start at the root
    var current = FS.root;
    var current_path = "/";

    for (var i = 0; i < parts.length; i++) {
      var islast = i === parts.length - 1;
      if (islast && opts.parent) {
        // stop resolving
        break;
      }

      current = FS.lookupNode(current, parts[i]);
      current_path = PATH.join2(current_path, parts[i]);

      // jump to the mount's root node if this is a mountpoint
      if (FS.isMountpoint(current)) {
        if (!islast || (islast && opts.follow_mount)) {
          current = current.mounted.root;
        }
      }

      // by default, lookupPath will not follow a symlink if it is the final path component.
      // setting opts.follow = true will override this behavior.
      if (!islast || opts.follow) {
        var count = 0;
        while (FS.isLink(current.mode)) {
          var link = FS.readlink(current_path);
          current_path = PATH_FS.resolve(PATH.dirname(current_path), link);

          var lookup = FS.lookupPath(current_path, {
            recurse_count: opts.recurse_count,
          });
          current = lookup.node;

          if (count++ > 40) {
            // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
            throw new FS.ErrnoError(32);
          }
        }
      }
    }

    return { path: current_path, node: current };
  },
  getPath: function (node) {
    var path;
    while (true) {
      if (FS.isRoot(node)) {
        var mount = node.mount.mountpoint;
        if (!path) return mount;
        return mount[mount.length - 1] !== "/"
          ? mount + "/" + path
          : mount + path;
      }
      path = path ? node.name + "/" + path : node.name;
      node = node.parent;
    }
  },
  hashName: function (parentid, name) {
    var hash = 0;

    for (var i = 0; i < name.length; i++) {
      hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
    }
    return ((parentid + hash) >>> 0) % FS.nameTable.length;
  },
  hashAddNode: function (node) {
    var hash = FS.hashName(node.parent.id, node.name);
    node.name_next = FS.nameTable[hash];
    FS.nameTable[hash] = node;
  },
  hashRemoveNode: function (node) {
    var hash = FS.hashName(node.parent.id, node.name);
    if (FS.nameTable[hash] === node) {
      FS.nameTable[hash] = node.name_next;
    } else {
      var current = FS.nameTable[hash];
      while (current) {
        if (current.name_next === node) {
          current.name_next = node.name_next;
          break;
        }
        current = current.name_next;
      }
    }
  },
  lookupNode: function (parent, name) {
    var errCode = FS.mayLookup(parent);
    if (errCode) {
      throw new FS.ErrnoError(errCode, parent);
    }
    var hash = FS.hashName(parent.id, name);
    for (var node = FS.nameTable[hash]; node; node = node.name_next) {
      var nodeName = node.name;
      if (node.parent.id === parent.id && nodeName === name) {
        return node;
      }
    }
    // if we failed to find it in the cache, call into the VFS
    return FS.lookup(parent, name);
  },
  createNode: function (parent, name, mode, rdev) {
    var node = new FS.FSNode(parent, name, mode, rdev);

    FS.hashAddNode(node);

    return node;
  },
  destroyNode: function (node) {
    FS.hashRemoveNode(node);
  },
  isRoot: function (node) {
    return node === node.parent;
  },
  isMountpoint: function (node) {
    return !!node.mounted;
  },
  isFile: function (mode) {
    return (mode & 61440) === 32768;
  },
  isDir: function (mode) {
    return (mode & 61440) === 16384;
  },
  isLink: function (mode) {
    return (mode & 61440) === 40960;
  },
  isChrdev: function (mode) {
    return (mode & 61440) === 8192;
  },
  isBlkdev: function (mode) {
    return (mode & 61440) === 24576;
  },
  isFIFO: function (mode) {
    return (mode & 61440) === 4096;
  },
  isSocket: function (mode) {
    return (mode & 49152) === 49152;
  },
  flagModes: {
    r: 0,
    rs: 1052672,
    "r+": 2,
    w: 577,
    wx: 705,
    xw: 705,
    "w+": 578,
    "wx+": 706,
    "xw+": 706,
    a: 1089,
    ax: 1217,
    xa: 1217,
    "a+": 1090,
    "ax+": 1218,
    "xa+": 1218,
  },
  modeStringToFlags: function (str) {
    var flags = FS.flagModes[str];
    if (typeof flags === "undefined") {
      throw new Error("Unknown file open mode: " + str);
    }
    return flags;
  },
  flagsToPermissionString: function (flag) {
    var perms = ["r", "w", "rw"][flag & 3];
    if (flag & 512) {
      perms += "w";
    }
    return perms;
  },
  nodePermissions: function (node, perms) {
    if (FS.ignorePermissions) {
      return 0;
    }
    // return 0 if any user, group or owner bits are set.
    if (perms.indexOf("r") !== -1 && !(node.mode & 292)) {
      return 2;
    } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) {
      return 2;
    } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) {
      return 2;
    }
    return 0;
  },
  mayLookup: function (dir) {
    var errCode = FS.nodePermissions(dir, "x");
    if (errCode) return errCode;
    if (!dir.node_ops.lookup) return 2;
    return 0;
  },
  mayCreate: function (dir, name) {
    try {
      var node = FS.lookupNode(dir, name);
      return 20;
    } catch (e) {}
    return FS.nodePermissions(dir, "wx");
  },
  mayDelete: function (dir, name, isdir) {
    var node;
    try {
      node = FS.lookupNode(dir, name);
    } catch (e) {
      return e.errno;
    }
    var errCode = FS.nodePermissions(dir, "wx");
    if (errCode) {
      return errCode;
    }
    if (isdir) {
      if (!FS.isDir(node.mode)) {
        return 54;
      }
      if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
        return 10;
      }
    } else {
      if (FS.isDir(node.mode)) {
        return 31;
      }
    }
    return 0;
  },
  mayOpen: function (node, flags) {
    if (!node) {
      return 44;
    }
    if (FS.isLink(node.mode)) {
      return 32;
    } else if (FS.isDir(node.mode)) {
      if (
        FS.flagsToPermissionString(flags) !== "r" || // opening for write
        flags & 512
      ) {
        // TODO: check for O_SEARCH? (== search for dir only)
        return 31;
      }
    }
    return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
  },
  MAX_OPEN_FDS: 4096,
  nextfd: function (fd_start, fd_end) {
    fd_start = fd_start || 0;
    fd_end = fd_end || FS.MAX_OPEN_FDS;
    for (var fd = fd_start; fd <= fd_end; fd++) {
      if (!FS.streams[fd]) {
        return fd;
      }
    }
    throw new FS.ErrnoError(33);
  },
  getStream: function (fd) {
    return FS.streams[fd];
  },
  createStream: function (stream, fd_start, fd_end) {
    if (!FS.FSStream) {
      FS.FSStream = /** @constructor */ function () {};
      FS.FSStream.prototype = {
        object: {
          get: function () {
            return this.node;
          },
          set: function (val) {
            this.node = val;
          },
        },
        isRead: {
          get: function () {
            return (this.flags & 2097155) !== 1;
          },
        },
        isWrite: {
          get: function () {
            return (this.flags & 2097155) !== 0;
          },
        },
        isAppend: {
          get: function () {
            return this.flags & 1024;
          },
        },
      };
    }
    // clone it, so we can return an instance of FSStream
    var newStream = new FS.FSStream();
    for (var p in stream) {
      newStream[p] = stream[p];
    }
    stream = newStream;
    var fd = FS.nextfd(fd_start, fd_end);
    stream.fd = fd;
    FS.streams[fd] = stream;
    return stream;
  },
  closeStream: function (fd) {
    FS.streams[fd] = null;
  },
  chrdev_stream_ops: {
    open: function (stream) {
      var device = FS.getDevice(stream.node.rdev);
      // override node's stream ops with the device's
      stream.stream_ops = device.stream_ops;
      // forward the open call
      if (stream.stream_ops.open) {
        stream.stream_ops.open(stream);
      }
    },
    llseek: function () {
      throw new FS.ErrnoError(70);
    },
  },
  major: function (dev) {
    return dev >> 8;
  },
  minor: function (dev) {
    return dev & 0xff;
  },
  makedev: function (ma, mi) {
    return (ma << 8) | mi;
  },
  registerDevice: function (dev, ops) {
    FS.devices[dev] = { stream_ops: ops };
  },
  getDevice: function (dev) {
    return FS.devices[dev];
  },
  getMounts: function (mount) {
    var mounts = [];
    var check = [mount];

    while (check.length) {
      var m = check.pop();

      mounts.push(m);

      check.push.apply(check, m.mounts);
    }

    return mounts;
  },
  syncfs: function (populate, callback) {
    if (typeof populate === "function") {
      callback = populate;
      populate = false;
    }

    FS.syncFSRequests++;

    if (FS.syncFSRequests > 1) {
      err(
        "warning: " +
          FS.syncFSRequests +
          " FS.syncfs operations in flight at once, probably just doing extra work"
      );
    }

    var mounts = FS.getMounts(FS.root.mount);
    var completed = 0;

    function doCallback(errCode) {
      assert(FS.syncFSRequests > 0);
      FS.syncFSRequests--;
      return callback(errCode);
    }

    function done(errCode) {
      if (errCode) {
        if (!done.errored) {
          done.errored = true;
          return doCallback(errCode);
        }
        return;
      }
      if (++completed >= mounts.length) {
        doCallback(null);
      }
    }

    // sync all mounts
    mounts.forEach(function (mount) {
      if (!mount.type.syncfs) {
        return done(null);
      }
      mount.type.syncfs(mount, populate, done);
    });
  },
  mount: function (type, opts, mountpoint) {
    if (typeof type === "string") {
      // The filesystem was not included, and instead we have an error
      // message stored in the variable.
      throw type;
    }
    var root = mountpoint === "/";
    var pseudo = !mountpoint;
    var node;

    if (root && FS.root) {
      throw new FS.ErrnoError(10);
    } else if (!root && !pseudo) {
      var lookup = FS.lookupPath(mountpoint, { follow_mount: false });

      mountpoint = lookup.path; // use the absolute path
      node = lookup.node;

      if (FS.isMountpoint(node)) {
        throw new FS.ErrnoError(10);
      }

      if (!FS.isDir(node.mode)) {
        throw new FS.ErrnoError(54);
      }
    }

    var mount = {
      type: type,
      opts: opts,
      mountpoint: mountpoint,
      mounts: [],
    };

    // create a root node for the fs
    var mountRoot = type.mount(mount);
    mountRoot.mount = mount;
    mount.root = mountRoot;

    if (root) {
      FS.root = mountRoot;
    } else if (node) {
      // set as a mountpoint
      node.mounted = mount;

      // add the new mount to the current mount's children
      if (node.mount) {
        node.mount.mounts.push(mount);
      }
    }

    return mountRoot;
  },
  unmount: function (mountpoint) {
    var lookup = FS.lookupPath(mountpoint, { follow_mount: false });

    if (!FS.isMountpoint(lookup.node)) {
      throw new FS.ErrnoError(28);
    }

    // destroy the nodes for this mount, and all its child mounts
    var node = lookup.node;
    var mount = node.mounted;
    var mounts = FS.getMounts(mount);

    Object.keys(FS.nameTable).forEach(function (hash) {
      var current = FS.nameTable[hash];

      while (current) {
        var next = current.name_next;

        if (mounts.indexOf(current.mount) !== -1) {
          FS.destroyNode(current);
        }

        current = next;
      }
    });

    // no longer a mountpoint
    node.mounted = null;

    // remove this mount from the child mounts
    var idx = node.mount.mounts.indexOf(mount);
    assert(idx !== -1);
    node.mount.mounts.splice(idx, 1);
  },
  lookup: function (parent, name) {
    return parent.node_ops.lookup(parent, name);
  },
  mknod: function (path, mode, dev) {
    var lookup = FS.lookupPath(path, { parent: true });
    var parent = lookup.node;
    var name = PATH.basename(path);
    if (!name || name === "." || name === "..") {
      throw new FS.ErrnoError(28);
    }
    var errCode = FS.mayCreate(parent, name);
    if (errCode) {
      throw new FS.ErrnoError(errCode);
    }
    if (!parent.node_ops.mknod) {
      throw new FS.ErrnoError(63);
    }
    return parent.node_ops.mknod(parent, name, mode, dev);
  },
  create: function (path, mode) {
    mode = mode !== undefined ? mode : 438 /* 0666 */;
    mode &= 4095;
    mode |= 32768;
    return FS.mknod(path, mode, 0);
  },
  mkdir: function (path, mode) {
    mode = mode !== undefined ? mode : 511 /* 0777 */;
    mode &= 511 | 512;
    mode |= 16384;
    return FS.mknod(path, mode, 0);
  },
  mkdirTree: function (path, mode) {
    var dirs = path.split("/");
    var d = "";
    for (var i = 0; i < dirs.length; ++i) {
      if (!dirs[i]) continue;
      d += "/" + dirs[i];
      try {
        FS.mkdir(d, mode);
      } catch (e) {
        if (e.errno != 20) throw e;
      }
    }
  },
  mkdev: function (path, mode, dev) {
    if (typeof dev === "undefined") {
      dev = mode;
      mode = 438 /* 0666 */;
    }
    mode |= 8192;
    return FS.mknod(path, mode, dev);
  },
  symlink: function (oldpath, newpath) {
    if (!PATH_FS.resolve(oldpath)) {
      throw new FS.ErrnoError(44);
    }
    var lookup = FS.lookupPath(newpath, { parent: true });
    var parent = lookup.node;
    if (!parent) {
      throw new FS.ErrnoError(44);
    }
    var newname = PATH.basename(newpath);
    var errCode = FS.mayCreate(parent, newname);
    if (errCode) {
      throw new FS.ErrnoError(errCode);
    }
    if (!parent.node_ops.symlink) {
      throw new FS.ErrnoError(63);
    }
    return parent.node_ops.symlink(parent, newname, oldpath);
  },
  rename: function (old_path, new_path) {
    var old_dirname = PATH.dirname(old_path);
    var new_dirname = PATH.dirname(new_path);
    var old_name = PATH.basename(old_path);
    var new_name = PATH.basename(new_path);
    // parents must exist
    var lookup, old_dir, new_dir;
    try {
      lookup = FS.lookupPath(old_path, { parent: true });
      old_dir = lookup.node;
      lookup = FS.lookupPath(new_path, { parent: true });
      new_dir = lookup.node;
    } catch (e) {
      throw new FS.ErrnoError(10);
    }
    if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
    // need to be part of the same mount
    if (old_dir.mount !== new_dir.mount) {
      throw new FS.ErrnoError(75);
    }
    // source must exist
    var old_node = FS.lookupNode(old_dir, old_name);
    // old path should not be an ancestor of the new path
    var relative = PATH_FS.relative(old_path, new_dirname);
    if (relative.charAt(0) !== ".") {
      throw new FS.ErrnoError(28);
    }
    // new path should not be an ancestor of the old path
    relative = PATH_FS.relative(new_path, old_dirname);
    if (relative.charAt(0) !== ".") {
      throw new FS.ErrnoError(55);
    }
    // see if the new path already exists
    var new_node;
    try {
      new_node = FS.lookupNode(new_dir, new_name);
    } catch (e) {
      // not fatal
    }
    // early out if nothing needs to change
    if (old_node === new_node) {
      return;
    }
    // we'll need to delete the old entry
    var isdir = FS.isDir(old_node.mode);
    var errCode = FS.mayDelete(old_dir, old_name, isdir);
    if (errCode) {
      throw new FS.ErrnoError(errCode);
    }
    // need delete permissions if we'll be overwriting.
    // need create permissions if new doesn't already exist.
    errCode = new_node
      ? FS.mayDelete(new_dir, new_name, isdir)
      : FS.mayCreate(new_dir, new_name);
    if (errCode) {
      throw new FS.ErrnoError(errCode);
    }
    if (!old_dir.node_ops.rename) {
      throw new FS.ErrnoError(63);
    }
    if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
      throw new FS.ErrnoError(10);
    }
    // if we are going to change the parent, check write permissions
    if (new_dir !== old_dir) {
      errCode = FS.nodePermissions(old_dir, "w");
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
    }
    try {
      if (FS.trackingDelegate["willMovePath"]) {
        FS.trackingDelegate["willMovePath"](old_path, new_path);
      }
    } catch (e) {
      err(
        "FS.trackingDelegate['willMovePath']('" +
          old_path +
          "', '" +
          new_path +
          "') threw an exception: " +
          e.message
      );
    }
    // remove the node from the lookup hash
    FS.hashRemoveNode(old_node);
    // do the underlying fs rename
    try {
      old_dir.node_ops.rename(old_node, new_dir, new_name);
    } catch (e) {
      throw e;
    } finally {
      // add the node back to the hash (in case node_ops.rename
      // changed its name)
      FS.hashAddNode(old_node);
    }
    try {
      if (FS.trackingDelegate["onMovePath"])
        FS.trackingDelegate["onMovePath"](old_path, new_path);
    } catch (e) {
      err(
        "FS.trackingDelegate['onMovePath']('" +
          old_path +
          "', '" +
          new_path +
          "') threw an exception: " +
          e.message
      );
    }
  },
  rmdir: function (path) {
    var lookup = FS.lookupPath(path, { parent: true });
    var parent = lookup.node;
    var name = PATH.basename(path);
    var node = FS.lookupNode(parent, name);
    var errCode = FS.mayDelete(parent, name, true);
    if (errCode) {
      throw new FS.ErrnoError(errCode);
    }
    if (!parent.node_ops.rmdir) {
      throw new FS.ErrnoError(63);
    }
    if (FS.isMountpoint(node)) {
      throw new FS.ErrnoError(10);
    }
    try {
      if (FS.trackingDelegate["willDeletePath"]) {
        FS.trackingDelegate["willDeletePath"](path);
      }
    } catch (e) {
      err(
        "FS.trackingDelegate['willDeletePath']('" +
          path +
          "') threw an exception: " +
          e.message
      );
    }
    parent.node_ops.rmdir(parent, name);
    FS.destroyNode(node);
    try {
      if (FS.trackingDelegate["onDeletePath"])
        FS.trackingDelegate["onDeletePath"](path);
    } catch (e) {
      err(
        "FS.trackingDelegate['onDeletePath']('" +
          path +
          "') threw an exception: " +
          e.message
      );
    }
  },
  readdir: function (path) {
    var lookup = FS.lookupPath(path, { follow: true });
    var node = lookup.node;
    if (!node.node_ops.readdir) {
      throw new FS.ErrnoError(54);
    }
    return node.node_ops.readdir(node);
  },
  unlink: function (path) {
    var lookup = FS.lookupPath(path, { parent: true });
    var parent = lookup.node;
    var name = PATH.basename(path);
    var node = FS.lookupNode(parent, name);
    var errCode = FS.mayDelete(parent, name, false);
    if (errCode) {
      // According to POSIX, we should map EISDIR to EPERM, but
      // we instead do what Linux does (and we must, as we use
      // the musl linux libc).
      throw new FS.ErrnoError(errCode);
    }
    if (!parent.node_ops.unlink) {
      throw new FS.ErrnoError(63);
    }
    if (FS.isMountpoint(node)) {
      throw new FS.ErrnoError(10);
    }
    try {
      if (FS.trackingDelegate["willDeletePath"]) {
        FS.trackingDelegate["willDeletePath"](path);
      }
    } catch (e) {
      err(
        "FS.trackingDelegate['willDeletePath']('" +
          path +
          "') threw an exception: " +
          e.message
      );
    }
    parent.node_ops.unlink(parent, name);
    FS.destroyNode(node);
    try {
      if (FS.trackingDelegate["onDeletePath"])
        FS.trackingDelegate["onDeletePath"](path);
    } catch (e) {
      err(
        "FS.trackingDelegate['onDeletePath']('" +
          path +
          "') threw an exception: " +
          e.message
      );
    }
  },
  readlink: function (path) {
    var lookup = FS.lookupPath(path);
    var link = lookup.node;
    if (!link) {
      throw new FS.ErrnoError(44);
    }
    if (!link.node_ops.readlink) {
      throw new FS.ErrnoError(28);
    }
    return PATH_FS.resolve(
      FS.getPath(link.parent),
      link.node_ops.readlink(link)
    );
  },
  stat: function (path, dontFollow) {
    var lookup = FS.lookupPath(path, { follow: !dontFollow });
    var node = lookup.node;
    if (!node) {
      throw new FS.ErrnoError(44);
    }
    if (!node.node_ops.getattr) {
      throw new FS.ErrnoError(63);
    }
    return node.node_ops.getattr(node);
  },
  lstat: function (path) {
    return FS.stat(path, true);
  },
  chmod: function (path, mode, dontFollow) {
    var node;
    if (typeof path === "string") {
      var lookup = FS.lookupPath(path, { follow: !dontFollow });
      node = lookup.node;
    } else {
      node = path;
    }
    if (!node.node_ops.setattr) {
      throw new FS.ErrnoError(63);
    }
    node.node_ops.setattr(node, {
      mode: (mode & 4095) | (node.mode & ~4095),
      timestamp: Date.now(),
    });
  },
  lchmod: function (path, mode) {
    FS.chmod(path, mode, true);
  },
  fchmod: function (fd, mode) {
    var stream = FS.getStream(fd);
    if (!stream) {
      throw new FS.ErrnoError(8);
    }
    FS.chmod(stream.node, mode);
  },
  chown: function (path, uid, gid, dontFollow) {
    var node;
    if (typeof path === "string") {
      var lookup = FS.lookupPath(path, { follow: !dontFollow });
      node = lookup.node;
    } else {
      node = path;
    }
    if (!node.node_ops.setattr) {
      throw new FS.ErrnoError(63);
    }
    node.node_ops.setattr(node, {
      timestamp: Date.now(),
      // we ignore the uid / gid for now
    });
  },
  lchown: function (path, uid, gid) {
    FS.chown(path, uid, gid, true);
  },
  fchown: function (fd, uid, gid) {
    var stream = FS.getStream(fd);
    if (!stream) {
      throw new FS.ErrnoError(8);
    }
    FS.chown(stream.node, uid, gid);
  },
  truncate: function (path, len) {
    if (len < 0) {
      throw new FS.ErrnoError(28);
    }
    var node;
    if (typeof path === "string") {
      var lookup = FS.lookupPath(path, { follow: true });
      node = lookup.node;
    } else {
      node = path;
    }
    if (!node.node_ops.setattr) {
      throw new FS.ErrnoError(63);
    }
    if (FS.isDir(node.mode)) {
      throw new FS.ErrnoError(31);
    }
    if (!FS.isFile(node.mode)) {
      throw new FS.ErrnoError(28);
    }
    var errCode = FS.nodePermissions(node, "w");
    if (errCode) {
      throw new FS.ErrnoError(errCode);
    }
    node.node_ops.setattr(node, {
      size: len,
      timestamp: Date.now(),
    });
  },
  ftruncate: function (fd, len) {
    var stream = FS.getStream(fd);
    if (!stream) {
      throw new FS.ErrnoError(8);
    }
    if ((stream.flags & 2097155) === 0) {
      throw new FS.ErrnoError(28);
    }
    FS.truncate(stream.node, len);
  },
  utime: function (path, atime, mtime) {
    var lookup = FS.lookupPath(path, { follow: true });
    var node = lookup.node;
    node.node_ops.setattr(node, {
      timestamp: Math.max(atime, mtime),
    });
  },
  open: function (path, flags, mode, fd_start, fd_end) {
    if (path === "") {
      throw new FS.ErrnoError(44);
    }
    flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags;
    mode = typeof mode === "undefined" ? 438 /* 0666 */ : mode;
    if (flags & 64) {
      mode = (mode & 4095) | 32768;
    } else {
      mode = 0;
    }
    var node;
    if (typeof path === "object") {
      node = path;
    } else {
      path = PATH.normalize(path);
      try {
        var lookup = FS.lookupPath(path, {
          follow: !(flags & 131072),
        });
        node = lookup.node;
      } catch (e) {
        // ignore
      }
    }
    // perhaps we need to create the node
    var created = false;
    if (flags & 64) {
      if (node) {
        // if O_CREAT and O_EXCL are set, error out if the node already exists
        if (flags & 128) {
          throw new FS.ErrnoError(20);
        }
      } else {
        // node doesn't exist, try to create it
        node = FS.mknod(path, mode, 0);
        created = true;
      }
    }
    if (!node) {
      throw new FS.ErrnoError(44);
    }
    // can't truncate a device
    if (FS.isChrdev(node.mode)) {
      flags &= ~512;
    }
    // if asked only for a directory, then this must be one
    if (flags & 65536 && !FS.isDir(node.mode)) {
      throw new FS.ErrnoError(54);
    }
    // check permissions, if this is not a file we just created now (it is ok to
    // create and write to a file with read-only permissions; it is read-only
    // for later use)
    if (!created) {
      var errCode = FS.mayOpen(node, flags);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
    }
    // do truncation if necessary
    if (flags & 512) {
      FS.truncate(node, 0);
    }
    // we've already handled these, don't pass down to the underlying vfs
    flags &= ~(128 | 512);

    // register the stream with the filesystem
    var stream = FS.createStream(
      {
        node: node,
        path: FS.getPath(node), // we want the absolute path to the node
        flags: flags,
        seekable: true,
        position: 0,
        stream_ops: node.stream_ops,
        // used by the file family libc calls (fopen, fwrite, ferror, etc.)
        ungotten: [],
        error: false,
      },
      fd_start,
      fd_end
    );
    // call the new stream's open function
    if (stream.stream_ops.open) {
      stream.stream_ops.open(stream);
    }
    if (Module["logReadFiles"] && !(flags & 1)) {
      if (!FS.readFiles) FS.readFiles = {};
      if (!(path in FS.readFiles)) {
        FS.readFiles[path] = 1;
        err("FS.trackingDelegate error on read file: " + path);
      }
    }
    try {
      if (FS.trackingDelegate["onOpenFile"]) {
        var trackingFlags = 0;
        if ((flags & 2097155) !== 1) {
          trackingFlags |= FS.tracking.openFlags.READ;
        }
        if ((flags & 2097155) !== 0) {
          trackingFlags |= FS.tracking.openFlags.WRITE;
        }
        FS.trackingDelegate["onOpenFile"](path, trackingFlags);
      }
    } catch (e) {
      err(
        "FS.trackingDelegate['onOpenFile']('" +
          path +
          "', flags) threw an exception: " +
          e.message
      );
    }
    return stream;
  },
  close: function (stream) {
    if (FS.isClosed(stream)) {
      throw new FS.ErrnoError(8);
    }
    if (stream.getdents) stream.getdents = null; // free readdir state
    try {
      if (stream.stream_ops.close) {
        stream.stream_ops.close(stream);
      }
    } catch (e) {
      throw e;
    } finally {
      FS.closeStream(stream.fd);
    }
    stream.fd = null;
  },
  isClosed: function (stream) {
    return stream.fd === null;
  },
  llseek: function (stream, offset, whence) {
    if (FS.isClosed(stream)) {
      throw new FS.ErrnoError(8);
    }
    if (!stream.seekable || !stream.stream_ops.llseek) {
      throw new FS.ErrnoError(70);
    }
    if (whence != 0 && whence != 1 && whence != 2) {
      throw new FS.ErrnoError(28);
    }
    stream.position = stream.stream_ops.llseek(stream, offset, whence);
    stream.ungotten = [];
    return stream.position;
  },
  read: function (stream, buffer, offset, length, position) {
    if (length < 0 || position < 0) {
      throw new FS.ErrnoError(28);
    }
    if (FS.isClosed(stream)) {
      throw new FS.ErrnoError(8);
    }
    if ((stream.flags & 2097155) === 1) {
      throw new FS.ErrnoError(8);
    }
    if (FS.isDir(stream.node.mode)) {
      throw new FS.ErrnoError(31);
    }
    if (!stream.stream_ops.read) {
      throw new FS.ErrnoError(28);
    }
    var seeking = typeof position !== "undefined";
    if (!seeking) {
      position = stream.position;
    } else if (!stream.seekable) {
      throw new FS.ErrnoError(70);
    }
    var bytesRead = stream.stream_ops.read(
      stream,
      buffer,
      offset,
      length,
      position
    );
    if (!seeking) stream.position += bytesRead;
    return bytesRead;
  },
  write: function (stream, buffer, offset, length, position, canOwn) {
    if (length < 0 || position < 0) {
      throw new FS.ErrnoError(28);
    }
    if (FS.isClosed(stream)) {
      throw new FS.ErrnoError(8);
    }
    if ((stream.flags & 2097155) === 0) {
      throw new FS.ErrnoError(8);
    }
    if (FS.isDir(stream.node.mode)) {
      throw new FS.ErrnoError(31);
    }
    if (!stream.stream_ops.write) {
      throw new FS.ErrnoError(28);
    }
    if (stream.flags & 1024) {
      // seek to the end before writing in append mode
      FS.llseek(stream, 0, 2);
    }
    var seeking = typeof position !== "undefined";
    if (!seeking) {
      position = stream.position;
    } else if (!stream.seekable) {
      throw new FS.ErrnoError(70);
    }
    var bytesWritten = stream.stream_ops.write(
      stream,
      buffer,
      offset,
      length,
      position,
      canOwn
    );
    if (!seeking) stream.position += bytesWritten;
    try {
      if (stream.path && FS.trackingDelegate["onWriteToFile"])
        FS.trackingDelegate["onWriteToFile"](stream.path);
    } catch (e) {
      err(
        "FS.trackingDelegate['onWriteToFile']('" +
          stream.path +
          "') threw an exception: " +
          e.message
      );
    }
    return bytesWritten;
  },
  allocate: function (stream, offset, length) {
    if (FS.isClosed(stream)) {
      throw new FS.ErrnoError(8);
    }
    if (offset < 0 || length <= 0) {
      throw new FS.ErrnoError(28);
    }
    if ((stream.flags & 2097155) === 0) {
      throw new FS.ErrnoError(8);
    }
    if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
      throw new FS.ErrnoError(43);
    }
    if (!stream.stream_ops.allocate) {
      throw new FS.ErrnoError(138);
    }
    stream.stream_ops.allocate(stream, offset, length);
  },
  mmap: function (stream, buffer, offset, length, position, prot, flags) {
    // User requests writing to file (prot & PROT_WRITE != 0).
    // Checking if we have permissions to write to the file unless
    // MAP_PRIVATE flag is set. According to POSIX spec it is possible
    // to write to file opened in read-only mode with MAP_PRIVATE flag,
    // as all modifications will be visible only in the memory of
    // the current process.
    if (
      (prot & 2) !== 0 &&
      (flags & 2) === 0 &&
      (stream.flags & 2097155) !== 2
    ) {
      throw new FS.ErrnoError(2);
    }
    if ((stream.flags & 2097155) === 1) {
      throw new FS.ErrnoError(2);
    }
    if (!stream.stream_ops.mmap) {
      throw new FS.ErrnoError(43);
    }
    return stream.stream_ops.mmap(
      stream,
      buffer,
      offset,
      length,
      position,
      prot,
      flags
    );
  },
  msync: function (stream, buffer, offset, length, mmapFlags) {
    if (!stream || !stream.stream_ops.msync) {
      return 0;
    }
    return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
  },
  munmap: function (stream) {
    return 0;
  },
  ioctl: function (stream, cmd, arg) {
    if (!stream.stream_ops.ioctl) {
      throw new FS.ErrnoError(59);
    }
    return stream.stream_ops.ioctl(stream, cmd, arg);
  },
  readFile: function (path, opts) {
    opts = opts || {};
    opts.flags = opts.flags || "r";
    opts.encoding = opts.encoding || "binary";
    if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
      throw new Error('Invalid encoding type "' + opts.encoding + '"');
    }
    var ret;
    var stream = FS.open(path, opts.flags);
    var stat = FS.stat(path);
    var length = stat.size;
    var buf = new Uint8Array(length);
    FS.read(stream, buf, 0, length, 0);
    if (opts.encoding === "utf8") {
      ret = UTF8ArrayToString(buf, 0);
    } else if (opts.encoding === "binary") {
      ret = buf;
    }
    FS.close(stream);
    return ret;
  },
  writeFile: function (path, data, opts) {
    opts = opts || {};
    opts.flags = opts.flags || "w";
    var stream = FS.open(path, opts.flags, opts.mode);
    if (typeof data === "string") {
      var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
      var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
      FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
    } else if (ArrayBuffer.isView(data)) {
      FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
    } else {
      throw new Error("Unsupported data type");
    }
    FS.close(stream);
  },
  cwd: function () {
    return FS.currentPath;
  },
  chdir: function (path) {
    var lookup = FS.lookupPath(path, { follow: true });
    if (lookup.node === null) {
      throw new FS.ErrnoError(44);
    }
    if (!FS.isDir(lookup.node.mode)) {
      throw new FS.ErrnoError(54);
    }
    var errCode = FS.nodePermissions(lookup.node, "x");
    if (errCode) {
      throw new FS.ErrnoError(errCode);
    }
    FS.currentPath = lookup.path;
  },
  createDefaultDirectories: function () {
    FS.mkdir("/tmp");
    FS.mkdir("/home");
    FS.mkdir("/home/web_user");
  },
  createDefaultDevices: function () {
    // create /dev
    FS.mkdir("/dev");
    // setup /dev/null
    FS.registerDevice(FS.makedev(1, 3), {
      read: function () {
        return 0;
      },
      write: function (stream, buffer, offset, length, pos) {
        return length;
      },
    });
    FS.mkdev("/dev/null", FS.makedev(1, 3));
    // setup /dev/tty and /dev/tty1
    // stderr needs to print output using Module['printErr']
    // so we register a second tty just for it.
    TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
    TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
    FS.mkdev("/dev/tty", FS.makedev(5, 0));
    FS.mkdev("/dev/tty1", FS.makedev(6, 0));
    // setup /dev/[u]random
    var random_device;
    if (
      typeof crypto === "object" &&
      typeof crypto["getRandomValues"] === "function"
    ) {
      // for modern web browsers
      var randomBuffer = new Uint8Array(1);
      random_device = function () {
        crypto.getRandomValues(randomBuffer);
        return randomBuffer[0];
      };
    } else if (ENVIRONMENT_IS_NODE) {
      // for nodejs with or without crypto support included
      try {
        var crypto_module = require("crypto");
        // nodejs has crypto support
        random_device = function () {
          return crypto_module["randomBytes"](1)[0];
        };
      } catch (e) {
        // nodejs doesn't have crypto support
      }
    } else {
    }
    if (!random_device) {
      // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096
      random_device = function () {
        abort(
          "no cryptographic support found for random_device. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };"
        );
      };
    }
    FS.createDevice("/dev", "random", random_device);
    FS.createDevice("/dev", "urandom", random_device);
    // we're not going to emulate the actual shm device,
    // just create the tmp dirs that reside in it commonly
    FS.mkdir("/dev/shm");
    FS.mkdir("/dev/shm/tmp");
  },
  createSpecialDirectories: function () {
    // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the name of the stream for fd 6 (see test_unistd_ttyname)
    FS.mkdir("/proc");
    FS.mkdir("/proc/self");
    FS.mkdir("/proc/self/fd");
    FS.mount(
      {
        mount: function () {
          var node = FS.createNode(
            "/proc/self",
            "fd",
            16384 | 511 /* 0777 */,
            73
          );
          node.node_ops = {
            lookup: function (parent, name) {
              var fd = +name;
              var stream = FS.getStream(fd);
              if (!stream) throw new FS.ErrnoError(8);
              var ret = {
                parent: null,
                mount: { mountpoint: "fake" },
                node_ops: {
                  readlink: function () {
                    return stream.path;
                  },
                },
              };
              ret.parent = ret; // make it look like a simple root node
              return ret;
            },
          };
          return node;
        },
      },
      {},
      "/proc/self/fd"
    );
  },
  createStandardStreams: function () {
    // TODO deprecate the old functionality of a single
    // input / output callback and that utilizes FS.createDevice
    // and instead require a unique set of stream ops

    // by default, we symlink the standard streams to the
    // default tty devices. however, if the standard streams
    // have been overwritten we create a unique device for
    // them instead.
    if (Module["stdin"]) {
      FS.createDevice("/dev", "stdin", Module["stdin"]);
    } else {
      FS.symlink("/dev/tty", "/dev/stdin");
    }
    if (Module["stdout"]) {
      FS.createDevice("/dev", "stdout", null, Module["stdout"]);
    } else {
      FS.symlink("/dev/tty", "/dev/stdout");
    }
    if (Module["stderr"]) {
      FS.createDevice("/dev", "stderr", null, Module["stderr"]);
    } else {
      FS.symlink("/dev/tty1", "/dev/stderr");
    }

    // open default streams for the stdin, stdout and stderr devices
    var stdin = FS.open("/dev/stdin", "r");
    var stdout = FS.open("/dev/stdout", "w");
    var stderr = FS.open("/dev/stderr", "w");
    assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")");
    assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")");
    assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")");
  },
  ensureErrnoError: function () {
    if (FS.ErrnoError) return;
    FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) {
      this.node = node;
      this.setErrno = /** @this{Object} */ function (errno) {
        this.errno = errno;
        for (var key in ERRNO_CODES) {
          if (ERRNO_CODES[key] === errno) {
            this.code = key;
            break;
          }
        }
      };
      this.setErrno(errno);
      this.message = ERRNO_MESSAGES[errno];

      // Try to get a maximally helpful stack trace. On Node.js, getting Error.stack
      // now ensures it shows what we want.
      if (this.stack) {
        // Define the stack property for Node.js 4, which otherwise errors on the next line.
        Object.defineProperty(this, "stack", {
          value: new Error().stack,
          writable: true,
        });
        this.stack = demangleAll(this.stack);
      }
    };
    FS.ErrnoError.prototype = new Error();
    FS.ErrnoError.prototype.constructor = FS.ErrnoError;
    // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
    [44].forEach(function (code) {
      FS.genericErrors[code] = new FS.ErrnoError(code);
      FS.genericErrors[code].stack = "<generic error, no stack>";
    });
  },
  staticInit: function () {
    FS.ensureErrnoError();

    FS.nameTable = new Array(4096);

    FS.mount(MEMFS, {}, "/");

    FS.createDefaultDirectories();
    FS.createDefaultDevices();
    FS.createSpecialDirectories();

    FS.filesystems = {
      MEMFS: MEMFS,
    };
  },
  init: function (input, output, error) {
    assert(
      !FS.init.initialized,
      "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)"
    );
    FS.init.initialized = true;

    FS.ensureErrnoError();

    // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
    Module["stdin"] = input || Module["stdin"];
    Module["stdout"] = output || Module["stdout"];
    Module["stderr"] = error || Module["stderr"];

    FS.createStandardStreams();
  },
  quit: function () {
    FS.init.initialized = false;
    // force-flush all streams, so we get musl std streams printed out
    var fflush = Module["_fflush"];
    if (fflush) fflush(0);
    // close all of our streams
    for (var i = 0; i < FS.streams.length; i++) {
      var stream = FS.streams[i];
      if (!stream) {
        continue;
      }
      FS.close(stream);
    }
  },
  getMode: function (canRead, canWrite) {
    var mode = 0;
    if (canRead) mode |= 292 | 73;
    if (canWrite) mode |= 146;
    return mode;
  },
  joinPath: function (parts, forceRelative) {
    var path = PATH.join.apply(null, parts);
    if (forceRelative && path[0] == "/") path = path.substr(1);
    return path;
  },
  absolutePath: function (relative, base) {
    return PATH_FS.resolve(base, relative);
  },
  standardizePath: function (path) {
    return PATH.normalize(path);
  },
  findObject: function (path, dontResolveLastLink) {
    var ret = FS.analyzePath(path, dontResolveLastLink);
    if (ret.exists) {
      return ret.object;
    } else {
      ___setErrNo(ret.error);
      return null;
    }
  },
  analyzePath: function (path, dontResolveLastLink) {
    // operate from within the context of the symlink's target
    try {
      var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
      path = lookup.path;
    } catch (e) {}
    var ret = {
      isRoot: false,
      exists: false,
      error: 0,
      name: null,
      path: null,
      object: null,
      parentExists: false,
      parentPath: null,
      parentObject: null,
    };
    try {
      var lookup = FS.lookupPath(path, { parent: true });
      ret.parentExists = true;
      ret.parentPath = lookup.path;
      ret.parentObject = lookup.node;
      ret.name = PATH.basename(path);
      lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
      ret.exists = true;
      ret.path = lookup.path;
      ret.object = lookup.node;
      ret.name = lookup.node.name;
      ret.isRoot = lookup.path === "/";
    } catch (e) {
      ret.error = e.errno;
    }
    return ret;
  },
  createFolder: function (parent, name, canRead, canWrite) {
    var path = PATH.join2(
      typeof parent === "string" ? parent : FS.getPath(parent),
      name
    );
    var mode = FS.getMode(canRead, canWrite);
    return FS.mkdir(path, mode);
  },
  createPath: function (parent, path, canRead, canWrite) {
    parent = typeof parent === "string" ? parent : FS.getPath(parent);
    var parts = path.split("/").reverse();
    while (parts.length) {
      var part = parts.pop();
      if (!part) continue;
      var current = PATH.join2(parent, part);
      try {
        FS.mkdir(current);
      } catch (e) {
        // ignore EEXIST
      }
      parent = current;
    }
    return current;
  },
  createFile: function (parent, name, properties, canRead, canWrite) {
    var path = PATH.join2(
      typeof parent === "string" ? parent : FS.getPath(parent),
      name
    );
    var mode = FS.getMode(canRead, canWrite);
    return FS.create(path, mode);
  },
  createDataFile: function (parent, name, data, canRead, canWrite, canOwn) {
    var path = name
      ? PATH.join2(
          typeof parent === "string" ? parent : FS.getPath(parent),
          name
        )
      : parent;
    var mode = FS.getMode(canRead, canWrite);
    var node = FS.create(path, mode);
    if (data) {
      if (typeof data === "string") {
        var arr = new Array(data.length);
        for (var i = 0, len = data.length; i < len; ++i)
          arr[i] = data.charCodeAt(i);
        data = arr;
      }
      // make sure we can write to the file
      FS.chmod(node, mode | 146);
      var stream = FS.open(node, "w");
      FS.write(stream, data, 0, data.length, 0, canOwn);
      FS.close(stream);
      FS.chmod(node, mode);
    }
    return node;
  },
  createDevice: function (parent, name, input, output) {
    var path = PATH.join2(
      typeof parent === "string" ? parent : FS.getPath(parent),
      name
    );
    var mode = FS.getMode(!!input, !!output);
    if (!FS.createDevice.major) FS.createDevice.major = 64;
    var dev = FS.makedev(FS.createDevice.major++, 0);
    // Create a fake device that a set of stream ops to emulate
    // the old behavior.
    FS.registerDevice(dev, {
      open: function (stream) {
        stream.seekable = false;
      },
      close: function (stream) {
        // flush any pending line data
        if (output && output.buffer && output.buffer.length) {
          output(10);
        }
      },
      read: function (stream, buffer, offset, length, pos /* ignored */) {
        var bytesRead = 0;
        for (var i = 0; i < length; i++) {
          var result;
          try {
            result = input();
          } catch (e) {
            throw new FS.ErrnoError(29);
          }
          if (result === undefined && bytesRead === 0) {
            throw new FS.ErrnoError(6);
          }
          if (result === null || result === undefined) break;
          bytesRead++;
          buffer[offset + i] = result;
        }
        if (bytesRead) {
          stream.node.timestamp = Date.now();
        }
        return bytesRead;
      },
      write: function (stream, buffer, offset, length, pos) {
        for (var i = 0; i < length; i++) {
          try {
            output(buffer[offset + i]);
          } catch (e) {
            throw new FS.ErrnoError(29);
          }
        }
        if (length) {
          stream.node.timestamp = Date.now();
        }
        return i;
      },
    });
    return FS.mkdev(path, mode, dev);
  },
  createLink: function (parent, name, target, canRead, canWrite) {
    var path = PATH.join2(
      typeof parent === "string" ? parent : FS.getPath(parent),
      name
    );
    return FS.symlink(target, path);
  },
  forceLoadFile: function (obj) {
    if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
    var success = true;
    if (typeof XMLHttpRequest !== "undefined") {
      throw new Error(
        "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."
      );
    } else if (read_) {
      // Command-line.
      try {
        // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
        //          read() will try to parse UTF8.
        obj.contents = intArrayFromString(read_(obj.url), true);
        obj.usedBytes = obj.contents.length;
      } catch (e) {
        success = false;
      }
    } else {
      throw new Error("Cannot load without read() or XMLHttpRequest.");
    }
    if (!success) ___setErrNo(29);
    return success;
  },
  createLazyFile: function (parent, name, url, canRead, canWrite) {
    // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
    /** @constructor */
    function LazyUint8Array() {
      this.lengthKnown = false;
      this.chunks = []; // Loaded chunks. Index is the chunk number
    }
    LazyUint8Array.prototype.get =
      /** @this{Object} */ function LazyUint8Array_get(idx) {
        if (idx > this.length - 1 || idx < 0) {
          return undefined;
        }
        var chunkOffset = idx % this.chunkSize;
        var chunkNum = (idx / this.chunkSize) | 0;
        return this.getter(chunkNum)[chunkOffset];
      };
    LazyUint8Array.prototype.setDataGetter =
      function LazyUint8Array_setDataGetter(getter) {
        this.getter = getter;
      };
    LazyUint8Array.prototype.cacheLength =
      function LazyUint8Array_cacheLength() {
        // Find length
        var xhr = new XMLHttpRequest();
        xhr.open("HEAD", url, false);
        xhr.send(null);
        if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
          throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
        var datalength = Number(xhr.getResponseHeader("Content-length"));
        var header;
        var hasByteServing =
          (header = xhr.getResponseHeader("Accept-Ranges")) &&
          header === "bytes";
        var usesGzip =
          (header = xhr.getResponseHeader("Content-Encoding")) &&
          header === "gzip";

        var chunkSize = 1024 * 1024; // Chunk size in bytes

        if (!hasByteServing) chunkSize = datalength;

        // Function to get a range from the remote URL.
        var doXHR = function (from, to) {
          if (from > to)
            throw new Error(
              "invalid range (" + from + ", " + to + ") or no bytes requested!"
            );
          if (to > datalength - 1)
            throw new Error(
              "only " + datalength + " bytes available! programmer error!"
            );

          // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
          var xhr = new XMLHttpRequest();
          xhr.open("GET", url, false);
          if (datalength !== chunkSize)
            xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);

          // Some hints to the browser that we want binary data.
          if (typeof Uint8Array != "undefined")
            xhr.responseType = "arraybuffer";
          if (xhr.overrideMimeType) {
            xhr.overrideMimeType("text/plain; charset=x-user-defined");
          }

          xhr.send(null);
          if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
            throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
          if (xhr.response !== undefined) {
            return new Uint8Array(
              /** @type{Array<number>} */ (xhr.response || [])
            );
          } else {
            return intArrayFromString(xhr.responseText || "", true);
          }
        };
        var lazyArray = this;
        lazyArray.setDataGetter(function (chunkNum) {
          var start = chunkNum * chunkSize;
          var end = (chunkNum + 1) * chunkSize - 1; // including this byte
          end = Math.min(end, datalength - 1); // if datalength-1 is selected, this is the last block
          if (typeof lazyArray.chunks[chunkNum] === "undefined") {
            lazyArray.chunks[chunkNum] = doXHR(start, end);
          }
          if (typeof lazyArray.chunks[chunkNum] === "undefined")
            throw new Error("doXHR failed!");
          return lazyArray.chunks[chunkNum];
        });

        if (usesGzip || !datalength) {
          // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length
          chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file
          datalength = this.getter(0).length;
          chunkSize = datalength;
          out(
            "LazyFiles on gzip forces download of the whole file when length is accessed"
          );
        }

        this._length = datalength;
        this._chunkSize = chunkSize;
        this.lengthKnown = true;
      };
    if (typeof XMLHttpRequest !== "undefined") {
      if (!ENVIRONMENT_IS_WORKER)
        throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
      var lazyArray = new LazyUint8Array();
      Object.defineProperties(lazyArray, {
        length: {
          get: /** @this{Object} */ function () {
            if (!this.lengthKnown) {
              this.cacheLength();
            }
            return this._length;
          },
        },
        chunkSize: {
          get: /** @this{Object} */ function () {
            if (!this.lengthKnown) {
              this.cacheLength();
            }
            return this._chunkSize;
          },
        },
      });

      var properties = { isDevice: false, contents: lazyArray };
    } else {
      var properties = { isDevice: false, url: url };
    }

    var node = FS.createFile(parent, name, properties, canRead, canWrite);
    // This is a total hack, but I want to get this lazy file code out of the
    // core of MEMFS. If we want to keep this lazy file concept I feel it should
    // be its own thin LAZYFS proxying calls to MEMFS.
    if (properties.contents) {
      node.contents = properties.contents;
    } else if (properties.url) {
      node.contents = null;
      node.url = properties.url;
    }
    // Add a function that defers querying the file size until it is asked the first time.
    Object.defineProperties(node, {
      usedBytes: {
        get: /** @this {FSNode} */ function () {
          return this.contents.length;
        },
      },
    });
    // override each stream op with one that tries to force load the lazy file first
    var stream_ops = {};
    var keys = Object.keys(node.stream_ops);
    keys.forEach(function (key) {
      var fn = node.stream_ops[key];
      stream_ops[key] = function forceLoadLazyFile() {
        if (!FS.forceLoadFile(node)) {
          throw new FS.ErrnoError(29);
        }
        return fn.apply(null, arguments);
      };
    });
    // use a custom read function
    stream_ops.read = function stream_ops_read(
      stream,
      buffer,
      offset,
      length,
      position
    ) {
      if (!FS.forceLoadFile(node)) {
        throw new FS.ErrnoError(29);
      }
      var contents = stream.node.contents;
      if (position >= contents.length) return 0;
      var size = Math.min(contents.length - position, length);
      assert(size >= 0);
      if (contents.slice) {
        // normal array
        for (var i = 0; i < size; i++) {
          buffer[offset + i] = contents[position + i];
        }
      } else {
        for (var i = 0; i < size; i++) {
          // LazyUint8Array from sync binary XHR
          buffer[offset + i] = contents.get(position + i);
        }
      }
      return size;
    };
    node.stream_ops = stream_ops;
    return node;
  },
  createPreloadedFile: function (
    parent,
    name,
    url,
    canRead,
    canWrite,
    onload,
    onerror,
    dontCreateFile,
    canOwn,
    preFinish
  ) {
    Browser.init(); // XXX perhaps this method should move onto Browser?
    // TODO we should allow people to just pass in a complete filename instead
    // of parent and name being that we just join them anyways
    var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
    var dep = getUniqueRunDependency("cp " + fullname); // might have several active requests for the same fullname
    function processData(byteArray) {
      function finish(byteArray) {
        if (preFinish) preFinish();
        if (!dontCreateFile) {
          FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
        }
        if (onload) onload();
        removeRunDependency(dep);
      }
      var handled = false;
      Module["preloadPlugins"].forEach(function (plugin) {
        if (handled) return;
        if (plugin["canHandle"](fullname)) {
          plugin["handle"](byteArray, fullname, finish, function () {
            if (onerror) onerror();
            removeRunDependency(dep);
          });
          handled = true;
        }
      });
      if (!handled) finish(byteArray);
    }
    addRunDependency(dep);
    if (typeof url == "string") {
      Browser.asyncLoad(
        url,
        function (byteArray) {
          processData(byteArray);
        },
        onerror
      );
    } else {
      processData(url);
    }
  },
  indexedDB: function () {
    return (
      window.indexedDB ||
      window.mozIndexedDB ||
      window.webkitIndexedDB ||
      window.msIndexedDB
    );
  },
  DB_NAME: function () {
    return "EM_FS_" + window.location.pathname;
  },
  DB_VERSION: 20,
  DB_STORE_NAME: "FILE_DATA",
  saveFilesToDB: function (paths, onload, onerror) {
    onload = onload || function () {};
    onerror = onerror || function () {};
    var indexedDB = FS.indexedDB();
    try {
      var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
    } catch (e) {
      return onerror(e);
    }
    openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
      out("creating db");
      var db = openRequest.result;
      db.createObjectStore(FS.DB_STORE_NAME);
    };
    openRequest.onsuccess = function openRequest_onsuccess() {
      var db = openRequest.result;
      var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite");
      var files = transaction.objectStore(FS.DB_STORE_NAME);
      var ok = 0,
        fail = 0,
        total = paths.length;
      function finish() {
        if (fail == 0) onload();
        else onerror();
      }
      paths.forEach(function (path) {
        var putRequest = files.put(FS.analyzePath(path).object.contents, path);
        putRequest.onsuccess = function putRequest_onsuccess() {
          ok++;
          if (ok + fail == total) finish();
        };
        putRequest.onerror = function putRequest_onerror() {
          fail++;
          if (ok + fail == total) finish();
        };
      });
      transaction.onerror = onerror;
    };
    openRequest.onerror = onerror;
  },
  loadFilesFromDB: function (paths, onload, onerror) {
    onload = onload || function () {};
    onerror = onerror || function () {};
    var indexedDB = FS.indexedDB();
    try {
      var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
    } catch (e) {
      return onerror(e);
    }
    openRequest.onupgradeneeded = onerror; // no database to load from
    openRequest.onsuccess = function openRequest_onsuccess() {
      var db = openRequest.result;
      try {
        var transaction = db.transaction([FS.DB_STORE_NAME], "readonly");
      } catch (e) {
        onerror(e);
        return;
      }
      var files = transaction.objectStore(FS.DB_STORE_NAME);
      var ok = 0,
        fail = 0,
        total = paths.length;
      function finish() {
        if (fail == 0) onload();
        else onerror();
      }
      paths.forEach(function (path) {
        var getRequest = files.get(path);
        getRequest.onsuccess = function getRequest_onsuccess() {
          if (FS.analyzePath(path).exists) {
            FS.unlink(path);
          }
          FS.createDataFile(
            PATH.dirname(path),
            PATH.basename(path),
            getRequest.result,
            true,
            true,
            true
          );
          ok++;
          if (ok + fail == total) finish();
        };
        getRequest.onerror = function getRequest_onerror() {
          fail++;
          if (ok + fail == total) finish();
        };
      });
      transaction.onerror = onerror;
    };
    openRequest.onerror = onerror;
  },
};
var SYSCALLS = {
  mappings: {},
  DEFAULT_POLLMASK: 5,
  umask: 511,
  calculateAt: function (dirfd, path) {
    if (path[0] !== "/") {
      // relative path
      var dir;
      if (dirfd === -100) {
        dir = FS.cwd();
      } else {
        var dirstream = FS.getStream(dirfd);
        if (!dirstream) throw new FS.ErrnoError(8);
        dir = dirstream.path;
      }
      path = PATH.join2(dir, path);
    }
    return path;
  },
  doStat: function (func, path, buf) {
    try {
      var stat = func(path);
    } catch (e) {
      if (
        e &&
        e.node &&
        PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))
      ) {
        // an error occurred while trying to look up the path; we should just report ENOTDIR
        return -54;
      }
      throw e;
    }
    HEAP32[buf >> 2] = stat.dev;
    HEAP32[(buf + 4) >> 2] = 0;
    HEAP32[(buf + 8) >> 2] = stat.ino;
    HEAP32[(buf + 12) >> 2] = stat.mode;
    HEAP32[(buf + 16) >> 2] = stat.nlink;
    HEAP32[(buf + 20) >> 2] = stat.uid;
    HEAP32[(buf + 24) >> 2] = stat.gid;
    HEAP32[(buf + 28) >> 2] = stat.rdev;
    HEAP32[(buf + 32) >> 2] = 0;
    (tempI64 = [
      stat.size >>> 0,
      ((tempDouble = stat.size),
      +Math_abs(tempDouble) >= 1.0
        ? tempDouble > 0.0
          ? (Math_min(+Math_floor(tempDouble / 4294967296.0), 4294967295.0) |
              0) >>>
            0
          : ~~+Math_ceil(
              (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
            ) >>> 0
        : 0),
    ]),
      (HEAP32[(buf + 40) >> 2] = tempI64[0]),
      (HEAP32[(buf + 44) >> 2] = tempI64[1]);
    HEAP32[(buf + 48) >> 2] = 4096;
    HEAP32[(buf + 52) >> 2] = stat.blocks;
    HEAP32[(buf + 56) >> 2] = (stat.atime.getTime() / 1000) | 0;
    HEAP32[(buf + 60) >> 2] = 0;
    HEAP32[(buf + 64) >> 2] = (stat.mtime.getTime() / 1000) | 0;
    HEAP32[(buf + 68) >> 2] = 0;
    HEAP32[(buf + 72) >> 2] = (stat.ctime.getTime() / 1000) | 0;
    HEAP32[(buf + 76) >> 2] = 0;
    (tempI64 = [
      stat.ino >>> 0,
      ((tempDouble = stat.ino),
      +Math_abs(tempDouble) >= 1.0
        ? tempDouble > 0.0
          ? (Math_min(+Math_floor(tempDouble / 4294967296.0), 4294967295.0) |
              0) >>>
            0
          : ~~+Math_ceil(
              (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
            ) >>> 0
        : 0),
    ]),
      (HEAP32[(buf + 80) >> 2] = tempI64[0]),
      (HEAP32[(buf + 84) >> 2] = tempI64[1]);
    return 0;
  },
  doMsync: function (addr, stream, len, flags, offset) {
    var buffer = HEAPU8.slice(addr, addr + len);
    FS.msync(stream, buffer, offset, len, flags);
  },
  doMkdir: function (path, mode) {
    // remove a trailing slash, if one - /a/b/ has basename of '', but
    // we want to create b in the context of this function
    path = PATH.normalize(path);
    if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1);
    FS.mkdir(path, mode, 0);
    return 0;
  },
  doMknod: function (path, mode, dev) {
    // we don't want this in the JS API as it uses mknod to create all nodes.
    switch (mode & 61440) {
      case 32768:
      case 8192:
      case 24576:
      case 4096:
      case 49152:
        break;
      default:
        return -28;
    }
    FS.mknod(path, mode, dev);
    return 0;
  },
  doReadlink: function (path, buf, bufsize) {
    if (bufsize <= 0) return -28;
    var ret = FS.readlink(path);

    var len = Math.min(bufsize, lengthBytesUTF8(ret));
    var endChar = HEAP8[buf + len];
    stringToUTF8(ret, buf, bufsize + 1);
    // readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!)
    // stringToUTF8() always appends a null byte, so restore the character under the null byte after the write.
    HEAP8[buf + len] = endChar;

    return len;
  },
  doAccess: function (path, amode) {
    if (amode & ~7) {
      // need a valid mode
      return -28;
    }
    var node;
    var lookup = FS.lookupPath(path, { follow: true });
    node = lookup.node;
    if (!node) {
      return -44;
    }
    var perms = "";
    if (amode & 4) perms += "r";
    if (amode & 2) perms += "w";
    if (amode & 1) perms += "x";
    if (
      perms /* otherwise, they've just passed F_OK */ &&
      FS.nodePermissions(node, perms)
    ) {
      return -2;
    }
    return 0;
  },
  doDup: function (path, flags, suggestFD) {
    var suggest = FS.getStream(suggestFD);
    if (suggest) FS.close(suggest);
    return FS.open(path, flags, 0, suggestFD, suggestFD).fd;
  },
  doReadv: function (stream, iov, iovcnt, offset) {
    var ret = 0;
    for (var i = 0; i < iovcnt; i++) {
      var ptr = HEAP32[(iov + i * 8) >> 2];
      var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
      var curr = FS.read(stream, HEAP8, ptr, len, offset);
      if (curr < 0) return -1;
      ret += curr;
      if (curr < len) break; // nothing more to read
    }
    return ret;
  },
  doWritev: function (stream, iov, iovcnt, offset) {
    var ret = 0;
    for (var i = 0; i < iovcnt; i++) {
      var ptr = HEAP32[(iov + i * 8) >> 2];
      var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
      var curr = FS.write(stream, HEAP8, ptr, len, offset);
      if (curr < 0) return -1;
      ret += curr;
    }
    return ret;
  },
  varargs: undefined,
  get: function () {
    assert(SYSCALLS.varargs != undefined);
    SYSCALLS.varargs += 4;
    var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
    return ret;
  },
  getStr: function (ptr) {
    var ret = UTF8ToString(ptr);
    return ret;
  },
  getStreamFromFD: function (fd) {
    var stream = FS.getStream(fd);
    if (!stream) throw new FS.ErrnoError(8);
    return stream;
  },
  get64: function (low, high) {
    if (low >= 0) assert(high === 0);
    else assert(high === -1);
    return low;
  },
};
function ___syscall221(fd, cmd, varargs) {
  SYSCALLS.varargs = varargs;
  try {
    // fcntl64
    var stream = SYSCALLS.getStreamFromFD(fd);
    switch (cmd) {
      case 0: {
        var arg = SYSCALLS.get();
        if (arg < 0) {
          return -28;
        }
        var newStream;
        newStream = FS.open(stream.path, stream.flags, 0, arg);
        return newStream.fd;
      }
      case 1:
      case 2:
        return 0; // FD_CLOEXEC makes no sense for a single process.
      case 3:
        return stream.flags;
      case 4: {
        var arg = SYSCALLS.get();
        stream.flags |= arg;
        return 0;
      }
      case 12: /* case 12: Currently in musl F_GETLK64 has same value as F_GETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ {
        var arg = SYSCALLS.get();
        var offset = 0;
        // We're always unlocked.
        HEAP16[(arg + offset) >> 1] = 2;
        return 0;
      }
      case 13:
      case 14:
        /* case 13: Currently in musl F_SETLK64 has same value as F_SETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */
        /* case 14: Currently in musl F_SETLKW64 has same value as F_SETLKW, so omitted to avoid duplicate case blocks. If that changes, uncomment this */

        return 0; // Pretend that the locking is successful.
      case 16:
      case 8:
        return -28; // These are for sockets. We don't have them fully implemented yet.
      case 9:
        // musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fnctl() returns that, and we set errno ourselves.
        ___setErrNo(28);
        return -1;
      default: {
        return -28;
      }
    }
  } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return -e.errno;
  }
}

function ___syscall5(path, flags, varargs) {
  SYSCALLS.varargs = varargs;
  try {
    // open
    var pathname = SYSCALLS.getStr(path);
    var mode = SYSCALLS.get();
    var stream = FS.open(pathname, flags, mode);
    return stream.fd;
  } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return -e.errno;
  }
}

function ___syscall54(fd, op, varargs) {
  SYSCALLS.varargs = varargs;
  try {
    // ioctl
    var stream = SYSCALLS.getStreamFromFD(fd);
    switch (op) {
      case 21509:
      case 21505: {
        if (!stream.tty) return -59;
        return 0;
      }
      case 21510:
      case 21511:
      case 21512:
      case 21506:
      case 21507:
      case 21508: {
        if (!stream.tty) return -59;
        return 0; // no-op, not actually adjusting terminal settings
      }
      case 21519: {
        if (!stream.tty) return -59;
        var argp = SYSCALLS.get();
        HEAP32[argp >> 2] = 0;
        return 0;
      }
      case 21520: {
        if (!stream.tty) return -59;
        return -28; // not supported
      }
      case 21531: {
        var argp = SYSCALLS.get();
        return FS.ioctl(stream, op, argp);
      }
      case 21523: {
        // TODO: in theory we should write to the winsize struct that gets
        // passed in, but for now musl doesn't read anything on it
        if (!stream.tty) return -59;
        return 0;
      }
      case 21524: {
        // TODO: technically, this ioctl call should change the window size.
        // but, since emscripten doesn't have any concept of a terminal window
        // yet, we'll just silently throw it away as we do TIOCGWINSZ
        if (!stream.tty) return -59;
        return 0;
      }
      default:
        abort("bad ioctl syscall " + op);
    }
  } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return -e.errno;
  }
}

function _abort() {
  abort();
}

function _atexit(func, arg) {
  warnOnce(
    "atexit() called, but EXIT_RUNTIME is not set, so atexits() will not be called. set EXIT_RUNTIME to 1 (see the FAQ)"
  );
  __ATEXIT__.unshift({ func: func, arg: arg });
}

var _emscripten_get_now;
if (ENVIRONMENT_IS_NODE) {
  _emscripten_get_now = function () {
    var t = process["hrtime"]();
    return t[0] * 1e3 + t[1] / 1e6;
  };
} else if (typeof dateNow !== "undefined") {
  _emscripten_get_now = dateNow;
} else
  _emscripten_get_now = function () {
    return performance.now();
  };

var _emscripten_get_now_is_monotonic = true;
function _clock_gettime(clk_id, tp) {
  // int clock_gettime(clockid_t clk_id, struct timespec *tp);
  var now;
  if (clk_id === 0) {
    now = Date.now();
  } else if (
    (clk_id === 1 || clk_id === 4) &&
    _emscripten_get_now_is_monotonic
  ) {
    now = _emscripten_get_now();
  } else {
    ___setErrNo(28);
    return -1;
  }
  HEAP32[tp >> 2] = (now / 1000) | 0; // seconds
  HEAP32[(tp + 4) >> 2] = ((now % 1000) * 1000 * 1000) | 0; // nanoseconds
  return 0;
}

function _dlclose(handle) {
  abort(
    "To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking"
  );
}

function _dlerror() {
  abort(
    "To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking"
  );
}

function _dlsym(handle, symbol) {
  abort(
    "To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking"
  );
}

function _emscripten_set_main_loop_timing(mode, value) {
  Browser.mainLoop.timingMode = mode;
  Browser.mainLoop.timingValue = value;

  if (!Browser.mainLoop.func) {
    console.error(
      "emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up."
    );
    return 1; // Return non-zero on failure, can't set timing mode when there is no main loop.
  }

  if (mode == 0 /*EM_TIMING_SETTIMEOUT*/) {
    Browser.mainLoop.scheduler =
      function Browser_mainLoop_scheduler_setTimeout() {
        var timeUntilNextTick =
          Math.max(
            0,
            Browser.mainLoop.tickStartTime + value - _emscripten_get_now()
          ) | 0;
        setTimeout(Browser.mainLoop.runner, timeUntilNextTick); // doing this each time means that on exception, we stop
      };
    Browser.mainLoop.method = "timeout";
  } else if (mode == 1 /*EM_TIMING_RAF*/) {
    Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() {
      Browser.requestAnimationFrame(Browser.mainLoop.runner);
    };
    Browser.mainLoop.method = "rAF";
  } else if (mode == 2 /*EM_TIMING_SETIMMEDIATE*/) {
    if (typeof setImmediate === "undefined") {
      // Emulate setImmediate. (note: not a complete polyfill, we don't emulate clearImmediate() to keep code size to minimum, since not needed)
      var setImmediates = [];
      var emscriptenMainLoopMessageId = "setimmediate";
      var Browser_setImmediate_messageHandler = function (event) {
        // When called in current thread or Worker, the main loop ID is structured slightly different to accommodate for --proxy-to-worker runtime listening to Worker events,
        // so check for both cases.
        if (
          event.data === emscriptenMainLoopMessageId ||
          event.data.target === emscriptenMainLoopMessageId
        ) {
          event.stopPropagation();
          setImmediates.shift()();
        }
      };
      addEventListener("message", Browser_setImmediate_messageHandler, true);
      setImmediate = /** @type{function(function(): ?, ...?): number} */ (
        function Browser_emulated_setImmediate(func) {
          setImmediates.push(func);
          if (ENVIRONMENT_IS_WORKER) {
            if (Module["setImmediates"] === undefined)
              Module["setImmediates"] = [];
            Module["setImmediates"].push(func);
            postMessage({ target: emscriptenMainLoopMessageId }); // In --proxy-to-worker, route the message via proxyClient.js
          } else postMessage(emscriptenMainLoopMessageId, "*"); // On the main thread, can just send the message to itself.
        }
      );
    }
    Browser.mainLoop.scheduler =
      function Browser_mainLoop_scheduler_setImmediate() {
        setImmediate(Browser.mainLoop.runner);
      };
    Browser.mainLoop.method = "immediate";
  }
  return 0;
} /** @param {number|boolean=} noSetTiming */
function _emscripten_set_main_loop(
  func,
  fps,
  simulateInfiniteLoop,
  arg,
  noSetTiming
) {
  noExitRuntime = true;

  assert(
    !Browser.mainLoop.func,
    "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters."
  );

  Browser.mainLoop.func = func;
  Browser.mainLoop.arg = arg;

  var browserIterationFunc;
  if (typeof arg !== "undefined") {
    browserIterationFunc = function () {
      Module["dynCall_vi"](func, arg);
    };
  } else {
    browserIterationFunc = function () {
      Module["dynCall_v"](func);
    };
  }

  var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop;

  Browser.mainLoop.runner = function Browser_mainLoop_runner() {
    if (ABORT) return;
    if (Browser.mainLoop.queue.length > 0) {
      var start = Date.now();
      var blocker = Browser.mainLoop.queue.shift();
      blocker.func(blocker.arg);
      if (Browser.mainLoop.remainingBlockers) {
        var remaining = Browser.mainLoop.remainingBlockers;
        var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
        if (blocker.counted) {
          Browser.mainLoop.remainingBlockers = next;
        } else {
          // not counted, but move the progress along a tiny bit
          next = next + 0.5; // do not steal all the next one's progress
          Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9;
        }
      }
      console.log(
        'main loop blocker "' +
          blocker.name +
          '" took ' +
          (Date.now() - start) +
          " ms"
      ); //, left: ' + Browser.mainLoop.remainingBlockers);
      Browser.mainLoop.updateStatus();

      // catches pause/resume main loop from blocker execution
      if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;

      setTimeout(Browser.mainLoop.runner, 0);
      return;
    }

    // catch pauses from non-main loop sources
    if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;

    // Implement very basic swap interval control
    Browser.mainLoop.currentFrameNumber =
      (Browser.mainLoop.currentFrameNumber + 1) | 0;
    if (
      Browser.mainLoop.timingMode == 1 /*EM_TIMING_RAF*/ &&
      Browser.mainLoop.timingValue > 1 &&
      Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0
    ) {
      // Not the scheduled time to render this frame - skip.
      Browser.mainLoop.scheduler();
      return;
    } else if (Browser.mainLoop.timingMode == 0 /*EM_TIMING_SETTIMEOUT*/) {
      Browser.mainLoop.tickStartTime = _emscripten_get_now();
    }

    // Signal GL rendering layer that processing of a new frame is about to start. This helps it optimize
    // VBO double-buffering and reduce GPU stalls.

    if (Browser.mainLoop.method === "timeout" && Module.ctx) {
      warnOnce(
        "Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!"
      );
      Browser.mainLoop.method = ""; // just warn once per call to set main loop
    }

    Browser.mainLoop.runIter(browserIterationFunc);

    checkStackCookie();

    // catch pauses from the main loop itself
    if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;

    // Queue new audio data. This is important to be right after the main loop invocation, so that we will immediately be able
    // to queue the newest produced audio samples.
    // TODO: Consider adding pre- and post- rAF callbacks so that GL.newRenderingFrameStarted() and SDL.audio.queueNewAudioData()
    //       do not need to be hardcoded into this function, but can be more generic.
    if (typeof SDL === "object" && SDL.audio && SDL.audio.queueNewAudioData)
      SDL.audio.queueNewAudioData();

    Browser.mainLoop.scheduler();
  };

  if (!noSetTiming) {
    if (fps && fps > 0)
      _emscripten_set_main_loop_timing(
        0 /*EM_TIMING_SETTIMEOUT*/,
        1000.0 / fps
      );
    else _emscripten_set_main_loop_timing(1 /*EM_TIMING_RAF*/, 1); // Do rAF by rendering each frame (no decimating)

    Browser.mainLoop.scheduler();
  }

  if (simulateInfiniteLoop) {
    throw "unwind";
  }
}
var Browser = {
  mainLoop: {
    scheduler: null,
    method: "",
    currentlyRunningMainloop: 0,
    func: null,
    arg: 0,
    timingMode: 0,
    timingValue: 0,
    currentFrameNumber: 0,
    queue: [],
    pause: function () {
      Browser.mainLoop.scheduler = null;
      Browser.mainLoop.currentlyRunningMainloop++; // Incrementing this signals the previous main loop that it's now become old, and it must return.
    },
    resume: function () {
      Browser.mainLoop.currentlyRunningMainloop++;
      var timingMode = Browser.mainLoop.timingMode;
      var timingValue = Browser.mainLoop.timingValue;
      var func = Browser.mainLoop.func;
      Browser.mainLoop.func = null;
      _emscripten_set_main_loop(
        func,
        0,
        false,
        Browser.mainLoop.arg,
        true /* do not set timing and call scheduler, we will do it on the next lines */
      );
      _emscripten_set_main_loop_timing(timingMode, timingValue);
      Browser.mainLoop.scheduler();
    },
    updateStatus: function () {
      if (Module["setStatus"]) {
        var message = Module["statusMessage"] || "Please wait...";
        var remaining = Browser.mainLoop.remainingBlockers;
        var expected = Browser.mainLoop.expectedBlockers;
        if (remaining) {
          if (remaining < expected) {
            Module["setStatus"](
              message + " (" + (expected - remaining) + "/" + expected + ")"
            );
          } else {
            Module["setStatus"](message);
          }
        } else {
          Module["setStatus"]("");
        }
      }
    },
    runIter: function (func) {
      if (ABORT) return;
      if (Module["preMainLoop"]) {
        var preRet = Module["preMainLoop"]();
        if (preRet === false) {
          return; // |return false| skips a frame
        }
      }
      try {
        func();
      } catch (e) {
        if (e instanceof ExitStatus) {
          return;
        } else {
          if (e && typeof e === "object" && e.stack)
            err("exception thrown: " + [e, e.stack]);
          throw e;
        }
      }
      if (Module["postMainLoop"]) Module["postMainLoop"]();
    },
  },
  isFullscreen: false,
  pointerLock: false,
  moduleContextCreatedCallbacks: [],
  workers: [],
  init: function () {
    if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers

    if (Browser.initted) return;
    Browser.initted = true;

    try {
      new Blob();
      Browser.hasBlobConstructor = true;
    } catch (e) {
      Browser.hasBlobConstructor = false;
      console.log(
        "warning: no blob constructor, cannot create blobs with mimetypes"
      );
    }
    Browser.BlobBuilder =
      typeof MozBlobBuilder != "undefined"
        ? MozBlobBuilder
        : typeof WebKitBlobBuilder != "undefined"
        ? WebKitBlobBuilder
        : !Browser.hasBlobConstructor
        ? console.log("warning: no BlobBuilder")
        : null;
    Browser.URLObject =
      typeof window != "undefined"
        ? window.URL
          ? window.URL
          : window.webkitURL
        : undefined;
    if (!Module.noImageDecoding && typeof Browser.URLObject === "undefined") {
      console.log(
        "warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available."
      );
      Module.noImageDecoding = true;
    }

    // Support for plugins that can process preloaded files. You can add more of these to
    // your app by creating and appending to Module.preloadPlugins.
    //
    // Each plugin is asked if it can handle a file based on the file's name. If it can,
    // it is given the file's raw data. When it is done, it calls a callback with the file's
    // (possibly modified) data. For example, a plugin might decompress a file, or it
    // might create some side data structure for use later (like an Image element, etc.).

    var imagePlugin = {};
    imagePlugin["canHandle"] = function imagePlugin_canHandle(name) {
      return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
    };
    imagePlugin["handle"] = function imagePlugin_handle(
      byteArray,
      name,
      onload,
      onerror
    ) {
      var b = null;
      if (Browser.hasBlobConstructor) {
        try {
          b = new Blob([byteArray], { type: Browser.getMimetype(name) });
          if (b.size !== byteArray.length) {
            // Safari bug #118630
            // Safari's Blob can only take an ArrayBuffer
            b = new Blob([new Uint8Array(byteArray).buffer], {
              type: Browser.getMimetype(name),
            });
          }
        } catch (e) {
          warnOnce(
            "Blob constructor present but fails: " +
              e +
              "; falling back to blob builder"
          );
        }
      }
      if (!b) {
        var bb = new Browser.BlobBuilder();
        bb.append(new Uint8Array(byteArray).buffer); // we need to pass a buffer, and must copy the array to get the right data range
        b = bb.getBlob();
      }
      var url = Browser.URLObject.createObjectURL(b);
      assert(
        typeof url == "string",
        "createObjectURL must return a url as a string"
      );
      var img = new Image();
      img.onload = function img_onload() {
        assert(img.complete, "Image " + name + " could not be decoded");
        var canvas = document.createElement("canvas");
        canvas.width = img.width;
        canvas.height = img.height;
        var ctx = canvas.getContext("2d");
        ctx.drawImage(img, 0, 0);
        Module["preloadedImages"][name] = canvas;
        Browser.URLObject.revokeObjectURL(url);
        if (onload) onload(byteArray);
      };
      img.onerror = function img_onerror(event) {
        console.log("Image " + url + " could not be decoded");
        if (onerror) onerror();
      };
      img.src = url;
    };
    Module["preloadPlugins"].push(imagePlugin);

    var audioPlugin = {};
    audioPlugin["canHandle"] = function audioPlugin_canHandle(name) {
      return (
        !Module.noAudioDecoding &&
        name.substr(-4) in { ".ogg": 1, ".wav": 1, ".mp3": 1 }
      );
    };
    audioPlugin["handle"] = function audioPlugin_handle(
      byteArray,
      name,
      onload,
      onerror
    ) {
      var done = false;
      function finish(audio) {
        if (done) return;
        done = true;
        Module["preloadedAudios"][name] = audio;
        if (onload) onload(byteArray);
      }
      function fail() {
        if (done) return;
        done = true;
        Module["preloadedAudios"][name] = new Audio(); // empty shim
        if (onerror) onerror();
      }
      if (Browser.hasBlobConstructor) {
        try {
          var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
        } catch (e) {
          return fail();
        }
        var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
        assert(
          typeof url == "string",
          "createObjectURL must return a url as a string"
        );
        var audio = new Audio();
        audio.addEventListener(
          "canplaythrough",
          function () {
            finish(audio);
          },
          false
        ); // use addEventListener due to chromium bug 124926
        audio.onerror = function audio_onerror(event) {
          if (done) return;
          console.log(
            "warning: browser could not fully decode audio " +
              name +
              ", trying slower base64 approach"
          );
          function encode64(data) {
            var BASE =
              "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
            var PAD = "=";
            var ret = "";
            var leftchar = 0;
            var leftbits = 0;
            for (var i = 0; i < data.length; i++) {
              leftchar = (leftchar << 8) | data[i];
              leftbits += 8;
              while (leftbits >= 6) {
                var curr = (leftchar >> (leftbits - 6)) & 0x3f;
                leftbits -= 6;
                ret += BASE[curr];
              }
            }
            if (leftbits == 2) {
              ret += BASE[(leftchar & 3) << 4];
              ret += PAD + PAD;
            } else if (leftbits == 4) {
              ret += BASE[(leftchar & 0xf) << 2];
              ret += PAD;
            }
            return ret;
          }
          audio.src =
            "data:audio/x-" +
            name.substr(-3) +
            ";base64," +
            encode64(byteArray);
          finish(audio); // we don't wait for confirmation this worked - but it's worth trying
        };
        audio.src = url;
        // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
        Browser.safeSetTimeout(function () {
          finish(audio); // try to use it even though it is not necessarily ready to play
        }, 10000);
      } else {
        return fail();
      }
    };
    Module["preloadPlugins"].push(audioPlugin);

    // Canvas event setup

    function pointerLockChange() {
      Browser.pointerLock =
        document["pointerLockElement"] === Module["canvas"] ||
        document["mozPointerLockElement"] === Module["canvas"] ||
        document["webkitPointerLockElement"] === Module["canvas"] ||
        document["msPointerLockElement"] === Module["canvas"];
    }
    var canvas = Module["canvas"];
    if (canvas) {
      // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
      // Module['forcedAspectRatio'] = 4 / 3;

      canvas.requestPointerLock =
        canvas["requestPointerLock"] ||
        canvas["mozRequestPointerLock"] ||
        canvas["webkitRequestPointerLock"] ||
        canvas["msRequestPointerLock"] ||
        function () {};
      canvas.exitPointerLock =
        document["exitPointerLock"] ||
        document["mozExitPointerLock"] ||
        document["webkitExitPointerLock"] ||
        document["msExitPointerLock"] ||
        function () {}; // no-op if function does not exist
      canvas.exitPointerLock = canvas.exitPointerLock.bind(document);

      document.addEventListener("pointerlockchange", pointerLockChange, false);
      document.addEventListener(
        "mozpointerlockchange",
        pointerLockChange,
        false
      );
      document.addEventListener(
        "webkitpointerlockchange",
        pointerLockChange,
        false
      );
      document.addEventListener(
        "mspointerlockchange",
        pointerLockChange,
        false
      );

      if (Module["elementPointerLock"]) {
        canvas.addEventListener(
          "click",
          function (ev) {
            if (!Browser.pointerLock && Module["canvas"].requestPointerLock) {
              Module["canvas"].requestPointerLock();
              ev.preventDefault();
            }
          },
          false
        );
      }
    }
  },
  createContext: function (
    canvas,
    useWebGL,
    setInModule,
    webGLContextAttributes
  ) {
    if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx; // no need to recreate GL context if it's already been created for this canvas.

    var ctx;
    var contextHandle;
    if (useWebGL) {
      // For GLES2/desktop GL compatibility, adjust a few defaults to be different to WebGL defaults, so that they align better with the desktop defaults.
      var contextAttributes = {
        antialias: false,
        alpha: false,
        majorVersion: 1,
      };

      if (webGLContextAttributes) {
        for (var attribute in webGLContextAttributes) {
          contextAttributes[attribute] = webGLContextAttributes[attribute];
        }
      }

      // This check of existence of GL is here to satisfy Closure compiler, which yells if variable GL is referenced below but GL object is not
      // actually compiled in because application is not doing any GL operations. TODO: Ideally if GL is not being used, this function
      // Browser.createContext() should not even be emitted.
      if (typeof GL !== "undefined") {
        contextHandle = GL.createContext(canvas, contextAttributes);
        if (contextHandle) {
          ctx = GL.getContext(contextHandle).GLctx;
        }
      }
    } else {
      ctx = canvas.getContext("2d");
    }

    if (!ctx) return null;

    if (setInModule) {
      if (!useWebGL)
        assert(
          typeof GLctx === "undefined",
          "cannot set in module if GLctx is used, but we are a non-GL context that would replace it"
        );

      Module.ctx = ctx;
      if (useWebGL) GL.makeContextCurrent(contextHandle);
      Module.useWebGL = useWebGL;
      Browser.moduleContextCreatedCallbacks.forEach(function (callback) {
        callback();
      });
      Browser.init();
    }
    return ctx;
  },
  destroyContext: function (canvas, useWebGL, setInModule) {},
  fullscreenHandlersInstalled: false,
  lockPointer: undefined,
  resizeCanvas: undefined,
  requestFullscreen: function (lockPointer, resizeCanvas) {
    Browser.lockPointer = lockPointer;
    Browser.resizeCanvas = resizeCanvas;
    if (typeof Browser.lockPointer === "undefined") Browser.lockPointer = true;
    if (typeof Browser.resizeCanvas === "undefined")
      Browser.resizeCanvas = false;

    var canvas = Module["canvas"];
    function fullscreenChange() {
      Browser.isFullscreen = false;
      var canvasContainer = canvas.parentNode;
      if (
        (document["fullscreenElement"] ||
          document["mozFullScreenElement"] ||
          document["msFullscreenElement"] ||
          document["webkitFullscreenElement"] ||
          document["webkitCurrentFullScreenElement"]) === canvasContainer
      ) {
        canvas.exitFullscreen = Browser.exitFullscreen;
        if (Browser.lockPointer) canvas.requestPointerLock();
        Browser.isFullscreen = true;
        if (Browser.resizeCanvas) {
          Browser.setFullscreenCanvasSize();
        } else {
          Browser.updateCanvasDimensions(canvas);
        }
      } else {
        // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
        canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
        canvasContainer.parentNode.removeChild(canvasContainer);

        if (Browser.resizeCanvas) {
          Browser.setWindowedCanvasSize();
        } else {
          Browser.updateCanvasDimensions(canvas);
        }
      }
      if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen);
      if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen);
    }

    if (!Browser.fullscreenHandlersInstalled) {
      Browser.fullscreenHandlersInstalled = true;
      document.addEventListener("fullscreenchange", fullscreenChange, false);
      document.addEventListener("mozfullscreenchange", fullscreenChange, false);
      document.addEventListener(
        "webkitfullscreenchange",
        fullscreenChange,
        false
      );
      document.addEventListener("MSFullscreenChange", fullscreenChange, false);
    }

    // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
    var canvasContainer = document.createElement("div");
    canvas.parentNode.insertBefore(canvasContainer, canvas);
    canvasContainer.appendChild(canvas);

    // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
    canvasContainer.requestFullscreen =
      canvasContainer["requestFullscreen"] ||
      canvasContainer["mozRequestFullScreen"] ||
      canvasContainer["msRequestFullscreen"] ||
      (canvasContainer["webkitRequestFullscreen"]
        ? function () {
            canvasContainer["webkitRequestFullscreen"](
              Element["ALLOW_KEYBOARD_INPUT"]
            );
          }
        : null) ||
      (canvasContainer["webkitRequestFullScreen"]
        ? function () {
            canvasContainer["webkitRequestFullScreen"](
              Element["ALLOW_KEYBOARD_INPUT"]
            );
          }
        : null);

    canvasContainer.requestFullscreen();
  },
  requestFullScreen: function () {
    abort(
      "Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)"
    );
  },
  exitFullscreen: function () {
    // This is workaround for chrome. Trying to exit from fullscreen
    // not in fullscreen state will cause "TypeError: Document not active"
    // in chrome. See https://github.com/emscripten-core/emscripten/pull/8236
    if (!Browser.isFullscreen) {
      return false;
    }

    var CFS =
      document["exitFullscreen"] ||
      document["cancelFullScreen"] ||
      document["mozCancelFullScreen"] ||
      document["msExitFullscreen"] ||
      document["webkitCancelFullScreen"] ||
      function () {};
    CFS.apply(document, []);
    return true;
  },
  nextRAF: 0,
  fakeRequestAnimationFrame: function (func) {
    // try to keep 60fps between calls to here
    var now = Date.now();
    if (Browser.nextRAF === 0) {
      Browser.nextRAF = now + 1000 / 60;
    } else {
      while (now + 2 >= Browser.nextRAF) {
        // fudge a little, to avoid timer jitter causing us to do lots of delay:0
        Browser.nextRAF += 1000 / 60;
      }
    }
    var delay = Math.max(Browser.nextRAF - now, 0);
    setTimeout(func, delay);
  },
  requestAnimationFrame: function (func) {
    if (typeof requestAnimationFrame === "function") {
      requestAnimationFrame(func);
      return;
    }
    var RAF = Browser.fakeRequestAnimationFrame;
    RAF(func);
  },
  safeCallback: function (func) {
    return function () {
      if (!ABORT) return func.apply(null, arguments);
    };
  },
  allowAsyncCallbacks: true,
  queuedAsyncCallbacks: [],
  pauseAsyncCallbacks: function () {
    Browser.allowAsyncCallbacks = false;
  },
  resumeAsyncCallbacks: function () {
    // marks future callbacks as ok to execute, and synchronously runs any remaining ones right now
    Browser.allowAsyncCallbacks = true;
    if (Browser.queuedAsyncCallbacks.length > 0) {
      var callbacks = Browser.queuedAsyncCallbacks;
      Browser.queuedAsyncCallbacks = [];
      callbacks.forEach(function (func) {
        func();
      });
    }
  },
  safeRequestAnimationFrame: function (func) {
    return Browser.requestAnimationFrame(function () {
      if (ABORT) return;
      if (Browser.allowAsyncCallbacks) {
        func();
      } else {
        Browser.queuedAsyncCallbacks.push(func);
      }
    });
  },
  safeSetTimeout: function (func, timeout) {
    noExitRuntime = true;
    return setTimeout(function () {
      if (ABORT) return;
      if (Browser.allowAsyncCallbacks) {
        func();
      } else {
        Browser.queuedAsyncCallbacks.push(func);
      }
    }, timeout);
  },
  safeSetInterval: function (func, timeout) {
    noExitRuntime = true;
    return setInterval(function () {
      if (ABORT) return;
      if (Browser.allowAsyncCallbacks) {
        func();
      } // drop it on the floor otherwise, next interval will kick in
    }, timeout);
  },
  getMimetype: function (name) {
    return {
      jpg: "image/jpeg",
      jpeg: "image/jpeg",
      png: "image/png",
      bmp: "image/bmp",
      ogg: "audio/ogg",
      wav: "audio/wav",
      mp3: "audio/mpeg",
    }[name.substr(name.lastIndexOf(".") + 1)];
  },
  getUserMedia: function (func) {
    if (!window.getUserMedia) {
      window.getUserMedia =
        navigator["getUserMedia"] || navigator["mozGetUserMedia"];
    }
    window.getUserMedia(func);
  },
  getMovementX: function (event) {
    return (
      event["movementX"] ||
      event["mozMovementX"] ||
      event["webkitMovementX"] ||
      0
    );
  },
  getMovementY: function (event) {
    return (
      event["movementY"] ||
      event["mozMovementY"] ||
      event["webkitMovementY"] ||
      0
    );
  },
  getMouseWheelDelta: function (event) {
    var delta = 0;
    switch (event.type) {
      case "DOMMouseScroll":
        // 3 lines make up a step
        delta = event.detail / 3;
        break;
      case "mousewheel":
        // 120 units make up a step
        delta = event.wheelDelta / 120;
        break;
      case "wheel":
        delta = event.deltaY;
        switch (event.deltaMode) {
          case 0:
            // DOM_DELTA_PIXEL: 100 pixels make up a step
            delta /= 100;
            break;
          case 1:
            // DOM_DELTA_LINE: 3 lines make up a step
            delta /= 3;
            break;
          case 2:
            // DOM_DELTA_PAGE: A page makes up 80 steps
            delta *= 80;
            break;
          default:
            throw "unrecognized mouse wheel delta mode: " + event.deltaMode;
        }
        break;
      default:
        throw "unrecognized mouse wheel event: " + event.type;
    }
    return delta;
  },
  mouseX: 0,
  mouseY: 0,
  mouseMovementX: 0,
  mouseMovementY: 0,
  touches: {},
  lastTouches: {},
  calculateMouseEvent: function (event) {
    // event should be mousemove, mousedown or mouseup
    if (Browser.pointerLock) {
      // When the pointer is locked, calculate the coordinates
      // based on the movement of the mouse.
      // Workaround for Firefox bug 764498
      if (event.type != "mousemove" && "mozMovementX" in event) {
        Browser.mouseMovementX = Browser.mouseMovementY = 0;
      } else {
        Browser.mouseMovementX = Browser.getMovementX(event);
        Browser.mouseMovementY = Browser.getMovementY(event);
      }

      // check if SDL is available
      if (typeof SDL != "undefined") {
        Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
        Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
      } else {
        // just add the mouse delta to the current absolut mouse position
        // FIXME: ideally this should be clamped against the canvas size and zero
        Browser.mouseX += Browser.mouseMovementX;
        Browser.mouseY += Browser.mouseMovementY;
      }
    } else {
      // Otherwise, calculate the movement based on the changes
      // in the coordinates.
      var rect = Module["canvas"].getBoundingClientRect();
      var cw = Module["canvas"].width;
      var ch = Module["canvas"].height;

      // Neither .scrollX or .pageXOffset are defined in a spec, but
      // we prefer .scrollX because it is currently in a spec draft.
      // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
      var scrollX =
        typeof window.scrollX !== "undefined"
          ? window.scrollX
          : window.pageXOffset;
      var scrollY =
        typeof window.scrollY !== "undefined"
          ? window.scrollY
          : window.pageYOffset;
      // If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset
      // and we have no viable fallback.
      assert(
        typeof scrollX !== "undefined" && typeof scrollY !== "undefined",
        "Unable to retrieve scroll position, mouse positions likely broken."
      );

      if (
        event.type === "touchstart" ||
        event.type === "touchend" ||
        event.type === "touchmove"
      ) {
        var touch = event.touch;
        if (touch === undefined) {
          return; // the "touch" property is only defined in SDL
        }
        var adjustedX = touch.pageX - (scrollX + rect.left);
        var adjustedY = touch.pageY - (scrollY + rect.top);

        adjustedX = adjustedX * (cw / rect.width);
        adjustedY = adjustedY * (ch / rect.height);

        var coords = { x: adjustedX, y: adjustedY };

        if (event.type === "touchstart") {
          Browser.lastTouches[touch.identifier] = coords;
          Browser.touches[touch.identifier] = coords;
        } else if (event.type === "touchend" || event.type === "touchmove") {
          var last = Browser.touches[touch.identifier];
          if (!last) last = coords;
          Browser.lastTouches[touch.identifier] = last;
          Browser.touches[touch.identifier] = coords;
        }
        return;
      }

      var x = event.pageX - (scrollX + rect.left);
      var y = event.pageY - (scrollY + rect.top);

      // the canvas might be CSS-scaled compared to its backbuffer;
      // SDL-using content will want mouse coordinates in terms
      // of backbuffer units.
      x = x * (cw / rect.width);
      y = y * (ch / rect.height);

      Browser.mouseMovementX = x - Browser.mouseX;
      Browser.mouseMovementY = y - Browser.mouseY;
      Browser.mouseX = x;
      Browser.mouseY = y;
    }
  },
  asyncLoad: function (url, onload, onerror, noRunDep) {
    var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
    readAsync(
      url,
      function (arrayBuffer) {
        assert(
          arrayBuffer,
          'Loading data file "' + url + '" failed (no arrayBuffer).'
        );
        onload(new Uint8Array(arrayBuffer));
        if (dep) removeRunDependency(dep);
      },
      function (event) {
        if (onerror) {
          onerror();
        } else {
          throw 'Loading data file "' + url + '" failed.';
        }
      }
    );
    if (dep) addRunDependency(dep);
  },
  resizeListeners: [],
  updateResizeListeners: function () {
    var canvas = Module["canvas"];
    Browser.resizeListeners.forEach(function (listener) {
      listener(canvas.width, canvas.height);
    });
  },
  setCanvasSize: function (width, height, noUpdates) {
    var canvas = Module["canvas"];
    Browser.updateCanvasDimensions(canvas, width, height);
    if (!noUpdates) Browser.updateResizeListeners();
  },
  windowedWidth: 0,
  windowedHeight: 0,
  setFullscreenCanvasSize: function () {
    // check if SDL is available
    if (typeof SDL != "undefined") {
      var flags = HEAPU32[SDL.screen >> 2];
      flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
      HEAP32[SDL.screen >> 2] = flags;
    }
    Browser.updateCanvasDimensions(Module["canvas"]);
    Browser.updateResizeListeners();
  },
  setWindowedCanvasSize: function () {
    // check if SDL is available
    if (typeof SDL != "undefined") {
      var flags = HEAPU32[SDL.screen >> 2];
      flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
      HEAP32[SDL.screen >> 2] = flags;
    }
    Browser.updateCanvasDimensions(Module["canvas"]);
    Browser.updateResizeListeners();
  },
  updateCanvasDimensions: function (canvas, wNative, hNative) {
    if (wNative && hNative) {
      canvas.widthNative = wNative;
      canvas.heightNative = hNative;
    } else {
      wNative = canvas.widthNative;
      hNative = canvas.heightNative;
    }
    var w = wNative;
    var h = hNative;
    if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) {
      if (w / h < Module["forcedAspectRatio"]) {
        w = Math.round(h * Module["forcedAspectRatio"]);
      } else {
        h = Math.round(w / Module["forcedAspectRatio"]);
      }
    }
    if (
      (document["fullscreenElement"] ||
        document["mozFullScreenElement"] ||
        document["msFullscreenElement"] ||
        document["webkitFullscreenElement"] ||
        document["webkitCurrentFullScreenElement"]) === canvas.parentNode &&
      typeof screen != "undefined"
    ) {
      var factor = Math.min(screen.width / w, screen.height / h);
      w = Math.round(w * factor);
      h = Math.round(h * factor);
    }
    if (Browser.resizeCanvas) {
      if (canvas.width != w) canvas.width = w;
      if (canvas.height != h) canvas.height = h;
      if (typeof canvas.style != "undefined") {
        canvas.style.removeProperty("width");
        canvas.style.removeProperty("height");
      }
    } else {
      if (canvas.width != wNative) canvas.width = wNative;
      if (canvas.height != hNative) canvas.height = hNative;
      if (typeof canvas.style != "undefined") {
        if (w != wNative || h != hNative) {
          canvas.style.setProperty("width", w + "px", "important");
          canvas.style.setProperty("height", h + "px", "important");
        } else {
          canvas.style.removeProperty("width");
          canvas.style.removeProperty("height");
        }
      }
    }
  },
  wgetRequests: {},
  nextWgetRequestHandle: 0,
  getNextWgetRequestHandle: function () {
    var handle = Browser.nextWgetRequestHandle;
    Browser.nextWgetRequestHandle++;
    return handle;
  },
};
var EGL = {
  errorCode: 12288,
  defaultDisplayInitialized: false,
  currentContext: 0,
  currentReadSurface: 0,
  currentDrawSurface: 0,
  contextAttributes: {
    alpha: false,
    depth: false,
    stencil: false,
    antialias: false,
  },
  stringCache: {},
  setErrorCode: function (code) {
    EGL.errorCode = code;
  },
  chooseConfig: function (
    display,
    attribList,
    config,
    config_size,
    numConfigs
  ) {
    if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
      EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
      return 0;
    }

    if (attribList) {
      // read attribList if it is non-null
      for (;;) {
        var param = HEAP32[attribList >> 2];
        if (param == 0x3021 /*EGL_ALPHA_SIZE*/) {
          var alphaSize = HEAP32[(attribList + 4) >> 2];
          EGL.contextAttributes.alpha = alphaSize > 0;
        } else if (param == 0x3025 /*EGL_DEPTH_SIZE*/) {
          var depthSize = HEAP32[(attribList + 4) >> 2];
          EGL.contextAttributes.depth = depthSize > 0;
        } else if (param == 0x3026 /*EGL_STENCIL_SIZE*/) {
          var stencilSize = HEAP32[(attribList + 4) >> 2];
          EGL.contextAttributes.stencil = stencilSize > 0;
        } else if (param == 0x3031 /*EGL_SAMPLES*/) {
          var samples = HEAP32[(attribList + 4) >> 2];
          EGL.contextAttributes.antialias = samples > 0;
        } else if (param == 0x3032 /*EGL_SAMPLE_BUFFERS*/) {
          var samples = HEAP32[(attribList + 4) >> 2];
          EGL.contextAttributes.antialias = samples == 1;
        } else if (param == 0x3100 /*EGL_CONTEXT_PRIORITY_LEVEL_IMG*/) {
          var requestedPriority = HEAP32[(attribList + 4) >> 2];
          EGL.contextAttributes.lowLatency =
            requestedPriority != 0x3103 /*EGL_CONTEXT_PRIORITY_LOW_IMG*/;
        } else if (param == 0x3038 /*EGL_NONE*/) {
          break;
        }
        attribList += 8;
      }
    }

    if ((!config || !config_size) && !numConfigs) {
      EGL.setErrorCode(0x300c /* EGL_BAD_PARAMETER */);
      return 0;
    }
    if (numConfigs) {
      HEAP32[numConfigs >> 2] = 1; // Total number of supported configs: 1.
    }
    if (config && config_size > 0) {
      HEAP32[config >> 2] = 62002;
    }

    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
    return 1;
  },
};
function _eglBindAPI(api) {
  if (api == 0x30a0 /* EGL_OPENGL_ES_API */) {
    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
    return 1;
  } else {
    // if (api == 0x30A1 /* EGL_OPENVG_API */ || api == 0x30A2 /* EGL_OPENGL_API */) {
    EGL.setErrorCode(0x300c /* EGL_BAD_PARAMETER */);
    return 0;
  }
}

function _eglChooseConfig(
  display,
  attrib_list,
  configs,
  config_size,
  numConfigs
) {
  return EGL.chooseConfig(
    display,
    attrib_list,
    configs,
    config_size,
    numConfigs
  );
}

function __webgl_acquireInstancedArraysExtension(ctx) {
  // Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2.
  var ext = ctx.getExtension("ANGLE_instanced_arrays");
  if (ext) {
    ctx["vertexAttribDivisor"] = function (index, divisor) {
      ext["vertexAttribDivisorANGLE"](index, divisor);
    };
    ctx["drawArraysInstanced"] = function (mode, first, count, primcount) {
      ext["drawArraysInstancedANGLE"](mode, first, count, primcount);
    };
    ctx["drawElementsInstanced"] = function (
      mode,
      count,
      type,
      indices,
      primcount
    ) {
      ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount);
    };
  }
}

function __webgl_acquireVertexArrayObjectExtension(ctx) {
  // Extension available in WebGL 1 from Firefox 25 and WebKit 536.28/desktop Safari 6.0.3 onwards. Core feature in WebGL 2.
  var ext = ctx.getExtension("OES_vertex_array_object");
  if (ext) {
    ctx["createVertexArray"] = function () {
      return ext["createVertexArrayOES"]();
    };
    ctx["deleteVertexArray"] = function (vao) {
      ext["deleteVertexArrayOES"](vao);
    };
    ctx["bindVertexArray"] = function (vao) {
      ext["bindVertexArrayOES"](vao);
    };
    ctx["isVertexArray"] = function (vao) {
      return ext["isVertexArrayOES"](vao);
    };
  }
}

function __webgl_acquireDrawBuffersExtension(ctx) {
  // Extension available in WebGL 1 from Firefox 28 onwards. Core feature in WebGL 2.
  var ext = ctx.getExtension("WEBGL_draw_buffers");
  if (ext) {
    ctx["drawBuffers"] = function (n, bufs) {
      ext["drawBuffersWEBGL"](n, bufs);
    };
  }
}
var GL = {
  counter: 1,
  lastError: 0,
  buffers: [],
  mappedBuffers: {},
  programs: [],
  framebuffers: [],
  renderbuffers: [],
  textures: [],
  uniforms: [],
  shaders: [],
  vaos: [],
  contexts: {},
  currentContext: null,
  offscreenCanvases: {},
  timerQueriesEXT: [],
  programInfos: {},
  stringCache: {},
  unpackAlignment: 4,
  init: function () {
    var miniTempFloatBuffer = new Float32Array(GL.MINI_TEMP_BUFFER_SIZE);
    for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) {
      GL.miniTempBufferFloatViews[i] = miniTempFloatBuffer.subarray(0, i + 1);
    }

    var miniTempIntBuffer = new Int32Array(GL.MINI_TEMP_BUFFER_SIZE);
    for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) {
      GL.miniTempBufferIntViews[i] = miniTempIntBuffer.subarray(0, i + 1);
    }
  },
  recordError: function recordError(errorCode) {
    if (!GL.lastError) {
      GL.lastError = errorCode;
    }
  },
  getNewId: function (table) {
    var ret = GL.counter++;
    for (var i = table.length; i < ret; i++) {
      table[i] = null;
    }
    return ret;
  },
  MINI_TEMP_BUFFER_SIZE: 256,
  miniTempBufferFloatViews: [0],
  miniTempBufferIntViews: [0],
  getSource: function (shader, count, string, length) {
    var source = "";
    for (var i = 0; i < count; ++i) {
      var len = length ? HEAP32[(length + i * 4) >> 2] : -1;
      source += UTF8ToString(
        HEAP32[(string + i * 4) >> 2],
        len < 0 ? undefined : len
      );
    }
    return source;
  },
  createContext: function (canvas, webGLContextAttributes) {
    var ctx = canvas.getContext("webgl", webGLContextAttributes);
    // https://caniuse.com/#feat=webgl

    if (!ctx) return 0;

    var handle = GL.registerContext(ctx, webGLContextAttributes);

    return handle;
  },
  registerContext: function (ctx, webGLContextAttributes) {
    var handle = _malloc(8); // Make space on the heap to store GL context attributes that need to be accessible as shared between threads.
    var context = {
      handle: handle,
      attributes: webGLContextAttributes,
      version: webGLContextAttributes.majorVersion,
      GLctx: ctx,
    };

    // Store the created context object so that we can access the context given a canvas without having to pass the parameters again.
    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]; // Active Emscripten GL layer context object.
    Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx; // Active WebGL context object.
    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
      ); // Release all JS event handlers on the DOM element that the GL context is associated with since the context is now deleted.
    if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas)
      GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; // Make sure the canvas object no longer refers to the context object so there are no GC surprises.
    _free(GL.contexts[contextHandle].handle);
    GL.contexts[contextHandle] = null;
  },
  initExtensions: function (context) {
    // If this function is called without a specific context object, init the extensions of the currently active context.
    if (!context) context = GL.currentContext;

    if (context.initExtensionsDone) return;
    context.initExtensionsDone = true;

    var GLctx = context.GLctx;

    // Detect the presence of a few extensions manually, this GL interop layer itself will need to know if they exist.

    if (context.version < 2) {
      __webgl_acquireInstancedArraysExtension(GLctx);
      __webgl_acquireVertexArrayObjectExtension(GLctx);
      __webgl_acquireDrawBuffersExtension(GLctx);
    }

    GLctx.disjointTimerQueryExt = GLctx.getExtension(
      "EXT_disjoint_timer_query"
    );

    // These are the 'safe' feature-enabling extensions that don't add any performance impact related to e.g. debugging, and
    // should be enabled by default so that client GLES2/GL code will not need to go through extra hoops to get its stuff working.
    // As new extensions are ratified at http://www.khronos.org/registry/webgl/extensions/ , feel free to add your new extensions
    // here, as long as they don't produce a performance impact for users that might not be using those extensions.
    // E.g. debugging-related extensions should probably be off by default.
    var automaticallyEnabledExtensions = [
      // Khronos ratified WebGL extensions ordered by number (no debug extensions):
      "OES_texture_float",
      "OES_texture_half_float",
      "OES_standard_derivatives",
      "OES_vertex_array_object",
      "WEBGL_compressed_texture_s3tc",
      "WEBGL_depth_texture",
      "OES_element_index_uint",
      "EXT_texture_filter_anisotropic",
      "EXT_frag_depth",
      "WEBGL_draw_buffers",
      "ANGLE_instanced_arrays",
      "OES_texture_float_linear",
      "OES_texture_half_float_linear",
      "EXT_blend_minmax",
      "EXT_shader_texture_lod",
      "EXT_texture_norm16",
      // Community approved WebGL extensions ordered by number:
      "WEBGL_compressed_texture_pvrtc",
      "EXT_color_buffer_half_float",
      "WEBGL_color_buffer_float",
      "EXT_sRGB",
      "WEBGL_compressed_texture_etc1",
      "EXT_disjoint_timer_query",
      "WEBGL_compressed_texture_etc",
      "WEBGL_compressed_texture_astc",
      "EXT_color_buffer_float",
      "WEBGL_compressed_texture_s3tc_srgb",
      "EXT_disjoint_timer_query_webgl2",
      // Old style prefixed forms of extensions (but still currently used on e.g. iPhone Xs as
      // tested on iOS 12.4.1):
      "WEBKIT_WEBGL_compressed_texture_pvrtc",
    ];

    function shouldEnableAutomatically(extension) {
      var ret = false;
      automaticallyEnabledExtensions.forEach(function (include) {
        if (extension.indexOf(include) != -1) {
          ret = true;
        }
      });
      return ret;
    }

    var exts = GLctx.getSupportedExtensions() || []; // .getSupportedExtensions() can return null if context is lost, so coerce to empty array.
    exts.forEach(function (ext) {
      if (automaticallyEnabledExtensions.indexOf(ext) != -1) {
        GLctx.getExtension(ext); // Calling .getExtension enables that extension permanently, no need to store the return value to be enabled.
      }
    });
  },
  populateUniformTable: function (program) {
    var p = GL.programs[program];
    var ptable = (GL.programInfos[program] = {
      uniforms: {},
      maxUniformLength: 0, // This is eagerly computed below, since we already enumerate all uniforms anyway.
      maxAttributeLength: -1, // This is lazily computed and cached, computed when/if first asked, "-1" meaning not computed yet.
      maxUniformBlockNameLength: -1, // Lazily computed as well
    });

    var utable = ptable.uniforms;
    // A program's uniform table maps the string name of an uniform to an integer location of that uniform.
    // The global GL.uniforms map maps integer locations to WebGLUniformLocations.
    var numUniforms = GLctx.getProgramParameter(
      p,
      0x8b86 /*GL_ACTIVE_UNIFORMS*/
    );
    for (var i = 0; i < numUniforms; ++i) {
      var u = GLctx.getActiveUniform(p, i);

      var name = u.name;
      ptable.maxUniformLength = Math.max(
        ptable.maxUniformLength,
        name.length + 1
      );

      // If we are dealing with an array, e.g. vec4 foo[3], strip off the array index part to canonicalize that "foo", "foo[]",
      // and "foo[0]" will mean the same. Loop below will populate foo[1] and foo[2].
      if (name.slice(-1) == "]") {
        name = name.slice(0, name.lastIndexOf("["));
      }

      // Optimize memory usage slightly: If we have an array of uniforms, e.g. 'vec3 colors[3];', then
      // only store the string 'colors' in utable, and 'colors[0]', 'colors[1]' and 'colors[2]' will be parsed as 'colors'+i.
      // Note that for the GL.uniforms table, we still need to fetch the all WebGLUniformLocations for all the indices.
      var loc = GLctx.getUniformLocation(p, name);
      if (loc) {
        var id = GL.getNewId(GL.uniforms);
        utable[name] = [u.size, id];
        GL.uniforms[id] = loc;

        for (var j = 1; j < u.size; ++j) {
          var n = name + "[" + j + "]";
          loc = GLctx.getUniformLocation(p, n);
          id = GL.getNewId(GL.uniforms);

          GL.uniforms[id] = loc;
        }
      }
    }
  },
};
function _eglCreateContext(display, config, hmm, contextAttribs) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }

  // EGL 1.4 spec says default EGL_CONTEXT_CLIENT_VERSION is GLES1, but this is not supported by Emscripten.
  // So user must pass EGL_CONTEXT_CLIENT_VERSION == 2 to initialize EGL.
  var glesContextVersion = 1;
  for (;;) {
    var param = HEAP32[contextAttribs >> 2];
    if (param == 0x3098 /*EGL_CONTEXT_CLIENT_VERSION*/) {
      glesContextVersion = HEAP32[(contextAttribs + 4) >> 2];
    } else if (param == 0x3038 /*EGL_NONE*/) {
      break;
    } else {
      /* EGL1.4 specifies only EGL_CONTEXT_CLIENT_VERSION as supported attribute */
      EGL.setErrorCode(0x3004 /*EGL_BAD_ATTRIBUTE*/);
      return 0;
    }
    contextAttribs += 8;
  }
  if (glesContextVersion != 2) {
    EGL.setErrorCode(0x3005 /* EGL_BAD_CONFIG */);
    return 0; /* EGL_NO_CONTEXT */
  }

  EGL.contextAttributes.majorVersion = glesContextVersion - 1; // WebGL 1 is GLES 2, WebGL2 is GLES3
  EGL.contextAttributes.minorVersion = 0;

  EGL.context = GL.createContext(Module["canvas"], EGL.contextAttributes);

  if (EGL.context != 0) {
    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);

    // Run callbacks so that GL emulation works
    GL.makeContextCurrent(EGL.context);
    Module.useWebGL = true;
    Browser.moduleContextCreatedCallbacks.forEach(function (callback) {
      callback();
    });

    // Note: This function only creates a context, but it shall not make it active.
    GL.makeContextCurrent(null);
    return 62004; // Magic ID for Emscripten EGLContext
  } else {
    EGL.setErrorCode(0x3009 /* EGL_BAD_MATCH */); // By the EGL 1.4 spec, an implementation that does not support GLES2 (WebGL in this case), this error code is set.
    return 0; /* EGL_NO_CONTEXT */
  }
}

function _eglCreateWindowSurface(display, config, win, attrib_list) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
  if (
    config !=
    62002 /* Magic ID for the only EGLConfig supported by Emscripten */
  ) {
    EGL.setErrorCode(0x3005 /* EGL_BAD_CONFIG */);
    return 0;
  }
  // TODO: Examine attrib_list! Parameters that can be present there are:
  // - EGL_RENDER_BUFFER (must be EGL_BACK_BUFFER)
  // - EGL_VG_COLORSPACE (can't be set)
  // - EGL_VG_ALPHA_FORMAT (can't be set)
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  return 62006; /* Magic ID for Emscripten 'default surface' */
}

function _eglDestroyContext(display, context) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
  if (context != 62004 /* Magic ID for Emscripten EGLContext */) {
    EGL.setErrorCode(0x3006 /* EGL_BAD_CONTEXT */);
    return 0;
  }

  GL.deleteContext(EGL.context);
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  if (EGL.currentContext == context) {
    EGL.currentContext = 0;
  }
  return 1 /* EGL_TRUE */;
}

function _eglDestroySurface(display, surface) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
  if (
    surface !=
    62006 /* Magic ID for the only EGLSurface supported by Emscripten */
  ) {
    EGL.setErrorCode(0x300d /* EGL_BAD_SURFACE */);
    return 1;
  }
  if (EGL.currentReadSurface == surface) {
    EGL.currentReadSurface = 0;
  }
  if (EGL.currentDrawSurface == surface) {
    EGL.currentDrawSurface = 0;
  }
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  return 1; /* Magic ID for Emscripten 'default surface' */
}

function _eglGetConfigAttrib(display, config, attribute, value) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
  if (
    config !=
    62002 /* Magic ID for the only EGLConfig supported by Emscripten */
  ) {
    EGL.setErrorCode(0x3005 /* EGL_BAD_CONFIG */);
    return 0;
  }
  if (!value) {
    EGL.setErrorCode(0x300c /* EGL_BAD_PARAMETER */);
    return 0;
  }
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  switch (attribute) {
    case 0x3020: // EGL_BUFFER_SIZE
      HEAP32[value >> 2] = EGL.contextAttributes.alpha ? 32 : 24;
      return 1;
    case 0x3021: // EGL_ALPHA_SIZE
      HEAP32[value >> 2] = EGL.contextAttributes.alpha ? 8 : 0;
      return 1;
    case 0x3022: // EGL_BLUE_SIZE
      HEAP32[value >> 2] = 8;
      return 1;
    case 0x3023: // EGL_GREEN_SIZE
      HEAP32[value >> 2] = 8;
      return 1;
    case 0x3024: // EGL_RED_SIZE
      HEAP32[value >> 2] = 8;
      return 1;
    case 0x3025: // EGL_DEPTH_SIZE
      HEAP32[value >> 2] = EGL.contextAttributes.depth ? 24 : 0;
      return 1;
    case 0x3026: // EGL_STENCIL_SIZE
      HEAP32[value >> 2] = EGL.contextAttributes.stencil ? 8 : 0;
      return 1;
    case 0x3027: // EGL_CONFIG_CAVEAT
      // We can return here one of EGL_NONE (0x3038), EGL_SLOW_CONFIG (0x3050) or EGL_NON_CONFORMANT_CONFIG (0x3051).
      HEAP32[value >> 2] = 0x3038;
      return 1;
    case 0x3028: // EGL_CONFIG_ID
      HEAP32[value >> 2] = 62002;
      return 1;
    case 0x3029: // EGL_LEVEL
      HEAP32[value >> 2] = 0;
      return 1;
    case 0x302a: // EGL_MAX_PBUFFER_HEIGHT
      HEAP32[value >> 2] = 4096;
      return 1;
    case 0x302b: // EGL_MAX_PBUFFER_PIXELS
      HEAP32[value >> 2] = 16777216;
      return 1;
    case 0x302c: // EGL_MAX_PBUFFER_WIDTH
      HEAP32[value >> 2] = 4096;
      return 1;
    case 0x302d: // EGL_NATIVE_RENDERABLE
      HEAP32[value >> 2] = 0;
      return 1;
    case 0x302e: // EGL_NATIVE_VISUAL_ID
      HEAP32[value >> 2] = 0;
      return 1;
    case 0x302f: // EGL_NATIVE_VISUAL_TYPE
      HEAP32[value >> 2] = 0x3038;
      return 1;
    case 0x3031: // EGL_SAMPLES
      HEAP32[value >> 2] = EGL.contextAttributes.antialias ? 4 : 0;
      return 1;
    case 0x3032: // EGL_SAMPLE_BUFFERS
      HEAP32[value >> 2] = EGL.contextAttributes.antialias ? 1 : 0;
      return 1;
    case 0x3033: // EGL_SURFACE_TYPE
      HEAP32[value >> 2] = 0x4;
      return 1;
    case 0x3034: // EGL_TRANSPARENT_TYPE
      // If this returns EGL_TRANSPARENT_RGB (0x3052), transparency is used through color-keying. No such thing applies to Emscripten canvas.
      HEAP32[value >> 2] = 0x3038;
      return 1;
    case 0x3035: // EGL_TRANSPARENT_BLUE_VALUE
    case 0x3036: // EGL_TRANSPARENT_GREEN_VALUE
    case 0x3037: // EGL_TRANSPARENT_RED_VALUE
      // "If EGL_TRANSPARENT_TYPE is EGL_NONE, then the values for EGL_TRANSPARENT_RED_VALUE, EGL_TRANSPARENT_GREEN_VALUE, and EGL_TRANSPARENT_BLUE_VALUE are undefined."
      HEAP32[value >> 2] = -1;
      return 1;
    case 0x3039: // EGL_BIND_TO_TEXTURE_RGB
    case 0x303a: // EGL_BIND_TO_TEXTURE_RGBA
      HEAP32[value >> 2] = 0;
      return 1;
    case 0x303b: // EGL_MIN_SWAP_INTERVAL
      HEAP32[value >> 2] = 0;
      return 1;
    case 0x303c: // EGL_MAX_SWAP_INTERVAL
      HEAP32[value >> 2] = 1;
      return 1;
    case 0x303d: // EGL_LUMINANCE_SIZE
    case 0x303e: // EGL_ALPHA_MASK_SIZE
      HEAP32[value >> 2] = 0;
      return 1;
    case 0x303f: // EGL_COLOR_BUFFER_TYPE
      // EGL has two types of buffers: EGL_RGB_BUFFER and EGL_LUMINANCE_BUFFER.
      HEAP32[value >> 2] = 0x308e;
      return 1;
    case 0x3040: // EGL_RENDERABLE_TYPE
      // A bit combination of EGL_OPENGL_ES_BIT,EGL_OPENVG_BIT,EGL_OPENGL_ES2_BIT and EGL_OPENGL_BIT.
      HEAP32[value >> 2] = 0x4;
      return 1;
    case 0x3042: // EGL_CONFORMANT
      // "EGL_CONFORMANT is a mask indicating if a client API context created with respect to the corresponding EGLConfig will pass the required conformance tests for that API."
      HEAP32[value >> 2] = 0;
      return 1;
    default:
      EGL.setErrorCode(0x3004 /* EGL_BAD_ATTRIBUTE */);
      return 0;
  }
}

function _eglGetDisplay(nativeDisplayType) {
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  // Note: As a 'conformant' implementation of EGL, we would prefer to init here only if the user
  //       calls this function with EGL_DEFAULT_DISPLAY. Other display IDs would be preferred to be unsupported
  //       and EGL_NO_DISPLAY returned. Uncomment the following code lines to do this.
  // Instead, an alternative route has been preferred, namely that the Emscripten EGL implementation
  // "emulates" X11, and eglGetDisplay is expected to accept/receive a pointer to an X11 Display object.
  // Therefore, be lax and allow anything to be passed in, and return the magic handle to our default EGLDisplay object.

  //    if (nativeDisplayType == 0 /* EGL_DEFAULT_DISPLAY */) {
  return 62000; // Magic ID for Emscripten 'default display'
  //    }
  //    else
  //      return 0; // EGL_NO_DISPLAY
}

function _eglGetError() {
  return EGL.errorCode;
}

function _eglGetProcAddress(name_) {
  return _emscripten_GetProcAddress(name_);
}

function _eglInitialize(display, majorVersion, minorVersion) {
  if (display == 62000 /* Magic ID for Emscripten 'default display' */) {
    if (majorVersion) {
      HEAP32[majorVersion >> 2] = 1; // Advertise EGL Major version: '1'
    }
    if (minorVersion) {
      HEAP32[minorVersion >> 2] = 4; // Advertise EGL Minor version: '4'
    }
    EGL.defaultDisplayInitialized = true;
    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
    return 1;
  } else {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
}

function _eglMakeCurrent(display, draw, read, context) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0 /* EGL_FALSE */;
  }
  //\todo An EGL_NOT_INITIALIZED error is generated if EGL is not initialized for dpy.
  if (
    context != 0 &&
    context != 62004 /* Magic ID for Emscripten EGLContext */
  ) {
    EGL.setErrorCode(0x3006 /* EGL_BAD_CONTEXT */);
    return 0;
  }
  if (
    (read != 0 && read != 62006) ||
    (draw != 0 && draw != 62006) /* Magic ID for Emscripten 'default surface' */
  ) {
    EGL.setErrorCode(0x300d /* EGL_BAD_SURFACE */);
    return 0;
  }

  GL.makeContextCurrent(context ? EGL.context : null);

  EGL.currentContext = context;
  EGL.currentDrawSurface = draw;
  EGL.currentReadSurface = read;
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  return 1 /* EGL_TRUE */;
}

function _eglQueryString(display, name) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
  //\todo An EGL_NOT_INITIALIZED error is generated if EGL is not initialized for dpy.
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  if (EGL.stringCache[name]) return EGL.stringCache[name];
  var ret;
  switch (name) {
    case 0x3053 /* EGL_VENDOR */:
      ret = allocateUTF8("Emscripten");
      break;
    case 0x3054 /* EGL_VERSION */:
      ret = allocateUTF8("1.4 Emscripten EGL");
      break;
    case 0x3055 /* EGL_EXTENSIONS */:
      ret = allocateUTF8("");
      break; // Currently not supporting any EGL extensions.
    case 0x308d /* EGL_CLIENT_APIS */:
      ret = allocateUTF8("OpenGL_ES");
      break;
    default:
      EGL.setErrorCode(0x300c /* EGL_BAD_PARAMETER */);
      return 0;
  }
  EGL.stringCache[name] = ret;
  return ret;
}

function _eglSwapBuffers() {
  if (!EGL.defaultDisplayInitialized) {
    EGL.setErrorCode(0x3001 /* EGL_NOT_INITIALIZED */);
  } else if (!Module.ctx) {
    EGL.setErrorCode(0x3002 /* EGL_BAD_ACCESS */);
  } else if (Module.ctx.isContextLost()) {
    EGL.setErrorCode(0x300e /* EGL_CONTEXT_LOST */);
  } else {
    // According to documentation this does an implicit flush.
    // Due to discussion at https://github.com/emscripten-core/emscripten/pull/1871
    // the flush was removed since this _may_ result in slowing code down.
    //_glFlush();
    EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
    return 1 /* EGL_TRUE */;
  }
  return 0 /* EGL_FALSE */;
}

function _eglSwapInterval(display, interval) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
  if (interval == 0)
    _emscripten_set_main_loop_timing(0 /*EM_TIMING_SETTIMEOUT*/, 0);
  else _emscripten_set_main_loop_timing(1 /*EM_TIMING_RAF*/, interval);

  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  return 1;
}

function _eglTerminate(display) {
  if (display != 62000 /* Magic ID for Emscripten 'default display' */) {
    EGL.setErrorCode(0x3008 /* EGL_BAD_DISPLAY */);
    return 0;
  }
  EGL.currentContext = 0;
  EGL.currentReadSurface = 0;
  EGL.currentDrawSurface = 0;
  EGL.defaultDisplayInitialized = false;
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  return 1;
}

function _eglWaitClient() {
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  return 1;
}
function _eglWaitGL() {
  return _eglWaitClient();
}

function _eglWaitNative(nativeEngineId) {
  EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
  return 1;
}

var JSEvents = {
  keyEvent: 0,
  mouseEvent: 0,
  wheelEvent: 0,
  uiEvent: 0,
  focusEvent: 0,
  deviceOrientationEvent: 0,
  deviceMotionEvent: 0,
  fullscreenChangeEvent: 0,
  pointerlockChangeEvent: 0,
  visibilityChangeEvent: 0,
  touchEvent: 0,
  previousFullscreenElement: null,
  previousScreenX: null,
  previousScreenY: null,
  removeEventListenersRegistered: false,
  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;
    }
    // Test if the given call was already queued, and if so, don't add it again.
    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);
    }
  },
  inEventHandler: 0,
  currentEventHandler: null,
  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) {
      // Increment nesting count for the event handler.
      ++JSEvents.inEventHandler;
      JSEvents.currentEventHandler = eventHandler;
      // Process any old deferred calls the user has placed.
      JSEvents.runDeferredCalls();
      // Process the actual event, calls back to user C code handler.
      eventHandler.handlerFunc(event);
      // Process any new deferred calls that were placed right now from this event handler.
      JSEvents.runDeferredCalls();
      // Out of event handler - restore nesting count.
      --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--);
        }
      }
    }
  },
  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 ||
      // Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitFullscreenEnabled.
      // TODO: If Safari at some point ships with unprefixed version, update the version check above.
      document.webkitFullscreenEnabled
    );
  },
};

var __currentFullscreenStrategy = {};

function __maybeCStringToJsString(cString) {
  return cString === cString + 0 ? UTF8ToString(cString) : cString;
}

var __specialEventTargets = [
  0,
  typeof document !== "undefined" ? document : 0,
  typeof window !== "undefined" ? window : 0,
];
function __findEventTarget(target) {
  var domElement =
    __specialEventTargets[target] ||
    (typeof document !== "undefined"
      ? document.querySelector(__maybeCStringToJsString(target))
      : undefined);
  return domElement;
}
function __findCanvasEventTarget(target) {
  return __findEventTarget(target);
}
function _emscripten_get_canvas_element_size(target, width, height) {
  var canvas = __findCanvasEventTarget(target);
  if (!canvas) return -4;
  HEAP32[width >> 2] = canvas.width;
  HEAP32[height >> 2] = canvas.height;
}
function __get_canvas_element_size(target) {
  var stackTop = stackSave();
  var w = stackAlloc(8);
  var h = w + 4;

  var targetInt = stackAlloc(target.id.length + 1);
  stringToUTF8(target.id, targetInt, target.id.length + 1);
  var ret = _emscripten_get_canvas_element_size(targetInt, w, h);
  var size = [HEAP32[w >> 2], HEAP32[h >> 2]];
  stackRestore(stackTop);
  return size;
}

function _emscripten_set_canvas_element_size(target, width, height) {
  var canvas = __findCanvasEventTarget(target);
  if (!canvas) return -4;
  canvas.width = width;
  canvas.height = height;
  return 0;
}
function __set_canvas_element_size(target, width, height) {
  if (!target.controlTransferredOffscreen) {
    target.width = width;
    target.height = height;
  } else {
    // This function is being called from high-level JavaScript code instead of asm.js/Wasm,
    // and it needs to synchronously proxy over to another thread, so marshal the string onto the heap to do the call.
    var stackTop = stackSave();
    var targetInt = stackAlloc(target.id.length + 1);
    stringToUTF8(target.id, targetInt, target.id.length + 1);
    _emscripten_set_canvas_element_size(targetInt, width, height);
    stackRestore(stackTop);
  }
}
function __registerRestoreOldStyle(canvas) {
  var canvasSize = __get_canvas_element_size(canvas);
  var oldWidth = canvasSize[0];
  var oldHeight = canvasSize[1];
  var oldCssWidth = canvas.style.width;
  var oldCssHeight = canvas.style.height;
  var oldBackgroundColor = canvas.style.backgroundColor; // Chrome reads color from here.
  var oldDocumentBackgroundColor = document.body.style.backgroundColor; // IE11 reads color from here.
  // Firefox always has black background color.
  var oldPaddingLeft = canvas.style.paddingLeft; // Chrome, FF, Safari
  var oldPaddingRight = canvas.style.paddingRight;
  var oldPaddingTop = canvas.style.paddingTop;
  var oldPaddingBottom = canvas.style.paddingBottom;
  var oldMarginLeft = canvas.style.marginLeft; // IE11
  var oldMarginRight = canvas.style.marginRight;
  var oldMarginTop = canvas.style.marginTop;
  var oldMarginBottom = canvas.style.marginBottom;
  var oldDocumentBodyMargin = document.body.style.margin;
  var oldDocumentOverflow = document.documentElement.style.overflow; // Chrome, Firefox
  var oldDocumentScroll = document.body.scroll; // IE
  var oldImageRendering = canvas.style.imageRendering;

  function restoreOldStyle() {
    var fullscreenElement =
      document.fullscreenElement ||
      document.webkitFullscreenElement ||
      document.msFullscreenElement;
    if (!fullscreenElement) {
      document.removeEventListener("fullscreenchange", restoreOldStyle);

      // Unprefixed Fullscreen API shipped in Chromium 71 (https://bugs.chromium.org/p/chromium/issues/detail?id=383813)
      // As of Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitfullscreenchange. TODO: revisit this check once Safari ships unprefixed version.
      document.removeEventListener("webkitfullscreenchange", restoreOldStyle);

      __set_canvas_element_size(canvas, oldWidth, oldHeight);

      canvas.style.width = oldCssWidth;
      canvas.style.height = oldCssHeight;
      canvas.style.backgroundColor = oldBackgroundColor; // Chrome
      // IE11 hack: assigning 'undefined' or an empty string to document.body.style.backgroundColor has no effect, so first assign back the default color
      // before setting the undefined value. Setting undefined value is also important, or otherwise we would later treat that as something that the user
      // had explicitly set so subsequent fullscreen transitions would not set background color properly.
      if (!oldDocumentBackgroundColor)
        document.body.style.backgroundColor = "white";
      document.body.style.backgroundColor = oldDocumentBackgroundColor; // IE11
      canvas.style.paddingLeft = oldPaddingLeft; // Chrome, FF, Safari
      canvas.style.paddingRight = oldPaddingRight;
      canvas.style.paddingTop = oldPaddingTop;
      canvas.style.paddingBottom = oldPaddingBottom;
      canvas.style.marginLeft = oldMarginLeft; // IE11
      canvas.style.marginRight = oldMarginRight;
      canvas.style.marginTop = oldMarginTop;
      canvas.style.marginBottom = oldMarginBottom;
      document.body.style.margin = oldDocumentBodyMargin;
      document.documentElement.style.overflow = oldDocumentOverflow; // Chrome, Firefox
      document.body.scroll = oldDocumentScroll; // IE
      canvas.style.imageRendering = oldImageRendering;
      if (canvas.GLctxObject)
        canvas.GLctxObject.GLctx.viewport(0, 0, oldWidth, oldHeight);

      if (__currentFullscreenStrategy.canvasResizedCallback) {
        dynCall_iiii(
          __currentFullscreenStrategy.canvasResizedCallback,
          37,
          0,
          __currentFullscreenStrategy.canvasResizedCallbackUserData
        );
      }
    }
  }
  document.addEventListener("fullscreenchange", restoreOldStyle);
  // Unprefixed Fullscreen API shipped in Chromium 71 (https://bugs.chromium.org/p/chromium/issues/detail?id=383813)
  // As of Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitfullscreenchange. TODO: revisit this check once Safari ships unprefixed version.
  document.addEventListener("webkitfullscreenchange", restoreOldStyle);
  return restoreOldStyle;
}

function __setLetterbox(element, topBottom, leftRight) {
  // Cannot use margin to specify letterboxes in FF or Chrome, since those ignore margins in fullscreen mode.
  element.style.paddingLeft = element.style.paddingRight = leftRight + "px";
  element.style.paddingTop = element.style.paddingBottom = topBottom + "px";
}

function __getBoundingClientRect(e) {
  return __specialEventTargets.indexOf(e) < 0
    ? e.getBoundingClientRect()
    : { left: 0, top: 0 };
}
function _JSEvents_resizeCanvasForFullscreen(target, strategy) {
  var restoreOldStyle = __registerRestoreOldStyle(target);
  var cssWidth = strategy.softFullscreen ? innerWidth : screen.width;
  var cssHeight = strategy.softFullscreen ? innerHeight : screen.height;
  var rect = __getBoundingClientRect(target);
  var windowedCssWidth = rect.width;
  var windowedCssHeight = rect.height;
  var canvasSize = __get_canvas_element_size(target);
  var windowedRttWidth = canvasSize[0];
  var windowedRttHeight = canvasSize[1];

  if (strategy.scaleMode == 3) {
    __setLetterbox(
      target,
      (cssHeight - windowedCssHeight) / 2,
      (cssWidth - windowedCssWidth) / 2
    );
    cssWidth = windowedCssWidth;
    cssHeight = windowedCssHeight;
  } else if (strategy.scaleMode == 2) {
    if (cssWidth * windowedRttHeight < windowedRttWidth * cssHeight) {
      var desiredCssHeight = (windowedRttHeight * cssWidth) / windowedRttWidth;
      __setLetterbox(target, (cssHeight - desiredCssHeight) / 2, 0);
      cssHeight = desiredCssHeight;
    } else {
      var desiredCssWidth = (windowedRttWidth * cssHeight) / windowedRttHeight;
      __setLetterbox(target, 0, (cssWidth - desiredCssWidth) / 2);
      cssWidth = desiredCssWidth;
    }
  }

  // If we are adding padding, must choose a background color or otherwise Chrome will give the
  // padding a default white color. Do it only if user has not customized their own background color.
  if (!target.style.backgroundColor) target.style.backgroundColor = "black";
  // IE11 does the same, but requires the color to be set in the document body.
  if (!document.body.style.backgroundColor)
    document.body.style.backgroundColor = "black"; // IE11
  // Firefox always shows black letterboxes independent of style color.

  target.style.width = cssWidth + "px";
  target.style.height = cssHeight + "px";

  if (strategy.filteringMode == 1) {
    target.style.imageRendering = "optimizeSpeed";
    target.style.imageRendering = "-moz-crisp-edges";
    target.style.imageRendering = "-o-crisp-edges";
    target.style.imageRendering = "-webkit-optimize-contrast";
    target.style.imageRendering = "optimize-contrast";
    target.style.imageRendering = "crisp-edges";
    target.style.imageRendering = "pixelated";
  }

  var dpiScale = strategy.canvasResolutionScaleMode == 2 ? devicePixelRatio : 1;
  if (strategy.canvasResolutionScaleMode != 0) {
    var newWidth = (cssWidth * dpiScale) | 0;
    var newHeight = (cssHeight * dpiScale) | 0;
    __set_canvas_element_size(target, newWidth, newHeight);
    if (target.GLctxObject)
      target.GLctxObject.GLctx.viewport(0, 0, newWidth, newHeight);
  }
  return restoreOldStyle;
}
function _JSEvents_requestFullscreen(target, strategy) {
  // EMSCRIPTEN_FULLSCREEN_SCALE_DEFAULT + EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_NONE is a mode where no extra logic is performed to the DOM elements.
  if (strategy.scaleMode != 0 || strategy.canvasResolutionScaleMode != 0) {
    _JSEvents_resizeCanvasForFullscreen(target, strategy);
  }

  if (target.requestFullscreen) {
    target.requestFullscreen();
  } else if (target.webkitRequestFullscreen) {
    target.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
  } else {
    return JSEvents.fullscreenEnabled() ? -3 : -1;
  }

  if (strategy.canvasResizedCallback) {
    dynCall_iiii(
      strategy.canvasResizedCallback,
      37,
      0,
      strategy.canvasResizedCallbackUserData
    );
  }

  return 0;
}
function _emscripten_exit_fullscreen() {
  if (!JSEvents.fullscreenEnabled()) return -1;
  // Make sure no queued up calls will fire after this.
  JSEvents.removeDeferredCalls(_JSEvents_requestFullscreen);

  var d = __specialEventTargets[1];
  if (d.exitFullscreen) {
    d.fullscreenElement && d.exitFullscreen();
  } else if (d.webkitExitFullscreen) {
    d.webkitFullscreenElement && d.webkitExitFullscreen();
  } else {
    return -1;
  }

  return 0;
}

function __requestPointerLock(target) {
  if (target.requestPointerLock) {
    target.requestPointerLock();
  } else if (target.msRequestPointerLock) {
    target.msRequestPointerLock();
  } else {
    // document.body is known to accept pointer lock, so use that to differentiate if the user passed a bad element,
    // or if the whole browser just doesn't support the feature.
    if (
      document.body.requestPointerLock ||
      document.body.msRequestPointerLock
    ) {
      return -3;
    } else {
      return -1;
    }
  }
  return 0;
}
function _emscripten_exit_pointerlock() {
  // Make sure no queued up calls will fire after this.
  JSEvents.removeDeferredCalls(__requestPointerLock);

  if (document.exitPointerLock) {
    document.exitPointerLock();
  } else if (document.msExitPointerLock) {
    document.msExitPointerLock();
  } else {
    return -1;
  }
  return 0;
}

function _emscripten_get_device_pixel_ratio() {
  return (typeof devicePixelRatio === "number" && devicePixelRatio) || 1.0;
}

function _emscripten_get_element_css_size(target, width, height) {
  target = __findEventTarget(target);
  if (!target) return -4;

  var rect = __getBoundingClientRect(target);
  HEAPF64[width >> 3] = rect.width;
  HEAPF64[height >> 3] = rect.height;

  return 0;
}

function __fillGamepadEventData(eventStruct, e) {
  HEAPF64[eventStruct >> 3] = e.timestamp;
  for (var i = 0; i < e.axes.length; ++i) {
    HEAPF64[(eventStruct + i * 8 + 16) >> 3] = e.axes[i];
  }
  for (var i = 0; i < e.buttons.length; ++i) {
    if (typeof e.buttons[i] === "object") {
      HEAPF64[(eventStruct + i * 8 + 528) >> 3] = e.buttons[i].value;
    } else {
      HEAPF64[(eventStruct + i * 8 + 528) >> 3] = e.buttons[i];
    }
  }
  for (var i = 0; i < e.buttons.length; ++i) {
    if (typeof e.buttons[i] === "object") {
      HEAP32[(eventStruct + i * 4 + 1040) >> 2] = e.buttons[i].pressed;
    } else {
      // Assigning a boolean to HEAP32, that's ok, but Closure would like to warn about it:
      /** @suppress {checkTypes} */
      HEAP32[(eventStruct + i * 4 + 1040) >> 2] = e.buttons[i] == 1;
    }
  }
  HEAP32[(eventStruct + 1296) >> 2] = e.connected;
  HEAP32[(eventStruct + 1300) >> 2] = e.index;
  HEAP32[(eventStruct + 8) >> 2] = e.axes.length;
  HEAP32[(eventStruct + 12) >> 2] = e.buttons.length;
  stringToUTF8(e.id, eventStruct + 1304, 64);
  stringToUTF8(e.mapping, eventStruct + 1368, 64);
}
function _emscripten_get_gamepad_status(index, gamepadState) {
  if (!JSEvents.lastGamepadState)
    throw "emscripten_get_gamepad_status() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!";

  // INVALID_PARAM is returned on a Gamepad index that never was there.
  if (index < 0 || index >= JSEvents.lastGamepadState.length) return -5;

  // NO_DATA is returned on a Gamepad index that was removed.
  // For previously disconnected gamepads there should be an empty slot (null/undefined/false) at the index.
  // This is because gamepads must keep their original position in the array.
  // For example, removing the first of two gamepads produces [null/undefined/false, gamepad].
  if (!JSEvents.lastGamepadState[index]) return -7;

  __fillGamepadEventData(gamepadState, JSEvents.lastGamepadState[index]);
  return 0;
}

function _emscripten_get_num_gamepads() {
  if (!JSEvents.lastGamepadState)
    throw "emscripten_get_num_gamepads() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!";
  // N.B. Do not call emscripten_get_num_gamepads() unless having first called emscripten_sample_gamepad_data(), and that has returned EMSCRIPTEN_RESULT_SUCCESS.
  // Otherwise the following line will throw an exception.
  return JSEvents.lastGamepadState.length;
}

function _emscripten_get_sbrk_ptr() {
  return 14350080;
}

function _emscripten_glActiveTexture(x0) {
  GLctx["activeTexture"](x0);
}

function _emscripten_glAttachShader(program, shader) {
  GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
}

function _emscripten_glBeginQueryEXT(target, id) {
  GLctx.disjointTimerQueryExt["beginQueryEXT"](target, GL.timerQueriesEXT[id]);
}

function _emscripten_glBindAttribLocation(program, index, name) {
  GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
}

function _emscripten_glBindBuffer(target, buffer) {
  GLctx.bindBuffer(target, GL.buffers[buffer]);
}

function _emscripten_glBindFramebuffer(target, framebuffer) {
  GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
}

function _emscripten_glBindRenderbuffer(target, renderbuffer) {
  GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
}

function _emscripten_glBindTexture(target, texture) {
  GLctx.bindTexture(target, GL.textures[texture]);
}

function _emscripten_glBindVertexArrayOES(vao) {
  GLctx["bindVertexArray"](GL.vaos[vao]);
}

function _emscripten_glBlendColor(x0, x1, x2, x3) {
  GLctx["blendColor"](x0, x1, x2, x3);
}

function _emscripten_glBlendEquation(x0) {
  GLctx["blendEquation"](x0);
}

function _emscripten_glBlendEquationSeparate(x0, x1) {
  GLctx["blendEquationSeparate"](x0, x1);
}

function _emscripten_glBlendFunc(x0, x1) {
  GLctx["blendFunc"](x0, x1);
}

function _emscripten_glBlendFuncSeparate(x0, x1, x2, x3) {
  GLctx["blendFuncSeparate"](x0, x1, x2, x3);
}

function _emscripten_glBufferData(target, size, data, usage) {
  // N.b. here first form specifies a heap subarray, second form an integer size, so the ?: code here is polymorphic. It is advised to avoid
  // randomly mixing both uses in calling code, to avoid any potential JS engine JIT issues.
  GLctx.bufferData(
    target,
    data ? HEAPU8.subarray(data, data + size) : size,
    usage
  );
}

function _emscripten_glBufferSubData(target, offset, size, data) {
  GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size));
}

function _emscripten_glCheckFramebufferStatus(x0) {
  return GLctx["checkFramebufferStatus"](x0);
}

function _emscripten_glClear(x0) {
  GLctx["clear"](x0);
}

function _emscripten_glClearColor(x0, x1, x2, x3) {
  GLctx["clearColor"](x0, x1, x2, x3);
}

function _emscripten_glClearDepthf(x0) {
  GLctx["clearDepth"](x0);
}

function _emscripten_glClearStencil(x0) {
  GLctx["clearStencil"](x0);
}

function _emscripten_glColorMask(red, green, blue, alpha) {
  GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
}

function _emscripten_glCompileShader(shader) {
  GLctx.compileShader(GL.shaders[shader]);
}

function _emscripten_glCompressedTexImage2D(
  target,
  level,
  internalFormat,
  width,
  height,
  border,
  imageSize,
  data
) {
  GLctx["compressedTexImage2D"](
    target,
    level,
    internalFormat,
    width,
    height,
    border,
    data ? HEAPU8.subarray(data, data + imageSize) : null
  );
}

function _emscripten_glCompressedTexSubImage2D(
  target,
  level,
  xoffset,
  yoffset,
  width,
  height,
  format,
  imageSize,
  data
) {
  GLctx["compressedTexSubImage2D"](
    target,
    level,
    xoffset,
    yoffset,
    width,
    height,
    format,
    data ? HEAPU8.subarray(data, data + imageSize) : null
  );
}

function _emscripten_glCopyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
  GLctx["copyTexImage2D"](x0, x1, x2, x3, x4, x5, x6, x7);
}

function _emscripten_glCopyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
  GLctx["copyTexSubImage2D"](x0, x1, x2, x3, x4, x5, x6, x7);
}

function _emscripten_glCreateProgram() {
  var id = GL.getNewId(GL.programs);
  var program = GLctx.createProgram();
  program.name = id;
  GL.programs[id] = program;
  return id;
}

function _emscripten_glCreateShader(shaderType) {
  var id = GL.getNewId(GL.shaders);
  GL.shaders[id] = GLctx.createShader(shaderType);
  return id;
}

function _emscripten_glCullFace(x0) {
  GLctx["cullFace"](x0);
}

function _emscripten_glDeleteBuffers(n, buffers) {
  for (var i = 0; i < n; i++) {
    var id = HEAP32[(buffers + i * 4) >> 2];
    var buffer = GL.buffers[id];

    // From spec: "glDeleteBuffers silently ignores 0's and names that do not
    // correspond to existing buffer objects."
    if (!buffer) continue;

    GLctx.deleteBuffer(buffer);
    buffer.name = 0;
    GL.buffers[id] = null;

    if (id == GL.currArrayBuffer) GL.currArrayBuffer = 0;
    if (id == GL.currElementArrayBuffer) GL.currElementArrayBuffer = 0;
  }
}

function _emscripten_glDeleteFramebuffers(n, framebuffers) {
  for (var i = 0; i < n; ++i) {
    var id = HEAP32[(framebuffers + i * 4) >> 2];
    var framebuffer = GL.framebuffers[id];
    if (!framebuffer) continue; // GL spec: "glDeleteFramebuffers silently ignores 0s and names that do not correspond to existing framebuffer objects".
    GLctx.deleteFramebuffer(framebuffer);
    framebuffer.name = 0;
    GL.framebuffers[id] = null;
  }
}

function _emscripten_glDeleteProgram(id) {
  if (!id) return;
  var program = GL.programs[id];
  if (!program) {
    // glDeleteProgram actually signals an error when deleting a nonexisting object, unlike some other GL delete functions.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  GLctx.deleteProgram(program);
  program.name = 0;
  GL.programs[id] = null;
  GL.programInfos[id] = null;
}

function _emscripten_glDeleteQueriesEXT(n, ids) {
  for (var i = 0; i < n; i++) {
    var id = HEAP32[(ids + i * 4) >> 2];
    var query = GL.timerQueriesEXT[id];
    if (!query) continue; // GL spec: "unused names in ids are ignored, as is the name zero."
    GLctx.disjointTimerQueryExt["deleteQueryEXT"](query);
    GL.timerQueriesEXT[id] = null;
  }
}

function _emscripten_glDeleteRenderbuffers(n, renderbuffers) {
  for (var i = 0; i < n; i++) {
    var id = HEAP32[(renderbuffers + i * 4) >> 2];
    var renderbuffer = GL.renderbuffers[id];
    if (!renderbuffer) continue; // GL spec: "glDeleteRenderbuffers silently ignores 0s and names that do not correspond to existing renderbuffer objects".
    GLctx.deleteRenderbuffer(renderbuffer);
    renderbuffer.name = 0;
    GL.renderbuffers[id] = null;
  }
}

function _emscripten_glDeleteShader(id) {
  if (!id) return;
  var shader = GL.shaders[id];
  if (!shader) {
    // glDeleteShader actually signals an error when deleting a nonexisting object, unlike some other GL delete functions.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  GLctx.deleteShader(shader);
  GL.shaders[id] = null;
}

function _emscripten_glDeleteTextures(n, textures) {
  for (var i = 0; i < n; i++) {
    var id = HEAP32[(textures + i * 4) >> 2];
    var texture = GL.textures[id];
    if (!texture) continue; // GL spec: "glDeleteTextures silently ignores 0s and names that do not correspond to existing textures".
    GLctx.deleteTexture(texture);
    texture.name = 0;
    GL.textures[id] = null;
  }
}

function _emscripten_glDeleteVertexArraysOES(n, vaos) {
  for (var i = 0; i < n; i++) {
    var id = HEAP32[(vaos + i * 4) >> 2];
    GLctx["deleteVertexArray"](GL.vaos[id]);
    GL.vaos[id] = null;
  }
}

function _emscripten_glDepthFunc(x0) {
  GLctx["depthFunc"](x0);
}

function _emscripten_glDepthMask(flag) {
  GLctx.depthMask(!!flag);
}

function _emscripten_glDepthRangef(x0, x1) {
  GLctx["depthRange"](x0, x1);
}

function _emscripten_glDetachShader(program, shader) {
  GLctx.detachShader(GL.programs[program], GL.shaders[shader]);
}

function _emscripten_glDisable(x0) {
  GLctx["disable"](x0);
}

function _emscripten_glDisableVertexAttribArray(index) {
  GLctx.disableVertexAttribArray(index);
}

function _emscripten_glDrawArrays(mode, first, count) {
  GLctx.drawArrays(mode, first, count);
}

function _emscripten_glDrawArraysInstancedANGLE(mode, first, count, primcount) {
  GLctx["drawArraysInstanced"](mode, first, count, primcount);
}

var __tempFixedLengthArray = [];
function _emscripten_glDrawBuffersWEBGL(n, bufs) {
  var bufArray = __tempFixedLengthArray[n];
  for (var i = 0; i < n; i++) {
    bufArray[i] = HEAP32[(bufs + i * 4) >> 2];
  }

  GLctx["drawBuffers"](bufArray);
}

function _emscripten_glDrawElements(mode, count, type, indices) {
  GLctx.drawElements(mode, count, type, indices);
}

function _emscripten_glDrawElementsInstancedANGLE(
  mode,
  count,
  type,
  indices,
  primcount
) {
  GLctx["drawElementsInstanced"](mode, count, type, indices, primcount);
}

function _emscripten_glEnable(x0) {
  GLctx["enable"](x0);
}

function _emscripten_glEnableVertexAttribArray(index) {
  GLctx.enableVertexAttribArray(index);
}

function _emscripten_glEndQueryEXT(target) {
  GLctx.disjointTimerQueryExt["endQueryEXT"](target);
}

function _emscripten_glFinish() {
  GLctx["finish"]();
}

function _emscripten_glFlush() {
  GLctx["flush"]();
}

function _emscripten_glFramebufferRenderbuffer(
  target,
  attachment,
  renderbuffertarget,
  renderbuffer
) {
  GLctx.framebufferRenderbuffer(
    target,
    attachment,
    renderbuffertarget,
    GL.renderbuffers[renderbuffer]
  );
}

function _emscripten_glFramebufferTexture2D(
  target,
  attachment,
  textarget,
  texture,
  level
) {
  GLctx.framebufferTexture2D(
    target,
    attachment,
    textarget,
    GL.textures[texture],
    level
  );
}

function _emscripten_glFrontFace(x0) {
  GLctx["frontFace"](x0);
}

function __glGenObject(n, buffers, createFunction, objectTable) {
  for (var i = 0; i < n; i++) {
    var buffer = GLctx[createFunction]();
    var id = buffer && GL.getNewId(objectTable);
    if (buffer) {
      buffer.name = id;
      objectTable[id] = buffer;
    } else {
      GL.recordError(0x502 /* GL_INVALID_OPERATION */);
    }
    HEAP32[(buffers + i * 4) >> 2] = id;
  }
}
function _emscripten_glGenBuffers(n, buffers) {
  __glGenObject(n, buffers, "createBuffer", GL.buffers);
}

function _emscripten_glGenFramebuffers(n, ids) {
  __glGenObject(n, ids, "createFramebuffer", GL.framebuffers);
}

function _emscripten_glGenQueriesEXT(n, ids) {
  for (var i = 0; i < n; i++) {
    var query = GLctx.disjointTimerQueryExt["createQueryEXT"]();
    if (!query) {
      GL.recordError(0x502 /* GL_INVALID_OPERATION */);
      while (i < n) HEAP32[(ids + i++ * 4) >> 2] = 0;
      return;
    }
    var id = GL.getNewId(GL.timerQueriesEXT);
    query.name = id;
    GL.timerQueriesEXT[id] = query;
    HEAP32[(ids + i * 4) >> 2] = id;
  }
}

function _emscripten_glGenRenderbuffers(n, renderbuffers) {
  __glGenObject(n, renderbuffers, "createRenderbuffer", GL.renderbuffers);
}

function _emscripten_glGenTextures(n, textures) {
  __glGenObject(n, textures, "createTexture", GL.textures);
}

function _emscripten_glGenVertexArraysOES(n, arrays) {
  __glGenObject(n, arrays, "createVertexArray", GL.vaos);
}

function _emscripten_glGenerateMipmap(x0) {
  GLctx["generateMipmap"](x0);
}

function _emscripten_glGetActiveAttrib(
  program,
  index,
  bufSize,
  length,
  size,
  type,
  name
) {
  program = GL.programs[program];
  var info = GLctx.getActiveAttrib(program, index);
  if (!info) return; // If an error occurs, nothing will be written to length, size and type and name.

  var numBytesWrittenExclNull =
    bufSize > 0 && name ? stringToUTF8(info.name, name, bufSize) : 0;
  if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
  if (size) HEAP32[size >> 2] = info.size;
  if (type) HEAP32[type >> 2] = info.type;
}

function _emscripten_glGetActiveUniform(
  program,
  index,
  bufSize,
  length,
  size,
  type,
  name
) {
  program = GL.programs[program];
  var info = GLctx.getActiveUniform(program, index);
  if (!info) return; // If an error occurs, nothing will be written to length, size, type and name.

  var numBytesWrittenExclNull =
    bufSize > 0 && name ? stringToUTF8(info.name, name, bufSize) : 0;
  if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
  if (size) HEAP32[size >> 2] = info.size;
  if (type) HEAP32[type >> 2] = info.type;
}

function _emscripten_glGetAttachedShaders(program, maxCount, count, shaders) {
  var result = GLctx.getAttachedShaders(GL.programs[program]);
  var len = result.length;
  if (len > maxCount) {
    len = maxCount;
  }
  HEAP32[count >> 2] = len;
  for (var i = 0; i < len; ++i) {
    var id = GL.shaders.indexOf(result[i]);
    HEAP32[(shaders + i * 4) >> 2] = id;
  }
}

function _emscripten_glGetAttribLocation(program, name) {
  return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
}

function readI53FromI64(ptr) {
  return HEAPU32[ptr >> 2] + HEAP32[(ptr + 4) >> 2] * 4294967296;
}

function readI53FromU64(ptr) {
  return HEAPU32[ptr >> 2] + HEAPU32[(ptr + 4) >> 2] * 4294967296;
}
function writeI53ToI64(ptr, num) {
  HEAPU32[ptr >> 2] = num;
  HEAPU32[(ptr + 4) >> 2] = (num - HEAPU32[ptr >> 2]) / 4294967296;
  var deserialized = num >= 0 ? readI53FromU64(ptr) : readI53FromI64(ptr);
  if (deserialized != num)
    warnOnce(
      "writeI53ToI64() out of range: serialized JS Number " +
        num +
        " to Wasm heap as bytes lo=0x" +
        HEAPU32[ptr >> 2].toString(16) +
        ", hi=0x" +
        HEAPU32[(ptr + 4) >> 2].toString(16) +
        ", which deserializes back to " +
        deserialized +
        " instead!"
    );
}
function emscriptenWebGLGet(name_, p, type) {
  // Guard against user passing a null pointer.
  // Note that GLES2 spec does not say anything about how passing a null pointer should be treated.
  // Testing on desktop core GL 3, the application crashes on glGetIntegerv to a null pointer, but
  // better to report an error instead of doing anything random.
  if (!p) {
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  var ret = undefined;
  switch (
    name_ // Handle a few trivial GLES values
  ) {
    case 0x8dfa: // GL_SHADER_COMPILER
      ret = 1;
      break;
    case 0x8df8: // GL_SHADER_BINARY_FORMATS
      if (type != 0 && type != 1) {
        GL.recordError(0x500); // GL_INVALID_ENUM
      }
      return; // Do not write anything to the out pointer, since no binary formats are supported.
    case 0x8df9: // GL_NUM_SHADER_BINARY_FORMATS
      ret = 0;
      break;
    case 0x86a2: // GL_NUM_COMPRESSED_TEXTURE_FORMATS
      // WebGL doesn't have GL_NUM_COMPRESSED_TEXTURE_FORMATS (it's obsolete since GL_COMPRESSED_TEXTURE_FORMATS returns a JS array that can be queried for length),
      // so implement it ourselves to allow C++ GLES2 code get the length.
      var formats = GLctx.getParameter(
        0x86a3 /*GL_COMPRESSED_TEXTURE_FORMATS*/
      );
      ret = formats ? formats.length : 0;
      break;
  }

  if (ret === undefined) {
    var result = GLctx.getParameter(name_);
    switch (typeof result) {
      case "number":
        ret = result;
        break;
      case "boolean":
        ret = result ? 1 : 0;
        break;
      case "string":
        GL.recordError(0x500); // GL_INVALID_ENUM
        return;
      case "object":
        if (result === null) {
          // null is a valid result for some (e.g., which buffer is bound - perhaps nothing is bound), but otherwise
          // can mean an invalid name_, which we need to report as an error
          switch (name_) {
            case 0x8894: // ARRAY_BUFFER_BINDING
            case 0x8b8d: // CURRENT_PROGRAM
            case 0x8895: // ELEMENT_ARRAY_BUFFER_BINDING
            case 0x8ca6: // FRAMEBUFFER_BINDING
            case 0x8ca7: // RENDERBUFFER_BINDING
            case 0x8069: // TEXTURE_BINDING_2D
            case 0x85b5: // WebGL 2 GL_VERTEX_ARRAY_BINDING, or WebGL 1 extension OES_vertex_array_object GL_VERTEX_ARRAY_BINDING_OES
            case 0x8514: {
              // TEXTURE_BINDING_CUBE_MAP
              ret = 0;
              break;
            }
            default: {
              GL.recordError(0x500); // GL_INVALID_ENUM
              return;
            }
          }
        } else if (
          result instanceof Float32Array ||
          result instanceof Uint32Array ||
          result instanceof Int32Array ||
          result instanceof Array
        ) {
          for (var i = 0; i < result.length; ++i) {
            switch (type) {
              case 0:
                HEAP32[(p + i * 4) >> 2] = result[i];
                break;
              case 2:
                HEAPF32[(p + i * 4) >> 2] = result[i];
                break;
              case 4:
                HEAP8[(p + i) >> 0] = result[i] ? 1 : 0;
                break;
            }
          }
          return;
        } else {
          try {
            ret = result.name | 0;
          } catch (e) {
            GL.recordError(0x500); // GL_INVALID_ENUM
            err(
              "GL_INVALID_ENUM in glGet" +
                type +
                "v: Unknown object returned from WebGL getParameter(" +
                name_ +
                ")! (error: " +
                e +
                ")"
            );
            return;
          }
        }
        break;
      default: // GL_INVALID_ENUM
        GL.recordError(0x500);
        err(
          "GL_INVALID_ENUM in glGet" +
            type +
            "v: Native code calling glGet" +
            type +
            "v(" +
            name_ +
            ") and it returns " +
            result +
            " of type " +
            typeof result +
            "!"
        );
        return;
    }
  }

  switch (type) {
    case 1:
      writeI53ToI64(p, ret);
      break;
    case 0:
      HEAP32[p >> 2] = ret;
      break;
    case 2:
      HEAPF32[p >> 2] = ret;
      break;
    case 4:
      HEAP8[p >> 0] = ret ? 1 : 0;
      break;
  }
}
function _emscripten_glGetBooleanv(name_, p) {
  emscriptenWebGLGet(name_, p, 4);
}

function _emscripten_glGetBufferParameteriv(target, value, data) {
  if (!data) {
    // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense
    // if data == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  HEAP32[data >> 2] = GLctx.getBufferParameter(target, value);
}

function _emscripten_glGetError() {
  var error = GLctx.getError() || GL.lastError;
  GL.lastError = 0 /*GL_NO_ERROR*/;
  return error;
}

function _emscripten_glGetFloatv(name_, p) {
  emscriptenWebGLGet(name_, p, 2);
}

function _emscripten_glGetFramebufferAttachmentParameteriv(
  target,
  attachment,
  pname,
  params
) {
  var result = GLctx.getFramebufferAttachmentParameter(
    target,
    attachment,
    pname
  );
  if (result instanceof WebGLRenderbuffer || result instanceof WebGLTexture) {
    result = result.name | 0;
  }
  HEAP32[params >> 2] = result;
}

function _emscripten_glGetIntegerv(name_, p) {
  emscriptenWebGLGet(name_, p, 0);
}

function _emscripten_glGetProgramInfoLog(program, maxLength, length, infoLog) {
  var log = GLctx.getProgramInfoLog(GL.programs[program]);
  if (log === null) log = "(unknown error)";
  var numBytesWrittenExclNull =
    maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
  if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
}

function _emscripten_glGetProgramiv(program, pname, p) {
  if (!p) {
    // GLES2 specification does not specify how to behave if p is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }

  if (program >= GL.counter) {
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }

  var ptable = GL.programInfos[program];
  if (!ptable) {
    GL.recordError(0x502 /* GL_INVALID_OPERATION */);
    return;
  }

  if (pname == 0x8b84) {
    // GL_INFO_LOG_LENGTH
    var log = GLctx.getProgramInfoLog(GL.programs[program]);
    if (log === null) log = "(unknown error)";
    HEAP32[p >> 2] = log.length + 1;
  } else if (pname == 0x8b87 /* GL_ACTIVE_UNIFORM_MAX_LENGTH */) {
    HEAP32[p >> 2] = ptable.maxUniformLength;
  } else if (pname == 0x8b8a /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */) {
    if (ptable.maxAttributeLength == -1) {
      program = GL.programs[program];
      var numAttribs = GLctx.getProgramParameter(
        program,
        0x8b89 /*GL_ACTIVE_ATTRIBUTES*/
      );
      ptable.maxAttributeLength = 0; // Spec says if there are no active attribs, 0 must be returned.
      for (var i = 0; i < numAttribs; ++i) {
        var activeAttrib = GLctx.getActiveAttrib(program, i);
        ptable.maxAttributeLength = Math.max(
          ptable.maxAttributeLength,
          activeAttrib.name.length + 1
        );
      }
    }
    HEAP32[p >> 2] = ptable.maxAttributeLength;
  } else if (pname == 0x8a35 /* GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH */) {
    if (ptable.maxUniformBlockNameLength == -1) {
      program = GL.programs[program];
      var numBlocks = GLctx.getProgramParameter(
        program,
        0x8a36 /*GL_ACTIVE_UNIFORM_BLOCKS*/
      );
      ptable.maxUniformBlockNameLength = 0;
      for (var i = 0; i < numBlocks; ++i) {
        var activeBlockName = GLctx.getActiveUniformBlockName(program, i);
        ptable.maxUniformBlockNameLength = Math.max(
          ptable.maxUniformBlockNameLength,
          activeBlockName.length + 1
        );
      }
    }
    HEAP32[p >> 2] = ptable.maxUniformBlockNameLength;
  } else {
    HEAP32[p >> 2] = GLctx.getProgramParameter(GL.programs[program], pname);
  }
}

function _emscripten_glGetQueryObjecti64vEXT(id, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  var query = GL.timerQueriesEXT[id];
  var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
  var ret;
  if (typeof param == "boolean") {
    ret = param ? 1 : 0;
  } else {
    ret = param;
  }
  writeI53ToI64(params, ret);
}

function _emscripten_glGetQueryObjectivEXT(id, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  var query = GL.timerQueriesEXT[id];
  var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
  var ret;
  if (typeof param == "boolean") {
    ret = param ? 1 : 0;
  } else {
    ret = param;
  }
  HEAP32[params >> 2] = ret;
}

function _emscripten_glGetQueryObjectui64vEXT(id, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  var query = GL.timerQueriesEXT[id];
  var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
  var ret;
  if (typeof param == "boolean") {
    ret = param ? 1 : 0;
  } else {
    ret = param;
  }
  writeI53ToI64(params, ret);
}

function _emscripten_glGetQueryObjectuivEXT(id, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  var query = GL.timerQueriesEXT[id];
  var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
  var ret;
  if (typeof param == "boolean") {
    ret = param ? 1 : 0;
  } else {
    ret = param;
  }
  HEAP32[params >> 2] = ret;
}

function _emscripten_glGetQueryivEXT(target, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  HEAP32[params >> 2] = GLctx.disjointTimerQueryExt["getQueryEXT"](
    target,
    pname
  );
}

function _emscripten_glGetRenderbufferParameteriv(target, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if params == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname);
}

function _emscripten_glGetShaderInfoLog(shader, maxLength, length, infoLog) {
  var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
  if (log === null) log = "(unknown error)";
  var numBytesWrittenExclNull =
    maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
  if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
}

function _emscripten_glGetShaderPrecisionFormat(
  shaderType,
  precisionType,
  range,
  precision
) {
  var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType);
  HEAP32[range >> 2] = result.rangeMin;
  HEAP32[(range + 4) >> 2] = result.rangeMax;
  HEAP32[precision >> 2] = result.precision;
}

function _emscripten_glGetShaderSource(shader, bufSize, length, source) {
  var result = GLctx.getShaderSource(GL.shaders[shader]);
  if (!result) return; // If an error occurs, nothing will be written to length or source.
  var numBytesWrittenExclNull =
    bufSize > 0 && source ? stringToUTF8(result, source, bufSize) : 0;
  if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
}

function _emscripten_glGetShaderiv(shader, pname, p) {
  if (!p) {
    // GLES2 specification does not specify how to behave if p is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  if (pname == 0x8b84) {
    // GL_INFO_LOG_LENGTH
    var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
    if (log === null) log = "(unknown error)";
    HEAP32[p >> 2] = log.length + 1;
  } else if (pname == 0x8b88) {
    // GL_SHADER_SOURCE_LENGTH
    var source = GLctx.getShaderSource(GL.shaders[shader]);
    var sourceLength =
      source === null || source.length == 0 ? 0 : source.length + 1;
    HEAP32[p >> 2] = sourceLength;
  } else {
    HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
  }
}

function stringToNewUTF8(jsString) {
  var length = lengthBytesUTF8(jsString) + 1;
  var cString = _malloc(length);
  stringToUTF8(jsString, cString, length);
  return cString;
}
function _emscripten_glGetString(name_) {
  if (GL.stringCache[name_]) return GL.stringCache[name_];
  var ret;
  switch (name_) {
    case 0x1f03 /* GL_EXTENSIONS */:
      var exts = GLctx.getSupportedExtensions() || []; // .getSupportedExtensions() can return null if context is lost, so coerce to empty array.
      exts = exts.concat(
        exts.map(function (e) {
          return "GL_" + e;
        })
      );
      ret = stringToNewUTF8(exts.join(" "));
      break;
    case 0x1f00 /* GL_VENDOR */:
    case 0x1f01 /* GL_RENDERER */:
    case 0x9245 /* UNMASKED_VENDOR_WEBGL */:
    case 0x9246 /* UNMASKED_RENDERER_WEBGL */:
      var s = GLctx.getParameter(name_);
      if (!s) {
        GL.recordError(0x500 /*GL_INVALID_ENUM*/);
      }
      ret = stringToNewUTF8(s);
      break;

    case 0x1f02 /* GL_VERSION */:
      var glVersion = GLctx.getParameter(0x1f02 /*GL_VERSION*/);
      // return GLES version string corresponding to the version of the WebGL context
      {
        glVersion = "OpenGL ES 2.0 (" + glVersion + ")";
      }
      ret = stringToNewUTF8(glVersion);
      break;
    case 0x8b8c /* GL_SHADING_LANGUAGE_VERSION */:
      var glslVersion = GLctx.getParameter(
        0x8b8c /*GL_SHADING_LANGUAGE_VERSION*/
      );
      // extract the version number 'N.M' from the string 'WebGL GLSL ES N.M ...'
      var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;
      var ver_num = glslVersion.match(ver_re);
      if (ver_num !== null) {
        if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0"; // ensure minor version has 2 digits
        glslVersion =
          "OpenGL ES GLSL ES " + ver_num[1] + " (" + glslVersion + ")";
      }
      ret = stringToNewUTF8(glslVersion);
      break;
    default:
      GL.recordError(0x500 /*GL_INVALID_ENUM*/);
      return 0;
  }
  GL.stringCache[name_] = ret;
  return ret;
}

function _emscripten_glGetTexParameterfv(target, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  HEAPF32[params >> 2] = GLctx.getTexParameter(target, pname);
}

function _emscripten_glGetTexParameteriv(target, pname, params) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  HEAP32[params >> 2] = GLctx.getTexParameter(target, pname);
}

function jstoi_q(str) {
  // TODO: If issues below are resolved, add a suitable suppression or remove this comment.
  return parseInt(
    str,
    undefined /* https://github.com/google/closure-compiler/issues/3230 / https://github.com/google/closure-compiler/issues/3548 */
  );
}
function _emscripten_glGetUniformLocation(program, name) {
  name = UTF8ToString(name);

  var arrayIndex = 0;
  // If user passed an array accessor "[index]", parse the array index off the accessor.
  if (name[name.length - 1] == "]") {
    var leftBrace = name.lastIndexOf("[");
    arrayIndex =
      name[leftBrace + 1] != "]" ? jstoi_q(name.slice(leftBrace + 1)) : 0; // "index]", parseInt will ignore the ']' at the end; but treat "foo[]" as "foo[0]"
    name = name.slice(0, leftBrace);
  }

  var uniformInfo =
    GL.programInfos[program] && GL.programInfos[program].uniforms[name]; // returns pair [ dimension_of_uniform_array, uniform_location ]
  if (uniformInfo && arrayIndex >= 0 && arrayIndex < uniformInfo[0]) {
    // Check if user asked for an out-of-bounds element, i.e. for 'vec4 colors[3];' user could ask for 'colors[10]' which should return -1.
    return uniformInfo[1] + arrayIndex;
  } else {
    return -1;
  }
}

/** @suppress{checkTypes} */
function emscriptenWebGLGetUniform(program, location, params, type) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if params == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  var data = GLctx.getUniform(GL.programs[program], GL.uniforms[location]);
  if (typeof data == "number" || typeof data == "boolean") {
    switch (type) {
      case 0:
        HEAP32[params >> 2] = data;
        break;
      case 2:
        HEAPF32[params >> 2] = data;
        break;
      default:
        throw "internal emscriptenWebGLGetUniform() error, bad type: " + type;
    }
  } else {
    for (var i = 0; i < data.length; i++) {
      switch (type) {
        case 0:
          HEAP32[(params + i * 4) >> 2] = data[i];
          break;
        case 2:
          HEAPF32[(params + i * 4) >> 2] = data[i];
          break;
        default:
          throw "internal emscriptenWebGLGetUniform() error, bad type: " + type;
      }
    }
  }
}
function _emscripten_glGetUniformfv(program, location, params) {
  emscriptenWebGLGetUniform(program, location, params, 2);
}

function _emscripten_glGetUniformiv(program, location, params) {
  emscriptenWebGLGetUniform(program, location, params, 0);
}

function _emscripten_glGetVertexAttribPointerv(index, pname, pointer) {
  if (!pointer) {
    // GLES2 specification does not specify how to behave if pointer is a null pointer. Since calling this function does not make sense
    // if pointer == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  HEAP32[pointer >> 2] = GLctx.getVertexAttribOffset(index, pname);
}

/** @suppress{checkTypes} */
function emscriptenWebGLGetVertexAttrib(index, pname, params, type) {
  if (!params) {
    // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
    // if params == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  var data = GLctx.getVertexAttrib(index, pname);
  if (pname == 0x889f /*VERTEX_ATTRIB_ARRAY_BUFFER_BINDING*/) {
    HEAP32[params >> 2] = data["name"];
  } else if (typeof data == "number" || typeof data == "boolean") {
    switch (type) {
      case 0:
        HEAP32[params >> 2] = data;
        break;
      case 2:
        HEAPF32[params >> 2] = data;
        break;
      case 5:
        HEAP32[params >> 2] = Math.fround(data);
        break;
      default:
        throw (
          "internal emscriptenWebGLGetVertexAttrib() error, bad type: " + type
        );
    }
  } else {
    for (var i = 0; i < data.length; i++) {
      switch (type) {
        case 0:
          HEAP32[(params + i * 4) >> 2] = data[i];
          break;
        case 2:
          HEAPF32[(params + i * 4) >> 2] = data[i];
          break;
        case 5:
          HEAP32[(params + i * 4) >> 2] = Math.fround(data[i]);
          break;
        default:
          throw (
            "internal emscriptenWebGLGetVertexAttrib() error, bad type: " + type
          );
      }
    }
  }
}
function _emscripten_glGetVertexAttribfv(index, pname, params) {
  // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttrib*f(),
  // otherwise the results are undefined. (GLES3 spec 6.1.12)
  emscriptenWebGLGetVertexAttrib(index, pname, params, 2);
}

function _emscripten_glGetVertexAttribiv(index, pname, params) {
  // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttrib*f(),
  // otherwise the results are undefined. (GLES3 spec 6.1.12)
  emscriptenWebGLGetVertexAttrib(index, pname, params, 5);
}

function _emscripten_glHint(x0, x1) {
  GLctx["hint"](x0, x1);
}

function _emscripten_glIsBuffer(buffer) {
  var b = GL.buffers[buffer];
  if (!b) return 0;
  return GLctx.isBuffer(b);
}

function _emscripten_glIsEnabled(x0) {
  return GLctx["isEnabled"](x0);
}

function _emscripten_glIsFramebuffer(framebuffer) {
  var fb = GL.framebuffers[framebuffer];
  if (!fb) return 0;
  return GLctx.isFramebuffer(fb);
}

function _emscripten_glIsProgram(program) {
  program = GL.programs[program];
  if (!program) return 0;
  return GLctx.isProgram(program);
}

function _emscripten_glIsQueryEXT(id) {
  var query = GL.timerQueriesEXT[id];
  if (!query) return 0;
  return GLctx.disjointTimerQueryExt["isQueryEXT"](query);
}

function _emscripten_glIsRenderbuffer(renderbuffer) {
  var rb = GL.renderbuffers[renderbuffer];
  if (!rb) return 0;
  return GLctx.isRenderbuffer(rb);
}

function _emscripten_glIsShader(shader) {
  var s = GL.shaders[shader];
  if (!s) return 0;
  return GLctx.isShader(s);
}

function _emscripten_glIsTexture(id) {
  var texture = GL.textures[id];
  if (!texture) return 0;
  return GLctx.isTexture(texture);
}

function _emscripten_glIsVertexArrayOES(array) {
  var vao = GL.vaos[array];
  if (!vao) return 0;
  return GLctx["isVertexArray"](vao);
}

function _emscripten_glLineWidth(x0) {
  GLctx["lineWidth"](x0);
}

function _emscripten_glLinkProgram(program) {
  GLctx.linkProgram(GL.programs[program]);
  GL.populateUniformTable(program);
}

function _emscripten_glPixelStorei(pname, param) {
  if (pname == 0xcf5 /* GL_UNPACK_ALIGNMENT */) {
    GL.unpackAlignment = param;
  }
  GLctx.pixelStorei(pname, param);
}

function _emscripten_glPolygonOffset(x0, x1) {
  GLctx["polygonOffset"](x0, x1);
}

function _emscripten_glQueryCounterEXT(id, target) {
  GLctx.disjointTimerQueryExt["queryCounterEXT"](
    GL.timerQueriesEXT[id],
    target
  );
}

function __computeUnpackAlignedImageSize(
  width,
  height,
  sizePerPixel,
  alignment
) {
  function roundedToNextMultipleOf(x, y) {
    return (x + y - 1) & -y;
  }
  var plainRowSize = width * sizePerPixel;
  var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment);
  return height * alignedRowSize;
}

function __colorChannelsInGlTextureFormat(format) {
  // Micro-optimizations for size: map format to size by subtracting smallest enum value (0x1902) from all values first.
  // Also omit the most common size value (1) from the list, which is assumed by formats not on the list.
  var colorChannels = {
    // 0x1902 /* GL_DEPTH_COMPONENT */ - 0x1902: 1,
    // 0x1906 /* GL_ALPHA */ - 0x1902: 1,
    5: 3,
    6: 4,
    // 0x1909 /* GL_LUMINANCE */ - 0x1902: 1,
    8: 2,
    29502: 3,
    29504: 4,
  };
  return colorChannels[format - 0x1902] || 1;
}

function __heapObjectForWebGLType(type) {
  // Micro-optimization for size: Subtract lowest GL enum number (0x1400/* GL_BYTE */) from type to compare
  // smaller values for the heap, for shorter generated code size.
  // Also the type HEAPU16 is not tested for explicitly, but any unrecognized type will return out HEAPU16.
  // (since most types are HEAPU16)
  type -= 0x1400;

  if (type == 1) return HEAPU8;

  if (type == 4) return HEAP32;

  if (type == 6) return HEAPF32;

  if (type == 5 || type == 28922) return HEAPU32;

  return HEAPU16;
}

function __heapAccessShiftForWebGLHeap(heap) {
  return 31 - Math.clz32(heap.BYTES_PER_ELEMENT);
}
function emscriptenWebGLGetTexPixelData(
  type,
  format,
  width,
  height,
  pixels,
  internalFormat
) {
  var heap = __heapObjectForWebGLType(type);
  var shift = __heapAccessShiftForWebGLHeap(heap);
  var byteSize = 1 << shift;
  var sizePerPixel = __colorChannelsInGlTextureFormat(format) * byteSize;
  var bytes = __computeUnpackAlignedImageSize(
    width,
    height,
    sizePerPixel,
    GL.unpackAlignment
  );
  return heap.subarray(pixels >> shift, (pixels + bytes) >> shift);
}
function _emscripten_glReadPixels(x, y, width, height, format, type, pixels) {
  var pixelData = emscriptenWebGLGetTexPixelData(
    type,
    format,
    width,
    height,
    pixels,
    format
  );
  if (!pixelData) {
    GL.recordError(0x500 /*GL_INVALID_ENUM*/);
    return;
  }
  GLctx.readPixels(x, y, width, height, format, type, pixelData);
}

function _emscripten_glReleaseShaderCompiler() {
  // NOP (as allowed by GLES 2.0 spec)
}

function _emscripten_glRenderbufferStorage(x0, x1, x2, x3) {
  GLctx["renderbufferStorage"](x0, x1, x2, x3);
}

function _emscripten_glSampleCoverage(value, invert) {
  GLctx.sampleCoverage(value, !!invert);
}

function _emscripten_glScissor(x0, x1, x2, x3) {
  GLctx["scissor"](x0, x1, x2, x3);
}

function _emscripten_glShaderBinary() {
  GL.recordError(0x500 /*GL_INVALID_ENUM*/);
}

function _emscripten_glShaderSource(shader, count, string, length) {
  var source = GL.getSource(shader, count, string, length);

  GLctx.shaderSource(GL.shaders[shader], source);
}

function _emscripten_glStencilFunc(x0, x1, x2) {
  GLctx["stencilFunc"](x0, x1, x2);
}

function _emscripten_glStencilFuncSeparate(x0, x1, x2, x3) {
  GLctx["stencilFuncSeparate"](x0, x1, x2, x3);
}

function _emscripten_glStencilMask(x0) {
  GLctx["stencilMask"](x0);
}

function _emscripten_glStencilMaskSeparate(x0, x1) {
  GLctx["stencilMaskSeparate"](x0, x1);
}

function _emscripten_glStencilOp(x0, x1, x2) {
  GLctx["stencilOp"](x0, x1, x2);
}

function _emscripten_glStencilOpSeparate(x0, x1, x2, x3) {
  GLctx["stencilOpSeparate"](x0, x1, x2, x3);
}

function _emscripten_glTexImage2D(
  target,
  level,
  internalFormat,
  width,
  height,
  border,
  format,
  type,
  pixels
) {
  GLctx.texImage2D(
    target,
    level,
    internalFormat,
    width,
    height,
    border,
    format,
    type,
    pixels
      ? emscriptenWebGLGetTexPixelData(
          type,
          format,
          width,
          height,
          pixels,
          internalFormat
        )
      : null
  );
}

function _emscripten_glTexParameterf(x0, x1, x2) {
  GLctx["texParameterf"](x0, x1, x2);
}

function _emscripten_glTexParameterfv(target, pname, params) {
  var param = HEAPF32[params >> 2];
  GLctx.texParameterf(target, pname, param);
}

function _emscripten_glTexParameteri(x0, x1, x2) {
  GLctx["texParameteri"](x0, x1, x2);
}

function _emscripten_glTexParameteriv(target, pname, params) {
  var param = HEAP32[params >> 2];
  GLctx.texParameteri(target, pname, param);
}

function _emscripten_glTexSubImage2D(
  target,
  level,
  xoffset,
  yoffset,
  width,
  height,
  format,
  type,
  pixels
) {
  var pixelData = null;
  if (pixels)
    pixelData = emscriptenWebGLGetTexPixelData(
      type,
      format,
      width,
      height,
      pixels,
      0
    );
  GLctx.texSubImage2D(
    target,
    level,
    xoffset,
    yoffset,
    width,
    height,
    format,
    type,
    pixelData
  );
}

function _emscripten_glUniform1f(location, v0) {
  GLctx.uniform1f(GL.uniforms[location], v0);
}

function _emscripten_glUniform1fv(location, count, value) {
  if (count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferFloatViews[count - 1];
    for (var i = 0; i < count; ++i) {
      view[i] = HEAPF32[(value + 4 * i) >> 2];
    }
  } else {
    var view = HEAPF32.subarray(value >> 2, (value + count * 4) >> 2);
  }
  GLctx.uniform1fv(GL.uniforms[location], view);
}

function _emscripten_glUniform1i(location, v0) {
  GLctx.uniform1i(GL.uniforms[location], v0);
}

function _emscripten_glUniform1iv(location, count, value) {
  if (count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferIntViews[count - 1];
    for (var i = 0; i < count; ++i) {
      view[i] = HEAP32[(value + 4 * i) >> 2];
    }
  } else {
    var view = HEAP32.subarray(value >> 2, (value + count * 4) >> 2);
  }
  GLctx.uniform1iv(GL.uniforms[location], view);
}

function _emscripten_glUniform2f(location, v0, v1) {
  GLctx.uniform2f(GL.uniforms[location], v0, v1);
}

function _emscripten_glUniform2fv(location, count, value) {
  if (2 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferFloatViews[2 * count - 1];
    for (var i = 0; i < 2 * count; i += 2) {
      view[i] = HEAPF32[(value + 4 * i) >> 2];
      view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
    }
  } else {
    var view = HEAPF32.subarray(value >> 2, (value + count * 8) >> 2);
  }
  GLctx.uniform2fv(GL.uniforms[location], view);
}

function _emscripten_glUniform2i(location, v0, v1) {
  GLctx.uniform2i(GL.uniforms[location], v0, v1);
}

function _emscripten_glUniform2iv(location, count, value) {
  if (2 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferIntViews[2 * count - 1];
    for (var i = 0; i < 2 * count; i += 2) {
      view[i] = HEAP32[(value + 4 * i) >> 2];
      view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2];
    }
  } else {
    var view = HEAP32.subarray(value >> 2, (value + count * 8) >> 2);
  }
  GLctx.uniform2iv(GL.uniforms[location], view);
}

function _emscripten_glUniform3f(location, v0, v1, v2) {
  GLctx.uniform3f(GL.uniforms[location], v0, v1, v2);
}

function _emscripten_glUniform3fv(location, count, value) {
  if (3 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferFloatViews[3 * count - 1];
    for (var i = 0; i < 3 * count; i += 3) {
      view[i] = HEAPF32[(value + 4 * i) >> 2];
      view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
      view[i + 2] = HEAPF32[(value + (4 * i + 8)) >> 2];
    }
  } else {
    var view = HEAPF32.subarray(value >> 2, (value + count * 12) >> 2);
  }
  GLctx.uniform3fv(GL.uniforms[location], view);
}

function _emscripten_glUniform3i(location, v0, v1, v2) {
  GLctx.uniform3i(GL.uniforms[location], v0, v1, v2);
}

function _emscripten_glUniform3iv(location, count, value) {
  if (3 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferIntViews[3 * count - 1];
    for (var i = 0; i < 3 * count; i += 3) {
      view[i] = HEAP32[(value + 4 * i) >> 2];
      view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2];
      view[i + 2] = HEAP32[(value + (4 * i + 8)) >> 2];
    }
  } else {
    var view = HEAP32.subarray(value >> 2, (value + count * 12) >> 2);
  }
  GLctx.uniform3iv(GL.uniforms[location], view);
}

function _emscripten_glUniform4f(location, v0, v1, v2, v3) {
  GLctx.uniform4f(GL.uniforms[location], v0, v1, v2, v3);
}

function _emscripten_glUniform4fv(location, count, value) {
  if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferFloatViews[4 * count - 1];
    // hoist the heap out of the loop for size and for pthreads+growth.
    var heap = HEAPF32;
    value >>= 2;
    for (var i = 0; i < 4 * count; i += 4) {
      var dst = value + i;
      view[i] = heap[dst];
      view[i + 1] = heap[dst + 1];
      view[i + 2] = heap[dst + 2];
      view[i + 3] = heap[dst + 3];
    }
  } else {
    var view = HEAPF32.subarray(value >> 2, (value + count * 16) >> 2);
  }
  GLctx.uniform4fv(GL.uniforms[location], view);
}

function _emscripten_glUniform4i(location, v0, v1, v2, v3) {
  GLctx.uniform4i(GL.uniforms[location], v0, v1, v2, v3);
}

function _emscripten_glUniform4iv(location, count, value) {
  if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferIntViews[4 * count - 1];
    for (var i = 0; i < 4 * count; i += 4) {
      view[i] = HEAP32[(value + 4 * i) >> 2];
      view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2];
      view[i + 2] = HEAP32[(value + (4 * i + 8)) >> 2];
      view[i + 3] = HEAP32[(value + (4 * i + 12)) >> 2];
    }
  } else {
    var view = HEAP32.subarray(value >> 2, (value + count * 16) >> 2);
  }
  GLctx.uniform4iv(GL.uniforms[location], view);
}

function _emscripten_glUniformMatrix2fv(location, count, transpose, value) {
  if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferFloatViews[4 * count - 1];
    for (var i = 0; i < 4 * count; i += 4) {
      view[i] = HEAPF32[(value + 4 * i) >> 2];
      view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
      view[i + 2] = HEAPF32[(value + (4 * i + 8)) >> 2];
      view[i + 3] = HEAPF32[(value + (4 * i + 12)) >> 2];
    }
  } else {
    var view = HEAPF32.subarray(value >> 2, (value + count * 16) >> 2);
  }
  GLctx.uniformMatrix2fv(GL.uniforms[location], !!transpose, view);
}

function _emscripten_glUniformMatrix3fv(location, count, transpose, value) {
  if (9 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferFloatViews[9 * count - 1];
    for (var i = 0; i < 9 * count; i += 9) {
      view[i] = HEAPF32[(value + 4 * i) >> 2];
      view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2];
      view[i + 2] = HEAPF32[(value + (4 * i + 8)) >> 2];
      view[i + 3] = HEAPF32[(value + (4 * i + 12)) >> 2];
      view[i + 4] = HEAPF32[(value + (4 * i + 16)) >> 2];
      view[i + 5] = HEAPF32[(value + (4 * i + 20)) >> 2];
      view[i + 6] = HEAPF32[(value + (4 * i + 24)) >> 2];
      view[i + 7] = HEAPF32[(value + (4 * i + 28)) >> 2];
      view[i + 8] = HEAPF32[(value + (4 * i + 32)) >> 2];
    }
  } else {
    var view = HEAPF32.subarray(value >> 2, (value + count * 36) >> 2);
  }
  GLctx.uniformMatrix3fv(GL.uniforms[location], !!transpose, view);
}

function _emscripten_glUniformMatrix4fv(location, count, transpose, value) {
  if (16 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
    // avoid allocation when uploading few enough uniforms
    var view = GL.miniTempBufferFloatViews[16 * count - 1];
    // hoist the heap out of the loop for size and for pthreads+growth.
    var heap = HEAPF32;
    value >>= 2;
    for (var i = 0; i < 16 * count; i += 16) {
      var dst = value + i;
      view[i] = heap[dst];
      view[i + 1] = heap[dst + 1];
      view[i + 2] = heap[dst + 2];
      view[i + 3] = heap[dst + 3];
      view[i + 4] = heap[dst + 4];
      view[i + 5] = heap[dst + 5];
      view[i + 6] = heap[dst + 6];
      view[i + 7] = heap[dst + 7];
      view[i + 8] = heap[dst + 8];
      view[i + 9] = heap[dst + 9];
      view[i + 10] = heap[dst + 10];
      view[i + 11] = heap[dst + 11];
      view[i + 12] = heap[dst + 12];
      view[i + 13] = heap[dst + 13];
      view[i + 14] = heap[dst + 14];
      view[i + 15] = heap[dst + 15];
    }
  } else {
    var view = HEAPF32.subarray(value >> 2, (value + count * 64) >> 2);
  }
  GLctx.uniformMatrix4fv(GL.uniforms[location], !!transpose, view);
}

function _emscripten_glUseProgram(program) {
  GLctx.useProgram(GL.programs[program]);
}

function _emscripten_glValidateProgram(program) {
  GLctx.validateProgram(GL.programs[program]);
}

function _emscripten_glVertexAttrib1f(x0, x1) {
  GLctx["vertexAttrib1f"](x0, x1);
}

function _emscripten_glVertexAttrib1fv(index, v) {
  GLctx.vertexAttrib1f(index, HEAPF32[v >> 2]);
}

function _emscripten_glVertexAttrib2f(x0, x1, x2) {
  GLctx["vertexAttrib2f"](x0, x1, x2);
}

function _emscripten_glVertexAttrib2fv(index, v) {
  GLctx.vertexAttrib2f(index, HEAPF32[v >> 2], HEAPF32[(v + 4) >> 2]);
}

function _emscripten_glVertexAttrib3f(x0, x1, x2, x3) {
  GLctx["vertexAttrib3f"](x0, x1, x2, x3);
}

function _emscripten_glVertexAttrib3fv(index, v) {
  GLctx.vertexAttrib3f(
    index,
    HEAPF32[v >> 2],
    HEAPF32[(v + 4) >> 2],
    HEAPF32[(v + 8) >> 2]
  );
}

function _emscripten_glVertexAttrib4f(x0, x1, x2, x3, x4) {
  GLctx["vertexAttrib4f"](x0, x1, x2, x3, x4);
}

function _emscripten_glVertexAttrib4fv(index, v) {
  GLctx.vertexAttrib4f(
    index,
    HEAPF32[v >> 2],
    HEAPF32[(v + 4) >> 2],
    HEAPF32[(v + 8) >> 2],
    HEAPF32[(v + 12) >> 2]
  );
}

function _emscripten_glVertexAttribDivisorANGLE(index, divisor) {
  GLctx["vertexAttribDivisor"](index, divisor);
}

function _emscripten_glVertexAttribPointer(
  index,
  size,
  type,
  normalized,
  stride,
  ptr
) {
  GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
}

function _emscripten_glViewport(x0, x1, x2, x3) {
  GLctx["viewport"](x0, x1, x2, x3);
}

function _emscripten_has_asyncify() {
  return 0;
}

function _emscripten_memcpy_big(dest, src, num) {
  HEAPU8.copyWithin(dest, src, src + num);
}

function __emscripten_do_request_fullscreen(target, strategy) {
  if (!JSEvents.fullscreenEnabled()) return -1;
  target = __findEventTarget(target);
  if (!target) return -4;

  if (!target.requestFullscreen && !target.webkitRequestFullscreen) {
    return -3;
  }

  var canPerformRequests = JSEvents.canPerformEventHandlerRequests();

  // Queue this function call if we're not currently in an event handler and the user saw it appropriate to do so.
  if (!canPerformRequests) {
    if (strategy.deferUntilInEventHandler) {
      JSEvents.deferCall(
        _JSEvents_requestFullscreen,
        1 /* priority over pointer lock */,
        [target, strategy]
      );
      return 1;
    } else {
      return -2;
    }
  }

  return _JSEvents_requestFullscreen(target, strategy);
}
function _emscripten_request_fullscreen_strategy(
  target,
  deferUntilInEventHandler,
  fullscreenStrategy
) {
  var strategy = {
    scaleMode: HEAP32[fullscreenStrategy >> 2],
    canvasResolutionScaleMode: HEAP32[(fullscreenStrategy + 4) >> 2],
    filteringMode: HEAP32[(fullscreenStrategy + 8) >> 2],
    deferUntilInEventHandler: deferUntilInEventHandler,
    canvasResizedCallback: HEAP32[(fullscreenStrategy + 12) >> 2],
    canvasResizedCallbackUserData: HEAP32[(fullscreenStrategy + 16) >> 2],
  };
  __currentFullscreenStrategy = strategy;

  return __emscripten_do_request_fullscreen(target, strategy);
}

function _emscripten_request_pointerlock(target, deferUntilInEventHandler) {
  target = __findEventTarget(target);
  if (!target) return -4;
  if (!target.requestPointerLock && !target.msRequestPointerLock) {
    return -1;
  }

  var canPerformRequests = JSEvents.canPerformEventHandlerRequests();

  // Queue this function call if we're not currently in an event handler and the user saw it appropriate to do so.
  if (!canPerformRequests) {
    if (deferUntilInEventHandler) {
      JSEvents.deferCall(
        __requestPointerLock,
        2 /* priority below fullscreen */,
        [target]
      );
      return 1;
    } else {
      return -2;
    }
  }

  return __requestPointerLock(target);
}

function _emscripten_get_heap_size() {
  return HEAPU8.length;
}

function abortOnCannotGrowMemory(requestedSize) {
  abort(
    "Cannot enlarge memory arrays to size " +
      requestedSize +
      " bytes (OOM). Either (1) compile with  -s INITIAL_MEMORY=X  with X higher than the current value " +
      HEAP8.length +
      ", (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 "
  );
}
function _emscripten_resize_heap(requestedSize) {
  abortOnCannotGrowMemory(requestedSize);
}

function _emscripten_sample_gamepad_data() {
  return (JSEvents.lastGamepadState = navigator.getGamepads
    ? navigator.getGamepads()
    : navigator.webkitGetGamepads
    ? navigator.webkitGetGamepads()
    : null)
    ? 0
    : -1;
}

function __registerBeforeUnloadEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString
) {
  var beforeUnloadEventHandlerFunc = function (ev) {
    var e = ev || event;

    // Note: This is always called on the main browser thread, since it needs synchronously return a value!
    var confirmationMessage = dynCall_iiii(
      callbackfunc,
      eventTypeId,
      0,
      userData
    );

    if (confirmationMessage) {
      confirmationMessage = UTF8ToString(confirmationMessage);
    }
    if (confirmationMessage) {
      e.preventDefault();
      e.returnValue = confirmationMessage;
      return confirmationMessage;
    }
  };

  var eventHandler = {
    target: __findEventTarget(target),
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: beforeUnloadEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_beforeunload_callback_on_thread(
  userData,
  callbackfunc,
  targetThread
) {
  if (typeof onbeforeunload === "undefined") return -1;
  // beforeunload callback can only be registered on the main browser thread, because the page will go away immediately after returning from the handler,
  // and there is no time to start proxying it anywhere.
  if (targetThread !== 1) return -5;
  __registerBeforeUnloadEventCallback(
    2,
    userData,
    true,
    callbackfunc,
    28,
    "beforeunload"
  );
  return 0;
}

function __registerFocusEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.focusEvent) JSEvents.focusEvent = _malloc(256);

  var focusEventHandlerFunc = function (ev) {
    var e = ev || event;

    var nodeName = JSEvents.getNodeNameForTarget(e.target);
    var id = e.target.id ? e.target.id : "";

    var focusEvent = JSEvents.focusEvent;
    stringToUTF8(nodeName, focusEvent + 0, 128);
    stringToUTF8(id, focusEvent + 128, 128);

    if (dynCall_iiii(callbackfunc, eventTypeId, focusEvent, userData))
      e.preventDefault();
  };

  var eventHandler = {
    target: __findEventTarget(target),
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: focusEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_blur_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerFocusEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    12,
    "blur",
    targetThread
  );
  return 0;
}

function _emscripten_set_element_css_size(target, width, height) {
  target = __findEventTarget(target);
  if (!target) return -4;

  target.style.width = width + "px";
  target.style.height = height + "px";

  return 0;
}

function _emscripten_set_focus_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerFocusEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    13,
    "focus",
    targetThread
  );
  return 0;
}

function __fillFullscreenChangeEventData(eventStruct) {
  var fullscreenElement =
    document.fullscreenElement ||
    document.mozFullScreenElement ||
    document.webkitFullscreenElement ||
    document.msFullscreenElement;
  var isFullscreen = !!fullscreenElement;
  /** @suppress{checkTypes} */
  HEAP32[eventStruct >> 2] = isFullscreen;
  HEAP32[(eventStruct + 4) >> 2] = JSEvents.fullscreenEnabled();
  // If transitioning to fullscreen, report info about the element that is now fullscreen.
  // If transitioning to windowed mode, report info about the element that just was fullscreen.
  var reportedElement = isFullscreen
    ? fullscreenElement
    : JSEvents.previousFullscreenElement;
  var nodeName = JSEvents.getNodeNameForTarget(reportedElement);
  var id = reportedElement && reportedElement.id ? reportedElement.id : "";
  stringToUTF8(nodeName, eventStruct + 8, 128);
  stringToUTF8(id, eventStruct + 136, 128);
  HEAP32[(eventStruct + 264) >> 2] = reportedElement
    ? reportedElement.clientWidth
    : 0;
  HEAP32[(eventStruct + 268) >> 2] = reportedElement
    ? reportedElement.clientHeight
    : 0;
  HEAP32[(eventStruct + 272) >> 2] = screen.width;
  HEAP32[(eventStruct + 276) >> 2] = screen.height;
  if (isFullscreen) {
    JSEvents.previousFullscreenElement = fullscreenElement;
  }
}
function __registerFullscreenChangeEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.fullscreenChangeEvent)
    JSEvents.fullscreenChangeEvent = _malloc(280);

  var fullscreenChangeEventhandlerFunc = function (ev) {
    var e = ev || event;

    var fullscreenChangeEvent = JSEvents.fullscreenChangeEvent;

    __fillFullscreenChangeEventData(fullscreenChangeEvent);

    if (
      dynCall_iiii(callbackfunc, eventTypeId, fullscreenChangeEvent, userData)
    )
      e.preventDefault();
  };

  var eventHandler = {
    target: target,
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: fullscreenChangeEventhandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_fullscreenchange_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  if (!JSEvents.fullscreenEnabled()) return -1;
  target = __findEventTarget(target);
  if (!target) return -4;
  __registerFullscreenChangeEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    19,
    "fullscreenchange",
    targetThread
  );

  // Unprefixed Fullscreen API shipped in Chromium 71 (https://bugs.chromium.org/p/chromium/issues/detail?id=383813)
  // As of Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitfullscreenchange. TODO: revisit this check once Safari ships unprefixed version.
  __registerFullscreenChangeEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    19,
    "webkitfullscreenchange",
    targetThread
  );

  return 0;
}

function __registerGamepadEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.gamepadEvent) JSEvents.gamepadEvent = _malloc(1432);

  var gamepadEventHandlerFunc = function (ev) {
    var e = ev || event;

    var gamepadEvent = JSEvents.gamepadEvent;
    __fillGamepadEventData(gamepadEvent, e["gamepad"]);

    if (dynCall_iiii(callbackfunc, eventTypeId, gamepadEvent, userData))
      e.preventDefault();
  };

  var eventHandler = {
    target: __findEventTarget(target),
    allowsDeferredCalls: true,
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: gamepadEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_gamepadconnected_callback_on_thread(
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  if (!navigator.getGamepads && !navigator.webkitGetGamepads) return -1;
  __registerGamepadEventCallback(
    2,
    userData,
    useCapture,
    callbackfunc,
    26,
    "gamepadconnected",
    targetThread
  );
  return 0;
}

function _emscripten_set_gamepaddisconnected_callback_on_thread(
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  if (!navigator.getGamepads && !navigator.webkitGetGamepads) return -1;
  __registerGamepadEventCallback(
    2,
    userData,
    useCapture,
    callbackfunc,
    27,
    "gamepaddisconnected",
    targetThread
  );
  return 0;
}

function __registerKeyEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.keyEvent) JSEvents.keyEvent = _malloc(164);

  var keyEventHandlerFunc = function (ev) {
    var e = ev || event;

    var keyEventData = JSEvents.keyEvent;
    stringToUTF8(e.key ? e.key : "", keyEventData + 0, 32);
    stringToUTF8(e.code ? e.code : "", keyEventData + 32, 32);
    HEAP32[(keyEventData + 64) >> 2] = e.location;
    HEAP32[(keyEventData + 68) >> 2] = e.ctrlKey;
    HEAP32[(keyEventData + 72) >> 2] = e.shiftKey;
    HEAP32[(keyEventData + 76) >> 2] = e.altKey;
    HEAP32[(keyEventData + 80) >> 2] = e.metaKey;
    HEAP32[(keyEventData + 84) >> 2] = e.repeat;
    stringToUTF8(e.locale ? e.locale : "", keyEventData + 88, 32);
    stringToUTF8(e.char ? e.char : "", keyEventData + 120, 32);
    HEAP32[(keyEventData + 152) >> 2] = e.charCode;
    HEAP32[(keyEventData + 156) >> 2] = e.keyCode;
    HEAP32[(keyEventData + 160) >> 2] = e.which;

    if (dynCall_iiii(callbackfunc, eventTypeId, keyEventData, userData))
      e.preventDefault();
  };

  var eventHandler = {
    target: __findEventTarget(target),
    allowsDeferredCalls: true,
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: keyEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_keydown_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerKeyEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    2,
    "keydown",
    targetThread
  );
  return 0;
}

function _emscripten_set_keypress_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerKeyEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    1,
    "keypress",
    targetThread
  );
  return 0;
}

function _emscripten_set_keyup_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerKeyEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    3,
    "keyup",
    targetThread
  );
  return 0;
}

function __fillMouseEventData(eventStruct, e, target) {
  HEAP32[eventStruct >> 2] = e.screenX;
  HEAP32[(eventStruct + 4) >> 2] = e.screenY;
  HEAP32[(eventStruct + 8) >> 2] = e.clientX;
  HEAP32[(eventStruct + 12) >> 2] = e.clientY;
  HEAP32[(eventStruct + 16) >> 2] = e.ctrlKey;
  HEAP32[(eventStruct + 20) >> 2] = e.shiftKey;
  HEAP32[(eventStruct + 24) >> 2] = e.altKey;
  HEAP32[(eventStruct + 28) >> 2] = e.metaKey;
  HEAP16[(eventStruct + 32) >> 1] = e.button;
  HEAP16[(eventStruct + 34) >> 1] = e.buttons;
  var movementX = e["movementX"] || e.screenX - JSEvents.previousScreenX;
  var movementY = e["movementY"] || e.screenY - JSEvents.previousScreenY;
  HEAP32[(eventStruct + 36) >> 2] = movementX;
  HEAP32[(eventStruct + 40) >> 2] = movementY;

  var rect = __getBoundingClientRect(target);
  HEAP32[(eventStruct + 44) >> 2] = e.clientX - rect.left;
  HEAP32[(eventStruct + 48) >> 2] = e.clientY - rect.top;

  // wheel and mousewheel events contain wrong screenX/screenY on chrome/opera
  // https://github.com/emscripten-core/emscripten/pull/4997
  // https://bugs.chromium.org/p/chromium/issues/detail?id=699956
  if (e.type !== "wheel" && e.type !== "mousewheel") {
    JSEvents.previousScreenX = e.screenX;
    JSEvents.previousScreenY = e.screenY;
  }
}
function __registerMouseEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.mouseEvent) JSEvents.mouseEvent = _malloc(64);
  target = __findEventTarget(target);

  var mouseEventHandlerFunc = function (ev) {
    var e = ev || event;

    // TODO: Make this access thread safe, or this could update live while app is reading it.
    __fillMouseEventData(JSEvents.mouseEvent, e, target);

    if (dynCall_iiii(callbackfunc, eventTypeId, JSEvents.mouseEvent, userData))
      e.preventDefault();
  };

  var eventHandler = {
    target: target,
    allowsDeferredCalls:
      eventTypeString != "mousemove" &&
      eventTypeString != "mouseenter" &&
      eventTypeString != "mouseleave", // Mouse move events do not allow fullscreen/pointer lock requests to be handled in them!
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: mouseEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_mousedown_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerMouseEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    5,
    "mousedown",
    targetThread
  );
  return 0;
}

function _emscripten_set_mouseenter_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerMouseEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    33,
    "mouseenter",
    targetThread
  );
  return 0;
}

function _emscripten_set_mouseleave_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerMouseEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    34,
    "mouseleave",
    targetThread
  );
  return 0;
}

function _emscripten_set_mousemove_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerMouseEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    8,
    "mousemove",
    targetThread
  );
  return 0;
}

function _emscripten_set_mouseup_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerMouseEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    6,
    "mouseup",
    targetThread
  );
  return 0;
}

function __fillPointerlockChangeEventData(eventStruct) {
  var pointerLockElement =
    document.pointerLockElement ||
    document.mozPointerLockElement ||
    document.webkitPointerLockElement ||
    document.msPointerLockElement;
  var isPointerlocked = !!pointerLockElement;
  /** @suppress {checkTypes} */
  HEAP32[eventStruct >> 2] = isPointerlocked;
  var nodeName = JSEvents.getNodeNameForTarget(pointerLockElement);
  var id =
    pointerLockElement && pointerLockElement.id ? pointerLockElement.id : "";
  stringToUTF8(nodeName, eventStruct + 4, 128);
  stringToUTF8(id, eventStruct + 132, 128);
}
function __registerPointerlockChangeEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.pointerlockChangeEvent)
    JSEvents.pointerlockChangeEvent = _malloc(260);

  var pointerlockChangeEventHandlerFunc = function (ev) {
    var e = ev || event;

    var pointerlockChangeEvent = JSEvents.pointerlockChangeEvent;
    __fillPointerlockChangeEventData(pointerlockChangeEvent);

    if (
      dynCall_iiii(callbackfunc, eventTypeId, pointerlockChangeEvent, userData)
    )
      e.preventDefault();
  };

  var eventHandler = {
    target: target,
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: pointerlockChangeEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
} /** @suppress {missingProperties} */
function _emscripten_set_pointerlockchange_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  // TODO: Currently not supported in pthreads or in --proxy-to-worker mode. (In pthreads mode, document object is not defined)
  if (
    !document ||
    !document.body ||
    (!document.body.requestPointerLock &&
      !document.body.mozRequestPointerLock &&
      !document.body.webkitRequestPointerLock &&
      !document.body.msRequestPointerLock)
  ) {
    return -1;
  }

  target = __findEventTarget(target);
  if (!target) return -4;
  __registerPointerlockChangeEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    20,
    "pointerlockchange",
    targetThread
  );
  __registerPointerlockChangeEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    20,
    "mozpointerlockchange",
    targetThread
  );
  __registerPointerlockChangeEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    20,
    "webkitpointerlockchange",
    targetThread
  );
  __registerPointerlockChangeEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    20,
    "mspointerlockchange",
    targetThread
  );
  return 0;
}

function __registerUiEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.uiEvent) JSEvents.uiEvent = _malloc(36);

  target = __findEventTarget(target);

  var uiEventHandlerFunc = function (ev) {
    var e = ev || event;
    if (e.target != target) {
      // Never take ui events such as scroll via a 'bubbled' route, but always from the direct element that
      // was targeted. Otherwise e.g. if app logs a message in response to a page scroll, the Emscripten log
      // message box could cause to scroll, generating a new (bubbled) scroll message, causing a new log print,
      // causing a new scroll, etc..
      return;
    }
    var uiEvent = JSEvents.uiEvent;
    var b = document.body; // Take document.body to a variable, Closure compiler does not outline access to it on its own.
    HEAP32[uiEvent >> 2] = e.detail;
    HEAP32[(uiEvent + 4) >> 2] = b.clientWidth;
    HEAP32[(uiEvent + 8) >> 2] = b.clientHeight;
    HEAP32[(uiEvent + 12) >> 2] = innerWidth;
    HEAP32[(uiEvent + 16) >> 2] = innerHeight;
    HEAP32[(uiEvent + 20) >> 2] = outerWidth;
    HEAP32[(uiEvent + 24) >> 2] = outerHeight;
    HEAP32[(uiEvent + 28) >> 2] = pageXOffset;
    HEAP32[(uiEvent + 32) >> 2] = pageYOffset;
    if (dynCall_iiii(callbackfunc, eventTypeId, uiEvent, userData))
      e.preventDefault();
  };

  var eventHandler = {
    target: target,
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: uiEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_resize_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerUiEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    10,
    "resize",
    targetThread
  );
  return 0;
}

function __registerTouchEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.touchEvent) JSEvents.touchEvent = _malloc(1684);

  target = __findEventTarget(target);

  var touchEventHandlerFunc = function (ev) {
    var e = ev || event;

    var touches = {};
    for (var i = 0; i < e.touches.length; ++i) {
      var touch = e.touches[i];
      touch.changed = false;
      touches[touch.identifier] = touch;
    }
    for (var i = 0; i < e.changedTouches.length; ++i) {
      var touch = e.changedTouches[i];
      touches[touch.identifier] = touch;
      touch.changed = true;
    }
    for (var i = 0; i < e.targetTouches.length; ++i) {
      var touch = e.targetTouches[i];
      touches[touch.identifier].onTarget = true;
    }

    var touchEvent = JSEvents.touchEvent;
    var ptr = touchEvent;
    HEAP32[(ptr + 4) >> 2] = e.ctrlKey;
    HEAP32[(ptr + 8) >> 2] = e.shiftKey;
    HEAP32[(ptr + 12) >> 2] = e.altKey;
    HEAP32[(ptr + 16) >> 2] = e.metaKey;
    ptr += 20; // Advance to the start of the touch array.
    var targetRect = __getBoundingClientRect(target);
    var numTouches = 0;
    for (var i in touches) {
      var t = touches[i];
      HEAP32[ptr >> 2] = t.identifier;
      HEAP32[(ptr + 4) >> 2] = t.screenX;
      HEAP32[(ptr + 8) >> 2] = t.screenY;
      HEAP32[(ptr + 12) >> 2] = t.clientX;
      HEAP32[(ptr + 16) >> 2] = t.clientY;
      HEAP32[(ptr + 20) >> 2] = t.pageX;
      HEAP32[(ptr + 24) >> 2] = t.pageY;
      HEAP32[(ptr + 28) >> 2] = t.changed;
      HEAP32[(ptr + 32) >> 2] = t.onTarget;
      HEAP32[(ptr + 36) >> 2] = t.clientX - targetRect.left;
      HEAP32[(ptr + 40) >> 2] = t.clientY - targetRect.top;

      ptr += 52;

      if (++numTouches >= 32) {
        break;
      }
    }
    HEAP32[touchEvent >> 2] = numTouches;

    if (dynCall_iiii(callbackfunc, eventTypeId, touchEvent, userData))
      e.preventDefault();
  };

  var eventHandler = {
    target: target,
    allowsDeferredCalls:
      eventTypeString == "touchstart" || eventTypeString == "touchend",
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: touchEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_touchcancel_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerTouchEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    25,
    "touchcancel",
    targetThread
  );
  return 0;
}

function _emscripten_set_touchend_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerTouchEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    23,
    "touchend",
    targetThread
  );
  return 0;
}

function _emscripten_set_touchmove_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerTouchEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    24,
    "touchmove",
    targetThread
  );
  return 0;
}

function _emscripten_set_touchstart_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  __registerTouchEventCallback(
    target,
    userData,
    useCapture,
    callbackfunc,
    22,
    "touchstart",
    targetThread
  );
  return 0;
}

function __fillVisibilityChangeEventData(eventStruct) {
  var visibilityStates = ["hidden", "visible", "prerender", "unloaded"];
  var visibilityState = visibilityStates.indexOf(document.visibilityState);

  // Assigning a boolean to HEAP32 with expected type coercion.
  /** @suppress {checkTypes} */
  HEAP32[eventStruct >> 2] = document.hidden;
  HEAP32[(eventStruct + 4) >> 2] = visibilityState;
}
function __registerVisibilityChangeEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.visibilityChangeEvent)
    JSEvents.visibilityChangeEvent = _malloc(8);

  var visibilityChangeEventHandlerFunc = function (ev) {
    var e = ev || event;

    var visibilityChangeEvent = JSEvents.visibilityChangeEvent;

    __fillVisibilityChangeEventData(visibilityChangeEvent);

    if (
      dynCall_iiii(callbackfunc, eventTypeId, visibilityChangeEvent, userData)
    )
      e.preventDefault();
  };

  var eventHandler = {
    target: target,
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc: visibilityChangeEventHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_visibilitychange_callback_on_thread(
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  if (!__specialEventTargets[1]) {
    return -4;
  }
  __registerVisibilityChangeEventCallback(
    __specialEventTargets[1],
    userData,
    useCapture,
    callbackfunc,
    21,
    "visibilitychange",
    targetThread
  );
  return 0;
}

function __registerWheelEventCallback(
  target,
  userData,
  useCapture,
  callbackfunc,
  eventTypeId,
  eventTypeString,
  targetThread
) {
  if (!JSEvents.wheelEvent) JSEvents.wheelEvent = _malloc(96);

  // The DOM Level 3 events spec event 'wheel'
  var wheelHandlerFunc = function (ev) {
    var e = ev || event;
    var wheelEvent = JSEvents.wheelEvent;
    __fillMouseEventData(wheelEvent, e, target);
    HEAPF64[(wheelEvent + 64) >> 3] = e["deltaX"];
    HEAPF64[(wheelEvent + 72) >> 3] = e["deltaY"];
    HEAPF64[(wheelEvent + 80) >> 3] = e["deltaZ"];
    HEAP32[(wheelEvent + 88) >> 2] = e["deltaMode"];
    if (dynCall_iiii(callbackfunc, eventTypeId, wheelEvent, userData))
      e.preventDefault();
  };
  // The 'mousewheel' event as implemented in Safari 6.0.5
  var mouseWheelHandlerFunc = function (ev) {
    var e = ev || event;
    __fillMouseEventData(JSEvents.wheelEvent, e, target);
    HEAPF64[(JSEvents.wheelEvent + 64) >> 3] = e["wheelDeltaX"] || 0;
    /* 1. Invert to unify direction with the DOM Level 3 wheel event. 2. MSIE does not provide wheelDeltaY, so wheelDelta is used as a fallback. */
    var wheelDeltaY = -(e["wheelDeltaY"] || e["wheelDelta"]);
    HEAPF64[(JSEvents.wheelEvent + 72) >> 3] = wheelDeltaY;
    HEAPF64[(JSEvents.wheelEvent + 80) >> 3] = 0 /* Not available */;
    HEAP32[(JSEvents.wheelEvent + 88) >> 2] = 0 /* DOM_DELTA_PIXEL */;
    var shouldCancel = dynCall_iiii(
      callbackfunc,
      eventTypeId,
      JSEvents.wheelEvent,
      userData
    );
    if (shouldCancel) {
      e.preventDefault();
    }
  };

  var eventHandler = {
    target: target,
    allowsDeferredCalls: true,
    eventTypeString: eventTypeString,
    callbackfunc: callbackfunc,
    handlerFunc:
      eventTypeString == "wheel" ? wheelHandlerFunc : mouseWheelHandlerFunc,
    useCapture: useCapture,
  };
  JSEvents.registerOrRemoveHandler(eventHandler);
}
function _emscripten_set_wheel_callback_on_thread(
  target,
  userData,
  useCapture,
  callbackfunc,
  targetThread
) {
  target = __findEventTarget(target);
  if (typeof target.onwheel !== "undefined") {
    __registerWheelEventCallback(
      target,
      userData,
      useCapture,
      callbackfunc,
      9,
      "wheel",
      targetThread
    );
    return 0;
  } else if (typeof target.onmousewheel !== "undefined") {
    __registerWheelEventCallback(
      target,
      userData,
      useCapture,
      callbackfunc,
      9,
      "mousewheel",
      targetThread
    );
    return 0;
  } else {
    return -1;
  }
}

function _emscripten_sleep() {
  throw "Please compile your program with async support in order to use asynchronous operations like emscripten_sleep";
}

var ENV = {};

function __getExecutableName() {
  return thisProgram || "./this.program";
}
function _emscripten_get_environ() {
  if (!_emscripten_get_environ.strings) {
    // Default values.
    var env = {
      USER: "web_user",
      LOGNAME: "web_user",
      PATH: "/",
      PWD: "/",
      HOME: "/home/web_user",
      // Browser language detection #8751
      LANG:
        (
          (typeof navigator === "object" &&
            navigator.languages &&
            navigator.languages[0]) ||
          "C"
        ).replace("-", "_") + ".UTF-8",
      _: __getExecutableName(),
    };
    // Apply the user-provided values, if any.
    for (var x in ENV) {
      env[x] = ENV[x];
    }
    var strings = [];
    for (var x in env) {
      strings.push(x + "=" + env[x]);
    }
    _emscripten_get_environ.strings = strings;
  }
  return _emscripten_get_environ.strings;
}
function _environ_get(__environ, environ_buf) {
  var strings = _emscripten_get_environ();
  var bufSize = 0;
  strings.forEach(function (string, i) {
    var ptr = environ_buf + bufSize;
    HEAP32[(__environ + i * 4) >> 2] = ptr;
    writeAsciiToMemory(string, ptr);
    bufSize += string.length + 1;
  });
  return 0;
}

function _environ_sizes_get(penviron_count, penviron_buf_size) {
  var strings = _emscripten_get_environ();
  HEAP32[penviron_count >> 2] = strings.length;
  var bufSize = 0;
  strings.forEach(function (string) {
    bufSize += string.length + 1;
  });
  HEAP32[penviron_buf_size >> 2] = bufSize;
  return 0;
}

function _exit(status) {
  // void _exit(int status);
  // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
  exit(status);
}

function _fd_close(fd) {
  try {
    var stream = SYSCALLS.getStreamFromFD(fd);
    FS.close(stream);
    return 0;
  } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return e.errno;
  }
}

function _fd_read(fd, iov, iovcnt, pnum) {
  try {
    var stream = SYSCALLS.getStreamFromFD(fd);
    var num = SYSCALLS.doReadv(stream, iov, iovcnt);
    HEAP32[pnum >> 2] = num;
    return 0;
  } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return e.errno;
  }
}

function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
  try {
    var stream = SYSCALLS.getStreamFromFD(fd);
    var HIGH_OFFSET = 0x100000000; // 2^32
    // use an unsigned operator on low and shift high by 32-bits
    var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0);

    var DOUBLE_LIMIT = 0x20000000000000; // 2^53
    // we also check for equality since DOUBLE_LIMIT + 1 == DOUBLE_LIMIT
    if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) {
      return -61;
    }

    FS.llseek(stream, offset, whence);
    (tempI64 = [
      stream.position >>> 0,
      ((tempDouble = stream.position),
      +Math_abs(tempDouble) >= 1.0
        ? tempDouble > 0.0
          ? (Math_min(+Math_floor(tempDouble / 4294967296.0), 4294967295.0) |
              0) >>>
            0
          : ~~+Math_ceil(
              (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
            ) >>> 0
        : 0),
    ]),
      (HEAP32[newOffset >> 2] = tempI64[0]),
      (HEAP32[(newOffset + 4) >> 2] = tempI64[1]);
    if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state
    return 0;
  } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return e.errno;
  }
}

function _fd_write(fd, iov, iovcnt, pnum) {
  try {
    var stream = SYSCALLS.getStreamFromFD(fd);
    var num = SYSCALLS.doWritev(stream, iov, iovcnt);
    HEAP32[pnum >> 2] = num;
    return 0;
  } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return e.errno;
  }
}

function _gettimeofday(ptr) {
  var now = Date.now();
  HEAP32[ptr >> 2] = (now / 1000) | 0; // seconds
  HEAP32[(ptr + 4) >> 2] = ((now % 1000) * 1000) | 0; // microseconds
  return 0;
}

function _glActiveTexture(x0) {
  GLctx["activeTexture"](x0);
}

function _glAttachShader(program, shader) {
  GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
}

function _glBindBuffer(target, buffer) {
  GLctx.bindBuffer(target, GL.buffers[buffer]);
}

function _glBindTexture(target, texture) {
  GLctx.bindTexture(target, GL.textures[texture]);
}

function _glBlendFunc(x0, x1) {
  GLctx["blendFunc"](x0, x1);
}

function _glBufferData(target, size, data, usage) {
  // N.b. here first form specifies a heap subarray, second form an integer size, so the ?: code here is polymorphic. It is advised to avoid
  // randomly mixing both uses in calling code, to avoid any potential JS engine JIT issues.
  GLctx.bufferData(
    target,
    data ? HEAPU8.subarray(data, data + size) : size,
    usage
  );
}

function _glClear(x0) {
  GLctx["clear"](x0);
}

function _glClearColor(x0, x1, x2, x3) {
  GLctx["clearColor"](x0, x1, x2, x3);
}

function _glCompileShader(shader) {
  GLctx.compileShader(GL.shaders[shader]);
}

function _glCreateProgram() {
  var id = GL.getNewId(GL.programs);
  var program = GLctx.createProgram();
  program.name = id;
  GL.programs[id] = program;
  return id;
}

function _glCreateShader(shaderType) {
  var id = GL.getNewId(GL.shaders);
  GL.shaders[id] = GLctx.createShader(shaderType);
  return id;
}

function _glDepthFunc(x0) {
  GLctx["depthFunc"](x0);
}

function _glDepthMask(flag) {
  GLctx.depthMask(!!flag);
}

function _glDisable(x0) {
  GLctx["disable"](x0);
}

function _glDisableVertexAttribArray(index) {
  GLctx.disableVertexAttribArray(index);
}

function _glDrawArrays(mode, first, count) {
  GLctx.drawArrays(mode, first, count);
}

function _glEnable(x0) {
  GLctx["enable"](x0);
}

function _glEnableVertexAttribArray(index) {
  GLctx.enableVertexAttribArray(index);
}

function _glGenBuffers(n, buffers) {
  __glGenObject(n, buffers, "createBuffer", GL.buffers);
}

function _glGenTextures(n, textures) {
  __glGenObject(n, textures, "createTexture", GL.textures);
}

function _glGetAttribLocation(program, name) {
  return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
}

function _glGetShaderInfoLog(shader, maxLength, length, infoLog) {
  var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
  if (log === null) log = "(unknown error)";
  var numBytesWrittenExclNull =
    maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
  if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
}

function _glGetShaderiv(shader, pname, p) {
  if (!p) {
    // GLES2 specification does not specify how to behave if p is a null pointer. Since calling this function does not make sense
    // if p == null, issue a GL error to notify user about it.
    GL.recordError(0x501 /* GL_INVALID_VALUE */);
    return;
  }
  if (pname == 0x8b84) {
    // GL_INFO_LOG_LENGTH
    var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
    if (log === null) log = "(unknown error)";
    HEAP32[p >> 2] = log.length + 1;
  } else if (pname == 0x8b88) {
    // GL_SHADER_SOURCE_LENGTH
    var source = GLctx.getShaderSource(GL.shaders[shader]);
    var sourceLength =
      source === null || source.length == 0 ? 0 : source.length + 1;
    HEAP32[p >> 2] = sourceLength;
  } else {
    HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
  }
}

function _glGetUniformLocation(program, name) {
  name = UTF8ToString(name);

  var arrayIndex = 0;
  // If user passed an array accessor "[index]", parse the array index off the accessor.
  if (name[name.length - 1] == "]") {
    var leftBrace = name.lastIndexOf("[");
    arrayIndex =
      name[leftBrace + 1] != "]" ? jstoi_q(name.slice(leftBrace + 1)) : 0; // "index]", parseInt will ignore the ']' at the end; but treat "foo[]" as "foo[0]"
    name = name.slice(0, leftBrace);
  }

  var uniformInfo =
    GL.programInfos[program] && GL.programInfos[program].uniforms[name]; // returns pair [ dimension_of_uniform_array, uniform_location ]
  if (uniformInfo && arrayIndex >= 0 && arrayIndex < uniformInfo[0]) {
    // Check if user asked for an out-of-bounds element, i.e. for 'vec4 colors[3];' user could ask for 'colors[10]' which should return -1.
    return uniformInfo[1] + arrayIndex;
  } else {
    return -1;
  }
}

function _glLinkProgram(program) {
  GLctx.linkProgram(GL.programs[program]);
  GL.populateUniformTable(program);
}

function _glPolygonOffset(x0, x1) {
  GLctx["polygonOffset"](x0, x1);
}

function _glScissor(x0, x1, x2, x3) {
  GLctx["scissor"](x0, x1, x2, x3);
}

function _glShaderSource(shader, count, string, length) {
  var source = GL.getSource(shader, count, string, length);

  GLctx.shaderSource(GL.shaders[shader], source);
}

function _glTexImage2D(
  target,
  level,
  internalFormat,
  width,
  height,
  border,
  format,
  type,
  pixels
) {
  GLctx.texImage2D(
    target,
    level,
    internalFormat,
    width,
    height,
    border,
    format,
    type,
    pixels
      ? emscriptenWebGLGetTexPixelData(
          type,
          format,
          width,
          height,
          pixels,
          internalFormat
        )
      : null
  );
}

function _glTexParameteri(x0, x1, x2) {
  GLctx["texParameteri"](x0, x1, x2);
}

function _glUniform1i(location, v0) {
  GLctx.uniform1i(GL.uniforms[location], v0);
}

function _glUseProgram(program) {
  GLctx.useProgram(GL.programs[program]);
}

function _glVertexAttribPointer(index, size, type, normalized, stride, ptr) {
  GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
}

function _glViewport(x0, x1, x2, x3) {
  GLctx["viewport"](x0, x1, x2, x3);
}

function _usleep(useconds) {
  // int usleep(useconds_t useconds);
  // http://pubs.opengroup.org/onlinepubs/000095399/functions/usleep.html
  // We're single-threaded, so use a busy loop. Super-ugly.
  var start = _emscripten_get_now();
  while (_emscripten_get_now() - start < useconds / 1000) {
    // Do nothing.
  }
}
function _nanosleep(rqtp, rmtp) {
  // int nanosleep(const struct timespec  *rqtp, struct timespec *rmtp);
  if (rqtp === 0) {
    ___setErrNo(28);
    return -1;
  }
  var seconds = HEAP32[rqtp >> 2];
  var nanoseconds = HEAP32[(rqtp + 4) >> 2];
  if (nanoseconds < 0 || nanoseconds > 999999999 || seconds < 0) {
    ___setErrNo(28);
    return -1;
  }
  if (rmtp !== 0) {
    HEAP32[rmtp >> 2] = 0;
    HEAP32[(rmtp + 4) >> 2] = 0;
  }
  return _usleep(seconds * 1e6 + nanoseconds / 1000);
}

function _setTempRet0($i) {
  setTempRet0($i | 0);
}

function _sigaction(signum, act, oldact) {
  //int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
  err("Calling stub instead of sigaction()");
  return 0;
}

var __sigalrm_handler = 0;
function _signal(sig, func) {
  if (sig == 14 /*SIGALRM*/) {
    __sigalrm_handler = func;
  } else {
    err("Calling stub instead of signal()");
  }
  return 0;
}

function readAsmConstArgs(sigPtr, buf) {
  if (!readAsmConstArgs.array) {
    readAsmConstArgs.array = [];
  }
  var args = readAsmConstArgs.array;
  args.length = 0;
  var ch;
  while ((ch = HEAPU8[sigPtr++])) {
    if (ch === 100 /*'d'*/ || ch === 102 /*'f'*/) {
      buf = (buf + 7) & ~7;
      args.push(HEAPF64[buf >> 3]);
      buf += 8;
    } else if (ch === 105 /*'i'*/) {
      buf = (buf + 3) & ~3;
      args.push(HEAP32[buf >> 2]);
      buf += 4;
    } else abort("unexpected char in asm const signature " + ch);
  }
  return args;
}
var FSNode = /** @constructor */ function (parent, name, mode, rdev) {
  if (!parent) {
    parent = this; // root node sets parent to itself
  }
  this.parent = parent;
  this.mount = parent.mount;
  this.mounted = null;
  this.id = FS.nextInode++;
  this.name = name;
  this.mode = mode;
  this.node_ops = {};
  this.stream_ops = {};
  this.rdev = rdev;
};
var readMode = 292 /*292*/ | 73; /*73*/
var writeMode = 146; /*146*/
Object.defineProperties(FSNode.prototype, {
  read: {
    get: /** @this{FSNode} */ function () {
      return (this.mode & readMode) === readMode;
    },
    set: /** @this{FSNode} */ function (val) {
      val ? (this.mode |= readMode) : (this.mode &= ~readMode);
    },
  },
  write: {
    get: /** @this{FSNode} */ function () {
      return (this.mode & writeMode) === writeMode;
    },
    set: /** @this{FSNode} */ function (val) {
      val ? (this.mode |= writeMode) : (this.mode &= ~writeMode);
    },
  },
  isFolder: {
    get: /** @this{FSNode} */ function () {
      return FS.isDir(this.mode);
    },
  },
  isDevice: {
    get: /** @this{FSNode} */ function () {
      return FS.isChrdev(this.mode);
    },
  },
});
FS.FSNode = FSNode;
FS.staticInit();
Module["requestFullscreen"] = function Module_requestFullscreen(
  lockPointer,
  resizeCanvas
) {
  Browser.requestFullscreen(lockPointer, resizeCanvas);
};
Module["requestFullScreen"] = function Module_requestFullScreen() {
  Browser.requestFullScreen();
};
Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) {
  Browser.requestAnimationFrame(func);
};
Module["setCanvasSize"] = function Module_setCanvasSize(
  width,
  height,
  noUpdates
) {
  Browser.setCanvasSize(width, height, noUpdates);
};
Module["pauseMainLoop"] = function Module_pauseMainLoop() {
  Browser.mainLoop.pause();
};
Module["resumeMainLoop"] = function Module_resumeMainLoop() {
  Browser.mainLoop.resume();
};
Module["getUserMedia"] = function Module_getUserMedia() {
  Browser.getUserMedia();
};
Module["createContext"] = function Module_createContext(
  canvas,
  useWebGL,
  setInModule,
  webGLContextAttributes
) {
  return Browser.createContext(
    canvas,
    useWebGL,
    setInModule,
    webGLContextAttributes
  );
};
var GLctx;
GL.init();
for (var i = 0; i < 32; i++) __tempFixedLengthArray.push(new Array(i));
var ASSERTIONS = true;

// Copyright 2017 The Emscripten Authors.  All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License.  Both these licenses can be
// found in the LICENSE file.

/** @type {function(string, boolean=, number=)} */
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 > 0xff) {
      if (ASSERTIONS) {
        assert(
          false,
          "Character code " +
            chr +
            " (" +
            String.fromCharCode(chr) +
            ")  at offset " +
            i +
            " not in 0x00-0xFF."
        );
      }
      chr &= 0xff;
    }
    ret.push(String.fromCharCode(chr));
  }
  return ret.join("");
}

var asmGlobalArg = {};
var asmLibraryArg = {
  __assert_fail: ___assert_fail,
  __handle_stack_overflow: ___handle_stack_overflow,
  __syscall221: ___syscall221,
  __syscall5: ___syscall5,
  __syscall54: ___syscall54,
  abort: _abort,
  atexit: _atexit,
  clock_gettime: _clock_gettime,
  dlclose: _dlclose,
  dlerror: _dlerror,
  dlsym: _dlsym,
  eglBindAPI: _eglBindAPI,
  eglChooseConfig: _eglChooseConfig,
  eglCreateContext: _eglCreateContext,
  eglCreateWindowSurface: _eglCreateWindowSurface,
  eglDestroyContext: _eglDestroyContext,
  eglDestroySurface: _eglDestroySurface,
  eglGetConfigAttrib: _eglGetConfigAttrib,
  eglGetDisplay: _eglGetDisplay,
  eglGetError: _eglGetError,
  eglGetProcAddress: _eglGetProcAddress,
  eglInitialize: _eglInitialize,
  eglMakeCurrent: _eglMakeCurrent,
  eglQueryString: _eglQueryString,
  eglSwapBuffers: _eglSwapBuffers,
  eglSwapInterval: _eglSwapInterval,
  eglTerminate: _eglTerminate,
  eglWaitGL: _eglWaitGL,
  eglWaitNative: _eglWaitNative,
  emscripten_asm_const_iii: _emscripten_asm_const_iii,
  emscripten_exit_fullscreen: _emscripten_exit_fullscreen,
  emscripten_exit_pointerlock: _emscripten_exit_pointerlock,
  emscripten_get_device_pixel_ratio: _emscripten_get_device_pixel_ratio,
  emscripten_get_element_css_size: _emscripten_get_element_css_size,
  emscripten_get_gamepad_status: _emscripten_get_gamepad_status,
  emscripten_get_num_gamepads: _emscripten_get_num_gamepads,
  emscripten_get_sbrk_ptr: _emscripten_get_sbrk_ptr,
  emscripten_glActiveTexture: _emscripten_glActiveTexture,
  emscripten_glAttachShader: _emscripten_glAttachShader,
  emscripten_glBeginQueryEXT: _emscripten_glBeginQueryEXT,
  emscripten_glBindAttribLocation: _emscripten_glBindAttribLocation,
  emscripten_glBindBuffer: _emscripten_glBindBuffer,
  emscripten_glBindFramebuffer: _emscripten_glBindFramebuffer,
  emscripten_glBindRenderbuffer: _emscripten_glBindRenderbuffer,
  emscripten_glBindTexture: _emscripten_glBindTexture,
  emscripten_glBindVertexArrayOES: _emscripten_glBindVertexArrayOES,
  emscripten_glBlendColor: _emscripten_glBlendColor,
  emscripten_glBlendEquation: _emscripten_glBlendEquation,
  emscripten_glBlendEquationSeparate: _emscripten_glBlendEquationSeparate,
  emscripten_glBlendFunc: _emscripten_glBlendFunc,
  emscripten_glBlendFuncSeparate: _emscripten_glBlendFuncSeparate,
  emscripten_glBufferData: _emscripten_glBufferData,
  emscripten_glBufferSubData: _emscripten_glBufferSubData,
  emscripten_glCheckFramebufferStatus: _emscripten_glCheckFramebufferStatus,
  emscripten_glClear: _emscripten_glClear,
  emscripten_glClearColor: _emscripten_glClearColor,
  emscripten_glClearDepthf: _emscripten_glClearDepthf,
  emscripten_glClearStencil: _emscripten_glClearStencil,
  emscripten_glColorMask: _emscripten_glColorMask,
  emscripten_glCompileShader: _emscripten_glCompileShader,
  emscripten_glCompressedTexImage2D: _emscripten_glCompressedTexImage2D,
  emscripten_glCompressedTexSubImage2D: _emscripten_glCompressedTexSubImage2D,
  emscripten_glCopyTexImage2D: _emscripten_glCopyTexImage2D,
  emscripten_glCopyTexSubImage2D: _emscripten_glCopyTexSubImage2D,
  emscripten_glCreateProgram: _emscripten_glCreateProgram,
  emscripten_glCreateShader: _emscripten_glCreateShader,
  emscripten_glCullFace: _emscripten_glCullFace,
  emscripten_glDeleteBuffers: _emscripten_glDeleteBuffers,
  emscripten_glDeleteFramebuffers: _emscripten_glDeleteFramebuffers,
  emscripten_glDeleteProgram: _emscripten_glDeleteProgram,
  emscripten_glDeleteQueriesEXT: _emscripten_glDeleteQueriesEXT,
  emscripten_glDeleteRenderbuffers: _emscripten_glDeleteRenderbuffers,
  emscripten_glDeleteShader: _emscripten_glDeleteShader,
  emscripten_glDeleteTextures: _emscripten_glDeleteTextures,
  emscripten_glDeleteVertexArraysOES: _emscripten_glDeleteVertexArraysOES,
  emscripten_glDepthFunc: _emscripten_glDepthFunc,
  emscripten_glDepthMask: _emscripten_glDepthMask,
  emscripten_glDepthRangef: _emscripten_glDepthRangef,
  emscripten_glDetachShader: _emscripten_glDetachShader,
  emscripten_glDisable: _emscripten_glDisable,
  emscripten_glDisableVertexAttribArray: _emscripten_glDisableVertexAttribArray,
  emscripten_glDrawArrays: _emscripten_glDrawArrays,
  emscripten_glDrawArraysInstancedANGLE: _emscripten_glDrawArraysInstancedANGLE,
  emscripten_glDrawBuffersWEBGL: _emscripten_glDrawBuffersWEBGL,
  emscripten_glDrawElements: _emscripten_glDrawElements,
  emscripten_glDrawElementsInstancedANGLE:
    _emscripten_glDrawElementsInstancedANGLE,
  emscripten_glEnable: _emscripten_glEnable,
  emscripten_glEnableVertexAttribArray: _emscripten_glEnableVertexAttribArray,
  emscripten_glEndQueryEXT: _emscripten_glEndQueryEXT,
  emscripten_glFinish: _emscripten_glFinish,
  emscripten_glFlush: _emscripten_glFlush,
  emscripten_glFramebufferRenderbuffer: _emscripten_glFramebufferRenderbuffer,
  emscripten_glFramebufferTexture2D: _emscripten_glFramebufferTexture2D,
  emscripten_glFrontFace: _emscripten_glFrontFace,
  emscripten_glGenBuffers: _emscripten_glGenBuffers,
  emscripten_glGenFramebuffers: _emscripten_glGenFramebuffers,
  emscripten_glGenQueriesEXT: _emscripten_glGenQueriesEXT,
  emscripten_glGenRenderbuffers: _emscripten_glGenRenderbuffers,
  emscripten_glGenTextures: _emscripten_glGenTextures,
  emscripten_glGenVertexArraysOES: _emscripten_glGenVertexArraysOES,
  emscripten_glGenerateMipmap: _emscripten_glGenerateMipmap,
  emscripten_glGetActiveAttrib: _emscripten_glGetActiveAttrib,
  emscripten_glGetActiveUniform: _emscripten_glGetActiveUniform,
  emscripten_glGetAttachedShaders: _emscripten_glGetAttachedShaders,
  emscripten_glGetAttribLocation: _emscripten_glGetAttribLocation,
  emscripten_glGetBooleanv: _emscripten_glGetBooleanv,
  emscripten_glGetBufferParameteriv: _emscripten_glGetBufferParameteriv,
  emscripten_glGetError: _emscripten_glGetError,
  emscripten_glGetFloatv: _emscripten_glGetFloatv,
  emscripten_glGetFramebufferAttachmentParameteriv:
    _emscripten_glGetFramebufferAttachmentParameteriv,
  emscripten_glGetIntegerv: _emscripten_glGetIntegerv,
  emscripten_glGetProgramInfoLog: _emscripten_glGetProgramInfoLog,
  emscripten_glGetProgramiv: _emscripten_glGetProgramiv,
  emscripten_glGetQueryObjecti64vEXT: _emscripten_glGetQueryObjecti64vEXT,
  emscripten_glGetQueryObjectivEXT: _emscripten_glGetQueryObjectivEXT,
  emscripten_glGetQueryObjectui64vEXT: _emscripten_glGetQueryObjectui64vEXT,
  emscripten_glGetQueryObjectuivEXT: _emscripten_glGetQueryObjectuivEXT,
  emscripten_glGetQueryivEXT: _emscripten_glGetQueryivEXT,
  emscripten_glGetRenderbufferParameteriv:
    _emscripten_glGetRenderbufferParameteriv,
  emscripten_glGetShaderInfoLog: _emscripten_glGetShaderInfoLog,
  emscripten_glGetShaderPrecisionFormat: _emscripten_glGetShaderPrecisionFormat,
  emscripten_glGetShaderSource: _emscripten_glGetShaderSource,
  emscripten_glGetShaderiv: _emscripten_glGetShaderiv,
  emscripten_glGetString: _emscripten_glGetString,
  emscripten_glGetTexParameterfv: _emscripten_glGetTexParameterfv,
  emscripten_glGetTexParameteriv: _emscripten_glGetTexParameteriv,
  emscripten_glGetUniformLocation: _emscripten_glGetUniformLocation,
  emscripten_glGetUniformfv: _emscripten_glGetUniformfv,
  emscripten_glGetUniformiv: _emscripten_glGetUniformiv,
  emscripten_glGetVertexAttribPointerv: _emscripten_glGetVertexAttribPointerv,
  emscripten_glGetVertexAttribfv: _emscripten_glGetVertexAttribfv,
  emscripten_glGetVertexAttribiv: _emscripten_glGetVertexAttribiv,
  emscripten_glHint: _emscripten_glHint,
  emscripten_glIsBuffer: _emscripten_glIsBuffer,
  emscripten_glIsEnabled: _emscripten_glIsEnabled,
  emscripten_glIsFramebuffer: _emscripten_glIsFramebuffer,
  emscripten_glIsProgram: _emscripten_glIsProgram,
  emscripten_glIsQueryEXT: _emscripten_glIsQueryEXT,
  emscripten_glIsRenderbuffer: _emscripten_glIsRenderbuffer,
  emscripten_glIsShader: _emscripten_glIsShader,
  emscripten_glIsTexture: _emscripten_glIsTexture,
  emscripten_glIsVertexArrayOES: _emscripten_glIsVertexArrayOES,
  emscripten_glLineWidth: _emscripten_glLineWidth,
  emscripten_glLinkProgram: _emscripten_glLinkProgram,
  emscripten_glPixelStorei: _emscripten_glPixelStorei,
  emscripten_glPolygonOffset: _emscripten_glPolygonOffset,
  emscripten_glQueryCounterEXT: _emscripten_glQueryCounterEXT,
  emscripten_glReadPixels: _emscripten_glReadPixels,
  emscripten_glReleaseShaderCompiler: _emscripten_glReleaseShaderCompiler,
  emscripten_glRenderbufferStorage: _emscripten_glRenderbufferStorage,
  emscripten_glSampleCoverage: _emscripten_glSampleCoverage,
  emscripten_glScissor: _emscripten_glScissor,
  emscripten_glShaderBinary: _emscripten_glShaderBinary,
  emscripten_glShaderSource: _emscripten_glShaderSource,
  emscripten_glStencilFunc: _emscripten_glStencilFunc,
  emscripten_glStencilFuncSeparate: _emscripten_glStencilFuncSeparate,
  emscripten_glStencilMask: _emscripten_glStencilMask,
  emscripten_glStencilMaskSeparate: _emscripten_glStencilMaskSeparate,
  emscripten_glStencilOp: _emscripten_glStencilOp,
  emscripten_glStencilOpSeparate: _emscripten_glStencilOpSeparate,
  emscripten_glTexImage2D: _emscripten_glTexImage2D,
  emscripten_glTexParameterf: _emscripten_glTexParameterf,
  emscripten_glTexParameterfv: _emscripten_glTexParameterfv,
  emscripten_glTexParameteri: _emscripten_glTexParameteri,
  emscripten_glTexParameteriv: _emscripten_glTexParameteriv,
  emscripten_glTexSubImage2D: _emscripten_glTexSubImage2D,
  emscripten_glUniform1f: _emscripten_glUniform1f,
  emscripten_glUniform1fv: _emscripten_glUniform1fv,
  emscripten_glUniform1i: _emscripten_glUniform1i,
  emscripten_glUniform1iv: _emscripten_glUniform1iv,
  emscripten_glUniform2f: _emscripten_glUniform2f,
  emscripten_glUniform2fv: _emscripten_glUniform2fv,
  emscripten_glUniform2i: _emscripten_glUniform2i,
  emscripten_glUniform2iv: _emscripten_glUniform2iv,
  emscripten_glUniform3f: _emscripten_glUniform3f,
  emscripten_glUniform3fv: _emscripten_glUniform3fv,
  emscripten_glUniform3i: _emscripten_glUniform3i,
  emscripten_glUniform3iv: _emscripten_glUniform3iv,
  emscripten_glUniform4f: _emscripten_glUniform4f,
  emscripten_glUniform4fv: _emscripten_glUniform4fv,
  emscripten_glUniform4i: _emscripten_glUniform4i,
  emscripten_glUniform4iv: _emscripten_glUniform4iv,
  emscripten_glUniformMatrix2fv: _emscripten_glUniformMatrix2fv,
  emscripten_glUniformMatrix3fv: _emscripten_glUniformMatrix3fv,
  emscripten_glUniformMatrix4fv: _emscripten_glUniformMatrix4fv,
  emscripten_glUseProgram: _emscripten_glUseProgram,
  emscripten_glValidateProgram: _emscripten_glValidateProgram,
  emscripten_glVertexAttrib1f: _emscripten_glVertexAttrib1f,
  emscripten_glVertexAttrib1fv: _emscripten_glVertexAttrib1fv,
  emscripten_glVertexAttrib2f: _emscripten_glVertexAttrib2f,
  emscripten_glVertexAttrib2fv: _emscripten_glVertexAttrib2fv,
  emscripten_glVertexAttrib3f: _emscripten_glVertexAttrib3f,
  emscripten_glVertexAttrib3fv: _emscripten_glVertexAttrib3fv,
  emscripten_glVertexAttrib4f: _emscripten_glVertexAttrib4f,
  emscripten_glVertexAttrib4fv: _emscripten_glVertexAttrib4fv,
  emscripten_glVertexAttribDivisorANGLE: _emscripten_glVertexAttribDivisorANGLE,
  emscripten_glVertexAttribPointer: _emscripten_glVertexAttribPointer,
  emscripten_glViewport: _emscripten_glViewport,
  emscripten_has_asyncify: _emscripten_has_asyncify,
  emscripten_memcpy_big: _emscripten_memcpy_big,
  emscripten_request_fullscreen_strategy:
    _emscripten_request_fullscreen_strategy,
  emscripten_request_pointerlock: _emscripten_request_pointerlock,
  emscripten_resize_heap: _emscripten_resize_heap,
  emscripten_sample_gamepad_data: _emscripten_sample_gamepad_data,
  emscripten_set_beforeunload_callback_on_thread:
    _emscripten_set_beforeunload_callback_on_thread,
  emscripten_set_blur_callback_on_thread:
    _emscripten_set_blur_callback_on_thread,
  emscripten_set_canvas_element_size: _emscripten_set_canvas_element_size,
  emscripten_set_element_css_size: _emscripten_set_element_css_size,
  emscripten_set_focus_callback_on_thread:
    _emscripten_set_focus_callback_on_thread,
  emscripten_set_fullscreenchange_callback_on_thread:
    _emscripten_set_fullscreenchange_callback_on_thread,
  emscripten_set_gamepadconnected_callback_on_thread:
    _emscripten_set_gamepadconnected_callback_on_thread,
  emscripten_set_gamepaddisconnected_callback_on_thread:
    _emscripten_set_gamepaddisconnected_callback_on_thread,
  emscripten_set_keydown_callback_on_thread:
    _emscripten_set_keydown_callback_on_thread,
  emscripten_set_keypress_callback_on_thread:
    _emscripten_set_keypress_callback_on_thread,
  emscripten_set_keyup_callback_on_thread:
    _emscripten_set_keyup_callback_on_thread,
  emscripten_set_main_loop: _emscripten_set_main_loop,
  emscripten_set_mousedown_callback_on_thread:
    _emscripten_set_mousedown_callback_on_thread,
  emscripten_set_mouseenter_callback_on_thread:
    _emscripten_set_mouseenter_callback_on_thread,
  emscripten_set_mouseleave_callback_on_thread:
    _emscripten_set_mouseleave_callback_on_thread,
  emscripten_set_mousemove_callback_on_thread:
    _emscripten_set_mousemove_callback_on_thread,
  emscripten_set_mouseup_callback_on_thread:
    _emscripten_set_mouseup_callback_on_thread,
  emscripten_set_pointerlockchange_callback_on_thread:
    _emscripten_set_pointerlockchange_callback_on_thread,
  emscripten_set_resize_callback_on_thread:
    _emscripten_set_resize_callback_on_thread,
  emscripten_set_touchcancel_callback_on_thread:
    _emscripten_set_touchcancel_callback_on_thread,
  emscripten_set_touchend_callback_on_thread:
    _emscripten_set_touchend_callback_on_thread,
  emscripten_set_touchmove_callback_on_thread:
    _emscripten_set_touchmove_callback_on_thread,
  emscripten_set_touchstart_callback_on_thread:
    _emscripten_set_touchstart_callback_on_thread,
  emscripten_set_visibilitychange_callback_on_thread:
    _emscripten_set_visibilitychange_callback_on_thread,
  emscripten_set_wheel_callback_on_thread:
    _emscripten_set_wheel_callback_on_thread,
  emscripten_sleep: _emscripten_sleep,
  environ_get: _environ_get,
  environ_sizes_get: _environ_sizes_get,
  exit: _exit,
  fd_close: _fd_close,
  fd_read: _fd_read,
  fd_seek: _fd_seek,
  fd_write: _fd_write,
  gettimeofday: _gettimeofday,
  glActiveTexture: _glActiveTexture,
  glAttachShader: _glAttachShader,
  glBindBuffer: _glBindBuffer,
  glBindTexture: _glBindTexture,
  glBlendFunc: _glBlendFunc,
  glBufferData: _glBufferData,
  glClear: _glClear,
  glClearColor: _glClearColor,
  glCompileShader: _glCompileShader,
  glCreateProgram: _glCreateProgram,
  glCreateShader: _glCreateShader,
  glDepthFunc: _glDepthFunc,
  glDepthMask: _glDepthMask,
  glDisable: _glDisable,
  glDisableVertexAttribArray: _glDisableVertexAttribArray,
  glDrawArrays: _glDrawArrays,
  glEnable: _glEnable,
  glEnableVertexAttribArray: _glEnableVertexAttribArray,
  glGenBuffers: _glGenBuffers,
  glGenTextures: _glGenTextures,
  glGetAttribLocation: _glGetAttribLocation,
  glGetShaderInfoLog: _glGetShaderInfoLog,
  glGetShaderiv: _glGetShaderiv,
  glGetUniformLocation: _glGetUniformLocation,
  glLinkProgram: _glLinkProgram,
  glPolygonOffset: _glPolygonOffset,
  glScissor: _glScissor,
  glShaderSource: _glShaderSource,
  glTexImage2D: _glTexImage2D,
  glTexParameteri: _glTexParameteri,
  glUniform1i: _glUniform1i,
  glUseProgram: _glUseProgram,
  glVertexAttribPointer: _glVertexAttribPointer,
  glViewport: _glViewport,
  memory: wasmMemory,
  nanosleep: _nanosleep,
  setTempRet0: _setTempRet0,
  sigaction: _sigaction,
  signal: _signal,
  table: wasmTable,
};
var asm = createWasm();
Module["asm"] = asm;
/** @type {function(...*):?} */
var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["__wasm_call_ctors"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _memcpy = (Module["_memcpy"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["memcpy"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _memset = (Module["_memset"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["memset"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _malloc = (Module["_malloc"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["malloc"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _free = (Module["_free"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["free"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _main = (Module["_main"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["main"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _strstr = (Module["_strstr"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["strstr"].apply(null, arguments);
});

/** @type {function(...*):?} */
var ___errno_location = (Module["___errno_location"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["__errno_location"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _fflush = (Module["_fflush"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["fflush"].apply(null, arguments);
});

/** @type {function(...*):?} */
var _emscripten_GetProcAddress = (Module["_emscripten_GetProcAddress"] =
  function () {
    assert(
      runtimeInitialized,
      "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
    );
    assert(
      !runtimeExited,
      "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
    );
    return Module["asm"]["emscripten_GetProcAddress"].apply(null, arguments);
  });

/** @type {function(...*):?} */
var ___set_stack_limit = (Module["___set_stack_limit"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["__set_stack_limit"].apply(null, arguments);
});

/** @type {function(...*):?} */
var stackSave = (Module["stackSave"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["stackSave"].apply(null, arguments);
});

/** @type {function(...*):?} */
var stackAlloc = (Module["stackAlloc"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["stackAlloc"].apply(null, arguments);
});

/** @type {function(...*):?} */
var stackRestore = (Module["stackRestore"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["stackRestore"].apply(null, arguments);
});

/** @type {function(...*):?} */
var __growWasmMemory = (Module["__growWasmMemory"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["__growWasmMemory"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_i = (Module["dynCall_i"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_i"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_v = (Module["dynCall_v"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_v"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iiii = (Module["dynCall_iiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vi = (Module["dynCall_vi"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vi"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iii = (Module["dynCall_iii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vd = (Module["dynCall_vd"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vd"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_ii = (Module["dynCall_ii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_ii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viii = (Module["dynCall_viii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vii = (Module["dynCall_vii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viiii = (Module["dynCall_viiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_d = (Module["dynCall_d"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_d"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iiiii = (Module["dynCall_iiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iiiiii = (Module["dynCall_iiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_jiji = (Module["dynCall_jiji"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_jiji"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_ji = (Module["dynCall_ji"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_ji"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iiiiidii = (Module["dynCall_iiiiidii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iiiiidii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iiiiiiiiii = (Module["dynCall_iiiiiiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iiiiiiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iiiiiiiii = (Module["dynCall_iiiiiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iiiiiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viiiiiii = (Module["dynCall_viiiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viiiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viiiiiiiiiii = (Module["dynCall_viiiiiiiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viiiiiiiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iiiiiiii = (Module["dynCall_iiiiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iiiiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_iidiiii = (Module["dynCall_iidiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_iidiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viiiii = (Module["dynCall_viiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vffff = (Module["dynCall_vffff"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vffff"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vf = (Module["dynCall_vf"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vf"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viiiiiiii = (Module["dynCall_viiiiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viiiiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viiiiiiiii = (Module["dynCall_viiiiiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viiiiiiiii"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vff = (Module["dynCall_vff"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vff"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vfi = (Module["dynCall_vfi"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vfi"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viif = (Module["dynCall_viif"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viif"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vif = (Module["dynCall_vif"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vif"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viff = (Module["dynCall_viff"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viff"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_vifff = (Module["dynCall_vifff"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_vifff"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viffff = (Module["dynCall_viffff"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viffff"].apply(null, arguments);
});

/** @type {function(...*):?} */
var dynCall_viiiiii = (Module["dynCall_viiiiii"] = function () {
  assert(
    runtimeInitialized,
    "you need to wait for the runtime to be ready (e.g. wait for main() to be called)"
  );
  assert(
    !runtimeExited,
    "the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"
  );
  return Module["asm"]["dynCall_viiiiii"].apply(null, arguments);
});

// === Auto-generated postamble setup entry stuff ===

Module["asm"] = asm;

if (!Object.getOwnPropertyDescriptor(Module, "intArrayFromString"))
  Module["intArrayFromString"] = function () {
    abort(
      "'intArrayFromString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "intArrayToString"))
  Module["intArrayToString"] = function () {
    abort(
      "'intArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "ccall"))
  Module["ccall"] = function () {
    abort(
      "'ccall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "cwrap"))
  Module["cwrap"] = function () {
    abort(
      "'cwrap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "setValue"))
  Module["setValue"] = function () {
    abort(
      "'setValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "getValue"))
  Module["getValue"] = function () {
    abort(
      "'getValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "allocate"))
  Module["allocate"] = function () {
    abort(
      "'allocate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "getMemory"))
  Module["getMemory"] = function () {
    abort(
      "'getMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString"))
  Module["UTF8ArrayToString"] = function () {
    abort(
      "'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString"))
  Module["UTF8ToString"] = function () {
    abort(
      "'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array"))
  Module["stringToUTF8Array"] = function () {
    abort(
      "'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8"))
  Module["stringToUTF8"] = function () {
    abort(
      "'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8"))
  Module["lengthBytesUTF8"] = function () {
    abort(
      "'lengthBytesUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace"))
  Module["stackTrace"] = function () {
    abort(
      "'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun"))
  Module["addOnPreRun"] = function () {
    abort(
      "'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "addOnInit"))
  Module["addOnInit"] = function () {
    abort(
      "'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain"))
  Module["addOnPreMain"] = function () {
    abort(
      "'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "addOnExit"))
  Module["addOnExit"] = function () {
    abort(
      "'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun"))
  Module["addOnPostRun"] = function () {
    abort(
      "'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory"))
  Module["writeStringToMemory"] = function () {
    abort(
      "'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeArrayToMemory"))
  Module["writeArrayToMemory"] = function () {
    abort(
      "'writeArrayToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory"))
  Module["writeAsciiToMemory"] = function () {
    abort(
      "'writeAsciiToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "addRunDependency"))
  Module["addRunDependency"] = function () {
    abort(
      "'addRunDependency' was not exported. add it to EXTRA_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"] = function () {
    abort(
      "'removeRunDependency' was not exported. add it to EXTRA_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"] = function () {
    abort(
      "'FS_createFolder' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "FS_createPath"))
  Module["FS_createPath"] = function () {
    abort(
      "'FS_createPath' was not exported. add it to EXTRA_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"] = function () {
    abort(
      "'FS_createDataFile' was not exported. add it to EXTRA_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"] = function () {
    abort(
      "'FS_createPreloadedFile' was not exported. add it to EXTRA_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"] = function () {
    abort(
      "'FS_createLazyFile' was not exported. add it to EXTRA_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"] = function () {
    abort(
      "'FS_createLink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "FS_createDevice"))
  Module["FS_createDevice"] = function () {
    abort(
      "'FS_createDevice' was not exported. add it to EXTRA_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"] = function () {
    abort(
      "'FS_unlink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "dynamicAlloc"))
  Module["dynamicAlloc"] = function () {
    abort(
      "'dynamicAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "loadDynamicLibrary"))
  Module["loadDynamicLibrary"] = function () {
    abort(
      "'loadDynamicLibrary' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "loadWebAssemblyModule"))
  Module["loadWebAssemblyModule"] = function () {
    abort(
      "'loadWebAssemblyModule' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "getLEB"))
  Module["getLEB"] = function () {
    abort(
      "'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables"))
  Module["getFunctionTables"] = function () {
    abort(
      "'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables"))
  Module["alignFunctionTables"] = function () {
    abort(
      "'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions"))
  Module["registerFunctions"] = function () {
    abort(
      "'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "addFunction"))
  Module["addFunction"] = function () {
    abort(
      "'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "removeFunction"))
  Module["removeFunction"] = function () {
    abort(
      "'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper"))
  Module["getFuncWrapper"] = function () {
    abort(
      "'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint"))
  Module["prettyPrint"] = function () {
    abort(
      "'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "makeBigInt"))
  Module["makeBigInt"] = function () {
    abort(
      "'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "dynCall"))
  Module["dynCall"] = function () {
    abort(
      "'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting"))
  Module["getCompilerSetting"] = function () {
    abort(
      "'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "print"))
  Module["print"] = function () {
    abort(
      "'print' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "printErr"))
  Module["printErr"] = function () {
    abort(
      "'printErr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0"))
  Module["getTempRet0"] = function () {
    abort(
      "'getTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0"))
  Module["setTempRet0"] = function () {
    abort(
      "'setTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
Module["callMain"] = callMain;
if (!Object.getOwnPropertyDescriptor(Module, "abort"))
  Module["abort"] = function () {
    abort(
      "'abort' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stringToNewUTF8"))
  Module["stringToNewUTF8"] = function () {
    abort(
      "'stringToNewUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "abortOnCannotGrowMemory"))
  Module["abortOnCannotGrowMemory"] = function () {
    abort(
      "'abortOnCannotGrowMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "emscripten_realloc_buffer"))
  Module["emscripten_realloc_buffer"] = function () {
    abort(
      "'emscripten_realloc_buffer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "ENV"))
  Module["ENV"] = function () {
    abort(
      "'ENV' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "setjmpId"))
  Module["setjmpId"] = function () {
    abort(
      "'setjmpId' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_CODES"))
  Module["ERRNO_CODES"] = function () {
    abort(
      "'ERRNO_CODES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_MESSAGES"))
  Module["ERRNO_MESSAGES"] = function () {
    abort(
      "'ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "DNS"))
  Module["DNS"] = function () {
    abort(
      "'DNS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "GAI_ERRNO_MESSAGES"))
  Module["GAI_ERRNO_MESSAGES"] = function () {
    abort(
      "'GAI_ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "Protocols"))
  Module["Protocols"] = function () {
    abort(
      "'Protocols' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "Sockets"))
  Module["Sockets"] = function () {
    abort(
      "'Sockets' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "UNWIND_CACHE"))
  Module["UNWIND_CACHE"] = function () {
    abort(
      "'UNWIND_CACHE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgs"))
  Module["readAsmConstArgs"] = function () {
    abort(
      "'readAsmConstArgs' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_q"))
  Module["jstoi_q"] = function () {
    abort(
      "'jstoi_q' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_s"))
  Module["jstoi_s"] = function () {
    abort(
      "'jstoi_s' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "PATH"))
  Module["PATH"] = function () {
    abort(
      "'PATH' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "PATH_FS"))
  Module["PATH_FS"] = function () {
    abort(
      "'PATH_FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "SYSCALLS"))
  Module["SYSCALLS"] = function () {
    abort(
      "'SYSCALLS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "syscallMmap2"))
  Module["syscallMmap2"] = function () {
    abort(
      "'syscallMmap2' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "syscallMunmap"))
  Module["syscallMunmap"] = function () {
    abort(
      "'syscallMunmap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "JSEvents"))
  Module["JSEvents"] = function () {
    abort(
      "'JSEvents' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "demangle"))
  Module["demangle"] = function () {
    abort(
      "'demangle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "demangleAll"))
  Module["demangleAll"] = function () {
    abort(
      "'demangleAll' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "jsStackTrace"))
  Module["jsStackTrace"] = function () {
    abort(
      "'jsStackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace"))
  Module["stackTrace"] = function () {
    abort(
      "'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64"))
  Module["writeI53ToI64"] = function () {
    abort(
      "'writeI53ToI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Clamped"))
  Module["writeI53ToI64Clamped"] = function () {
    abort(
      "'writeI53ToI64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Signaling"))
  Module["writeI53ToI64Signaling"] = function () {
    abort(
      "'writeI53ToI64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Clamped"))
  Module["writeI53ToU64Clamped"] = function () {
    abort(
      "'writeI53ToU64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Signaling"))
  Module["writeI53ToU64Signaling"] = function () {
    abort(
      "'writeI53ToU64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromI64"))
  Module["readI53FromI64"] = function () {
    abort(
      "'readI53FromI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromU64"))
  Module["readI53FromU64"] = function () {
    abort(
      "'readI53FromU64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "convertI32PairToI53"))
  Module["convertI32PairToI53"] = function () {
    abort(
      "'convertI32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "convertU32PairToI53"))
  Module["convertU32PairToI53"] = function () {
    abort(
      "'convertU32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "Browser"))
  Module["Browser"] = function () {
    abort(
      "'Browser' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "FS"))
  Module["FS"] = function () {
    abort(
      "'FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "MEMFS"))
  Module["MEMFS"] = function () {
    abort(
      "'MEMFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "TTY"))
  Module["TTY"] = function () {
    abort(
      "'TTY' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "PIPEFS"))
  Module["PIPEFS"] = function () {
    abort(
      "'PIPEFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "SOCKFS"))
  Module["SOCKFS"] = function () {
    abort(
      "'SOCKFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "GL"))
  Module["GL"] = function () {
    abort(
      "'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGet"))
  Module["emscriptenWebGLGet"] = function () {
    abort(
      "'emscriptenWebGLGet' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetTexPixelData"))
  Module["emscriptenWebGLGetTexPixelData"] = function () {
    abort(
      "'emscriptenWebGLGetTexPixelData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetUniform"))
  Module["emscriptenWebGLGetUniform"] = function () {
    abort(
      "'emscriptenWebGLGetUniform' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetVertexAttrib"))
  Module["emscriptenWebGLGetVertexAttrib"] = function () {
    abort(
      "'emscriptenWebGLGetVertexAttrib' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "AL"))
  Module["AL"] = function () {
    abort(
      "'AL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "SDL"))
  Module["SDL"] = function () {
    abort(
      "'SDL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "SDL_gfx"))
  Module["SDL_gfx"] = function () {
    abort(
      "'SDL_gfx' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "GLUT"))
  Module["GLUT"] = function () {
    abort(
      "'GLUT' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "EGL"))
  Module["EGL"] = function () {
    abort(
      "'EGL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "GLFW_Window"))
  Module["GLFW_Window"] = function () {
    abort(
      "'GLFW_Window' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "GLFW"))
  Module["GLFW"] = function () {
    abort(
      "'GLFW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "GLEW"))
  Module["GLEW"] = function () {
    abort(
      "'GLEW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "IDBStore"))
  Module["IDBStore"] = function () {
    abort(
      "'IDBStore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "runAndAbortIfError"))
  Module["runAndAbortIfError"] = function () {
    abort(
      "'runAndAbortIfError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "warnOnce"))
  Module["warnOnce"] = function () {
    abort(
      "'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stackSave"))
  Module["stackSave"] = function () {
    abort(
      "'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stackRestore"))
  Module["stackRestore"] = function () {
    abort(
      "'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc"))
  Module["stackAlloc"] = function () {
    abort(
      "'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString"))
  Module["AsciiToString"] = function () {
    abort(
      "'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii"))
  Module["stringToAscii"] = function () {
    abort(
      "'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "UTF16ToString"))
  Module["UTF16ToString"] = function () {
    abort(
      "'UTF16ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF16"))
  Module["stringToUTF16"] = function () {
    abort(
      "'stringToUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16"))
  Module["lengthBytesUTF16"] = function () {
    abort(
      "'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString"))
  Module["UTF32ToString"] = function () {
    abort(
      "'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32"))
  Module["stringToUTF32"] = function () {
    abort(
      "'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32"))
  Module["lengthBytesUTF32"] = function () {
    abort(
      "'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8"))
  Module["allocateUTF8"] = function () {
    abort(
      "'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8OnStack"))
  Module["allocateUTF8OnStack"] = function () {
    abort(
      "'allocateUTF8OnStack' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
    );
  };
Module["writeStackCookie"] = writeStackCookie;
Module["checkStackCookie"] = checkStackCookie;
Module["abortStackOverflow"] = abortStackOverflow;
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NORMAL"))
  Object.defineProperty(Module, "ALLOC_NORMAL", {
    configurable: true,
    get: function () {
      abort(
        "'ALLOC_NORMAL' was not exported. add it to EXTRA_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 EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
      );
    },
  });
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_DYNAMIC"))
  Object.defineProperty(Module, "ALLOC_DYNAMIC", {
    configurable: true,
    get: function () {
      abort(
        "'ALLOC_DYNAMIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
      );
    },
  });
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NONE"))
  Object.defineProperty(Module, "ALLOC_NONE", {
    configurable: true,
    get: function () {
      abort(
        "'ALLOC_NONE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"
      );
    },
  });

var calledRun;

/**
 * @constructor
 * @this {ExitStatus}
 */
function ExitStatus(status) {
  this.name = "ExitStatus";
  this.message = "Program terminated with exit(" + status + ")";
  this.status = status;
}

var calledMain = false;

dependenciesFulfilled = function runCaller() {
  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
  if (!calledRun) run();
  if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
};

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);
  HEAP32[argv >> 2] = allocateUTF8OnStack(thisProgram);
  for (var i = 1; i < argc; i++) {
    HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]);
  }
  HEAP32[(argv >> 2) + argc] = 0;

  try {
    Module["___set_stack_limit"](STACK_MAX);

    var ret = entryFunction(argc, argv);

    // In PROXY_TO_PTHREAD builds, we should never exit the runtime below, as execution is asynchronously handed
    // off to a pthread.
    // if we're not running an evented main loop, it's time to exit
    exit(ret, /* implicit = */ true);
  } catch (e) {
    if (e instanceof ExitStatus) {
      // exit() throws this once it's done to make sure execution
      // has been stopped completely
      return;
    } else if (e == "unwind") {
      // running an evented main loop, don't immediately exit
      noExitRuntime = true;
      return;
    } else {
      var toLog = e;
      if (e && typeof e === "object" && e.stack) {
        toLog = [e, e.stack];
      }
      err("exception thrown: " + toLog);
      quit_(1, e);
    }
  } finally {
    calledMain = true;
  }
}

/** @type {function(Array=)} */
function run(args) {
  args = args || arguments_;

  if (runDependencies > 0) {
    return;
  }

  writeStackCookie();

  preRun();

  if (runDependencies > 0) return; // a preRun added a dependency, run will be called later

  function doRun() {
    // run may have just been called through dependencies being fulfilled just in this very frame,
    // or while the async setStatus time below was happening
    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() {
  // Compiler settings do not allow exiting the runtime, so flushing
  // the streams is not possible. but in ASSERTIONS mode we check
  // if there was something to flush, and if so tell the user they
  // should request that the runtime be exitable.
  // Normally we would not even include flush() at all, but in ASSERTIONS
  // builds we do so just for this check, and here we see if there is any
  // content to flush, that is, we check if there would have been
  // something a non-ASSERTIONS build would have not seen.
  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
  // mode (which has its own special function for this; otherwise, all
  // the code is inside libc)
  var print = out;
  var printErr = err;
  var has = false;
  out = err = function (x) {
    has = true;
  };
  try {
    // it doesn't matter if it fails
    var flush = Module["_fflush"];
    if (flush) flush(0);
    // also flush in the JS FS layer
    ["stdout", "stderr"].forEach(function (name) {
      var info = FS.analyzePath("/dev/" + name);
      if (!info) return;
      var stream = info.object;
      var rdev = stream.rdev;
      var tty = TTY.ttys[rdev];
      if (tty && tty.output && tty.output.length) {
        has = true;
      }
    });
  } catch (e) {}
  out = print;
  err = printErr;
  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."
    );
  }
}

/** @param {boolean|number=} implicit */
function exit(status, implicit) {
  checkUnflushedContent();

  // if this is just main exit-ing implicitly, and the status is 0, then we
  // don't need to do anything here and can just leave. if the status is
  // non-zero, though, then we need to report it.
  // (we may have warned about this earlier, if a situation justifies doing so)
  if (implicit && noExitRuntime && status === 0) {
    return;
  }

  if (noExitRuntime) {
    // if exit() was called, we may warn the user if the runtime isn't actually being shut down
    if (!implicit) {
      err(
        "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)"
      );
    }
  } else {
    ABORT = true;
    EXITSTATUS = status;

    exitRuntime();

    if (Module["onExit"]) Module["onExit"](status);
  }

  quit_(status, new ExitStatus(status));
}

if (Module["preInit"]) {
  if (typeof Module["preInit"] == "function")
    Module["preInit"] = [Module["preInit"]];
  while (Module["preInit"].length > 0) {
    Module["preInit"].pop()();
  }
}

// shouldRunNow refers to calling main(), not run().
var shouldRunNow = true;

if (Module["noInitialRun"]) shouldRunNow = false;

noExitRuntime = true;

run();

// {{MODULE_ADDITIONS}}