Skip to content

Instantly share code, notes, and snippets.

@willemolding

willemolding/soljson.js

Created September 5, 2025 01:51
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save willemolding/ea9ceed4be33c133783333a1e6802eec to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save willemolding/ea9ceed4be33c133783333a1e6802eec to your computer and use it in GitHub Desktop.
Download ZIP
Wrapper javascript code for solc wasm
Raw
soljson.js
null;
var Module = typeof Module !== "undefined" ? Module : {};
var moduleOverrides = {};
var key;
for (key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key];
}
}
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = function (status, toThrow) {
throw toThrow;
};
var ENVIRONMENT_IS_WEB = false;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
ENVIRONMENT_IS_WEB = typeof window === "object";
ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
ENVIRONMENT_IS_NODE =
typeof process === "object" &&
typeof process.versions === "object" &&
typeof process.versions.node === "string";
ENVIRONMENT_IS_SHELL =
!ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var read_, readAsync, readBinary, setWindowTitle;
var nodeFS;
var nodePath;
if (ENVIRONMENT_IS_NODE) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = require("path").dirname(scriptDirectory) + "/";
} else {
scriptDirectory = __dirname + "/";
}
read_ = function shell_read(filename, binary) {
var ret = tryParseAsDataURI(filename);
if (ret) {
return binary ? ret : ret.toString();
}
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"]("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) {
var data = tryParseAsDataURI(f);
if (data) {
return intArrayToString(data);
}
return read(f);
};
}
readBinary = function readBinary(f) {
var data;
data = tryParseAsDataURI(f);
if (data) {
return data;
}
if (typeof readbuffer === "function") {
return new Uint8Array(readbuffer(f));
}
data = read(f, "binary");
assert(typeof data === "object");
return data;
};
if (typeof scriptArgs != "undefined") {
arguments_ = scriptArgs;
} else if (typeof arguments != "undefined") {
arguments_ = arguments;
}
if (typeof quit === "function") {
quit_ = function (status) {
quit(status);
};
}
if (typeof print !== "undefined") {
if (typeof console === "undefined") console = {};
console.log = print;
console.warn = console.error =
typeof printErr !== "undefined" ? printErr : print;
}
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = self.location.href;
} else if (typeof document !== "undefined" && document.currentScript) {
scriptDirectory = document.currentScript.src;
}
if (scriptDirectory.indexOf("blob:") !== 0) {
scriptDirectory = scriptDirectory.substr(
0,
scriptDirectory.lastIndexOf("/") + 1
);
} else {
scriptDirectory = "";
}
{
read_ = function (url) {
try {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
} catch (err) {
var data = tryParseAsDataURI(url);
if (data) {
return intArrayToString(data);
}
throw err;
}
};
if (ENVIRONMENT_IS_WORKER) {
readBinary = function (url) {
try {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
} catch (err) {
var data = tryParseAsDataURI(url);
if (data) {
return data;
}
throw err;
}
};
}
readAsync = function (url, onload, onerror) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = function () {
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
onload(xhr.response);
return;
}
var data = tryParseAsDataURI(url);
if (data) {
onload(data.buffer);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
};
}
setWindowTitle = function (title) {
document.title = title;
};
} else {
}
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.warn.bind(console);
for (key in moduleOverrides) {
if (moduleOverrides.hasOwnProperty(key)) {
Module[key] = moduleOverrides[key];
}
}
moduleOverrides = null;
if (Module["arguments"]) arguments_ = Module["arguments"];
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
if (Module["quit"]) quit_ = Module["quit"];
function convertJsFunctionToWasm(func, sig) {
if (typeof WebAssembly.Function === "function") {
var typeNames = { i: "i32", j: "i64", f: "f32", d: "f64" };
var type = {
parameters: [],
results: sig[0] == "v" ? [] : [typeNames[sig[0]]],
};
for (var i = 1; i < sig.length; ++i) {
type.parameters.push(typeNames[sig[i]]);
}
return new WebAssembly.Function(type, func);
}
var typeSection = [1, 0, 1, 96];
var sigRet = sig.slice(0, 1);
var sigParam = sig.slice(1);
var typeCodes = { i: 127, j: 126, f: 125, d: 124 };
typeSection.push(sigParam.length);
for (var i = 0; i < sigParam.length; ++i) {
typeSection.push(typeCodes[sigParam[i]]);
}
if (sigRet == "v") {
typeSection.push(0);
} else {
typeSection = typeSection.concat([1, typeCodes[sigRet]]);
}
typeSection[1] = typeSection.length - 2;
var bytes = new Uint8Array(
[0, 97, 115, 109, 1, 0, 0, 0].concat(
typeSection,
[2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0]
)
);
var module = new WebAssembly.Module(bytes);
var instance = new WebAssembly.Instance(module, { e: { f: func } });
var wrappedFunc = instance.exports["f"];
return wrappedFunc;
}
var freeTableIndexes = [];
var functionsInTableMap;
function getEmptyTableSlot() {
if (freeTableIndexes.length) {
return freeTableIndexes.pop();
}
try {
wasmTable.grow(1);
} catch (err) {
if (!(err instanceof RangeError)) {
throw err;
}
throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
}
return wasmTable.length - 1;
}
function addFunctionWasm(func, sig) {
if (!functionsInTableMap) {
functionsInTableMap = new WeakMap();
for (var i = 0; i < wasmTable.length; i++) {
var item = wasmTable.get(i);
if (item) {
functionsInTableMap.set(item, i);
}
}
}
if (functionsInTableMap.has(func)) {
return functionsInTableMap.get(func);
}
var ret = getEmptyTableSlot();
try {
wasmTable.set(ret, func);
} catch (err) {
if (!(err instanceof TypeError)) {
throw err;
}
var wrapped = convertJsFunctionToWasm(func, sig);
wasmTable.set(ret, wrapped);
}
functionsInTableMap.set(func, ret);
return ret;
}
function removeFunction(index) {
functionsInTableMap.delete(wasmTable.get(index));
freeTableIndexes.push(index);
}
function addFunction(func, sig) {
sig = sig || "viiiii";
return addFunctionWasm(func, sig);
}
var tempRet0 = 0;
var setTempRet0 = function (value) {
tempRet0 = value;
};
var getTempRet0 = function () {
return tempRet0;
};
var wasmBinary;
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
var noExitRuntime;
if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
if (typeof WebAssembly !== "object") {
abort("no native wasm support detected");
}
function setValue(ptr, value, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*") type = "i32";
switch (type) {
case "i1":
HEAP8[ptr >> 0] = value;
break;
case "i8":
HEAP8[ptr >> 0] = value;
break;
case "i16":
HEAP16[ptr >> 1] = value;
break;
case "i32":
HEAP32[ptr >> 2] = value;
break;
case "i64":
(tempI64 = [
value >>> 0,
((tempDouble = value),
+Math.abs(tempDouble) >= 1
? tempDouble > 0
? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) |
0) >>>
0
: ~~+Math.ceil(
(tempDouble - +(~~tempDouble >>> 0)) / 4294967296
) >>> 0
: 0),
]),
(HEAP32[ptr >> 2] = tempI64[0]),
(HEAP32[(ptr + 4) >> 2] = tempI64[1]);
break;
case "float":
HEAPF32[ptr >> 2] = value;
break;
case "double":
HEAPF64[ptr >> 3] = value;
break;
default:
abort("invalid type for setValue: " + type);
}
}
var wasmMemory;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed: " + text);
}
}
function getCFunc(ident) {
var func = Module["_" + ident];
assert(
func,
"Cannot call unknown function " + ident + ", make sure it is exported"
);
return func;
}
function ccall(ident, returnType, argTypes, args, opts) {
var toC = {
string: function (str) {
var ret = 0;
if (str !== null && str !== undefined && str !== 0) {
var len = (str.length << 2) + 1;
ret = stackAlloc(len);
stringToUTF8(str, ret, len);
}
return ret;
},
array: function (arr) {
var ret = stackAlloc(arr.length);
writeArrayToMemory(arr, ret);
return ret;
},
};
function convertReturnValue(ret) {
if (returnType === "string") return UTF8ToString(ret);
if (returnType === "boolean") return Boolean(ret);
return ret;
}
var func = getCFunc(ident);
var cArgs = [];
var stack = 0;
if (args) {
for (var i = 0; i < args.length; i++) {
var converter = toC[argTypes[i]];
if (converter) {
if (stack === 0) stack = stackSave();
cArgs[i] = converter(args[i]);
} else {
cArgs[i] = args[i];
}
}
}
var ret = func.apply(null, cArgs);
ret = convertReturnValue(ret);
if (stack !== 0) stackRestore(stack);
return ret;
}
function cwrap(ident, returnType, argTypes, opts) {
argTypes = argTypes || [];
var numericArgs = argTypes.every(function (type) {
return type === "number";
});
var numericRet = returnType !== "string";
if (numericRet && numericArgs && !opts) {
return getCFunc(ident);
}
return function () {
return ccall(ident, returnType, argTypes, arguments, opts);
};
}
var UTF8Decoder =
typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
function UTF8ArrayToString(heap, idx, maxBytesToRead) {
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
return UTF8Decoder.decode(heap.subarray(idx, endPtr));
} else {
var str = "";
while (idx < endPtr) {
var u0 = heap[idx++];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = heap[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode(((u0 & 31) << 6) | u1);
continue;
}
var u2 = heap[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
} else {
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
}
if (u0 < 65536) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
}
}
}
return str;
}
function UTF8ToString(ptr, maxBytesToRead) {
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
}
if (u <= 127) {
if (outIdx >= endIdx) break;
heap[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
heap[outIdx++] = 192 | (u >> 6);
heap[outIdx++] = 128 | (u & 63);
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
heap[outIdx++] = 224 | (u >> 12);
heap[outIdx++] = 128 | ((u >> 6) & 63);
heap[outIdx++] = 128 | (u & 63);
} else {
if (outIdx + 3 >= endIdx) break;
heap[outIdx++] = 240 | (u >> 18);
heap[outIdx++] = 128 | ((u >> 12) & 63);
heap[outIdx++] = 128 | ((u >> 6) & 63);
heap[outIdx++] = 128 | (u & 63);
}
}
heap[outIdx] = 0;
return outIdx - startIdx;
}
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}
function lengthBytesUTF8(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343)
u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
if (u <= 127) ++len;
else if (u <= 2047) len += 2;
else if (u <= 65535) len += 3;
else len += 4;
}
return len;
}
function writeArrayToMemory(array, buffer) {
HEAP8.set(array, buffer);
}
function writeAsciiToMemory(str, buffer, dontAddNull) {
for (var i = 0; i < str.length; ++i) {
HEAP8[buffer++ >> 0] = str.charCodeAt(i);
}
if (!dontAddNull) HEAP8[buffer >> 0] = 0;
}
function alignUp(x, multiple) {
if (x % multiple > 0) {
x += multiple - (x % multiple);
}
return x;
}
var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
function updateGlobalBufferAndViews(buf) {
buffer = buf;
Module["HEAP8"] = HEAP8 = new Int8Array(buf);
Module["HEAP16"] = HEAP16 = new Int16Array(buf);
Module["HEAP32"] = HEAP32 = new Int32Array(buf);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
}
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
var wasmTable;
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
var runtimeExited = false;
__ATINIT__.push({
func: function () {
___wasm_call_ctors();
},
});
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function exitRuntime() {
runtimeExited = true;
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
function addRunDependency(id) {
runDependencies++;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
Module["preloadedImages"] = {};
Module["preloadedAudios"] = {};
function abort(what) {
if (Module["onAbort"]) {
Module["onAbort"](what);
}
what += "";
err(what);
ABORT = true;
EXITSTATUS = 1;
what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
var e = new WebAssembly.RuntimeError(what);
throw e;
}
function hasPrefix(str, prefix) {
return String.prototype.startsWith
? str.startsWith(prefix)
: str.indexOf(prefix) === 0;
}
var dataURIPrefix = "data:application/octet-stream;base64,";
function isDataURI(filename) {
return hasPrefix(filename, dataURIPrefix);
}
var wasmBinaryFile = "<WASM_GOES_HERE>"
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
function getBinary(file) {
try {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
var binary = tryParseAsDataURI(file);
if (binary) {
return binary;
}
if (readBinary) {
return readBinary(file);
} else {
throw "sync fetching of the wasm failed: you can preload it to Module['wasmBinary'] manually, or emcc.py will do that for you when generating HTML (but not JS)";
}
} catch (err) {
abort(err);
}
}
function instantiateSync(file, info) {
var instance;
var module;
var binary;
try {
binary = getBinary(file);
module = new WebAssembly.Module(binary);
instance = new WebAssembly.Instance(module, info);
} catch (e) {
var str = e.toString();
err("failed to compile wasm module: " + str);
if (
str.indexOf("imported Memory") >= 0 ||
str.indexOf("memory import") >= 0
) {
err(
"Memory size incompatibility issues may be due to changing INITIAL_MEMORY at runtime to something too large. Use ALLOW_MEMORY_GROWTH to allow any size memory (and also make sure not to set INITIAL_MEMORY at runtime to something smaller than it was at compile time)."
);
}
throw e;
}
return [instance, module];
}
function createWasm() {
var info = { a: asmLibraryArg };
function receiveInstance(instance, module) {
var exports = instance.exports;
Module["asm"] = exports;
wasmMemory = Module["asm"]["qb"];
updateGlobalBufferAndViews(wasmMemory.buffer);
wasmTable = Module["asm"]["rb"];
removeRunDependency("wasm-instantiate");
}
addRunDependency("wasm-instantiate");
if (Module["instantiateWasm"]) {
try {
var exports = Module["instantiateWasm"](info, receiveInstance);
return exports;
} catch (e) {
err("Module.instantiateWasm callback failed with error: " + e);
return false;
}
}
var result = instantiateSync(wasmBinaryFile, info);
receiveInstance(result[0], result[1]);
return Module["asm"];
}
var tempDouble;
var tempI64;
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback(Module);
continue;
}
var func = callback.func;
if (typeof func === "number") {
if (callback.arg === undefined) {
wasmTable.get(func)();
} else {
wasmTable.get(func)(callback.arg);
}
} else {
func(callback.arg === undefined ? null : callback.arg);
}
}
}
function _exit(status) {
exit(status);
}
function __Exit(a0) {
return _exit(a0);
}
var ExceptionInfoAttrs = {
DESTRUCTOR_OFFSET: 0,
REFCOUNT_OFFSET: 4,
TYPE_OFFSET: 8,
CAUGHT_OFFSET: 12,
RETHROWN_OFFSET: 13,
SIZE: 16,
};
function ___cxa_allocate_exception(size) {
return _malloc(size + ExceptionInfoAttrs.SIZE) + ExceptionInfoAttrs.SIZE;
}
function ExceptionInfo(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - ExceptionInfoAttrs.SIZE;
this.set_type = function (type) {
HEAP32[(this.ptr + ExceptionInfoAttrs.TYPE_OFFSET) >> 2] = type;
};
this.get_type = function () {
return HEAP32[(this.ptr + ExceptionInfoAttrs.TYPE_OFFSET) >> 2];
};
this.set_destructor = function (destructor) {
HEAP32[(this.ptr + ExceptionInfoAttrs.DESTRUCTOR_OFFSET) >> 2] = destructor;
};
this.get_destructor = function () {
return HEAP32[(this.ptr + ExceptionInfoAttrs.DESTRUCTOR_OFFSET) >> 2];
};
this.set_refcount = function (refcount) {
HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2] = refcount;
};
this.set_caught = function (caught) {
caught = caught ? 1 : 0;
HEAP8[(this.ptr + ExceptionInfoAttrs.CAUGHT_OFFSET) >> 0] = caught;
};
this.get_caught = function () {
return HEAP8[(this.ptr + ExceptionInfoAttrs.CAUGHT_OFFSET) >> 0] != 0;
};
this.set_rethrown = function (rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[(this.ptr + ExceptionInfoAttrs.RETHROWN_OFFSET) >> 0] = rethrown;
};
this.get_rethrown = function () {
return HEAP8[(this.ptr + ExceptionInfoAttrs.RETHROWN_OFFSET) >> 0] != 0;
};
this.init = function (type, destructor) {
this.set_type(type);
this.set_destructor(destructor);
this.set_refcount(0);
this.set_caught(false);
this.set_rethrown(false);
};
this.add_ref = function () {
var value = HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2];
HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2] = value + 1;
};
this.release_ref = function () {
var prev = HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2];
HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2] = prev - 1;
return prev === 1;
};
}
function CatchInfo(ptr) {
this.free = function () {
_free(this.ptr);
this.ptr = 0;
};
this.set_base_ptr = function (basePtr) {
HEAP32[this.ptr >> 2] = basePtr;
};
this.get_base_ptr = function () {
return HEAP32[this.ptr >> 2];
};
this.set_adjusted_ptr = function (adjustedPtr) {
var ptrSize = 4;
HEAP32[(this.ptr + ptrSize) >> 2] = adjustedPtr;
};
this.get_adjusted_ptr = function () {
var ptrSize = 4;
return HEAP32[(this.ptr + ptrSize) >> 2];
};
this.get_exception_ptr = function () {
var isPointer = ___cxa_is_pointer_type(
this.get_exception_info().get_type()
);
if (isPointer) {
return HEAP32[this.get_base_ptr() >> 2];
}
var adjusted = this.get_adjusted_ptr();
if (adjusted !== 0) return adjusted;
return this.get_base_ptr();
};
this.get_exception_info = function () {
return new ExceptionInfo(this.get_base_ptr());
};
if (ptr === undefined) {
this.ptr = _malloc(8);
this.set_adjusted_ptr(0);
} else {
this.ptr = ptr;
}
}
var exceptionCaught = [];
function exception_addRef(info) {
info.add_ref();
}
var uncaughtExceptionCount = 0;
function ___cxa_begin_catch(ptr) {
var catchInfo = new CatchInfo(ptr);
var info = catchInfo.get_exception_info();
if (!info.get_caught()) {
info.set_caught(true);
uncaughtExceptionCount--;
}
info.set_rethrown(false);
exceptionCaught.push(catchInfo);
exception_addRef(info);
return catchInfo.get_exception_ptr();
}
var exceptionLast = 0;
function ___cxa_free_exception(ptr) {
return _free(new ExceptionInfo(ptr).ptr);
}
function exception_decRef(info) {
if (info.release_ref() && !info.get_rethrown()) {
var destructor = info.get_destructor();
if (destructor) {
wasmTable.get(destructor)(info.excPtr);
}
___cxa_free_exception(info.excPtr);
}
}
function ___cxa_end_catch() {
_setThrew(0);
var catchInfo = exceptionCaught.pop();
exception_decRef(catchInfo.get_exception_info());
catchInfo.free();
exceptionLast = 0;
}
function ___resumeException(catchInfoPtr) {
var catchInfo = new CatchInfo(catchInfoPtr);
var ptr = catchInfo.get_base_ptr();
if (!exceptionLast) {
exceptionLast = ptr;
}
catchInfo.free();
throw ptr;
}
function ___cxa_find_matching_catch_12() {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0 | 0);
return 0 | 0;
}
var info = new ExceptionInfo(thrown);
var thrownType = info.get_type();
var catchInfo = new CatchInfo();
catchInfo.set_base_ptr(thrown);
if (!thrownType) {
setTempRet0(0 | 0);
return catchInfo.ptr | 0;
}
var typeArray = Array.prototype.slice.call(arguments);
var stackTop = stackSave();
var exceptionThrowBuf = stackAlloc(4);
HEAP32[exceptionThrowBuf >> 2] = thrown;
for (var i = 0; i < typeArray.length; i++) {
var caughtType = typeArray[i];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
var adjusted = HEAP32[exceptionThrowBuf >> 2];
if (thrown !== adjusted) {
catchInfo.set_adjusted_ptr(adjusted);
}
setTempRet0(caughtType | 0);
return catchInfo.ptr | 0;
}
}
stackRestore(stackTop);
setTempRet0(thrownType | 0);
return catchInfo.ptr | 0;
}
function ___cxa_find_matching_catch_2() {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0 | 0);
return 0 | 0;
}
var info = new ExceptionInfo(thrown);
var thrownType = info.get_type();
var catchInfo = new CatchInfo();
catchInfo.set_base_ptr(thrown);
if (!thrownType) {
setTempRet0(0 | 0);
return catchInfo.ptr | 0;
}
var typeArray = Array.prototype.slice.call(arguments);
var stackTop = stackSave();
var exceptionThrowBuf = stackAlloc(4);
HEAP32[exceptionThrowBuf >> 2] = thrown;
for (var i = 0; i < typeArray.length; i++) {
var caughtType = typeArray[i];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
var adjusted = HEAP32[exceptionThrowBuf >> 2];
if (thrown !== adjusted) {
catchInfo.set_adjusted_ptr(adjusted);
}
setTempRet0(caughtType | 0);
return catchInfo.ptr | 0;
}
}
stackRestore(stackTop);
setTempRet0(thrownType | 0);
return catchInfo.ptr | 0;
}
function ___cxa_find_matching_catch_3() {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0 | 0);
return 0 | 0;
}
var info = new ExceptionInfo(thrown);
var thrownType = info.get_type();
var catchInfo = new CatchInfo();
catchInfo.set_base_ptr(thrown);
if (!thrownType) {
setTempRet0(0 | 0);
return catchInfo.ptr | 0;
}
var typeArray = Array.prototype.slice.call(arguments);
var stackTop = stackSave();
var exceptionThrowBuf = stackAlloc(4);
HEAP32[exceptionThrowBuf >> 2] = thrown;
for (var i = 0; i < typeArray.length; i++) {
var caughtType = typeArray[i];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
var adjusted = HEAP32[exceptionThrowBuf >> 2];
if (thrown !== adjusted) {
catchInfo.set_adjusted_ptr(adjusted);
}
setTempRet0(caughtType | 0);
return catchInfo.ptr | 0;
}
}
stackRestore(stackTop);
setTempRet0(thrownType | 0);
return catchInfo.ptr | 0;
}
function ___cxa_find_matching_catch_4() {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0 | 0);
return 0 | 0;
}
var info = new ExceptionInfo(thrown);
var thrownType = info.get_type();
var catchInfo = new CatchInfo();
catchInfo.set_base_ptr(thrown);
if (!thrownType) {
setTempRet0(0 | 0);
return catchInfo.ptr | 0;
}
var typeArray = Array.prototype.slice.call(arguments);
var stackTop = stackSave();
var exceptionThrowBuf = stackAlloc(4);
HEAP32[exceptionThrowBuf >> 2] = thrown;
for (var i = 0; i < typeArray.length; i++) {
var caughtType = typeArray[i];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
var adjusted = HEAP32[exceptionThrowBuf >> 2];
if (thrown !== adjusted) {
catchInfo.set_adjusted_ptr(adjusted);
}
setTempRet0(caughtType | 0);
return catchInfo.ptr | 0;
}
}
stackRestore(stackTop);
setTempRet0(thrownType | 0);
return catchInfo.ptr | 0;
}
function ___cxa_find_matching_catch_6() {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0 | 0);
return 0 | 0;
}
var info = new ExceptionInfo(thrown);
var thrownType = info.get_type();
var catchInfo = new CatchInfo();
catchInfo.set_base_ptr(thrown);
if (!thrownType) {
setTempRet0(0 | 0);
return catchInfo.ptr | 0;
}
var typeArray = Array.prototype.slice.call(arguments);
var stackTop = stackSave();
var exceptionThrowBuf = stackAlloc(4);
HEAP32[exceptionThrowBuf >> 2] = thrown;
for (var i = 0; i < typeArray.length; i++) {
var caughtType = typeArray[i];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
var adjusted = HEAP32[exceptionThrowBuf >> 2];
if (thrown !== adjusted) {
catchInfo.set_adjusted_ptr(adjusted);
}
setTempRet0(caughtType | 0);
return catchInfo.ptr | 0;
}
}
stackRestore(stackTop);
setTempRet0(thrownType | 0);
return catchInfo.ptr | 0;
}
function ___cxa_find_matching_catch_7() {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0 | 0);
return 0 | 0;
}
var info = new ExceptionInfo(thrown);
var thrownType = info.get_type();
var catchInfo = new CatchInfo();
catchInfo.set_base_ptr(thrown);
if (!thrownType) {
setTempRet0(0 | 0);
return catchInfo.ptr | 0;
}
var typeArray = Array.prototype.slice.call(arguments);
var stackTop = stackSave();
var exceptionThrowBuf = stackAlloc(4);
HEAP32[exceptionThrowBuf >> 2] = thrown;
for (var i = 0; i < typeArray.length; i++) {
var caughtType = typeArray[i];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
var adjusted = HEAP32[exceptionThrowBuf >> 2];
if (thrown !== adjusted) {
catchInfo.set_adjusted_ptr(adjusted);
}
setTempRet0(caughtType | 0);
return catchInfo.ptr | 0;
}
}
stackRestore(stackTop);
setTempRet0(thrownType | 0);
return catchInfo.ptr | 0;
}
function ___cxa_rethrow() {
var catchInfo = exceptionCaught.pop();
if (!catchInfo) {
abort("no exception to throw");
}
var info = catchInfo.get_exception_info();
var ptr = catchInfo.get_base_ptr();
if (!info.get_rethrown()) {
exceptionCaught.push(catchInfo);
info.set_rethrown(true);
info.set_caught(false);
uncaughtExceptionCount++;
} else {
catchInfo.free();
}
exceptionLast = ptr;
throw ptr;
}
function ___cxa_throw(ptr, type, destructor) {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw ptr;
}
function ___cxa_uncaught_exceptions() {
return uncaughtExceptionCount;
}
function setErrNo(value) {
HEAP32[___errno_location() >> 2] = value;
return value;
}
var SYSCALLS = {
mappings: {},
buffers: [null, [], []],
printChar: function (stream, curr) {
var buffer = SYSCALLS.buffers[stream];
if (curr === 0 || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
buffer.length = 0;
} else {
buffer.push(curr);
}
},
varargs: undefined,
get: function () {
SYSCALLS.varargs += 4;
var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
return ret;
},
getStr: function (ptr) {
var ret = UTF8ToString(ptr);
return ret;
},
get64: function (low, high) {
return low;
},
};
function ___sys_fcntl64(fd, cmd, varargs) {
SYSCALLS.varargs = varargs;
return 0;
}
function ___sys_ioctl(fd, op, varargs) {
SYSCALLS.varargs = varargs;
return 0;
}
function ___sys_open(path, flags, varargs) {
SYSCALLS.varargs = varargs;
}
function _abort() {
abort();
}
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) {
var now;
if (clk_id === 0) {
now = Date.now();
} else if (
(clk_id === 1 || clk_id === 4) &&
_emscripten_get_now_is_monotonic
) {
now = _emscripten_get_now();
} else {
setErrNo(28);
return -1;
}
HEAP32[tp >> 2] = (now / 1e3) | 0;
HEAP32[(tp + 4) >> 2] = ((now % 1e3) * 1e3 * 1e3) | 0;
return 0;
}
function _emscripten_memcpy_big(dest, src, num) {
HEAPU8.copyWithin(dest, src, src + num);
}
function _emscripten_get_heap_size() {
return HEAPU8.length;
}
function emscripten_realloc_buffer(size) {
try {
wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
updateGlobalBufferAndViews(wasmMemory.buffer);
return 1;
} catch (e) {}
}
function _emscripten_resize_heap(requestedSize) {
requestedSize = requestedSize >>> 0;
var oldSize = _emscripten_get_heap_size();
var maxHeapSize = 2147483648;
if (requestedSize > maxHeapSize) {
return false;
}
var minHeapSize = 16777216;
for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
var newSize = Math.min(
maxHeapSize,
alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), 65536)
);
var replacement = emscripten_realloc_buffer(newSize);
if (replacement) {
return true;
}
}
return false;
}
var ENV = {};
function getExecutableName() {
return thisProgram || "./this.program";
}
function getEnvStrings() {
if (!getEnvStrings.strings) {
var lang =
(
(typeof navigator === "object" &&
navigator.languages &&
navigator.languages[0]) ||
"C"
).replace("-", "_") + ".UTF-8";
var env = {
USER: "web_user",
LOGNAME: "web_user",
PATH: "/",
PWD: "/",
HOME: "/home/web_user",
LANG: lang,
_: getExecutableName(),
};
for (var x in ENV) {
env[x] = ENV[x];
}
var strings = [];
for (var x in env) {
strings.push(x + "=" + env[x]);
}
getEnvStrings.strings = strings;
}
return getEnvStrings.strings;
}
function _environ_get(__environ, environ_buf) {
var bufSize = 0;
getEnvStrings().forEach(function (string, i) {
var ptr = environ_buf + bufSize;
HEAP32[(__environ + i * 4) >> 2] = ptr;
writeAsciiToMemory(string, ptr);
bufSize += string.length + 1;
});
return 0;
}
function _environ_sizes_get(penviron_count, penviron_buf_size) {
var strings = getEnvStrings();
HEAP32[penviron_count >> 2] = strings.length;
var bufSize = 0;
strings.forEach(function (string) {
bufSize += string.length + 1;
});
HEAP32[penviron_buf_size >> 2] = bufSize;
return 0;
}
function _fd_close(fd) {
return 0;
}
function _fd_read(fd, iov, iovcnt, pnum) {
var stream = SYSCALLS.getStreamFromFD(fd);
var num = SYSCALLS.doReadv(stream, iov, iovcnt);
HEAP32[pnum >> 2] = num;
return 0;
}
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {}
function _fd_write(fd, iov, iovcnt, pnum) {
var num = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = HEAP32[(iov + i * 8) >> 2];
var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
for (var j = 0; j < len; j++) {
SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
}
num += len;
}
HEAP32[pnum >> 2] = num;
return 0;
}
function _getTempRet0() {
return getTempRet0() | 0;
}
function _llvm_eh_typeid_for(type) {
return type;
}
function _pthread_create() {
return 6;
}
function _pthread_join() {
return 28;
}
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,
};
function _raise(sig) {
setErrNo(ERRNO_CODES.ENOSYS);
return -1;
}
function _setTempRet0($i) {
setTempRet0($i | 0);
}
var __sigalrm_handler = 0;
function _signal(sig, func) {
if (sig == 14) {
__sigalrm_handler = func;
} else {
}
return 0;
}
function __isLeapYear(year) {
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
}
function __arraySum(array, index) {
var sum = 0;
for (var i = 0; i <= index; sum += array[i++]) {}
return sum;
}
var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
function __addDays(date, days) {
var newDate = new Date(date.getTime());
while (days > 0) {
var leap = __isLeapYear(newDate.getFullYear());
var currentMonth = newDate.getMonth();
var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[
currentMonth
];
if (days > daysInCurrentMonth - newDate.getDate()) {
days -= daysInCurrentMonth - newDate.getDate() + 1;
newDate.setDate(1);
if (currentMonth < 11) {
newDate.setMonth(currentMonth + 1);
} else {
newDate.setMonth(0);
newDate.setFullYear(newDate.getFullYear() + 1);
}
} else {
newDate.setDate(newDate.getDate() + days);
return newDate;
}
}
return newDate;
}
function _strftime(s, maxsize, format, tm) {
var tm_zone = HEAP32[(tm + 40) >> 2];
var date = {
tm_sec: HEAP32[tm >> 2],
tm_min: HEAP32[(tm + 4) >> 2],
tm_hour: HEAP32[(tm + 8) >> 2],
tm_mday: HEAP32[(tm + 12) >> 2],
tm_mon: HEAP32[(tm + 16) >> 2],
tm_year: HEAP32[(tm + 20) >> 2],
tm_wday: HEAP32[(tm + 24) >> 2],
tm_yday: HEAP32[(tm + 28) >> 2],
tm_isdst: HEAP32[(tm + 32) >> 2],
tm_gmtoff: HEAP32[(tm + 36) >> 2],
tm_zone: tm_zone ? UTF8ToString(tm_zone) : "",
};
var pattern = UTF8ToString(format);
var EXPANSION_RULES_1 = {
"%c": "%a %b %d %H:%M:%S %Y",
"%D": "%m/%d/%y",
"%F": "%Y-%m-%d",
"%h": "%b",
"%r": "%I:%M:%S %p",
"%R": "%H:%M",
"%T": "%H:%M:%S",
"%x": "%m/%d/%y",
"%X": "%H:%M:%S",
"%Ec": "%c",
"%EC": "%C",
"%Ex": "%m/%d/%y",
"%EX": "%H:%M:%S",
"%Ey": "%y",
"%EY": "%Y",
"%Od": "%d",
"%Oe": "%e",
"%OH": "%H",
"%OI": "%I",
"%Om": "%m",
"%OM": "%M",
"%OS": "%S",
"%Ou": "%u",
"%OU": "%U",
"%OV": "%V",
"%Ow": "%w",
"%OW": "%W",
"%Oy": "%y",
};
for (var rule in EXPANSION_RULES_1) {
pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
}
var WEEKDAYS = [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
];
var MONTHS = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
function leadingSomething(value, digits, character) {
var str = typeof value === "number" ? value.toString() : value || "";
while (str.length < digits) {
str = character[0] + str;
}
return str;
}
function leadingNulls(value, digits) {
return leadingSomething(value, digits, "0");
}
function compareByDay(date1, date2) {
function sgn(value) {
return value < 0 ? -1 : value > 0 ? 1 : 0;
}
var compare;
if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
compare = sgn(date1.getDate() - date2.getDate());
}
}
return compare;
}
function getFirstWeekStartDate(janFourth) {
switch (janFourth.getDay()) {
case 0:
return new Date(janFourth.getFullYear() - 1, 11, 29);
case 1:
return janFourth;
case 2:
return new Date(janFourth.getFullYear(), 0, 3);
case 3:
return new Date(janFourth.getFullYear(), 0, 2);
case 4:
return new Date(janFourth.getFullYear(), 0, 1);
case 5:
return new Date(janFourth.getFullYear() - 1, 11, 31);
case 6:
return new Date(janFourth.getFullYear() - 1, 11, 30);
}
}
function getWeekBasedYear(date) {
var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
return thisDate.getFullYear() + 1;
} else {
return thisDate.getFullYear();
}
} else {
return thisDate.getFullYear() - 1;
}
}
var EXPANSION_RULES_2 = {
"%a": function (date) {
return WEEKDAYS[date.tm_wday].substring(0, 3);
},
"%A": function (date) {
return WEEKDAYS[date.tm_wday];
},
"%b": function (date) {
return MONTHS[date.tm_mon].substring(0, 3);
},
"%B": function (date) {
return MONTHS[date.tm_mon];
},
"%C": function (date) {
var year = date.tm_year + 1900;
return leadingNulls((year / 100) | 0, 2);
},
"%d": function (date) {
return leadingNulls(date.tm_mday, 2);
},
"%e": function (date) {
return leadingSomething(date.tm_mday, 2, " ");
},
"%g": function (date) {
return getWeekBasedYear(date).toString().substring(2);
},
"%G": function (date) {
return getWeekBasedYear(date);
},
"%H": function (date) {
return leadingNulls(date.tm_hour, 2);
},
"%I": function (date) {
var twelveHour = date.tm_hour;
if (twelveHour == 0) twelveHour = 12;
else if (twelveHour > 12) twelveHour -= 12;
return leadingNulls(twelveHour, 2);
},
"%j": function (date) {
return leadingNulls(
date.tm_mday +
__arraySum(
__isLeapYear(date.tm_year + 1900)
? __MONTH_DAYS_LEAP
: __MONTH_DAYS_REGULAR,
date.tm_mon - 1
),
3
);
},
"%m": function (date) {
return leadingNulls(date.tm_mon + 1, 2);
},
"%M": function (date) {
return leadingNulls(date.tm_min, 2);
},
"%n": function () {
return "\n";
},
"%p": function (date) {
if (date.tm_hour >= 0 && date.tm_hour < 12) {
return "AM";
} else {
return "PM";
}
},
"%S": function (date) {
return leadingNulls(date.tm_sec, 2);
},
"%t": function () {
return "\t";
},
"%u": function (date) {
return date.tm_wday || 7;
},
"%U": function (date) {
var janFirst = new Date(date.tm_year + 1900, 0, 1);
var firstSunday =
janFirst.getDay() === 0
? janFirst
: __addDays(janFirst, 7 - janFirst.getDay());
var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
if (compareByDay(firstSunday, endDate) < 0) {
var februaryFirstUntilEndMonth =
__arraySum(
__isLeapYear(endDate.getFullYear())
? __MONTH_DAYS_LEAP
: __MONTH_DAYS_REGULAR,
endDate.getMonth() - 1
) - 31;
var firstSundayUntilEndJanuary = 31 - firstSunday.getDate();
var days =
firstSundayUntilEndJanuary +
februaryFirstUntilEndMonth +
endDate.getDate();
return leadingNulls(Math.ceil(days / 7), 2);
}
return compareByDay(firstSunday, janFirst) === 0 ? "01" : "00";
},
"%V": function (date) {
var janFourthThisYear = new Date(date.tm_year + 1900, 0, 4);
var janFourthNextYear = new Date(date.tm_year + 1901, 0, 4);
var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
var endDate = __addDays(
new Date(date.tm_year + 1900, 0, 1),
date.tm_yday
);
if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
return "53";
}
if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
return "01";
}
var daysDifference;
if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) {
daysDifference = date.tm_yday + 32 - firstWeekStartThisYear.getDate();
} else {
daysDifference = date.tm_yday + 1 - firstWeekStartThisYear.getDate();
}
return leadingNulls(Math.ceil(daysDifference / 7), 2);
},
"%w": function (date) {
return date.tm_wday;
},
"%W": function (date) {
var janFirst = new Date(date.tm_year, 0, 1);
var firstMonday =
janFirst.getDay() === 1
? janFirst
: __addDays(
janFirst,
janFirst.getDay() === 0 ? 1 : 7 - janFirst.getDay() + 1
);
var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
if (compareByDay(firstMonday, endDate) < 0) {
var februaryFirstUntilEndMonth =
__arraySum(
__isLeapYear(endDate.getFullYear())
? __MONTH_DAYS_LEAP
: __MONTH_DAYS_REGULAR,
endDate.getMonth() - 1
) - 31;
var firstMondayUntilEndJanuary = 31 - firstMonday.getDate();
var days =
firstMondayUntilEndJanuary +
februaryFirstUntilEndMonth +
endDate.getDate();
return leadingNulls(Math.ceil(days / 7), 2);
}
return compareByDay(firstMonday, janFirst) === 0 ? "01" : "00";
},
"%y": function (date) {
return (date.tm_year + 1900).toString().substring(2);
},
"%Y": function (date) {
return date.tm_year + 1900;
},
"%z": function (date) {
var off = date.tm_gmtoff;
var ahead = off >= 0;
off = Math.abs(off) / 60;
off = (off / 60) * 100 + (off % 60);
return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
},
"%Z": function (date) {
return date.tm_zone;
},
"%%": function () {
return "%";
},
};
for (var rule in EXPANSION_RULES_2) {
if (pattern.indexOf(rule) >= 0) {
pattern = pattern.replace(
new RegExp(rule, "g"),
EXPANSION_RULES_2[rule](date)
);
}
}
var bytes = intArrayFromString(pattern, false);
if (bytes.length > maxsize) {
return 0;
}
writeArrayToMemory(bytes, s);
return bytes.length - 1;
}
function _strftime_l(s, maxsize, format, tm) {
return _strftime(s, maxsize, format, tm);
}
var ASSERTIONS = false;
function intArrayFromString(stringy, dontAddNull, length) {
var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
var u8array = new Array(len);
var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
if (dontAddNull) u8array.length = numBytesWritten;
return u8array;
}
function intArrayToString(array) {
var ret = [];
for (var i = 0; i < array.length; i++) {
var chr = array[i];
if (chr > 255) {
if (ASSERTIONS) {
assert(
false,
"Character code " +
chr +
" (" +
String.fromCharCode(chr) +
") at offset " +
i +
" not in 0x00-0xFF."
);
}
chr &= 255;
}
ret.push(String.fromCharCode(chr));
}
return ret.join("");
}
var decodeBase64 =
typeof atob === "function"
? atob
: function (input) {
var keyStr =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var output = "";
var chr1, chr2, chr3;
var enc1, enc2, enc3, enc4;
var i = 0;
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
do {
enc1 = keyStr.indexOf(input.charAt(i++));
enc2 = keyStr.indexOf(input.charAt(i++));
enc3 = keyStr.indexOf(input.charAt(i++));
enc4 = keyStr.indexOf(input.charAt(i++));
chr1 = (enc1 << 2) | (enc2 >> 4);
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
chr3 = ((enc3 & 3) << 6) | enc4;
output = output + String.fromCharCode(chr1);
if (enc3 !== 64) {
output = output + String.fromCharCode(chr2);
}
if (enc4 !== 64) {
output = output + String.fromCharCode(chr3);
}
} while (i < input.length);
return output;
};
function intArrayFromBase64(s) {
if (typeof ENVIRONMENT_IS_NODE === "boolean" && ENVIRONMENT_IS_NODE) {
var buf;
try {
buf = Buffer.from(s, "base64");
} catch (_) {
buf = new Buffer(s, "base64");
}
return new Uint8Array(buf["buffer"], buf["byteOffset"], buf["byteLength"]);
}
try {
var decoded = decodeBase64(s);
var bytes = new Uint8Array(decoded.length);
for (var i = 0; i < decoded.length; ++i) {
bytes[i] = decoded.charCodeAt(i);
}
return bytes;
} catch (_) {
throw new Error("Converting base64 string to bytes failed.");
}
}
function tryParseAsDataURI(filename) {
if (!isDataURI(filename)) {
return;
}
return intArrayFromBase64(filename.slice(dataURIPrefix.length));
}
var asmLibraryArg = {
ba: __Exit,
p: ___cxa_allocate_exception,
w: ___cxa_begin_catch,
A: ___cxa_end_catch,
_: ___cxa_find_matching_catch_12,
b: ___cxa_find_matching_catch_2,
j: ___cxa_find_matching_catch_3,
J: ___cxa_find_matching_catch_4,
O: ___cxa_find_matching_catch_6,
aa: ___cxa_find_matching_catch_7,
q: ___cxa_free_exception,
la: ___cxa_rethrow,
x: ___cxa_throw,
Ea: ___cxa_uncaught_exceptions,
f: ___resumeException,
ga: ___sys_fcntl64,
Ka: ___sys_ioctl,
La: ___sys_open,
da: _abort,
Da: _clock_gettime,
Ba: _emscripten_memcpy_big,
Ca: _emscripten_resize_heap,
Ha: _environ_get,
Ia: _environ_sizes_get,
n: _exit,
ia: _fd_close,
Ja: _fd_read,
Wa: _fd_seek,
ha: _fd_write,
a: _getTempRet0,
ja: invoke_d,
C: invoke_di,
Q: invoke_dii,
Na: invoke_diid,
X: invoke_diii,
S: invoke_fii,
ea: invoke_fiii,
u: invoke_i,
W: invoke_id,
d: invoke_ii,
G: invoke_iid,
ca: invoke_iidi,
c: invoke_iii,
Ma: invoke_iiid,
g: invoke_iiii,
Pa: invoke_iiiif,
l: invoke_iiiii,
fa: invoke_iiiiid,
o: invoke_iiiiii,
s: invoke_iiiiiii,
v: invoke_iiiiiiii,
B: invoke_iiiiiiiii,
F: invoke_iiiiiiiiii,
P: invoke_iiiiiiiiiii,
L: invoke_iiiiiiiiiiii,
E: invoke_iiiiiiiiiiiii,
I: invoke_iiiiiiiiiiiiii,
Za: invoke_iiiiiiji,
Va: invoke_iiiiij,
hb: invoke_iiiij,
$a: invoke_iiiijiii,
Ya: invoke_iiijii,
lb: invoke_iij,
ra: invoke_iiji,
ta: invoke_iijii,
sa: invoke_iijiii,
pa: invoke_iijiiii,
qa: invoke_iijiiiii,
pb: invoke_iijiiiiii,
oa: invoke_iijiiiiiiii,
ma: invoke_iijiiiiiiiiiii,
na: invoke_iijiiiiiiiiiiiiii,
gb: invoke_j,
ab: invoke_ji,
ib: invoke_jii,
kb: invoke_jiii,
Ua: invoke_jiiii,
bb: invoke_jiij,
r: invoke_v,
i: invoke_vi,
Oa: invoke_vidii,
e: invoke_vii,
K: invoke_viid,
V: invoke_viidd,
N: invoke_viidi,
ka: invoke_viifi,
h: invoke_viii,
k: invoke_viiii,
$: invoke_viiiid,
m: invoke_viiiii,
t: invoke_viiiiii,
z: invoke_viiiiiii,
D: invoke_viiiiiiii,
H: invoke_viiiiiiiii,
M: invoke_viiiiiiiiii,
Z: invoke_viiiiiiiiiii,
T: invoke_viiiiiiiiiiii,
U: invoke_viiiiiiiiiiiiiii,
Sa: invoke_viiiiiiiiiiiiiiiiiiiiiiiiiiiii,
Ta: invoke_viiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii,
cb: invoke_viiiiiji,
nb: invoke_viiiiijjiii,
eb: invoke_viiiij,
db: invoke_viiiiji,
_a: invoke_viiij,
jb: invoke_viiiji,
ob: invoke_viiijii,
fb: invoke_viij,
xa: invoke_viiji,
mb: invoke_viijii,
wa: invoke_vij,
ua: invoke_viji,
ya: invoke_vijii,
va: invoke_vijiii,
za: invoke_vijj,
Xa: invoke_vijji,
Aa: invoke_vjii,
y: _llvm_eh_typeid_for,
Ra: _pthread_create,
Fa: _pthread_join,
Qa: _raise,
R: _setTempRet0,
Y: _signal,
Ga: _strftime_l,
};
var asm = createWasm();
var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = asm["sb"]);
var _solidity_license = (Module["_solidity_license"] = asm["tb"]);
var _solidity_version = (Module["_solidity_version"] = asm["ub"]);
var _solidity_compile = (Module["_solidity_compile"] = asm["vb"]);
var _solidity_alloc = (Module["_solidity_alloc"] = asm["wb"]);
var _solidity_free = (Module["_solidity_free"] = asm["xb"]);
var _solidity_reset = (Module["_solidity_reset"] = asm["yb"]);
var _free = (Module["_free"] = asm["zb"]);
var _malloc = (Module["_malloc"] = asm["Ab"]);
var ___errno_location = (Module["___errno_location"] = asm["Bb"]);
var stackSave = (Module["stackSave"] = asm["Cb"]);
var stackRestore = (Module["stackRestore"] = asm["Db"]);
var stackAlloc = (Module["stackAlloc"] = asm["Eb"]);
var _setThrew = (Module["_setThrew"] = asm["Fb"]);
var ___cxa_can_catch = (Module["___cxa_can_catch"] = asm["Gb"]);
var ___cxa_is_pointer_type = (Module["___cxa_is_pointer_type"] = asm["Hb"]);
var dynCall_vijii = (Module["dynCall_vijii"] = asm["Ib"]);
var dynCall_vjii = (Module["dynCall_vjii"] = asm["Jb"]);
var dynCall_vijj = (Module["dynCall_vijj"] = asm["Kb"]);
var dynCall_vij = (Module["dynCall_vij"] = asm["Lb"]);
var dynCall_viiji = (Module["dynCall_viiji"] = asm["Mb"]);
var dynCall_iijiiii = (Module["dynCall_iijiiii"] = asm["Nb"]);
var dynCall_iiji = (Module["dynCall_iiji"] = asm["Ob"]);
var dynCall_iijiiiiiiii = (Module["dynCall_iijiiiiiiii"] = asm["Pb"]);
var dynCall_vijiii = (Module["dynCall_vijiii"] = asm["Qb"]);
var dynCall_viiijii = (Module["dynCall_viiijii"] = asm["Rb"]);
var dynCall_iijii = (Module["dynCall_iijii"] = asm["Sb"]);
var dynCall_viji = (Module["dynCall_viji"] = asm["Tb"]);
var dynCall_viiiiijjiii = (Module["dynCall_viiiiijjiii"] = asm["Ub"]);
var dynCall_viijii = (Module["dynCall_viijii"] = asm["Vb"]);
var dynCall_iij = (Module["dynCall_iij"] = asm["Wb"]);
var dynCall_jiii = (Module["dynCall_jiii"] = asm["Xb"]);
var dynCall_iijiii = (Module["dynCall_iijiii"] = asm["Yb"]);
var dynCall_iijiiiii = (Module["dynCall_iijiiiii"] = asm["Zb"]);
var dynCall_iijiiiiiiiiiiiiii = (Module["dynCall_iijiiiiiiiiiiiiii"] =
asm["_b"]);
var dynCall_iijiiiiiiiiiii = (Module["dynCall_iijiiiiiiiiiii"] = asm["$b"]);
var dynCall_iijiiiiii = (Module["dynCall_iijiiiiii"] = asm["ac"]);
var dynCall_viiiji = (Module["dynCall_viiiji"] = asm["bc"]);
var dynCall_jii = (Module["dynCall_jii"] = asm["cc"]);
var dynCall_iiiij = (Module["dynCall_iiiij"] = asm["dc"]);
var dynCall_j = (Module["dynCall_j"] = asm["ec"]);
var dynCall_viij = (Module["dynCall_viij"] = asm["fc"]);
var dynCall_viiiij = (Module["dynCall_viiiij"] = asm["gc"]);
var dynCall_viiiiji = (Module["dynCall_viiiiji"] = asm["hc"]);
var dynCall_viiiiiji = (Module["dynCall_viiiiiji"] = asm["ic"]);
var dynCall_jiij = (Module["dynCall_jiij"] = asm["jc"]);
var dynCall_ji = (Module["dynCall_ji"] = asm["kc"]);
var dynCall_iiiijiii = (Module["dynCall_iiiijiii"] = asm["lc"]);
var dynCall_viiij = (Module["dynCall_viiij"] = asm["mc"]);
var dynCall_iiiiiiji = (Module["dynCall_iiiiiiji"] = asm["nc"]);
var dynCall_iiijii = (Module["dynCall_iiijii"] = asm["oc"]);
var dynCall_vijji = (Module["dynCall_vijji"] = asm["pc"]);
var dynCall_iiiiij = (Module["dynCall_iiiiij"] = asm["qc"]);
var dynCall_jiiii = (Module["dynCall_jiiii"] = asm["rc"]);
function invoke_vi(index, a1) {
var sp = stackSave();
try {
wasmTable.get(index)(a1);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_ii(index, a1) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiii(index, a1, a2, a3) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vii(index, a1, a2) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_v(index) {
var sp = stackSave();
try {
wasmTable.get(index)();
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iii(index, a1, a2) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viii(index, a1, a2, a3) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiii(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiii(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiii(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12
) {
var sp = stackSave();
try {
return wasmTable.get(index)(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iidi(index, a1, a2, a3) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_i(index) {
var sp = stackSave();
try {
return wasmTable.get(index)();
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13
) {
var sp = stackSave();
try {
return wasmTable.get(index)(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15
) {
var sp = stackSave();
try {
wasmTable.get(index)(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12
) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19,
a20,
a21,
a22,
a23,
a24,
a25,
a26,
a27,
a28,
a29,
a30,
a31,
a32
) {
var sp = stackSave();
try {
wasmTable.get(index)(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19,
a20,
a21,
a22,
a23,
a24,
a25,
a26,
a27,
a28,
a29,
a30,
a31,
a32
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiiiiiiiiiiiiiiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19,
a20,
a21,
a22,
a23,
a24,
a25,
a26,
a27,
a28,
a29
) {
var sp = stackSave();
try {
wasmTable.get(index)(
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19,
a20,
a21,
a22,
a23,
a24,
a25,
a26,
a27,
a28,
a29
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iid(index, a1, a2) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11
) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11
) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_di(index, a1) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viifi(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiif(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viid(index, a1, a2, a3) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viidi(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_diii(index, a1, a2, a3) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_d(index) {
var sp = stackSave();
try {
return wasmTable.get(index)();
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_dii(index, a1, a2) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vidii(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiid(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_fii(index, a1, a2) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_diid(index, a1, a2, a3) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_id(index, a1) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiid(index, a1, a2, a3) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viidd(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiid(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_fiii(index, a1, a2, a3) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vjii(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
dynCall_vjii(index, a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vijj(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
dynCall_vijj(index, a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vijii(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
dynCall_vijii(index, a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiji(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
dynCall_viiji(index, a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vij(index, a1, a2, a3) {
var sp = stackSave();
try {
dynCall_vij(index, a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vijiii(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
dynCall_vijiii(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viji(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
dynCall_viji(index, a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijii(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
return dynCall_iijii(index, a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijiii(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
return dynCall_iijiii(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiji(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
return dynCall_iiji(index, a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
var sp = stackSave();
try {
return dynCall_iijiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijiiii(index, a1, a2, a3, a4, a5, a6, a7) {
var sp = stackSave();
try {
return dynCall_iijiiii(index, a1, a2, a3, a4, a5, a6, a7);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11
) {
var sp = stackSave();
try {
return dynCall_iijiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijiiiiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17
) {
var sp = stackSave();
try {
return dynCall_iijiiiiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14
) {
var sp = stackSave();
try {
return dynCall_iijiiiiiiiiiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
var sp = stackSave();
try {
return dynCall_iijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiijii(index, a1, a2, a3, a4, a5, a6, a7) {
var sp = stackSave();
try {
dynCall_viiijii(index, a1, a2, a3, a4, a5, a6, a7);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiijjiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12
) {
var sp = stackSave();
try {
dynCall_viiiiijjiii(
index,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12
);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viijii(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
dynCall_viijii(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iij(index, a1, a2, a3) {
var sp = stackSave();
try {
return dynCall_iij(index, a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_jiii(index, a1, a2, a3) {
var sp = stackSave();
try {
return dynCall_jiii(index, a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiji(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
dynCall_viiiji(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_jii(index, a1, a2) {
var sp = stackSave();
try {
return dynCall_jii(index, a1, a2);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiij(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
return dynCall_iiiij(index, a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_j(index) {
var sp = stackSave();
try {
return dynCall_j(index);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viij(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
dynCall_viij(index, a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiij(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
dynCall_viiiij(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiji(index, a1, a2, a3, a4, a5, a6, a7) {
var sp = stackSave();
try {
dynCall_viiiiji(index, a1, a2, a3, a4, a5, a6, a7);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8) {
var sp = stackSave();
try {
dynCall_viiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_jiij(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
return dynCall_jiij(index, a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_ji(index, a1) {
var sp = stackSave();
try {
return dynCall_ji(index, a1);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiijiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
var sp = stackSave();
try {
return dynCall_iiiijiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_viiij(index, a1, a2, a3, a4, a5) {
var sp = stackSave();
try {
dynCall_viiij(index, a1, a2, a3, a4, a5);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8) {
var sp = stackSave();
try {
return dynCall_iiiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiijii(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
return dynCall_iiijii(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vijji(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
dynCall_vijji(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiiiij(index, a1, a2, a3, a4, a5, a6) {
var sp = stackSave();
try {
return dynCall_iiiiij(index, a1, a2, a3, a4, a5, a6);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_jiiii(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
return dynCall_jiiii(index, a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
Module["cwrap"] = cwrap;
Module["setValue"] = setValue;
Module["UTF8ToString"] = UTF8ToString;
Module["stringToUTF8"] = stringToUTF8;
Module["lengthBytesUTF8"] = lengthBytesUTF8;
Module["addFunction"] = addFunction;
Module["removeFunction"] = removeFunction;
var calledRun;
function ExitStatus(status) {
this.name = "ExitStatus";
this.message = "Program terminated with exit(" + status + ")";
this.status = status;
}
dependenciesFulfilled = function runCaller() {
if (!calledRun) run();
if (!calledRun) dependenciesFulfilled = runCaller;
};
function run(args) {
args = args || arguments_;
if (runDependencies > 0) {
return;
}
preRun();
if (runDependencies > 0) return;
function doRun() {
if (calledRun) return;
calledRun = true;
Module["calledRun"] = true;
if (ABORT) return;
initRuntime();
preMain();
if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
postRun();
}
if (Module["setStatus"]) {
Module["setStatus"]("Running...");
setTimeout(function () {
setTimeout(function () {
Module["setStatus"]("");
}, 1);
doRun();
}, 1);
} else {
doRun();
}
}
Module["run"] = run;
function exit(status, implicit) {
if (implicit && noExitRuntime && status === 0) {
return;
}
if (noExitRuntime) {
} else {
EXITSTATUS = status;
exitRuntime();
if (Module["onExit"]) Module["onExit"](status);
ABORT = true;
}
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()();
}
}
noExitRuntime = true;
run();
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment