diff --git a/RPG/Assets/BattleSystem3.cs b/RPG/Assets/BattleSystem3.cs index 260595f..76a64ed 100644 --- a/RPG/Assets/BattleSystem3.cs +++ b/RPG/Assets/BattleSystem3.cs @@ -369,7 +369,7 @@ public class BattleSystem3 : MonoBehaviour if (state == BattleState.WON) { dialogueText.text = "Victory!"; - SceneManager.LoadScene("2D_3B"); + SceneManager.LoadScene("Winner"); } else if (state == BattleState.LOST) diff --git a/RPG/Assets/Scenes/2D_3B.unity b/RPG/Assets/Scenes/2D_3B.unity index b1f1ffc..11a9ab2 100644 --- a/RPG/Assets/Scenes/2D_3B.unity +++ b/RPG/Assets/Scenes/2D_3B.unity @@ -953,7 +953,7 @@ GameObject: - component: {fileID: 1051997526} m_Layer: 0 m_Name: Cube - m_TagString: Cube3 + m_TagString: Blank m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 diff --git a/RPG/Assets/Scenes/2D_4.unity b/RPG/Assets/Scenes/Blank.unity similarity index 100% rename from RPG/Assets/Scenes/2D_4.unity rename to RPG/Assets/Scenes/Blank.unity diff --git a/RPG/Assets/Scenes/2D_4.unity.meta b/RPG/Assets/Scenes/Blank.unity.meta similarity index 100% rename from RPG/Assets/Scenes/2D_4.unity.meta rename to RPG/Assets/Scenes/Blank.unity.meta diff --git a/RPG/Assets/Scenes/Mage.unity b/RPG/Assets/Scenes/Mage.unity index 809e624..5e47fbf 100644 --- a/RPG/Assets/Scenes/Mage.unity +++ b/RPG/Assets/Scenes/Mage.unity @@ -4654,7 +4654,7 @@ MonoBehaviour: unitName: Mage unitLevel: 2 damage0: 0 - damage: 12 + damage: 10 damage2: 0 damage3: 0 maxHP: 35 diff --git a/RPG/Assets/Scripts/PlayerController.cs b/RPG/Assets/Scripts/PlayerController.cs index efd2bbb..37d579b 100644 --- a/RPG/Assets/Scripts/PlayerController.cs +++ b/RPG/Assets/Scripts/PlayerController.cs @@ -95,9 +95,9 @@ public class PlayerController : MonoBehaviour { SceneManager.LoadScene("Yourself"); - if (other.gameObject.CompareTag("Cube3")) + if (other.gameObject.CompareTag("Blank")) { - SceneManager.LoadScene("2D_4"); + SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex + 1); } if (other.gameObject.CompareTag("CubeBattle")) diff --git a/RPG/Build/Build/Build/Build.data.unityweb b/RPG/Build/Build/Build/Build.data.unityweb new file mode 100644 index 0000000..7d174d5 Binary files /dev/null and b/RPG/Build/Build/Build/Build.data.unityweb differ diff --git a/RPG/Build/Build/Build/Build.json b/RPG/Build/Build/Build/Build.json new file mode 100644 index 0000000..9ddf15c --- /dev/null +++ b/RPG/Build/Build/Build/Build.json @@ -0,0 +1,13 @@ +{ +"companyName": "DefaultCompany", +"productName": "RPG", +"dataUrl": "Build.data.unityweb", +"wasmCodeUrl": "Build.wasm.code.unityweb", +"wasmFrameworkUrl": "Build.wasm.framework.unityweb", +"TOTAL_MEMORY": 268435456, +"graphicsAPI": ["WebGL 2.0", "WebGL 1.0"], +"webglContextAttributes": {"preserveDrawingBuffer": false}, +"splashScreenStyle": "Dark", +"backgroundColor": "#231F20", +"cacheControl": {"default": "must-revalidate"} +} \ No newline at end of file diff --git a/RPG/Build/Build/Build/Build.wasm.code.unityweb b/RPG/Build/Build/Build/Build.wasm.code.unityweb new file mode 100644 index 0000000..6ab97aa Binary files /dev/null and b/RPG/Build/Build/Build/Build.wasm.code.unityweb differ diff --git a/RPG/Build/Build/Build/Build.wasm.framework.unityweb b/RPG/Build/Build/Build/Build.wasm.framework.unityweb new file mode 100644 index 0000000..2cb26fe --- /dev/null +++ b/RPG/Build/Build/Build/Build.wasm.framework.unityweb @@ -0,0 +1,27041 @@ +(function(Module) { +var Module = typeof Module !== "undefined" ? Module : {}; +Module["preRun"].push((function() { + var unityFileSystemInit = Module["unityFileSystemInit"] || (function() { + if (!Module.indexedDB) { + console.log("IndexedDB is not available. Data will not persist in cache and PlayerPrefs will not be saved."); + } + FS.mkdir("/idbfs"); + FS.mount(IDBFS, {}, "/idbfs"); + Module.addRunDependency("JS_FileSystem_Mount"); + FS.syncfs(true, (function(err) { + Module.removeRunDependency("JS_FileSystem_Mount"); + })); + }); + unityFileSystemInit(); +})); +Module["SetFullscreen"] = (function(fullscreen) { + if (typeof runtimeInitialized === "undefined" || !runtimeInitialized) { + console.log("Runtime not initialized yet."); + } else if (typeof JSEvents === "undefined") { + console.log("Player not loaded yet."); + } else { + var tmp = JSEvents.canPerformEventHandlerRequests; + JSEvents.canPerformEventHandlerRequests = (function() { + return 1; + }); + Module.ccall("SetFullscreen", null, [ "number" ], [ fullscreen ]); + JSEvents.canPerformEventHandlerRequests = tmp; + } +}); +Module["demangle"] = demangle || (function(symbol) { + return symbol; +}); +var MediaDevices = []; +Module["preRun"].push((function() { + var enumerateMediaDevices = (function() { + var getMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia; + if (!getMedia) return; + function addDevice(label) { + label = label ? label : "device #" + MediaDevices.length; + var device = { + deviceName: label, + refCount: 0, + video: null + }; + MediaDevices.push(device); + } + if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) { + if (typeof MediaStreamTrack == "undefined" || typeof MediaStreamTrack.getSources == "undefined") { + console.log("Media Devices cannot be enumerated on this browser."); + return; + } + function gotSources(sourceInfos) { + for (var i = 0; i !== sourceInfos.length; ++i) { + var sourceInfo = sourceInfos[i]; + if (sourceInfo.kind === "video") addDevice(sourceInfo.label); + } + } + MediaStreamTrack.getSources(gotSources); + } + navigator.mediaDevices.enumerateDevices().then((function(devices) { + devices.forEach((function(device) { + if (device.kind == "videoinput") addDevice(device.label); + })); + })).catch((function(err) { + console.log(err.name + ": " + error.message); + })); + }); + enumerateMediaDevices(); +})); +function SendMessage(gameObject, func, param) { + if (param === undefined) Module.ccall("SendMessage", null, [ "string", "string" ], [ gameObject, func ]); else if (typeof param === "string") Module.ccall("SendMessageString", null, [ "string", "string", "string" ], [ gameObject, func, param ]); else if (typeof param === "number") Module.ccall("SendMessageFloat", null, [ "string", "string", "number" ], [ gameObject, func, param ]); else throw "" + param + " is does not have a type which is supported by SendMessage."; +} +Module["SendMessage"] = SendMessage; +var moduleOverrides = {}; +var key; +for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key]; + } +} +Module["arguments"] = []; +Module["thisProgram"] = "./this.program"; +Module["quit"] = (function(status, toThrow) { + throw toThrow; +}); +Module["preRun"] = []; +Module["postRun"] = []; +var ENVIRONMENT_IS_WEB = false; +var ENVIRONMENT_IS_WORKER = false; +var ENVIRONMENT_IS_NODE = false; +var ENVIRONMENT_IS_SHELL = false; +if (Module["ENVIRONMENT"]) { + if (Module["ENVIRONMENT"] === "WEB") { + ENVIRONMENT_IS_WEB = true; + } else if (Module["ENVIRONMENT"] === "WORKER") { + ENVIRONMENT_IS_WORKER = true; + } else if (Module["ENVIRONMENT"] === "NODE") { + ENVIRONMENT_IS_NODE = true; + } else if (Module["ENVIRONMENT"] === "SHELL") { + ENVIRONMENT_IS_SHELL = true; + } else { + throw new Error("Module['ENVIRONMENT'] value is not valid. must be one of: WEB|WORKER|NODE|SHELL."); + } +} else { + ENVIRONMENT_IS_WEB = typeof window === "object"; + ENVIRONMENT_IS_WORKER = typeof importScripts === "function"; + ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; + ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; +} +if (ENVIRONMENT_IS_NODE) { + var nodeFS; + var nodePath; + Module["read"] = function shell_read(filename, binary) { + var ret; + if (!nodeFS) nodeFS = require("fs"); + if (!nodePath) nodePath = require("path"); + filename = nodePath["normalize"](filename); + ret = nodeFS["readFileSync"](filename); + return binary ? ret : ret.toString(); + }; + Module["readBinary"] = function readBinary(filename) { + var ret = Module["read"](filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + if (process["argv"].length > 1) { + Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/"); + } + Module["arguments"] = process["argv"].slice(2); + if (typeof module !== "undefined") { + module["exports"] = Module; + } + process["on"]("uncaughtException", (function(ex) { + if (!(ex instanceof ExitStatus)) { + throw ex; + } + })); + process["on"]("unhandledRejection", (function(reason, p) { + Module["printErr"]("node.js exiting due to unhandled promise rejection"); + process["exit"](1); + })); + Module["inspect"] = (function() { + return "[Emscripten Module object]"; + }); +} else if (ENVIRONMENT_IS_SHELL) { + if (typeof read != "undefined") { + Module["read"] = function shell_read(f) { + return read(f); + }; + } + Module["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") { + Module["arguments"] = scriptArgs; + } else if (typeof arguments != "undefined") { + Module["arguments"] = arguments; + } + if (typeof quit === "function") { + Module["quit"] = (function(status, toThrow) { + quit(status); + }); + } +} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + Module["read"] = function shell_read(url) { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.send(null); + return xhr.responseText; + }; + if (ENVIRONMENT_IS_WORKER) { + Module["readBinary"] = function readBinary(url) { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + Module["readAsync"] = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || xhr.status == 0 && xhr.response) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + Module["setWindowTitle"] = (function(title) { + document.title = title; + }); +} else { + throw new Error("unknown runtime environment"); +} +Module["print"] = typeof console !== "undefined" ? console.log.bind(console) : typeof print !== "undefined" ? print : null; +Module["printErr"] = typeof printErr !== "undefined" ? printErr : typeof console !== "undefined" && console.warn.bind(console) || Module["print"]; +Module.print = Module["print"]; +Module.printErr = Module["printErr"]; +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} +moduleOverrides = undefined; +var STACK_ALIGN = 16; +stackSave = stackRestore = stackAlloc = setTempRet0 = getTempRet0 = (function() { + abort("cannot use the stack before compiled code is ready to run, and has provided stack access"); +}); +function staticAlloc(size) { + assert(!staticSealed); + var ret = STATICTOP; + STATICTOP = STATICTOP + size + 15 & -16; + return ret; +} +function dynamicAlloc(size) { + assert(DYNAMICTOP_PTR); + var ret = HEAP32[DYNAMICTOP_PTR >> 2]; + var end = ret + size + 15 & -16; + HEAP32[DYNAMICTOP_PTR >> 2] = end; + if (end >= TOTAL_MEMORY) { + var success = enlargeMemory(); + if (!success) { + HEAP32[DYNAMICTOP_PTR >> 2] = ret; + return 0; + } + } + return ret; +} +function alignMemory(size, factor) { + if (!factor) factor = STACK_ALIGN; + var ret = size = Math.ceil(size / factor) * factor; + return ret; +} +function getNativeTypeSize(type) { + switch (type) { + case "i1": + case "i8": + return 1; + case "i16": + return 2; + case "i32": + return 4; + case "i64": + return 8; + case "float": + return 4; + case "double": + return 8; + default: + { + if (type[type.length - 1] === "*") { + return 4; + } else if (type[0] === "i") { + var bits = parseInt(type.substr(1)); + assert(bits % 8 === 0); + return bits / 8; + } else { + return 0; + } + } + } +} +function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + Module.printErr(text); + } +} +var jsCallStartIndex = 1; +var functionPointers = new Array(0); +function addFunction(func, sig) { + if (typeof sig === "undefined") { + Module.printErr("Warning: addFunction: Provide a wasm function signature " + "string as a second argument"); + } + var base = 0; + for (var i = base; i < base + 0; i++) { + if (!functionPointers[i]) { + functionPointers[i] = func; + return jsCallStartIndex + i; + } + } + throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."; +} +var funcWrappers = {}; +function getFuncWrapper(func, sig) { + if (!func) return; + assert(sig); + if (!funcWrappers[sig]) { + funcWrappers[sig] = {}; + } + var sigCache = funcWrappers[sig]; + if (!sigCache[func]) { + 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 { + 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 : +(low >>> 0) + +(high | 0) * 4294967296; +} +function dynCall(sig, ptr, args) { + if (args && args.length) { + assert(args.length == sig.length - 1); + 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 GLOBAL_BASE = 1024; +var ABORT = 0; +var EXITSTATUS = 0; +function assert(condition, text) { + if (!condition) { + abort("Assertion failed: " + text); + } +} +function getCFunc(ident) { + var func = Module["_" + ident]; + assert(func, "Cannot call unknown function " + ident + ", make sure it is exported"); + return func; +} +var JSfuncs = { + "stackSave": (function() { + stackSave(); + }), + "stackRestore": (function() { + stackRestore(); + }), + "arrayToC": (function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + }), + "stringToC": (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; + }) +}; +var toC = { + "string": JSfuncs["stringToC"], + "array": JSfuncs["arrayToC"] +}; +function ccall(ident, returnType, argTypes, args, opts) { + 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); + if (returnType === "string") ret = Pointer_stringify(ret); else if (returnType === "boolean") ret = Boolean(ret); + if (stack !== 0) { + stackRestore(stack); + } + return ret; +} +function cwrap(ident, returnType, argTypes) { + argTypes = argTypes || []; + var cfunc = getCFunc(ident); + var numericArgs = argTypes.every((function(type) { + return type === "number"; + })); + var numericRet = returnType !== "string"; + if (numericRet && numericArgs) { + return cfunc; + } + return (function() { + return ccall(ident, returnType, argTypes, arguments); + }); +} +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 ALLOC_NORMAL = 0; +var ALLOC_STACK = 1; +var ALLOC_STATIC = 2; +var ALLOC_NONE = 4; +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 = [ typeof _malloc === "function" ? _malloc : staticAlloc, stackAlloc, staticAlloc, dynamicAlloc ][allocator === undefined ? ALLOC_STATIC : 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(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"; + setValue(ret + i, curr, type); + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type; + } + i += typeSize; + } + return ret; +} +function Pointer_stringify(ptr, length) { + if (length === 0 || !ptr) return ""; + var hasUtf = 0; + var t; + var i = 0; + while (1) { + assert(ptr + i < TOTAL_MEMORY); + t = HEAPU8[ptr + i >> 0]; + hasUtf |= t; + if (t == 0 && !length) break; + i++; + if (length && i == length) break; + } + if (!length) length = i; + var ret = ""; + if (hasUtf < 128) { + var MAX_CHUNK = 1024; + var curr; + while (length > 0) { + curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK))); + ret = ret ? ret + curr : curr; + ptr += MAX_CHUNK; + length -= MAX_CHUNK; + } + return ret; + } + return UTF8ToString(ptr); +} +var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined; +function UTF8ArrayToString(u8Array, idx) { + var endPtr = idx; + while (u8Array[endPtr]) ++endPtr; + if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { + return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); + } else { + var u0, u1, u2, u3, u4, u5; + var str = ""; + while (1) { + u0 = u8Array[idx++]; + if (!u0) return str; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + u1 = u8Array[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode((u0 & 31) << 6 | u1); + continue; + } + u2 = u8Array[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = (u0 & 15) << 12 | u1 << 6 | u2; + } else { + u3 = u8Array[idx++] & 63; + if ((u0 & 248) == 240) { + u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3; + } else { + u4 = u8Array[idx++] & 63; + if ((u0 & 252) == 248) { + u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4; + } else { + u5 = u8Array[idx++] & 63; + u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5; + } + } + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } + } + } +} +function UTF8ToString(ptr) { + return UTF8ArrayToString(HEAPU8, ptr); +} +function stringToUTF8Array(str, outU8Array, 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) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023; + if (u <= 127) { + if (outIdx >= endIdx) break; + outU8Array[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + outU8Array[outIdx++] = 192 | u >> 6; + outU8Array[outIdx++] = 128 | u & 63; + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + outU8Array[outIdx++] = 224 | u >> 12; + outU8Array[outIdx++] = 128 | u >> 6 & 63; + outU8Array[outIdx++] = 128 | u & 63; + } else if (u <= 2097151) { + if (outIdx + 3 >= endIdx) break; + outU8Array[outIdx++] = 240 | u >> 18; + outU8Array[outIdx++] = 128 | u >> 12 & 63; + outU8Array[outIdx++] = 128 | u >> 6 & 63; + outU8Array[outIdx++] = 128 | u & 63; + } else if (u <= 67108863) { + if (outIdx + 4 >= endIdx) break; + outU8Array[outIdx++] = 248 | u >> 24; + outU8Array[outIdx++] = 128 | u >> 18 & 63; + outU8Array[outIdx++] = 128 | u >> 12 & 63; + outU8Array[outIdx++] = 128 | u >> 6 & 63; + outU8Array[outIdx++] = 128 | u & 63; + } else { + if (outIdx + 5 >= endIdx) break; + outU8Array[outIdx++] = 252 | u >> 30; + outU8Array[outIdx++] = 128 | u >> 24 & 63; + outU8Array[outIdx++] = 128 | u >> 18 & 63; + outU8Array[outIdx++] = 128 | u >> 12 & 63; + outU8Array[outIdx++] = 128 | u >> 6 & 63; + outU8Array[outIdx++] = 128 | u & 63; + } + } + outU8Array[outIdx] = 0; + return outIdx - startIdx; +} +function stringToUTF8(str, outPtr, maxBytesToWrite) { + assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"); + return stringToUTF8Array(str, 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 if (u <= 2097151) { + len += 4; + } else if (u <= 67108863) { + len += 5; + } else { + len += 6; + } + } + return len; +} +var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined; +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} +function demangle(func) { + var __cxa_demangle_func = Module["___cxa_demangle"] || Module["__cxa_demangle"]; + assert(__cxa_demangle_func); + try { + var s = func.substr(1); + var len = lengthBytesUTF8(s) + 1; + var buf = _malloc(len); + stringToUTF8(s, buf, len); + var status = _malloc(4); + var ret = __cxa_demangle_func(buf, 0, 0, status); + if (HEAP32[status >> 2] === 0 && ret) { + return Pointer_stringify(ret); + } + } catch (e) {} finally { + if (buf) _free(buf); + if (status) _free(status); + if (ret) _free(ret); + } + return func; +} +function demangleAll(text) { + var regex = /__Z[\w\d_]+/g; + return text.replace(regex, (function(x) { + var y = demangle(x); + return x === y ? x : x + " [" + y + "]"; + })); +} +function jsStackTrace() { + var err = new Error; + if (!err.stack) { + try { + throw new Error(0); + } 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); +} +var PAGE_SIZE = 16384; +var WASM_PAGE_SIZE = 65536; +var ASMJS_PAGE_SIZE = 16777216; +var MIN_TOTAL_MEMORY = 16777216; +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 updateGlobalBuffer(buf) { + Module["buffer"] = buffer = buf; +} +function updateGlobalBufferViews() { + Module["HEAP8"] = HEAP8 = new Int8Array(buffer); + Module["HEAP16"] = HEAP16 = new Int16Array(buffer); + Module["HEAP32"] = HEAP32 = new Int32Array(buffer); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer); + Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer); + Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer); +} +var STATIC_BASE, STATICTOP, staticSealed; +var STACK_BASE, STACKTOP, STACK_MAX; +var DYNAMIC_BASE, DYNAMICTOP_PTR; +STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0; +staticSealed = false; +function writeStackCookie() { + assert((STACK_MAX & 3) == 0); + HEAPU32[(STACK_MAX >> 2) - 1] = 34821223; + HEAPU32[(STACK_MAX >> 2) - 2] = 2310721022; +} +function checkStackCookie() { + if (HEAPU32[(STACK_MAX >> 2) - 1] != 34821223 || HEAPU32[(STACK_MAX >> 2) - 2] != 2310721022) { + abort("Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x02135467, but received 0x" + HEAPU32[(STACK_MAX >> 2) - 2].toString(16) + " " + HEAPU32[(STACK_MAX >> 2) - 1].toString(16)); + } + if (HEAP32[0] !== 1668509029) throw "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!"); +} +function abortOnCannotGrowMemory() { + abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value " + TOTAL_MEMORY + ", (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 "); +} +if (!Module["reallocBuffer"]) Module["reallocBuffer"] = (function(size) { + var ret; + try { + if (ArrayBuffer.transfer) { + ret = ArrayBuffer.transfer(buffer, size); + } else { + var oldHEAP8 = HEAP8; + ret = new ArrayBuffer(size); + var temp = new Int8Array(ret); + temp.set(oldHEAP8); + } + } catch (e) { + return false; + } + var success = _emscripten_replace_memory(ret); + if (!success) return false; + return ret; +}); +function enlargeMemory() { + assert(HEAP32[DYNAMICTOP_PTR >> 2] > TOTAL_MEMORY); + var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; + var LIMIT = 2147483648 - PAGE_MULTIPLE; + if (HEAP32[DYNAMICTOP_PTR >> 2] > LIMIT) { + Module.printErr("Cannot enlarge memory, asked to go up to " + HEAP32[DYNAMICTOP_PTR >> 2] + " bytes, but the limit is " + LIMIT + " bytes!"); + return false; + } + var OLD_TOTAL_MEMORY = TOTAL_MEMORY; + TOTAL_MEMORY = Math.max(TOTAL_MEMORY, MIN_TOTAL_MEMORY); + while (TOTAL_MEMORY < HEAP32[DYNAMICTOP_PTR >> 2]) { + if (TOTAL_MEMORY <= 536870912) { + TOTAL_MEMORY = alignUp(2 * TOTAL_MEMORY, PAGE_MULTIPLE); + } else { + TOTAL_MEMORY = Math.min(alignUp((3 * TOTAL_MEMORY + 2147483648) / 4, PAGE_MULTIPLE), LIMIT); + } + } + var start = Date.now(); + var replacement = Module["reallocBuffer"](TOTAL_MEMORY); + if (!replacement || replacement.byteLength != TOTAL_MEMORY) { + Module.printErr("Failed to grow the heap from " + OLD_TOTAL_MEMORY + " bytes to " + TOTAL_MEMORY + " bytes, not enough memory!"); + if (replacement) { + Module.printErr("Expected to get back a buffer of size " + TOTAL_MEMORY + " bytes, but instead got back a buffer of size " + replacement.byteLength); + } + TOTAL_MEMORY = OLD_TOTAL_MEMORY; + return false; + } + updateGlobalBuffer(replacement); + updateGlobalBufferViews(); + if (!Module["usingWasm"]) { + Module.printErr("Warning: Enlarging memory arrays, this is not fast! " + [ OLD_TOTAL_MEMORY, TOTAL_MEMORY ]); + } + return true; +} +var byteLength; +try { + byteLength = Function.prototype.call.bind(Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get); + byteLength(new ArrayBuffer(4)); +} catch (e) { + byteLength = (function(buffer) { + return buffer.byteLength; + }); +} +var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880; +var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 268435456; +if (TOTAL_MEMORY < TOTAL_STACK) Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")"); +assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, "JS engine does not provide full typed array support"); +if (Module["buffer"]) { + buffer = Module["buffer"]; + assert(buffer.byteLength === TOTAL_MEMORY, "provided buffer should be " + TOTAL_MEMORY + " bytes, but it is " + buffer.byteLength); +} else { + if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") { + assert(TOTAL_MEMORY % WASM_PAGE_SIZE === 0); + Module["wasmMemory"] = new WebAssembly.Memory({ + "initial": TOTAL_MEMORY / WASM_PAGE_SIZE + }); + buffer = Module["wasmMemory"].buffer; + } else { + buffer = new ArrayBuffer(TOTAL_MEMORY); + } + assert(buffer.byteLength === TOTAL_MEMORY); + Module["buffer"] = buffer; +} +updateGlobalBufferViews(); +function getTotalMemory() { + return TOTAL_MEMORY; +} +HEAP32[0] = 1668509029; +HEAP16[1] = 25459; +if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99) throw "Runtime error: expected the system to be little-endian!"; +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__ = []; +var __ATINIT__ = []; +var __ATMAIN__ = []; +var __ATEXIT__ = []; +var __ATPOSTRUN__ = []; +var runtimeInitialized = false; +var runtimeExited = false; +function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); +} +function ensureInitRuntime() { + checkStackCookie(); + if (runtimeInitialized) return; + runtimeInitialized = true; + callRuntimeCallbacks(__ATINIT__); +} +function preMain() { + checkStackCookie(); + callRuntimeCallbacks(__ATMAIN__); +} +function exitRuntime() { + checkStackCookie(); + callRuntimeCallbacks(__ATEXIT__); + 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 addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} +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); +} +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === str.charCodeAt(i) & 255); + HEAP8[buffer++ >> 0] = str.charCodeAt(i); + } + if (!dontAddNull) HEAP8[buffer >> 0] = 0; +} +function unSign(value, bits, ignore) { + if (value >= 0) { + return value; + } + return bits <= 32 ? 2 * Math.abs(1 << bits - 1) + value : Math.pow(2, bits) + value; +} +function reSign(value, bits, ignore) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << bits - 1) : Math.pow(2, bits - 1); + if (value >= half && (bits <= 32 || value > half)) { + value = -2 * half + value; + } + return value; +} +assert(Math["imul"] && Math["fround"] && Math["clz32"] && Math["trunc"], "this is a legacy browser, build with LEGACY_VM_SUPPORT"); +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; +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; +var runDependencyTracking = {}; +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } + return id; +} +function addRunDependency(id) { + runDependencies++; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval !== "undefined") { + runDependencyWatcher = setInterval((function() { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + Module.printErr("still waiting on run dependencies:"); + } + Module.printErr("dependency: " + dep); + } + if (shown) { + Module.printErr("(end of list)"); + } + }), 1e4); + } + } else { + Module.printErr("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 { + Module.printErr("warning: run dependency removed without ID"); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } +} +Module["preloadedImages"] = {}; +Module["preloadedAudios"] = {}; +var dataURIPrefix = "data:application/octet-stream;base64,"; +function isDataURI(filename) { + return String.prototype.startsWith ? filename.startsWith(dataURIPrefix) : filename.indexOf(dataURIPrefix) === 0; +} +function integrateWasmJS() { + var wasmTextFile = "build.wast"; + var wasmBinaryFile = "build.wasm"; + var asmjsCodeFile = "build.temp.asm.js"; + if (typeof Module["locateFile"] === "function") { + if (!isDataURI(wasmTextFile)) { + wasmTextFile = Module["locateFile"](wasmTextFile); + } + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = Module["locateFile"](wasmBinaryFile); + } + if (!isDataURI(asmjsCodeFile)) { + asmjsCodeFile = Module["locateFile"](asmjsCodeFile); + } + } + var wasmPageSize = 64 * 1024; + var info = { + "global": null, + "env": null, + "asm2wasm": { + "f64-rem": (function(x, y) { + return x % y; + }), + "debugger": (function() { + debugger; + }) + }, + "parent": Module + }; + var exports = null; + function mergeMemory(newBuffer) { + var oldBuffer = Module["buffer"]; + if (newBuffer.byteLength < oldBuffer.byteLength) { + Module["printErr"]("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here"); + } + var oldView = new Int8Array(oldBuffer); + var newView = new Int8Array(newBuffer); + newView.set(oldView); + updateGlobalBuffer(newBuffer); + updateGlobalBufferViews(); + } + function fixImports(imports) { + return imports; + } + function getBinary() { + try { + if (Module["wasmBinary"]) { + return new Uint8Array(Module["wasmBinary"]); + } + if (Module["readBinary"]) { + return Module["readBinary"](wasmBinaryFile); + } else { + throw "on the web, we need the wasm binary to be preloaded and set on Module['wasmBinary']. emcc.py will do that for you when generating HTML (but not JS)"; + } + } catch (err) { + abort(err); + } + } + function getBinaryPromise() { + if (!Module["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(); + })); + } + return new Promise((function(resolve, reject) { + resolve(getBinary()); + })); + } + function doNativeWasm(global, env, providedBuffer) { + if (typeof WebAssembly !== "object") { + Module["printErr"]("no native wasm support detected"); + return false; + } + if (!(Module["wasmMemory"] instanceof WebAssembly.Memory)) { + Module["printErr"]("no native wasm Memory in use"); + return false; + } + env["memory"] = Module["wasmMemory"]; + info["global"] = { + "NaN": NaN, + "Infinity": Infinity + }; + info["global.Math"] = Math; + info["env"] = env; + function receiveInstance(instance, module) { + exports = instance.exports; + if (exports.memory) mergeMemory(exports.memory); + Module["asm"] = exports; + Module["usingWasm"] = true; + removeRunDependency("wasm-instantiate"); + } + addRunDependency("wasm-instantiate"); + if (Module["instantiateWasm"]) { + try { + return Module["instantiateWasm"](info, receiveInstance); + } catch (e) { + Module["printErr"]("Module.instantiateWasm callback failed with error: " + e); + return false; + } + } + var trueModule = Module; + function receiveInstantiatedSource(output) { + assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"); + trueModule = null; + receiveInstance(output["instance"], output["module"]); + } + function instantiateArrayBuffer(receiver) { + getBinaryPromise().then((function(binary) { + return WebAssembly.instantiate(binary, info); + })).then(receiver).catch((function(reason) { + Module["printErr"]("failed to asynchronously prepare wasm: " + reason); + abort(reason); + })); + } + if (!Module["wasmBinary"] && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") { + WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, { + credentials: "same-origin" + }), info).then(receiveInstantiatedSource).catch((function(reason) { + Module["printErr"]("wasm streaming compile failed: " + reason); + Module["printErr"]("falling back to ArrayBuffer instantiation"); + instantiateArrayBuffer(receiveInstantiatedSource); + })); + } else { + instantiateArrayBuffer(receiveInstantiatedSource); + } + return {}; + } + Module["asmPreload"] = Module["asm"]; + var asmjsReallocBuffer = Module["reallocBuffer"]; + var wasmReallocBuffer = (function(size) { + var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; + size = alignUp(size, PAGE_MULTIPLE); + var old = Module["buffer"]; + var oldSize = old.byteLength; + if (Module["usingWasm"]) { + try { + var result = Module["wasmMemory"].grow((size - oldSize) / wasmPageSize); + if (result !== (-1 | 0)) { + return Module["buffer"] = Module["wasmMemory"].buffer; + } else { + return null; + } + } catch (e) { + console.error("Module.reallocBuffer: Attempted to grow from " + oldSize + " bytes to " + size + " bytes, but got error: " + e); + return null; + } + } + }); + Module["reallocBuffer"] = (function(size) { + if (finalMethod === "asmjs") { + return asmjsReallocBuffer(size); + } else { + return wasmReallocBuffer(size); + } + }); + var finalMethod = ""; + Module["asm"] = (function(global, env, providedBuffer) { + env = fixImports(env); + if (!env["table"]) { + var TABLE_SIZE = Module["wasmTableSize"]; + if (TABLE_SIZE === undefined) TABLE_SIZE = 1024; + var MAX_TABLE_SIZE = Module["wasmMaxTableSize"]; + if (typeof WebAssembly === "object" && typeof WebAssembly.Table === "function") { + if (MAX_TABLE_SIZE !== undefined) { + env["table"] = new WebAssembly.Table({ + "initial": TABLE_SIZE, + "maximum": MAX_TABLE_SIZE, + "element": "anyfunc" + }); + } else { + env["table"] = new WebAssembly.Table({ + "initial": TABLE_SIZE, + element: "anyfunc" + }); + } + } else { + env["table"] = new Array(TABLE_SIZE); + } + Module["wasmTable"] = env["table"]; + } + if (!env["memoryBase"]) { + env["memoryBase"] = Module["STATIC_BASE"]; + } + if (!env["tableBase"]) { + env["tableBase"] = 0; + } + var exports; + exports = doNativeWasm(global, env, providedBuffer); + if (!exports) abort("no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: https://github.com/kripken/emscripten/wiki/WebAssembly#binaryen-methods"); + return exports; + }); +} +integrateWasmJS(); +var ASM_CONSTS = [ (function() { + Module["emscripten_get_now_backup"] = performance.now; +}), (function($0) { + performance.now = (function() { + return $0; + }); +}), (function() { + performance.now = Module["emscripten_get_now_backup"]; +}) ]; +function _emscripten_asm_const_i(code) { + return ASM_CONSTS[code](); +} +function _emscripten_asm_const_id(code, a0) { + return ASM_CONSTS[code](a0); +} +STATIC_BASE = GLOBAL_BASE; +STATICTOP = STATIC_BASE + 3362240; +__ATINIT__.push({ + func: (function() { + __GLOBAL__sub_I_AccessibilityScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_AIScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_47(); + }) +}, { + func: (function() { + ___cxx_global_var_init_48(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AI_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AI_Builder_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AI_Crowd_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_AnimationScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_110(); + }) +}, { + func: (function() { + ___cxx_global_var_init_111(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_3_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_5_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_6_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_Director_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Animation_Director_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_AnimationClip_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Avatar_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ConstraintJob_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_7(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ConstraintManager_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_clipmuscle_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ARScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_AssetBundleScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_AudioScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_425(); + }) +}, { + func: (function() { + ___cxx_global_var_init_4(); + }) +}, { + func: (function() { + ___cxx_global_var_init_5(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Audio_Public_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_145(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Audio_Public_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Audio_Public_3_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Video_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ClothScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_21(); + }) +}, { + func: (function() { + ___cxx_global_var_init_22(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Cloth_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_16(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SwCollision_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SwFactory_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SwInterCollision_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SwSelfCollision_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SwSolverKernel_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Input_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_GfxDeviceNull_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SpriteRendererJobs_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_19(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_16_727(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_4_728(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Allocator_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Allocator_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Application_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_BaseClasses_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_BaseClasses_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_BaseClasses_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_BaseClasses_3_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Burst_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_38(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_2_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_120(); + }) +}, { + func: (function() { + ___cxx_global_var_init_121(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_3_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_4_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_65(); + }) +}, { + func: (function() { + ___cxx_global_var_init_66(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_5_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_6_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_7_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Shadows_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_26_2966(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Containers_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_File_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_GameCode_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Geometry_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Geometry_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_1_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_48_729(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_5_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_16_4048(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_6_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_7_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_8_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_9_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_10_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_122(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_11_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_78(); + }) +}, { + func: (function() { + ___cxx_global_var_init_79(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Interfaces_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Interfaces_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Interfaces_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Jobs_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Jobs_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Math_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Math_Random_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Misc_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_73(); + }) +}, { + func: (function() { + ___cxx_global_var_init_75(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Misc_1_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_173(); + }) +}, { + func: (function() { + ___cxx_global_var_init_174(); + }) +}, { + func: (function() { + ___cxx_global_var_init_175(); + }) +}, { + func: (function() { + ___cxx_global_var_init_176(); + }) +}, { + func: (function() { + ___cxx_global_var_init_177(); + }) +}, { + func: (function() { + ___cxx_global_var_init_178(); + }) +}, { + func: (function() { + ___cxx_global_var_init_179(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Misc_2_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_159(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Misc_3_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_13(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Misc_4_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_159_7516(); + }) +}, { + func: (function() { + ___cxx_global_var_init_160(); + }) +}, { + func: (function() { + ___cxx_global_var_init_161(); + }) +}, { + func: (function() { + ___cxx_global_var_init_162(); + }) +}, { + func: (function() { + ___cxx_global_var_init_163(); + }) +}, { + func: (function() { + ___cxx_global_var_init_164(); + }) +}, { + func: (function() { + ___cxx_global_var_init_165(); + }) +}, { + func: (function() { + ___cxx_global_var_init_166(); + }) +}, { + func: (function() { + ___cxx_global_var_init_167(); + }) +}, { + func: (function() { + ___cxx_global_var_init_168(); + }) +}, { + func: (function() { + ___cxx_global_var_init_169(); + }) +}, { + func: (function() { + ___cxx_global_var_init_170(); + }) +}, { + func: (function() { + ___cxx_global_var_init_171(); + }) +}, { + func: (function() { + ___cxx_global_var_init_172(); + }) +}, { + func: (function() { + ___cxx_global_var_init_173_7517(); + }) +}, { + func: (function() { + ___cxx_global_var_init_174_7518(); + }) +}, { + func: (function() { + ___cxx_global_var_init_175_7519(); + }) +}, { + func: (function() { + ___cxx_global_var_init_176_7520(); + }) +}, { + func: (function() { + ___cxx_global_var_init_177_7521(); + }) +}, { + func: (function() { + ___cxx_global_var_init_178_7522(); + }) +}, { + func: (function() { + ___cxx_global_var_init_179_7523(); + }) +}, { + func: (function() { + ___cxx_global_var_init_180(); + }) +}, { + func: (function() { + ___cxx_global_var_init_181(); + }) +}, { + func: (function() { + ___cxx_global_var_init_182(); + }) +}, { + func: (function() { + ___cxx_global_var_init_183(); + }) +}, { + func: (function() { + ___cxx_global_var_init_184(); + }) +}, { + func: (function() { + ___cxx_global_var_init_185(); + }) +}, { + func: (function() { + ___cxx_global_var_init_186(); + }) +}, { + func: (function() { + ___cxx_global_var_init_187(); + }) +}, { + func: (function() { + ___cxx_global_var_init_188(); + }) +}, { + func: (function() { + ___cxx_global_var_init_189(); + }) +}, { + func: (function() { + ___cxx_global_var_init_190(); + }) +}, { + func: (function() { + ___cxx_global_var_init_191(); + }) +}, { + func: (function() { + ___cxx_global_var_init_192(); + }) +}, { + func: (function() { + ___cxx_global_var_init_193(); + }) +}, { + func: (function() { + ___cxx_global_var_init_194(); + }) +}, { + func: (function() { + ___cxx_global_var_init_195(); + }) +}, { + func: (function() { + ___cxx_global_var_init_196(); + }) +}, { + func: (function() { + ___cxx_global_var_init_197(); + }) +}, { + func: (function() { + ___cxx_global_var_init_198(); + }) +}, { + func: (function() { + ___cxx_global_var_init_199(); + }) +}, { + func: (function() { + ___cxx_global_var_init_200(); + }) +}, { + func: (function() { + ___cxx_global_var_init_201(); + }) +}, { + func: (function() { + ___cxx_global_var_init_202(); + }) +}, { + func: (function() { + ___cxx_global_var_init_203(); + }) +}, { + func: (function() { + ___cxx_global_var_init_204(); + }) +}, { + func: (function() { + ___cxx_global_var_init_205(); + }) +}, { + func: (function() { + ___cxx_global_var_init_206(); + }) +}, { + func: (function() { + ___cxx_global_var_init_207(); + }) +}, { + func: (function() { + ___cxx_global_var_init_208(); + }) +}, { + func: (function() { + ___cxx_global_var_init_209(); + }) +}, { + func: (function() { + ___cxx_global_var_init_210(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Misc_5_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Network_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_28_7904(); + }) +}, { + func: (function() { + ___cxx_global_var_init_29(); + }) +}, { + func: (function() { + ___cxx_global_var_init_30_7905(); + }) +}, { + func: (function() { + ___cxx_global_var_init_31(); + }) +}, { + func: (function() { + ___cxx_global_var_init_32_7906(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_PreloadManager_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Profiler_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Profiler_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Profiler_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_19_8116(); + }) +}, { + func: (function() { + ___cxx_global_var_init_20_8117(); + }) +}, { + func: (function() { + ___cxx_global_var_init_21_730(); + }) +}, { + func: (function() { + ___cxx_global_var_init_22_8118(); + }) +}, { + func: (function() { + ___cxx_global_var_init_23_8119(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_SceneManager_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_75_8232(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Shaders_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Shaders_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Shaders_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Streaming_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Streaming_1_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_17(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Transform_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Transform_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Utilities_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Utilities_5_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Utilities_6_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Utilities_7_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Utilities_8_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Utilities_9_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_AssetBundleFileSystem_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Modules_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Profiler_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Profiler_Public_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Export_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_UnsafeUtility_bindings_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_45(); + }) +}, { + func: (function() { + ___cxx_global_var_init_46(); + }) +}, { + func: (function() { + ___cxx_global_var_init_47_731(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_GfxDevice_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_GfxDevice_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_GfxDevice_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_GfxDevice_3_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_PluginInterface_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_34(); + }) +}, { + func: (function() { + ___cxx_global_var_init_35(); + }) +}, { + func: (function() { + ___cxx_global_var_init_36(); + }) +}, { + func: (function() { + ___cxx_global_var_init_37(); + }) +}, { + func: (function() { + ___cxx_global_var_init_38_11026(); + }) +}, { + func: (function() { + ___cxx_global_var_init_39(); + }) +}, { + func: (function() { + ___cxx_global_var_init_40(); + }) +}, { + func: (function() { + ___cxx_global_var_init_41(); + }) +}, { + func: (function() { + ___cxx_global_var_init_42(); + }) +}, { + func: (function() { + ___cxx_global_var_init_43(); + }) +}, { + func: (function() { + ___cxx_global_var_init_44(); + }) +}, { + func: (function() { + ___cxx_global_var_init_45_11027(); + }) +}, { + func: (function() { + ___cxx_global_var_init_46_11028(); + }) +}, { + func: (function() { + ___cxx_global_var_init_47_11029(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Director_Core_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_127(); + }) +}, { + func: (function() { + ___cxx_global_var_init_128(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Scripting_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_34_11610(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Scripting_3_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_55(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Mono_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Serialize_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_14(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SparseTextureGLES_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_TransformFeedbackSkinning_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_LineRenderer_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_TrailRenderer_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_SkinnedMeshRendererManager_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_20_15986(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_LogAssert_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Shader_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Transform_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_DirectorScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_GridScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Grid_Public_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_3057(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_IMGUIScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_IMGUI_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_24_3154(); + }) +}, { + func: (function() { + ___cxx_global_var_init_25(); + }) +}, { + func: (function() { + ___cxx_global_var_init_26_3155(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_IMGUI_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_InputScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_38_3480(); + }) +}, { + func: (function() { + ___cxx_global_var_init_39_3481(); + }) +}, { + func: (function() { + ___cxx_global_var_init_40_3482(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ParticleSystemGeometryJob_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_26_3483(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ParticleSystemRenderer_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ShapeModule_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_4149(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Physics2DScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_109(); + }) +}, { + func: (function() { + ___cxx_global_var_init_110_4202(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Physics2D_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_PhysicsScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_79_4682(); + }) +}, { + func: (function() { + ___cxx_global_var_init_80(); + }) +}, { + func: (function() { + ___cxx_global_var_init_81(); + }) +}, { + func: (function() { + ___cxx_global_var_init_82(); + }) +}, { + func: (function() { + ___cxx_global_var_init_83(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Dynamics_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Dynamics_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Dynamics_3_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_PhysicsQuery_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_PhysicsScene_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_7_5458(); + }) +}, { + func: (function() { + ___cxx_global_var_init_11(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_3_5530(); + }) +}, { + func: (function() { + ___cxx_global_var_init_5581(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_TerrainScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_111_5625(); + }) +}, { + func: (function() { + ___cxx_global_var_init_112(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Terrain_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Terrain_Public_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Terrain_Public_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Terrain_VR_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_TextCoreScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_TextRenderingScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_6006(); + }) +}, { + func: (function() { + ___cxx_global_var_init_34_6007(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_TilemapScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Tilemap_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_44_6207(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_UIElementsScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_External_Yoga_Yoga_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_UIElements_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_UIScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_36_6476(); + }) +}, { + func: (function() { + ___cxx_global_var_init_37_6477(); + }) +}, { + func: (function() { + ___cxx_global_var_init_38_6478(); + }) +}, { + func: (function() { + ___cxx_global_var_init_39_6479(); + }) +}, { + func: (function() { + ___cxx_global_var_init_40_6480(); + }) +}, { + func: (function() { + ___cxx_global_var_init_41_6481(); + }) +}, { + func: (function() { + ___cxx_global_var_init_42_6482(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_UI_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_UI_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_UI_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_umbra_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_6718(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_46_6730(); + }) +}, { + func: (function() { + ___cxx_global_var_init_6731(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_UnityAdsSettings_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_Vehicles_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_VFXScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_67(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_VFX_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_VFX_Public_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_VFX_Public_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_VideoScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_7731(); + }) +}, { + func: (function() { + ___cxx_global_var_init_1_7732(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Video_Public_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_VRScriptingClasses_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_36_7915(); + }) +}, { + func: (function() { + ___cxx_global_var_init_37_7916(); + }) +}, { + func: (function() { + ___cxx_global_var_init_38_7917(); + }) +}, { + func: (function() { + ___cxx_global_var_init_39_7918(); + }) +}, { + func: (function() { + ___cxx_global_var_init_40_7919(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_VR_0_cpp(); + }) +}, { + func: (function() { + ___cxx_global_var_init_16_7920(); + }) +}, { + func: (function() { + ___cxx_global_var_init_17_7921(); + }) +}, { + func: (function() { + ___cxx_global_var_init_18_7922(); + }) +}, { + func: (function() { + ___cxx_global_var_init_19_7923(); + }) +}, { + func: (function() { + ___cxx_global_var_init_20_7924(); + }) +}, { + func: (function() { + ___cxx_global_var_init_21_7925(); + }) +}, { + func: (function() { + ___cxx_global_var_init_22_7926(); + }) +}, { + func: (function() { + ___cxx_global_var_init_23(); + }) +}, { + func: (function() { + ___cxx_global_var_init_24_7927(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_VR_2_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Wind_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_XRScriptingClasses_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Class_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_MetadataCache_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_threadpool_ms_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_File_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Reflection_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Thread_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ArrayMetadata_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_RCW_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Assembly_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_threadpool_ms_io_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Image_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_GenericMetadata_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_GarbageCollector_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_GCHandle_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Socket_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_StackTrace_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_BoehmGC_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Thread_cpp_95153(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_AppDomain_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_ThreadImpl_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Console_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_LibraryLoader_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_GenericMethod_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_MemoryMapImpl_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Interlocked_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_String_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_COMEntryPoints_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Assembly_cpp_95986(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_MemoryMappedFile_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Runtime_cpp_96605(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Il2CppCodeRegistration_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Environment_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_NativeDelegateMethodCache_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Error_cpp(); + }) +}, { + func: (function() { + __GLOBAL__sub_I_Path_cpp(); + }) +}); +var STATIC_BUMP = 3362240; +Module["STATIC_BASE"] = STATIC_BASE; +Module["STATIC_BUMP"] = STATIC_BUMP; +var tempDoublePtr = STATICTOP; +STATICTOP += 16; +assert(tempDoublePtr % 8 == 0); +function _JS_Cursor_SetImage(ptr, length) { + var binary = ""; + for (var i = 0; i < length; i++) binary += String.fromCharCode(HEAPU8[ptr + i]); + Module.canvas.style.cursor = "url(data:image/cur;base64," + btoa(binary) + "),default"; +} +function _JS_Cursor_SetShow(show) { + Module.canvas.style.cursor = show ? "default" : "none"; +} +function _JS_Eval_ClearTimeout(id) { + window.clearTimeout(id); +} +function _JS_Eval_SetTimeout(func, arg, millis) { + Module["noExitRuntime"] = true; + function wrapper() { + getFuncWrapper(func, "vi")(arg); + } + return Browser.safeSetTimeout(wrapper, millis); +} +var fs = { + numPendingSync: 0, + syncIntervalID: 0, + syncInProgress: false, + sync: (function(onlyPendingSync) { + if (onlyPendingSync) { + if (fs.numPendingSync == 0) return; + } else if (fs.syncInProgress) { + fs.numPendingSync++; + return; + } + fs.syncInProgress = true; + FS.syncfs(false, (function(err) { + fs.syncInProgress = false; + })); + fs.numPendingSync = 0; + }) +}; +function _JS_FileSystem_SetSyncInterval(ms) { + if (!Module.indexedDB) return; + fs.syncIntervalID = window.setInterval((function() { + fs.sync(true); + }), ms); +} +function _JS_FileSystem_Sync() { + if (!Module.indexedDB) return; + fs.sync(false); +} +function _JS_Log_StackTrace(buffer, bufferSize) { + var trace = stackTrace(); + if (buffer) stringToUTF8(trace, buffer, bufferSize); + return lengthBytesUTF8(trace); +} +function _JS_Profiler_InjectJobs() { + for (var jobname in Module["Jobs"]) { + var job = Module["Jobs"][jobname]; + if (typeof job["endtime"] != "undefined") Module.ccall("InjectProfilerSample", null, [ "string", "number", "number" ], [ jobname, job.starttime, job.endtime ]); + } +} +var WEBAudio = { + audioInstances: [], + audioContext: {}, + audioWebEnabled: 0 +}; +function _JS_Sound_Create_Channel(callback, userData) { + if (WEBAudio.audioWebEnabled == 0) return; + var channel = { + gain: WEBAudio.audioContext.createGain(), + panner: WEBAudio.audioContext.createPanner(), + threeD: false, + playBuffer: (function(delay, buffer, offset) { + this.source.buffer = buffer; + var chan = this; + this.source.onended = (function() { + if (callback) dynCall("vi", callback, [ userData ]); + chan.setup(); + }); + this.source.start(delay, offset); + }), + setup: (function() { + this.source = WEBAudio.audioContext.createBufferSource(); + this.setupPanning(); + }), + setupPanning: (function() { + if (this.threeD) { + this.source.disconnect(); + this.source.connect(this.panner); + this.panner.connect(this.gain); + } else { + this.panner.disconnect(); + this.source.connect(this.gain); + } + }) + }; + channel.panner.rolloffFactor = 0; + channel.gain.connect(WEBAudio.audioContext.destination); + channel.setup(); + return WEBAudio.audioInstances.push(channel) - 1; +} +function _JS_Sound_GetLength(bufferInstance) { + if (WEBAudio.audioWebEnabled == 0) return 0; + var sound = WEBAudio.audioInstances[bufferInstance]; + var sampleRateRatio = 44100 / sound.buffer.sampleRate; + return sound.buffer.length * sampleRateRatio; +} +function _JS_Sound_GetLoadState(bufferInstance) { + if (WEBAudio.audioWebEnabled == 0) return 2; + var sound = WEBAudio.audioInstances[bufferInstance]; + if (sound.error) return 2; + if (sound.buffer) return 0; + return 1; +} +function _JS_Sound_Init() { + try { + window.AudioContext = window.AudioContext || window.webkitAudioContext; + WEBAudio.audioContext = new AudioContext; + var tryToResumeAudioContext = (function() { + if (WEBAudio.audioContext.state === "suspended") WEBAudio.audioContext.resume(); else clearInterval(resumeInterval); + }); + var resumeInterval = setInterval(tryToResumeAudioContext, 400); + WEBAudio.audioWebEnabled = 1; + } catch (e) { + alert("Web Audio API is not supported in this browser"); + } +} +function _JS_Sound_Load(ptr, length) { + if (WEBAudio.audioWebEnabled == 0) return 0; + var sound = { + buffer: null, + error: false + }; + var instance = WEBAudio.audioInstances.push(sound) - 1; + WEBAudio.audioContext.decodeAudioData(HEAPU8.buffer.slice(ptr, ptr + length), (function(buffer) { + sound.buffer = buffer; + }), (function() { + sound.error = true; + console.log("Decode error."); + })); + return instance; +} +function _JS_Sound_Load_PCM(channels, length, sampleRate, ptr) { + if (WEBAudio.audioWebEnabled == 0) return 0; + var sound = { + buffer: WEBAudio.audioContext.createBuffer(channels, length, sampleRate), + error: false + }; + for (var i = 0; i < channels; i++) { + var offs = (ptr >> 2) + length * i; + var buffer = sound.buffer; + var copyToChannel = buffer["copyToChannel"] || (function(source, channelNumber, startInChannel) { + var clipped = source.subarray(0, Math.min(source.length, this.length - (startInChannel | 0))); + this.getChannelData(channelNumber | 0).set(clipped, startInChannel | 0); + }); + copyToChannel.apply(buffer, [ HEAPF32.subarray(offs, offs + length), i, 0 ]); + } + var instance = WEBAudio.audioInstances.push(sound) - 1; + return instance; +} +function _JS_Sound_Play(bufferInstance, channelInstance, offset, delay) { + _JS_Sound_Stop(channelInstance, 0); + if (WEBAudio.audioWebEnabled == 0) return; + var sound = WEBAudio.audioInstances[bufferInstance]; + var channel = WEBAudio.audioInstances[channelInstance]; + if (sound.buffer) { + try { + channel.playBuffer(WEBAudio.audioContext.currentTime + delay, sound.buffer, offset); + } catch (e) { + console.error("playBuffer error. Exception: " + e); + } + } else console.log("Trying to play sound which is not loaded."); +} +function _JS_Sound_ReleaseInstance(instance) { + WEBAudio.audioInstances[instance] = null; +} +function _JS_Sound_ResumeIfNeeded() { + if (WEBAudio.audioWebEnabled == 0) return; + if (WEBAudio.audioContext.state === "suspended") WEBAudio.audioContext.resume(); +} +function _JS_Sound_Set3D(channelInstance, threeD) { + var channel = WEBAudio.audioInstances[channelInstance]; + if (channel.threeD != threeD) { + channel.threeD = threeD; + channel.setupPanning(); + } +} +function _JS_Sound_SetListenerOrientation(x, y, z, xUp, yUp, zUp) { + if (WEBAudio.audioWebEnabled == 0) return; + if (WEBAudio.audioContext.listener.forwardX) { + WEBAudio.audioContext.listener.forwardX.setValueAtTime(-x, WEBAudio.audioContext.currentTime); + WEBAudio.audioContext.listener.forwardY.setValueAtTime(-y, WEBAudio.audioContext.currentTime); + WEBAudio.audioContext.listener.forwardZ.setValueAtTime(-z, WEBAudio.audioContext.currentTime); + WEBAudio.audioContext.listener.upX.setValueAtTime(xUp, WEBAudio.audioContext.currentTime); + WEBAudio.audioContext.listener.upY.setValueAtTime(yUp, WEBAudio.audioContext.currentTime); + WEBAudio.audioContext.listener.upZ.setValueAtTime(zUp, WEBAudio.audioContext.currentTime); + } else { + WEBAudio.audioContext.listener.setOrientation(-x, -y, -z, xUp, yUp, zUp); + } +} +function _JS_Sound_SetListenerPosition(x, y, z) { + if (WEBAudio.audioWebEnabled == 0) return; + if (WEBAudio.audioContext.listener.positionX) { + WEBAudio.audioContext.listener.positionX.setValueAtTime(x, WEBAudio.audioContext.currentTime); + WEBAudio.audioContext.listener.positionY.setValueAtTime(y, WEBAudio.audioContext.currentTime); + WEBAudio.audioContext.listener.positionZ.setValueAtTime(z, WEBAudio.audioContext.currentTime); + } else { + WEBAudio.audioContext.listener.setPosition(x, y, z); + } +} +function _JS_Sound_SetLoop(channelInstance, loop) { + if (WEBAudio.audioWebEnabled == 0) return; + WEBAudio.audioInstances[channelInstance].source.loop = loop; +} +function _JS_Sound_SetLoopPoints(channelInstance, loopStart, loopEnd) { + if (WEBAudio.audioWebEnabled == 0) return; + var channel = WEBAudio.audioInstances[channelInstance]; + channel.source.loopStart = loopStart; + channel.source.loopEnd = loopEnd; +} +function _JS_Sound_SetPitch(channelInstance, v) { + if (WEBAudio.audioWebEnabled == 0) return; + WEBAudio.audioInstances[channelInstance].source.playbackRate.setValueAtTime(v, WEBAudio.audioContext.currentTime); +} +function _JS_Sound_SetPosition(channelInstance, x, y, z) { + if (WEBAudio.audioWebEnabled == 0) return; + WEBAudio.audioInstances[channelInstance].panner.setPosition(x, y, z); +} +function _JS_Sound_SetVolume(channelInstance, v) { + if (WEBAudio.audioWebEnabled == 0) return; + WEBAudio.audioInstances[channelInstance].gain.gain.setValueAtTime(v, WEBAudio.audioContext.currentTime); +} +function _JS_Sound_Stop(channelInstance, delay) { + if (WEBAudio.audioWebEnabled == 0) return; + var channel = WEBAudio.audioInstances[channelInstance]; + if (channel.source.buffer) { + try { + channel.source.stop(WEBAudio.audioContext.currentTime + delay); + } catch (e) { + channel.source.disconnect(); + } + if (delay == 0) { + channel.source.onended = (function() {}); + channel.setup(); + } + } +} +function _JS_SystemInfo_GetBrowserName(buffer, bufferSize) { + var browser = UnityLoader.SystemInfo.browser; + if (buffer) stringToUTF8(browser, buffer, bufferSize); + return lengthBytesUTF8(browser); +} +function _JS_SystemInfo_GetBrowserVersionString(buffer, bufferSize) { + var browserVer = UnityLoader.SystemInfo.browserVersion; + if (buffer) stringToUTF8(browserVer, buffer, bufferSize); + return lengthBytesUTF8(browserVer); +} +function _JS_SystemInfo_GetCurrentCanvasHeight() { + return Module["canvas"].clientHeight; +} +function _JS_SystemInfo_GetCurrentCanvasWidth() { + return Module["canvas"].clientWidth; +} +function _JS_SystemInfo_GetDocumentURL(buffer, bufferSize) { + if (buffer) stringToUTF8(document.URL, buffer, bufferSize); + return lengthBytesUTF8(document.URL); +} +function _JS_SystemInfo_GetGPUInfo(buffer, bufferSize) { + var gpuinfo = UnityLoader.SystemInfo.gpu; + if (buffer) stringToUTF8(gpuinfo, buffer, bufferSize); + return lengthBytesUTF8(gpuinfo); +} +function _JS_SystemInfo_GetHeight() { + return UnityLoader.SystemInfo.height; +} +function _JS_SystemInfo_GetLanguage(buffer, bufferSize) { + var language = UnityLoader.SystemInfo.language; + if (buffer) stringToUTF8(language, buffer, bufferSize); + return lengthBytesUTF8(language); +} +function _JS_SystemInfo_GetMemory() { + return TOTAL_MEMORY / (1024 * 1024); +} +function _JS_SystemInfo_GetOS(buffer, bufferSize) { + var browser = UnityLoader.SystemInfo.os + " " + UnityLoader.SystemInfo.osVersion; + if (buffer) stringToUTF8(browser, buffer, bufferSize); + return lengthBytesUTF8(browser); +} +function _JS_SystemInfo_GetWidth() { + return UnityLoader.SystemInfo.width; +} +function _JS_SystemInfo_HasCursorLock() { + return UnityLoader.SystemInfo.hasCursorLock; +} +function _JS_SystemInfo_HasFullscreen() { + return UnityLoader.SystemInfo.hasFullscreen; +} +function _JS_SystemInfo_HasWebGL() { + return UnityLoader.SystemInfo.hasWebGL; +} +function _JS_WebGL_InitContextAttributes(attributes) { + HEAP32[attributes >> 2] = 1; + HEAP32[attributes + 4 >> 2] = 1; + HEAP32[attributes + 8 >> 2] = 1; + HEAP32[attributes + 12 >> 2] = 0; + HEAP32[attributes + 16 >> 2] = Module.webglContextAttributes.premultipliedAlpha; + HEAP32[attributes + 20 >> 2] = Module.webglContextAttributes.preserveDrawingBuffer; + HEAP32[attributes + 24 >> 2] = 0; + HEAP32[attributes + 28 >> 2] = 0; + HEAP32[attributes + 32 >> 2] = 1; + HEAP32[attributes + 36 >> 2] = 0; + HEAP32[attributes + 40 >> 2] = 1; + HEAP32[attributes + 44 >> 2] = 0; + return 0; +} +var wr = { + requestInstances: {}, + nextRequestId: 1 +}; +function _JS_WebRequest_Abort(request) { + wr.requestInstances[request].abort(); +} +function _JS_WebRequest_Create(url, method) { + var http = new XMLHttpRequest; + var _url = Pointer_stringify(url); + var _method = Pointer_stringify(method); + http.open(_method, _url, true); + http.responseType = "arraybuffer"; + wr.requestInstances[wr.nextRequestId] = http; + return wr.nextRequestId++; +} +function _JS_WebRequest_GetResponseHeaders(request, buffer, bufferSize) { + var headers = wr.requestInstances[request].getAllResponseHeaders(); + if (buffer) stringToUTF8(headers, buffer, bufferSize); + return lengthBytesUTF8(headers); +} +function _JS_WebRequest_Release(request) { + var http = wr.requestInstances[request]; + http.onload = null; + http.onerror = null; + http.ontimeout = null; + http.onabort = null; + delete http; + wr.requestInstances[request] = null; +} +function _JS_WebRequest_Send(request, ptr, length) { + var http = wr.requestInstances[request]; + try { + if (length > 0) http.send(HEAPU8.subarray(ptr, ptr + length)); else http.send(); + } catch (e) { + console.error(e.name + ": " + e.message); + } +} +function _JS_WebRequest_SetProgressHandler(request, arg, onprogress) { + var http = wr.requestInstances[request]; + http.onprogress = function http_onprogress(e) { + if (onprogress) { + if (e.lengthComputable) dynCall("viii", onprogress, [ arg, e.loaded, e.total ]); + } + }; +} +function _JS_WebRequest_SetRequestHeader(request, header, value) { + var _header = Pointer_stringify(header); + var _value = Pointer_stringify(value); + wr.requestInstances[request].setRequestHeader(_header, _value); +} +function _JS_WebRequest_SetResponseHandler(request, arg, onresponse) { + var http = wr.requestInstances[request]; + http.onload = function http_onload(e) { + if (onresponse) { + var kWebRequestOK = 0; + var byteArray = new Uint8Array(http.response); + if (byteArray.length != 0) { + var buffer = _malloc(byteArray.length); + HEAPU8.set(byteArray, buffer); + dynCall("viiiiii", onresponse, [ arg, http.status, buffer, byteArray.length, 0, kWebRequestOK ]); + } else { + dynCall("viiiiii", onresponse, [ arg, http.status, 0, 0, 0, kWebRequestOK ]); + } + } + }; + function HandleError(err, code) { + if (onresponse) { + var len = lengthBytesUTF8(err) + 1; + var buffer = _malloc(len); + stringToUTF8(err, buffer, len); + dynCall("viiiiii", onresponse, [ arg, http.status, 0, 0, buffer, code ]); + _free(buffer); + } + } + http.onerror = function http_onerror(e) { + var kWebErrorUnknown = 2; + HandleError("Unknown error.", kWebErrorUnknown); + }; + http.ontimeout = function http_onerror(e) { + var kWebErrorTimeout = 14; + HandleError("Connection timed out.", kWebErrorTimeout); + }; + http.onabort = function http_onerror(e) { + var kWebErrorAborted = 17; + HandleError("Aborted.", kWebErrorAborted); + }; +} +function _JS_WebRequest_SetTimeout(request, timeout) { + wr.requestInstances[request].timeout = timeout; +} +var ERRNO_CODES = { + EPERM: 1, + ENOENT: 2, + ESRCH: 3, + EINTR: 4, + EIO: 5, + ENXIO: 6, + E2BIG: 7, + ENOEXEC: 8, + EBADF: 9, + ECHILD: 10, + EAGAIN: 11, + EWOULDBLOCK: 11, + ENOMEM: 12, + EACCES: 13, + EFAULT: 14, + ENOTBLK: 15, + EBUSY: 16, + EEXIST: 17, + EXDEV: 18, + ENODEV: 19, + ENOTDIR: 20, + EISDIR: 21, + EINVAL: 22, + ENFILE: 23, + EMFILE: 24, + ENOTTY: 25, + ETXTBSY: 26, + EFBIG: 27, + ENOSPC: 28, + ESPIPE: 29, + EROFS: 30, + EMLINK: 31, + EPIPE: 32, + EDOM: 33, + ERANGE: 34, + ENOMSG: 42, + EIDRM: 43, + ECHRNG: 44, + EL2NSYNC: 45, + EL3HLT: 46, + EL3RST: 47, + ELNRNG: 48, + EUNATCH: 49, + ENOCSI: 50, + EL2HLT: 51, + EDEADLK: 35, + ENOLCK: 37, + EBADE: 52, + EBADR: 53, + EXFULL: 54, + ENOANO: 55, + EBADRQC: 56, + EBADSLT: 57, + EDEADLOCK: 35, + EBFONT: 59, + ENOSTR: 60, + ENODATA: 61, + ETIME: 62, + ENOSR: 63, + ENONET: 64, + ENOPKG: 65, + EREMOTE: 66, + ENOLINK: 67, + EADV: 68, + ESRMNT: 69, + ECOMM: 70, + EPROTO: 71, + EMULTIHOP: 72, + EDOTDOT: 73, + EBADMSG: 74, + ENOTUNIQ: 76, + EBADFD: 77, + EREMCHG: 78, + ELIBACC: 79, + ELIBBAD: 80, + ELIBSCN: 81, + ELIBMAX: 82, + ELIBEXEC: 83, + ENOSYS: 38, + ENOTEMPTY: 39, + ENAMETOOLONG: 36, + ELOOP: 40, + EOPNOTSUPP: 95, + EPFNOSUPPORT: 96, + ECONNRESET: 104, + ENOBUFS: 105, + EAFNOSUPPORT: 97, + EPROTOTYPE: 91, + ENOTSOCK: 88, + ENOPROTOOPT: 92, + ESHUTDOWN: 108, + ECONNREFUSED: 111, + EADDRINUSE: 98, + ECONNABORTED: 103, + ENETUNREACH: 101, + ENETDOWN: 100, + ETIMEDOUT: 110, + EHOSTDOWN: 112, + EHOSTUNREACH: 113, + EINPROGRESS: 115, + EALREADY: 114, + EDESTADDRREQ: 89, + EMSGSIZE: 90, + EPROTONOSUPPORT: 93, + ESOCKTNOSUPPORT: 94, + EADDRNOTAVAIL: 99, + ENETRESET: 102, + EISCONN: 106, + ENOTCONN: 107, + ETOOMANYREFS: 109, + EUSERS: 87, + EDQUOT: 122, + ESTALE: 116, + ENOTSUP: 95, + ENOMEDIUM: 123, + EILSEQ: 84, + EOVERFLOW: 75, + ECANCELED: 125, + ENOTRECOVERABLE: 131, + EOWNERDEAD: 130, + ESTRPIPE: 86 +}; +var ERRNO_MESSAGES = { + 0: "Success", + 1: "Not super-user", + 2: "No such file or directory", + 3: "No such process", + 4: "Interrupted system call", + 5: "I/O error", + 6: "No such device or address", + 7: "Arg list too long", + 8: "Exec format error", + 9: "Bad file number", + 10: "No children", + 11: "No more processes", + 12: "Not enough core", + 13: "Permission denied", + 14: "Bad address", + 15: "Block device required", + 16: "Mount device busy", + 17: "File exists", + 18: "Cross-device link", + 19: "No such device", + 20: "Not a directory", + 21: "Is a directory", + 22: "Invalid argument", + 23: "Too many open files in system", + 24: "Too many open files", + 25: "Not a typewriter", + 26: "Text file busy", + 27: "File too large", + 28: "No space left on device", + 29: "Illegal seek", + 30: "Read only file system", + 31: "Too many links", + 32: "Broken pipe", + 33: "Math arg out of domain of func", + 34: "Math result not representable", + 35: "File locking deadlock error", + 36: "File or path name too long", + 37: "No record locks available", + 38: "Function not implemented", + 39: "Directory not empty", + 40: "Too many symbolic links", + 42: "No message of desired type", + 43: "Identifier removed", + 44: "Channel number out of range", + 45: "Level 2 not synchronized", + 46: "Level 3 halted", + 47: "Level 3 reset", + 48: "Link number out of range", + 49: "Protocol driver not attached", + 50: "No CSI structure available", + 51: "Level 2 halted", + 52: "Invalid exchange", + 53: "Invalid request descriptor", + 54: "Exchange full", + 55: "No anode", + 56: "Invalid request code", + 57: "Invalid slot", + 59: "Bad font file fmt", + 60: "Device not a stream", + 61: "No data (for no delay io)", + 62: "Timer expired", + 63: "Out of streams resources", + 64: "Machine is not on the network", + 65: "Package not installed", + 66: "The object is remote", + 67: "The link has been severed", + 68: "Advertise error", + 69: "Srmount error", + 70: "Communication error on send", + 71: "Protocol error", + 72: "Multihop attempted", + 73: "Cross mount point (not really error)", + 74: "Trying to read unreadable message", + 75: "Value too large for defined data type", + 76: "Given log. name not unique", + 77: "f.d. invalid for this operation", + 78: "Remote address changed", + 79: "Can access a needed shared lib", + 80: "Accessing a corrupted shared lib", + 81: ".lib section in a.out corrupted", + 82: "Attempting to link in too many libs", + 83: "Attempting to exec a shared library", + 84: "Illegal byte sequence", + 86: "Streams pipe error", + 87: "Too many users", + 88: "Socket operation on non-socket", + 89: "Destination address required", + 90: "Message too long", + 91: "Protocol wrong type for socket", + 92: "Protocol not available", + 93: "Unknown protocol", + 94: "Socket type not supported", + 95: "Not supported", + 96: "Protocol family not supported", + 97: "Address family not supported by protocol family", + 98: "Address already in use", + 99: "Address not available", + 100: "Network interface is not configured", + 101: "Network is unreachable", + 102: "Connection reset by network", + 103: "Connection aborted", + 104: "Connection reset by peer", + 105: "No buffer space available", + 106: "Socket is already connected", + 107: "Socket is not connected", + 108: "Can't send after socket shutdown", + 109: "Too many references", + 110: "Connection timed out", + 111: "Connection refused", + 112: "Host is down", + 113: "Host is unreachable", + 114: "Socket already connected", + 115: "Connection already in progress", + 116: "Stale file handle", + 122: "Quota exceeded", + 123: "No medium (in tape drive)", + 125: "Operation canceled", + 130: "Previous owner died", + 131: "State not recoverable" +}; +function ___setErrNo(value) { + if (Module["___errno_location"]) HEAP32[Module["___errno_location"]() >> 2] = value; else Module.printErr("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) { + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === ".") { + parts.splice(i, 1); + } else if (last === "..") { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift(".."); + } + } + return parts; + }), + normalize: (function(path) { + var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/"; + path = PATH.normalizeArray(path.split("/").filter((function(p) { + return !!p; + })), !isAbsolute).join("/"); + if (!path && !isAbsolute) { + path = "."; + } + if (path && trailingSlash) { + path += "/"; + } + return (isAbsolute ? "/" : "") + path; + }), + dirname: (function(path) { + var result = PATH.splitPath(path), root = result[0], dir = result[1]; + if (!root && !dir) { + return "."; + } + if (dir) { + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }), + basename: (function(path) { + if (path === "/") return "/"; + var lastSlash = path.lastIndexOf("/"); + if (lastSlash === -1) return path; + return path.substr(lastSlash + 1); + }), + extname: (function(path) { + return PATH.splitPath(path)[3]; + }), + join: (function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join("/")); + }), + join2: (function(l, r) { + return PATH.normalize(l + "/" + r); + }), + resolve: (function() { + var resolvedPath = "", resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = i >= 0 ? arguments[i] : FS.cwd(); + if (typeof path !== "string") { + throw new TypeError("Arguments to path.resolve must be strings"); + } else if (!path) { + return ""; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = path.charAt(0) === "/"; + } + resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((function(p) { + return !!p; + })), !resolvedAbsolute).join("/"); + return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; + }), + relative: (function(from, to) { + from = PATH.resolve(from).substr(1); + to = PATH.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() {}), + shutdown: (function() {}), + 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(ERRNO_CODES.ENODEV); + } + stream.tty = tty; + stream.seekable = false; + }), + close: (function(stream) { + stream.tty.ops.flush(stream.tty); + }), + flush: (function(stream) { + stream.tty.ops.flush(stream.tty); + }), + read: (function(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(ERRNO_CODES.ENXIO); + } + 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(ERRNO_CODES.EIO); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); + } + 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(ERRNO_CODES.ENXIO); + } + for (var i = 0; i < length; i++) { + try { + stream.tty.ops.put_char(stream.tty, buffer[offset + i]); + } catch (e) { + throw new FS.ErrnoError(ERRNO_CODES.EIO); + } + } + 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) { + var BUFSIZE = 256; + var buf = new Buffer(BUFSIZE); + var bytesRead = 0; + var isPosixPlatform = process.platform != "win32"; + var fd = process.stdin.fd; + if (isPosixPlatform) { + var usingDevice = false; + try { + fd = fs.openSync("/dev/stdin", "r"); + usingDevice = true; + } catch (e) {} + } + try { + bytesRead = fs.readSync(fd, buf, 0, BUFSIZE, null); + } catch (e) { + if (e.toString().indexOf("EOF") != -1) bytesRead = 0; else throw e; + } + if (usingDevice) { + fs.closeSync(fd); + } + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString("utf-8"); + } else { + result = null; + } + } else if (typeof window != "undefined" && typeof window.prompt == "function") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n"; + } + } else if (typeof readline == "function") { + 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) { + Module["print"](UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }), + flush: (function(tty) { + if (tty.output && tty.output.length > 0) { + Module["print"](UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }) + }, + default_tty1_ops: { + put_char: (function(tty, val) { + if (val === null || val === 10) { + Module["printErr"](UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }), + flush: (function(tty) { + if (tty.output && tty.output.length > 0) { + Module["printErr"](UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }) + } +}; +var MEMFS = { + ops_table: null, + mount: (function(mount) { + return MEMFS.createNode(null, "/", 16384 | 511, 0); + }), + createNode: (function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + } + 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; + 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(); + 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; + } + return node.contents; + }), + getFileDataAsTypedArray: (function(node) { + if (!node.contents) return new Uint8Array; + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents); + }), + expandFileStorage: (function(node, newCapacity) { + if (node.contents && node.contents.subarray && newCapacity > node.contents.length) { + node.contents = MEMFS.getFileDataAsRegularArray(node); + node.usedBytes = node.contents.length; + } + if (!node.contents || node.contents.subarray) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) | 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); + return; + } + if (!node.contents && newCapacity > 0) node.contents = []; + while (node.contents.length < newCapacity) node.contents.push(0); + }), + resizeFileStorage: (function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0; + return; + } + if (!node.contents || node.contents.subarray) { + var oldContents = node.contents; + node.contents = new Uint8Array(new ArrayBuffer(newSize)); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); + } + node.usedBytes = newSize; + return; + } + 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 = {}; + 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); + 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[ERRNO_CODES.ENOENT]; + }), + mknod: (function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + }), + rename: (function(old_node, new_dir, new_name) { + 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(ERRNO_CODES.ENOTEMPTY); + } + } + } + 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(ERRNO_CODES.ENOTEMPTY); + } + 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 | 40960, 0); + node.link = oldpath; + return node; + }), + readlink: (function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + 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) { + 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) { + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + 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) { + node.contents = new Uint8Array(buffer.subarray(offset, offset + length)); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position); else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; + } + } + 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(ERRNO_CODES.EINVAL); + } + 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) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.ENODEV); + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && (contents.buffer === buffer || contents.buffer === buffer.buffer)) { + allocated = false; + ptr = contents.byteOffset; + } else { + if (position > 0 || position + length < stream.node.usedBytes) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = _malloc(length); + if (!ptr) { + throw new FS.ErrnoError(ERRNO_CODES.ENOMEM); + } + 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(ERRNO_CODES.ENODEV); + } + if (mmapFlags & 2) { + return 0; + } + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + return 0; + }) + } +}; +var IDBFS = { + dbs: {}, + indexedDB: (function() { + if (typeof indexedDB !== "undefined") return indexedDB; + var ret = null; + if (typeof window === "object") ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + assert(ret, "IDBFS used, but indexedDB not supported"); + return ret; + }), + DB_VERSION: 21, + DB_STORE_NAME: "FILE_DATA", + mount: (function(mount) { + return MEMFS.mount.apply(null, arguments); + }), + syncfs: (function(mount, populate, callback) { + IDBFS.getLocalSet(mount, (function(err, local) { + if (err) return callback(err); + IDBFS.getRemoteSet(mount, (function(err, remote) { + if (err) return callback(err); + var src = populate ? remote : local; + var dst = populate ? local : remote; + IDBFS.reconcile(src, dst, callback); + })); + })); + }), + getDB: (function(name, callback) { + var db = IDBFS.dbs[name]; + if (db) { + return callback(null, db); + } + var req; + try { + req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION); + } catch (e) { + return callback(e); + } + if (!req) { + return callback("Unable to connect to IndexedDB"); + } + req.onupgradeneeded = (function(e) { + var db = e.target.result; + var transaction = e.target.transaction; + var fileStore; + if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) { + fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME); + } else { + fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME); + } + if (!fileStore.indexNames.contains("timestamp")) { + fileStore.createIndex("timestamp", "timestamp", { + unique: false + }); + } + }); + req.onsuccess = (function() { + db = req.result; + IDBFS.dbs[name] = db; + callback(null, db); + }); + req.onerror = (function(e) { + callback(this.error); + e.preventDefault(); + }); + }), + getLocalSet: (function(mount, callback) { + var entries = {}; + function isRealDir(p) { + return p !== "." && p !== ".."; + } + function toAbsolute(root) { + return (function(p) { + return PATH.join2(root, p); + }); + } + var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint)); + while (check.length) { + var path = check.pop(); + var stat; + try { + stat = FS.stat(path); + } catch (e) { + return callback(e); + } + if (FS.isDir(stat.mode)) { + check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path))); + } + entries[path] = { + timestamp: stat.mtime + }; + } + return callback(null, { + type: "local", + entries: entries + }); + }), + getRemoteSet: (function(mount, callback) { + var entries = {}; + IDBFS.getDB(mount.mountpoint, (function(err, db) { + if (err) return callback(err); + try { + var transaction = db.transaction([ IDBFS.DB_STORE_NAME ], "readonly"); + transaction.onerror = (function(e) { + callback(this.error); + e.preventDefault(); + }); + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + var index = store.index("timestamp"); + index.openKeyCursor().onsuccess = (function(event) { + var cursor = event.target.result; + if (!cursor) { + return callback(null, { + type: "remote", + db: db, + entries: entries + }); + } + entries[cursor.primaryKey] = { + timestamp: cursor.key + }; + cursor.continue(); + }); + } catch (e) { + return callback(e); + } + })); + }), + loadLocalEntry: (function(path, callback) { + var stat, node; + try { + var lookup = FS.lookupPath(path); + node = lookup.node; + stat = FS.stat(path); + } catch (e) { + return callback(e); + } + if (FS.isDir(stat.mode)) { + return callback(null, { + timestamp: stat.mtime, + mode: stat.mode + }); + } else if (FS.isFile(stat.mode)) { + node.contents = MEMFS.getFileDataAsTypedArray(node); + return callback(null, { + timestamp: stat.mtime, + mode: stat.mode, + contents: node.contents + }); + } else { + return callback(new Error("node type not supported")); + } + }), + storeLocalEntry: (function(path, entry, callback) { + try { + if (FS.isDir(entry.mode)) { + FS.mkdir(path, entry.mode); + } else if (FS.isFile(entry.mode)) { + FS.writeFile(path, entry.contents, { + canOwn: true + }); + } else { + return callback(new Error("node type not supported")); + } + FS.chmod(path, entry.mode); + FS.utime(path, entry.timestamp, entry.timestamp); + } catch (e) { + return callback(e); + } + callback(null); + }), + removeLocalEntry: (function(path, callback) { + try { + var lookup = FS.lookupPath(path); + var stat = FS.stat(path); + if (FS.isDir(stat.mode)) { + FS.rmdir(path); + } else if (FS.isFile(stat.mode)) { + FS.unlink(path); + } + } catch (e) { + return callback(e); + } + callback(null); + }), + loadRemoteEntry: (function(store, path, callback) { + var req = store.get(path); + req.onsuccess = (function(event) { + callback(null, event.target.result); + }); + req.onerror = (function(e) { + callback(this.error); + e.preventDefault(); + }); + }), + storeRemoteEntry: (function(store, path, entry, callback) { + var req = store.put(entry, path); + req.onsuccess = (function() { + callback(null); + }); + req.onerror = (function(e) { + callback(this.error); + e.preventDefault(); + }); + }), + removeRemoteEntry: (function(store, path, callback) { + var req = store.delete(path); + req.onsuccess = (function() { + callback(null); + }); + req.onerror = (function(e) { + callback(this.error); + e.preventDefault(); + }); + }), + reconcile: (function(src, dst, callback) { + var total = 0; + var create = []; + Object.keys(src.entries).forEach((function(key) { + var e = src.entries[key]; + var e2 = dst.entries[key]; + if (!e2 || e.timestamp > e2.timestamp) { + create.push(key); + total++; + } + })); + var remove = []; + Object.keys(dst.entries).forEach((function(key) { + var e = dst.entries[key]; + var e2 = src.entries[key]; + if (!e2) { + remove.push(key); + total++; + } + })); + if (!total) { + return callback(null); + } + var completed = 0; + var db = src.type === "remote" ? src.db : dst.db; + var transaction = db.transaction([ IDBFS.DB_STORE_NAME ], "readwrite"); + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + function done(err) { + if (err) { + if (!done.errored) { + done.errored = true; + return callback(err); + } + return; + } + if (++completed >= total) { + return callback(null); + } + } + transaction.onerror = (function(e) { + done(this.error); + e.preventDefault(); + }); + create.sort().forEach((function(path) { + if (dst.type === "local") { + IDBFS.loadRemoteEntry(store, path, (function(err, entry) { + if (err) return done(err); + IDBFS.storeLocalEntry(path, entry, done); + })); + } else { + IDBFS.loadLocalEntry(path, (function(err, entry) { + if (err) return done(err); + IDBFS.storeRemoteEntry(store, path, entry, done); + })); + } + })); + remove.sort().reverse().forEach((function(path) { + if (dst.type === "local") { + IDBFS.removeLocalEntry(path, done); + } else { + IDBFS.removeRemoteEntry(store, path, done); + } + })); + }) +}; +var NODEFS = { + isWindows: false, + staticInit: (function() { + NODEFS.isWindows = !!process.platform.match(/^win/); + var flags = process["binding"]("constants"); + if (flags["fs"]) { + flags = flags["fs"]; + } + NODEFS.flagsForNodeMap = { + "1024": flags["O_APPEND"], + "64": flags["O_CREAT"], + "128": flags["O_EXCL"], + "0": flags["O_RDONLY"], + "2": flags["O_RDWR"], + "4096": flags["O_SYNC"], + "512": flags["O_TRUNC"], + "1": flags["O_WRONLY"] + }; + }), + bufferFrom: (function(arrayBuffer) { + return Buffer.alloc ? Buffer.from(arrayBuffer) : new Buffer(arrayBuffer); + }), + mount: (function(mount) { + assert(ENVIRONMENT_IS_NODE); + return NODEFS.createNode(null, "/", NODEFS.getMode(mount.opts.root), 0); + }), + createNode: (function(parent, name, mode, dev) { + if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + var node = FS.createNode(parent, name, mode); + node.node_ops = NODEFS.node_ops; + node.stream_ops = NODEFS.stream_ops; + return node; + }), + getMode: (function(path) { + var stat; + try { + stat = fs.lstatSync(path); + if (NODEFS.isWindows) { + stat.mode = stat.mode | (stat.mode & 292) >> 2; + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + return stat.mode; + }), + realPath: (function(node) { + var parts = []; + while (node.parent !== node) { + parts.push(node.name); + node = node.parent; + } + parts.push(node.mount.opts.root); + parts.reverse(); + return PATH.join.apply(null, parts); + }), + flagsForNode: (function(flags) { + flags &= ~2097152; + flags &= ~2048; + flags &= ~32768; + flags &= ~524288; + var newFlags = 0; + for (var k in NODEFS.flagsForNodeMap) { + if (flags & k) { + newFlags |= NODEFS.flagsForNodeMap[k]; + flags ^= k; + } + } + if (!flags) { + return newFlags; + } else { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + }), + node_ops: { + getattr: (function(node) { + var path = NODEFS.realPath(node); + var stat; + try { + stat = fs.lstatSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + if (NODEFS.isWindows && !stat.blksize) { + stat.blksize = 4096; + } + if (NODEFS.isWindows && !stat.blocks) { + stat.blocks = (stat.size + stat.blksize - 1) / stat.blksize | 0; + } + return { + dev: stat.dev, + ino: stat.ino, + mode: stat.mode, + nlink: stat.nlink, + uid: stat.uid, + gid: stat.gid, + rdev: stat.rdev, + size: stat.size, + atime: stat.atime, + mtime: stat.mtime, + ctime: stat.ctime, + blksize: stat.blksize, + blocks: stat.blocks + }; + }), + setattr: (function(node, attr) { + var path = NODEFS.realPath(node); + try { + if (attr.mode !== undefined) { + fs.chmodSync(path, attr.mode); + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + var date = new Date(attr.timestamp); + fs.utimesSync(path, date, date); + } + if (attr.size !== undefined) { + fs.truncateSync(path, attr.size); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + lookup: (function(parent, name) { + var path = PATH.join2(NODEFS.realPath(parent), name); + var mode = NODEFS.getMode(path); + return NODEFS.createNode(parent, name, mode); + }), + mknod: (function(parent, name, mode, dev) { + var node = NODEFS.createNode(parent, name, mode, dev); + var path = NODEFS.realPath(node); + try { + if (FS.isDir(node.mode)) { + fs.mkdirSync(path, node.mode); + } else { + fs.writeFileSync(path, "", { + mode: node.mode + }); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + return node; + }), + rename: (function(oldNode, newDir, newName) { + var oldPath = NODEFS.realPath(oldNode); + var newPath = PATH.join2(NODEFS.realPath(newDir), newName); + try { + fs.renameSync(oldPath, newPath); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + unlink: (function(parent, name) { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.unlinkSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + rmdir: (function(parent, name) { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.rmdirSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + readdir: (function(node) { + var path = NODEFS.realPath(node); + try { + return fs.readdirSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + symlink: (function(parent, newName, oldPath) { + var newPath = PATH.join2(NODEFS.realPath(parent), newName); + try { + fs.symlinkSync(oldPath, newPath); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + readlink: (function(node) { + var path = NODEFS.realPath(node); + try { + path = fs.readlinkSync(path); + path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path); + return path; + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }) + }, + stream_ops: { + open: (function(stream) { + var path = NODEFS.realPath(stream.node); + try { + if (FS.isFile(stream.node.mode)) { + stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags)); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + close: (function(stream) { + try { + if (FS.isFile(stream.node.mode) && stream.nfd) { + fs.closeSync(stream.nfd); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + read: (function(stream, buffer, offset, length, position) { + if (length === 0) return 0; + try { + return fs.readSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position); + } catch (e) { + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + write: (function(stream, buffer, offset, length, position) { + try { + return fs.writeSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position); + } catch (e) { + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + }), + llseek: (function(stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + try { + var stat = fs.fstatSync(stream.nfd); + position += stat.size; + } catch (e) { + throw new FS.ErrnoError(ERRNO_CODES[e.code]); + } + } + } + if (position < 0) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + return position; + }) + } +}; +var WORKERFS = { + DIR_MODE: 16895, + FILE_MODE: 33279, + reader: null, + mount: (function(mount) { + assert(ENVIRONMENT_IS_WORKER); + if (!WORKERFS.reader) WORKERFS.reader = new FileReaderSync; + var root = WORKERFS.createNode(null, "/", WORKERFS.DIR_MODE, 0); + var createdParents = {}; + function ensureParent(path) { + var parts = path.split("/"); + var parent = root; + for (var i = 0; i < parts.length - 1; i++) { + var curr = parts.slice(0, i + 1).join("/"); + if (!createdParents[curr]) { + createdParents[curr] = WORKERFS.createNode(parent, parts[i], WORKERFS.DIR_MODE, 0); + } + parent = createdParents[curr]; + } + return parent; + } + function base(path) { + var parts = path.split("/"); + return parts[parts.length - 1]; + } + Array.prototype.forEach.call(mount.opts["files"] || [], (function(file) { + WORKERFS.createNode(ensureParent(file.name), base(file.name), WORKERFS.FILE_MODE, 0, file, file.lastModifiedDate); + })); + (mount.opts["blobs"] || []).forEach((function(obj) { + WORKERFS.createNode(ensureParent(obj["name"]), base(obj["name"]), WORKERFS.FILE_MODE, 0, obj["data"]); + })); + (mount.opts["packages"] || []).forEach((function(pack) { + pack["metadata"].files.forEach((function(file) { + var name = file.filename.substr(1); + WORKERFS.createNode(ensureParent(name), base(name), WORKERFS.FILE_MODE, 0, pack["blob"].slice(file.start, file.end)); + })); + })); + return root; + }), + createNode: (function(parent, name, mode, dev, contents, mtime) { + var node = FS.createNode(parent, name, mode); + node.mode = mode; + node.node_ops = WORKERFS.node_ops; + node.stream_ops = WORKERFS.stream_ops; + node.timestamp = (mtime || new Date).getTime(); + assert(WORKERFS.FILE_MODE !== WORKERFS.DIR_MODE); + if (mode === WORKERFS.FILE_MODE) { + node.size = contents.size; + node.contents = contents; + } else { + node.size = 4096; + node.contents = {}; + } + if (parent) { + parent.contents[name] = node; + } + return node; + }), + node_ops: { + getattr: (function(node) { + return { + dev: 1, + ino: undefined, + mode: node.mode, + nlink: 1, + uid: 0, + gid: 0, + rdev: undefined, + size: node.size, + atime: new Date(node.timestamp), + mtime: new Date(node.timestamp), + ctime: new Date(node.timestamp), + blksize: 4096, + blocks: Math.ceil(node.size / 4096) + }; + }), + setattr: (function(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + }), + lookup: (function(parent, name) { + throw new FS.ErrnoError(ERRNO_CODES.ENOENT); + }), + mknod: (function(parent, name, mode, dev) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + }), + rename: (function(oldNode, newDir, newName) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + }), + unlink: (function(parent, name) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + }), + rmdir: (function(parent, name) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + }), + 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) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + }), + readlink: (function(node) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + }) + }, + stream_ops: { + read: (function(stream, buffer, offset, length, position) { + if (position >= stream.node.size) return 0; + var chunk = stream.node.contents.slice(position, position + length); + var ab = WORKERFS.reader.readAsArrayBuffer(chunk); + buffer.set(new Uint8Array(ab), offset); + return chunk.size; + }), + write: (function(stream, buffer, offset, length, position) { + throw new FS.ErrnoError(ERRNO_CODES.EIO); + }), + 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.size; + } + } + if (position < 0) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + return position; + }) + } +}; +STATICTOP += 16; +STATICTOP += 16; +STATICTOP += 16; +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.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) { + throw new FS.ErrnoError(ERRNO_CODES.ELOOP); + } + var parts = PATH.normalizeArray(path.split("/").filter((function(p) { + return !!p; + })), false); + 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) { + break; + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || islast && opts.follow_mount) { + current = current.mounted.root; + } + } + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH.resolve(PATH.dirname(current_path), link); + var lookup = FS.lookupPath(current_path, { + recurse_count: opts.recurse_count + }); + current = lookup.node; + if (count++ > 40) { + throw new FS.ErrnoError(ERRNO_CODES.ELOOP); + } + } + } + } + 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 err = FS.mayLookup(parent); + if (err) { + throw new FS.ErrnoError(err, 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; + } + } + return FS.lookup(parent, name); + }), + createNode: (function(parent, name, mode, rdev) { + if (!FS.FSNode) { + FS.FSNode = (function(parent, name, mode, rdev) { + if (!parent) { + parent = this; + } + 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; + }); + FS.FSNode.prototype = {}; + var readMode = 292 | 73; + var writeMode = 146; + Object.defineProperties(FS.FSNode.prototype, { + read: { + get: (function() { + return (this.mode & readMode) === readMode; + }), + set: (function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + }) + }, + write: { + get: (function() { + return (this.mode & writeMode) === writeMode; + }), + set: (function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + }) + }, + isFolder: { + get: (function() { + return FS.isDir(this.mode); + }) + }, + isDevice: { + get: (function() { + return FS.isChrdev(this.mode); + }) + } + }); + } + 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; + } + if (perms.indexOf("r") !== -1 && !(node.mode & 292)) { + return ERRNO_CODES.EACCES; + } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) { + return ERRNO_CODES.EACCES; + } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) { + return ERRNO_CODES.EACCES; + } + return 0; + }), + mayLookup: (function(dir) { + var err = FS.nodePermissions(dir, "x"); + if (err) return err; + if (!dir.node_ops.lookup) return ERRNO_CODES.EACCES; + return 0; + }), + mayCreate: (function(dir, name) { + try { + var node = FS.lookupNode(dir, name); + return ERRNO_CODES.EEXIST; + } 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 err = FS.nodePermissions(dir, "wx"); + if (err) { + return err; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return ERRNO_CODES.ENOTDIR; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return ERRNO_CODES.EBUSY; + } + } else { + if (FS.isDir(node.mode)) { + return ERRNO_CODES.EISDIR; + } + } + return 0; + }), + mayOpen: (function(node, flags) { + if (!node) { + return ERRNO_CODES.ENOENT; + } + if (FS.isLink(node.mode)) { + return ERRNO_CODES.ELOOP; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { + return ERRNO_CODES.EISDIR; + } + } + 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(ERRNO_CODES.EMFILE); + }), + getStream: (function(fd) { + return FS.streams[fd]; + }), + createStream: (function(stream, fd_start, fd_end) { + if (!FS.FSStream) { + FS.FSStream = (function() {}); + FS.FSStream.prototype = {}; + Object.defineProperties(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; + }) + } + }); + } + 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); + stream.stream_ops = device.stream_ops; + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + }), + llseek: (function() { + throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); + }) + }, + major: (function(dev) { + return dev >> 8; + }), + minor: (function(dev) { + return dev & 255; + }), + 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) { + console.log("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(err) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(err); + } + function done(err) { + if (err) { + if (!done.errored) { + done.errored = true; + return doCallback(err); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + } + mounts.forEach((function(mount) { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + })); + }), + mount: (function(type, opts, mountpoint) { + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(ERRNO_CODES.EBUSY); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + mountpoint = lookup.path; + node = lookup.node; + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(ERRNO_CODES.EBUSY); + } + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); + } + } + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot; + } else if (node) { + node.mounted = mount; + 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(ERRNO_CODES.EINVAL); + } + 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; + } + })); + node.mounted = null; + 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(ERRNO_CODES.EINVAL); + } + var err = FS.mayCreate(parent, name); + if (err) { + throw new FS.ErrnoError(err); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + } + return parent.node_ops.mknod(parent, name, mode, dev); + }), + create: (function(path, mode) { + mode = mode !== undefined ? mode : 438; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }), + mkdir: (function(path, mode) { + mode = mode !== undefined ? mode : 511; + 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 != ERRNO_CODES.EEXIST) throw e; + } + } + }), + mkdev: (function(path, mode, dev) { + if (typeof dev === "undefined") { + dev = mode; + mode = 438; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + }), + symlink: (function(oldpath, newpath) { + if (!PATH.resolve(oldpath)) { + throw new FS.ErrnoError(ERRNO_CODES.ENOENT); + } + var lookup = FS.lookupPath(newpath, { + parent: true + }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(ERRNO_CODES.ENOENT); + } + var newname = PATH.basename(newpath); + var err = FS.mayCreate(parent, newname); + if (err) { + throw new FS.ErrnoError(err); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + } + 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); + 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(ERRNO_CODES.EBUSY); + } + if (!old_dir || !new_dir) throw new FS.ErrnoError(ERRNO_CODES.ENOENT); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(ERRNO_CODES.EXDEV); + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + relative = PATH.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY); + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (old_node === new_node) { + return; + } + var isdir = FS.isDir(old_node.mode); + var err = FS.mayDelete(old_dir, old_name, isdir); + if (err) { + throw new FS.ErrnoError(err); + } + err = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name); + if (err) { + throw new FS.ErrnoError(err); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + } + if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) { + throw new FS.ErrnoError(ERRNO_CODES.EBUSY); + } + if (new_dir !== old_dir) { + err = FS.nodePermissions(old_dir, "w"); + if (err) { + throw new FS.ErrnoError(err); + } + } + try { + if (FS.trackingDelegate["willMovePath"]) { + FS.trackingDelegate["willMovePath"](old_path, new_path); + } + } catch (e) { + console.log("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message); + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + FS.hashAddNode(old_node); + } + try { + if (FS.trackingDelegate["onMovePath"]) FS.trackingDelegate["onMovePath"](old_path, new_path); + } catch (e) { + console.log("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 err = FS.mayDelete(parent, name, true); + if (err) { + throw new FS.ErrnoError(err); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(ERRNO_CODES.EBUSY); + } + try { + if (FS.trackingDelegate["willDeletePath"]) { + FS.trackingDelegate["willDeletePath"](path); + } + } catch (e) { + console.log("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) { + console.log("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(ERRNO_CODES.ENOTDIR); + } + 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 err = FS.mayDelete(parent, name, false); + if (err) { + throw new FS.ErrnoError(err); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(ERRNO_CODES.EBUSY); + } + try { + if (FS.trackingDelegate["willDeletePath"]) { + FS.trackingDelegate["willDeletePath"](path); + } + } catch (e) { + console.log("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) { + console.log("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(ERRNO_CODES.ENOENT); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + return PATH.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(ERRNO_CODES.ENOENT); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(ERRNO_CODES.EPERM); + } + 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(ERRNO_CODES.EPERM); + } + 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(ERRNO_CODES.EBADF); + } + 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(ERRNO_CODES.EPERM); + } + node.node_ops.setattr(node, { + timestamp: Date.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(ERRNO_CODES.EBADF); + } + FS.chown(stream.node, uid, gid); + }), + truncate: (function(path, len) { + if (len < 0) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + 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(ERRNO_CODES.EPERM); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.EISDIR); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + var err = FS.nodePermissions(node, "w"); + if (err) { + throw new FS.ErrnoError(err); + } + 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(ERRNO_CODES.EBADF); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + 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(ERRNO_CODES.ENOENT); + } + flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode === "undefined" ? 438 : 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) {} + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(ERRNO_CODES.EEXIST); + } + } else { + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(ERRNO_CODES.ENOENT); + } + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); + } + if (!created) { + var err = FS.mayOpen(node, flags); + if (err) { + throw new FS.ErrnoError(err); + } + } + if (flags & 512) { + FS.truncate(node, 0); + } + flags &= ~(128 | 512); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false + }, fd_start, fd_end); + 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; + Module["printErr"]("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) { + console.log("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message); + } + return stream; + }), + close: (function(stream) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(ERRNO_CODES.EBADF); + } + if (stream.getdents) stream.getdents = null; + 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(ERRNO_CODES.EBADF); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); + } + 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(ERRNO_CODES.EINVAL); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(ERRNO_CODES.EBADF); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(ERRNO_CODES.EBADF); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.EISDIR); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + var seeking = typeof position !== "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); + } + 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(ERRNO_CODES.EINVAL); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(ERRNO_CODES.EBADF); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(ERRNO_CODES.EBADF); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.EISDIR); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + if (stream.flags & 1024) { + FS.llseek(stream, 0, 2); + } + var seeking = typeof position !== "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); + } + 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) { + console.log("FS.trackingDelegate['onWriteToFile']('" + path + "') threw an exception: " + e.message); + } + return bytesWritten; + }), + allocate: (function(stream, offset, length) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(ERRNO_CODES.EBADF); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(ERRNO_CODES.EBADF); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.ENODEV); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP); + } + stream.stream_ops.allocate(stream, offset, length); + }), + mmap: (function(stream, buffer, offset, length, position, prot, flags) { + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(ERRNO_CODES.EACCES); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(ERRNO_CODES.ENODEV); + } + 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(ERRNO_CODES.ENOTTY); + } + 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(ERRNO_CODES.ENOENT); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); + } + var err = FS.nodePermissions(lookup.node, "x"); + if (err) { + throw new FS.ErrnoError(err); + } + FS.currentPath = lookup.path; + }), + createDefaultDirectories: (function() { + FS.mkdir("/tmp"); + FS.mkdir("/home"); + FS.mkdir("/home/web_user"); + }), + createDefaultDevices: (function() { + FS.mkdir("/dev"); + 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)); + 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)); + var random_device; + if (typeof crypto !== "undefined") { + var randomBuffer = new Uint8Array(1); + random_device = (function() { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0]; + }); + } else if (ENVIRONMENT_IS_NODE) { + random_device = (function() { + return require("crypto")["randomBytes"](1)[0]; + }); + } else { + random_device = (function() { + return Math.random() * 256 | 0; + }); + } + FS.createDevice("/dev", "random", random_device); + FS.createDevice("/dev", "urandom", random_device); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp"); + }), + createSpecialDirectories: (function() { + 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, 73); + node.node_ops = { + lookup: (function(parent, name) { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF); + var ret = { + parent: null, + mount: { + mountpoint: "fake" + }, + node_ops: { + readlink: (function() { + return stream.path; + }) + } + }; + ret.parent = ret; + return ret; + }) + }; + return node; + }) + }, {}, "/proc/self/fd"); + }), + createStandardStreams: (function() { + 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"); + } + var stdin = FS.open("/dev/stdin", "r"); + assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")"); + var stdout = FS.open("/dev/stdout", "w"); + assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")"); + var stderr = FS.open("/dev/stderr", "w"); + assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")"); + }), + ensureErrnoError: (function() { + if (FS.ErrnoError) return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = (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]; + if (this.stack) Object.defineProperty(this, "stack", { + value: (new Error).stack, + writable: true + }); + if (this.stack) this.stack = demangleAll(this.stack); + }; + FS.ErrnoError.prototype = new Error; + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + [ ERRNO_CODES.ENOENT ].forEach((function(code) { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ""; + })); + }), + staticInit: (function() { + FS.ensureErrnoError(); + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = { + "MEMFS": MEMFS, + "IDBFS": IDBFS, + "NODEFS": NODEFS, + "WORKERFS": WORKERFS + }; + }), + 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(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams(); + }), + quit: (function() { + FS.init.initialized = false; + var fflush = Module["_fflush"]; + if (fflush) fflush(0); + 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.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) { + 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) {} + 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; + } + 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); + FS.registerDevice(dev, { + open: (function(stream) { + stream.seekable = false; + }), + close: (function(stream) { + if (output && output.buffer && output.buffer.length) { + output(10); + } + }), + read: (function(stream, buffer, offset, length, pos) { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(ERRNO_CODES.EIO); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); + } + 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(ERRNO_CODES.EIO); + } + } + 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 (Module["read"]) { + try { + obj.contents = intArrayFromString(Module["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(ERRNO_CODES.EIO); + return success; + }), + createLazyFile: (function(parent, name, url, canRead, canWrite) { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = 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() { + 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; + if (!hasByteServing) chunkSize = datalength; + 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!"); + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + 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(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; + end = Math.min(end, datalength - 1); + 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) { + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + console.log("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: (function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + }) + }, + chunkSize: { + get: (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); + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + Object.defineProperties(node, { + usedBytes: { + get: (function() { + return this.contents.length; + }) + } + }); + 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(ERRNO_CODES.EIO); + } + return fn.apply(null, arguments); + }; + })); + stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) { + if (!FS.forceLoadFile(node)) { + throw new FS.ErrnoError(ERRNO_CODES.EIO); + } + 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) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + 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(); + var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency("cp " + 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() { + console.log("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; + 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; + }) +}; +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; + } + if (mode == 0) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() { + var timeUntilNextTick = Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0; + setTimeout(Browser.mainLoop.runner, timeUntilNextTick); + }; + Browser.mainLoop.method = "timeout"; + } else if (mode == 1) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() { + Browser.requestAnimationFrame(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "rAF"; + } else if (mode == 2) { + if (typeof setImmediate === "undefined") { + var setImmediates = []; + var emscriptenMainLoopMessageId = "setimmediate"; + function Browser_setImmediate_messageHandler(event) { + if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) { + event.stopPropagation(); + setImmediates.shift()(); + } + } + addEventListener("message", Browser_setImmediate_messageHandler, true); + setImmediate = function Browser_emulated_setImmediate(func) { + setImmediates.push(func); + if (ENVIRONMENT_IS_WORKER) { + if (Module["setImmediates"] === undefined) Module["setImmediates"] = []; + Module["setImmediates"].push(func); + postMessage({ + target: emscriptenMainLoopMessageId + }); + } else postMessage(emscriptenMainLoopMessageId, "*"); + }; + } + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() { + setImmediate(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "immediate"; + } + return 0; +} +function _emscripten_get_now() { + abort(); +} +function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop, arg, noSetTiming) { + Module["noExitRuntime"] = true; + assert(!Browser.mainLoop.func, "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters."); + Browser.mainLoop.func = func; + Browser.mainLoop.arg = arg; + var browserIterationFunc; + if (typeof arg !== "undefined") { + browserIterationFunc = (function() { + Module["dynCall_vi"](func, arg); + }); + } else { + browserIterationFunc = (function() { + Module["dynCall_v"](func); + }); + } + var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop; + Browser.mainLoop.runner = function Browser_mainLoop_runner() { + if (ABORT) return; + if (Browser.mainLoop.queue.length > 0) { + var start = Date.now(); + var blocker = Browser.mainLoop.queue.shift(); + blocker.func(blocker.arg); + if (Browser.mainLoop.remainingBlockers) { + var remaining = Browser.mainLoop.remainingBlockers; + var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining); + if (blocker.counted) { + Browser.mainLoop.remainingBlockers = next; + } else { + next = next + .5; + Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9; + } + } + console.log('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms"); + Browser.mainLoop.updateStatus(); + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return; + setTimeout(Browser.mainLoop.runner, 0); + return; + } + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return; + Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0; + if (Browser.mainLoop.timingMode == 1 && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) { + Browser.mainLoop.scheduler(); + return; + } else if (Browser.mainLoop.timingMode == 0) { + Browser.mainLoop.tickStartTime = _emscripten_get_now(); + } + if (Browser.mainLoop.method === "timeout" && Module.ctx) { + Module.printErr("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 = ""; + } + Browser.mainLoop.runIter(browserIterationFunc); + checkStackCookie(); + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return; + if (typeof SDL === "object" && SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData(); + Browser.mainLoop.scheduler(); + }; + if (!noSetTiming) { + if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps); else _emscripten_set_main_loop_timing(1, 1); + Browser.mainLoop.scheduler(); + } + if (simulateInfiniteLoop) { + throw "SimulateInfiniteLoop"; + } +} +var Browser = { + mainLoop: { + scheduler: null, + method: "", + currentlyRunningMainloop: 0, + func: null, + arg: 0, + timingMode: 0, + timingValue: 0, + currentFrameNumber: 0, + queue: [], + pause: (function() { + Browser.mainLoop.scheduler = null; + Browser.mainLoop.currentlyRunningMainloop++; + }), + resume: (function() { + Browser.mainLoop.currentlyRunningMainloop++; + var timingMode = Browser.mainLoop.timingMode; + var timingValue = Browser.mainLoop.timingValue; + var func = Browser.mainLoop.func; + Browser.mainLoop.func = null; + _emscripten_set_main_loop(func, 0, false, Browser.mainLoop.arg, true); + _emscripten_set_main_loop_timing(timingMode, timingValue); + Browser.mainLoop.scheduler(); + }), + updateStatus: (function() { + if (Module["setStatus"]) { + var message = Module["statusMessage"] || "Please wait..."; + var remaining = Browser.mainLoop.remainingBlockers; + var expected = Browser.mainLoop.expectedBlockers; + if (remaining) { + if (remaining < expected) { + Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")"); + } else { + Module["setStatus"](message); + } + } else { + Module["setStatus"](""); + } + } + }), + runIter: (function(func) { + if (ABORT) return; + if (Module["preMainLoop"]) { + var preRet = Module["preMainLoop"](); + if (preRet === false) { + return; + } + } + try { + func(); + } catch (e) { + if (e instanceof ExitStatus) { + return; + } else { + if (e && typeof e === "object" && e.stack) Module.printErr("exception thrown: " + [ e, e.stack ]); + throw e; + } + } + if (Module["postMainLoop"]) Module["postMainLoop"](); + }) + }, + isFullscreen: false, + pointerLock: false, + moduleContextCreatedCallbacks: [], + workers: [], + init: (function() { + if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; + if (Browser.initted) return; + Browser.initted = true; + try { + new Blob; + Browser.hasBlobConstructor = true; + } catch (e) { + Browser.hasBlobConstructor = false; + console.log("warning: no blob constructor, cannot create blobs with mimetypes"); + } + Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : !Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null; + Browser.URLObject = typeof window != "undefined" ? window.URL ? window.URL : window.webkitURL : undefined; + if (!Module.noImageDecoding && typeof Browser.URLObject === "undefined") { + console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available."); + Module.noImageDecoding = true; + } + var imagePlugin = {}; + imagePlugin["canHandle"] = function imagePlugin_canHandle(name) { + return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name); + }; + imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) { + var b = null; + if (Browser.hasBlobConstructor) { + try { + b = new Blob([ byteArray ], { + type: Browser.getMimetype(name) + }); + if (b.size !== byteArray.length) { + b = new Blob([ (new Uint8Array(byteArray)).buffer ], { + type: Browser.getMimetype(name) + }); + } + } catch (e) { + warnOnce("Blob constructor present but fails: " + e + "; falling back to blob builder"); + } + } + if (!b) { + var bb = new Browser.BlobBuilder; + bb.append((new Uint8Array(byteArray)).buffer); + b = bb.getBlob(); + } + var url = Browser.URLObject.createObjectURL(b); + 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; + 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); + assert(typeof url == "string", "createObjectURL must return a url as a string"); + var audio = new Audio; + audio.addEventListener("canplaythrough", (function() { + finish(audio); + }), false); + audio.onerror = function audio_onerror(event) { + if (done) return; + console.log("warning: browser could not fully decode audio " + name + ", trying slower base64 approach"); + function encode64(data) { + var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var PAD = "="; + var ret = ""; + var leftchar = 0; + var leftbits = 0; + for (var i = 0; i < data.length; i++) { + leftchar = leftchar << 8 | data[i]; + leftbits += 8; + while (leftbits >= 6) { + var curr = leftchar >> leftbits - 6 & 63; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar & 3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar & 15) << 2]; + ret += PAD; + } + return ret; + } + audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray); + finish(audio); + }; + audio.src = url; + Browser.safeSetTimeout((function() { + finish(audio); + }), 1e4); + } else { + return fail(); + } + }; + Module["preloadPlugins"].push(audioPlugin); + function pointerLockChange() { + Browser.pointerLock = document["pointerLockElement"] === Module["canvas"] || document["mozPointerLockElement"] === Module["canvas"] || document["webkitPointerLockElement"] === Module["canvas"] || document["msPointerLockElement"] === Module["canvas"]; + } + var canvas = Module["canvas"]; + if (canvas) { + canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || (function() {}); + canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] || (function() {}); + canvas.exitPointerLock = canvas.exitPointerLock.bind(document); + document.addEventListener("pointerlockchange", pointerLockChange, false); + document.addEventListener("mozpointerlockchange", pointerLockChange, false); + document.addEventListener("webkitpointerlockchange", pointerLockChange, false); + document.addEventListener("mspointerlockchange", pointerLockChange, false); + if (Module["elementPointerLock"]) { + canvas.addEventListener("click", (function(ev) { + if (!Browser.pointerLock && Module["canvas"].requestPointerLock) { + Module["canvas"].requestPointerLock(); + ev.preventDefault(); + } + }), false); + } + } + }), + createContext: (function(canvas, useWebGL, setInModule, webGLContextAttributes) { + if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx; + var ctx; + var contextHandle; + if (useWebGL) { + var contextAttributes = { + antialias: false, + alpha: false + }; + if (webGLContextAttributes) { + for (var attribute in webGLContextAttributes) { + contextAttributes[attribute] = webGLContextAttributes[attribute]; + } + } + 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, vrDevice) { + Browser.lockPointer = lockPointer; + Browser.resizeCanvas = resizeCanvas; + Browser.vrDevice = vrDevice; + if (typeof Browser.lockPointer === "undefined") Browser.lockPointer = true; + if (typeof Browser.resizeCanvas === "undefined") Browser.resizeCanvas = false; + if (typeof Browser.vrDevice === "undefined") Browser.vrDevice = null; + 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 = document["exitFullscreen"] || document["cancelFullScreen"] || document["mozCancelFullScreen"] || document["msExitFullscreen"] || document["webkitCancelFullScreen"] || (function() {}); + canvas.exitFullscreen = canvas.exitFullscreen.bind(document); + if (Browser.lockPointer) canvas.requestPointerLock(); + Browser.isFullscreen = true; + if (Browser.resizeCanvas) Browser.setFullscreenCanvasSize(); + } else { + canvasContainer.parentNode.insertBefore(canvas, canvasContainer); + canvasContainer.parentNode.removeChild(canvasContainer); + if (Browser.resizeCanvas) Browser.setWindowedCanvasSize(); + } + if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen); + if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen); + Browser.updateCanvasDimensions(canvas); + } + if (!Browser.fullscreenHandlersInstalled) { + Browser.fullscreenHandlersInstalled = true; + document.addEventListener("fullscreenchange", fullscreenChange, false); + document.addEventListener("mozfullscreenchange", fullscreenChange, false); + document.addEventListener("webkitfullscreenchange", fullscreenChange, false); + document.addEventListener("MSFullscreenChange", fullscreenChange, false); + } + var canvasContainer = document.createElement("div"); + canvas.parentNode.insertBefore(canvasContainer, canvas); + canvasContainer.appendChild(canvas); + canvasContainer.requestFullscreen = canvasContainer["requestFullscreen"] || canvasContainer["mozRequestFullScreen"] || canvasContainer["msRequestFullscreen"] || (canvasContainer["webkitRequestFullscreen"] ? (function() { + canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]); + }) : null) || (canvasContainer["webkitRequestFullScreen"] ? (function() { + canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]); + }) : null); + if (vrDevice) { + canvasContainer.requestFullscreen({ + vrDisplay: vrDevice + }); + } else { + canvasContainer.requestFullscreen(); + } + }), + requestFullScreen: (function(lockPointer, resizeCanvas, vrDevice) { + Module.printErr("Browser.requestFullScreen() is deprecated. Please call Browser.requestFullscreen instead."); + Browser.requestFullScreen = (function(lockPointer, resizeCanvas, vrDevice) { + return Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice); + }); + return Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice); + }), + nextRAF: 0, + fakeRequestAnimationFrame: (function(func) { + var now = Date.now(); + if (Browser.nextRAF === 0) { + Browser.nextRAF = now + 1e3 / 60; + } else { + while (now + 2 >= Browser.nextRAF) { + Browser.nextRAF += 1e3 / 60; + } + } + var delay = Math.max(Browser.nextRAF - now, 0); + setTimeout(func, delay); + }), + requestAnimationFrame: function requestAnimationFrame(func) { + if (typeof window === "undefined") { + Browser.fakeRequestAnimationFrame(func); + } else { + if (!window.requestAnimationFrame) { + window.requestAnimationFrame = window["requestAnimationFrame"] || window["mozRequestAnimationFrame"] || window["webkitRequestAnimationFrame"] || window["msRequestAnimationFrame"] || window["oRequestAnimationFrame"] || Browser.fakeRequestAnimationFrame; + } + window.requestAnimationFrame(func); + } + }, + safeCallback: (function(func) { + return (function() { + if (!ABORT) return func.apply(null, arguments); + }); + }), + allowAsyncCallbacks: true, + queuedAsyncCallbacks: [], + pauseAsyncCallbacks: (function() { + Browser.allowAsyncCallbacks = false; + }), + resumeAsyncCallbacks: (function() { + Browser.allowAsyncCallbacks = true; + if (Browser.queuedAsyncCallbacks.length > 0) { + var callbacks = Browser.queuedAsyncCallbacks; + Browser.queuedAsyncCallbacks = []; + callbacks.forEach((function(func) { + func(); + })); + } + }), + safeRequestAnimationFrame: (function(func) { + return Browser.requestAnimationFrame((function() { + if (ABORT) return; + if (Browser.allowAsyncCallbacks) { + func(); + } else { + Browser.queuedAsyncCallbacks.push(func); + } + })); + }), + safeSetTimeout: (function(func, timeout) { + Module["noExitRuntime"] = true; + return setTimeout((function() { + if (ABORT) return; + if (Browser.allowAsyncCallbacks) { + func(); + } else { + Browser.queuedAsyncCallbacks.push(func); + } + }), timeout); + }), + safeSetInterval: (function(func, timeout) { + Module["noExitRuntime"] = true; + return setInterval((function() { + if (ABORT) return; + if (Browser.allowAsyncCallbacks) { + func(); + } + }), timeout); + }), + getMimetype: (function(name) { + return { + "jpg": "image/jpeg", + "jpeg": "image/jpeg", + "png": "image/png", + "bmp": "image/bmp", + "ogg": "audio/ogg", + "wav": "audio/wav", + "mp3": "audio/mpeg" + }[name.substr(name.lastIndexOf(".") + 1)]; + }), + getUserMedia: (function(func) { + if (!window.getUserMedia) { + window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"]; + } + window.getUserMedia(func); + }), + getMovementX: (function(event) { + return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0; + }), + getMovementY: (function(event) { + return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0; + }), + getMouseWheelDelta: (function(event) { + var delta = 0; + switch (event.type) { + case "DOMMouseScroll": + delta = event.detail; + break; + case "mousewheel": + delta = event.wheelDelta; + break; + case "wheel": + delta = event["deltaY"]; + break; + default: + throw "unrecognized mouse wheel event: " + event.type; + } + return delta; + }), + mouseX: 0, + mouseY: 0, + mouseMovementX: 0, + mouseMovementY: 0, + touches: {}, + lastTouches: {}, + calculateMouseEvent: (function(event) { + if (Browser.pointerLock) { + if (event.type != "mousemove" && "mozMovementX" in event) { + Browser.mouseMovementX = Browser.mouseMovementY = 0; + } else { + Browser.mouseMovementX = Browser.getMovementX(event); + Browser.mouseMovementY = Browser.getMovementY(event); + } + if (typeof SDL != "undefined") { + Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; + Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; + } else { + Browser.mouseX += Browser.mouseMovementX; + Browser.mouseY += Browser.mouseMovementY; + } + } else { + var rect = Module["canvas"].getBoundingClientRect(); + var cw = Module["canvas"].width; + var ch = Module["canvas"].height; + var scrollX = typeof window.scrollX !== "undefined" ? window.scrollX : window.pageXOffset; + var scrollY = typeof window.scrollY !== "undefined" ? window.scrollY : window.pageYOffset; + 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; + } + var adjustedX = touch.pageX - (scrollX + rect.left); + var adjustedY = touch.pageY - (scrollY + rect.top); + adjustedX = adjustedX * (cw / rect.width); + adjustedY = adjustedY * (ch / rect.height); + var coords = { + x: adjustedX, + y: adjustedY + }; + if (event.type === "touchstart") { + Browser.lastTouches[touch.identifier] = coords; + Browser.touches[touch.identifier] = coords; + } else if (event.type === "touchend" || event.type === "touchmove") { + var last = Browser.touches[touch.identifier]; + if (!last) last = coords; + Browser.lastTouches[touch.identifier] = last; + Browser.touches[touch.identifier] = coords; + } + return; + } + var x = event.pageX - (scrollX + rect.left); + var y = event.pageY - (scrollY + rect.top); + x = x * (cw / rect.width); + y = y * (ch / rect.height); + Browser.mouseMovementX = x - Browser.mouseX; + Browser.mouseMovementY = y - Browser.mouseY; + Browser.mouseX = x; + Browser.mouseY = y; + } + }), + asyncLoad: (function(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency("al " + url) : ""; + Module["readAsync"](url, (function(arrayBuffer) { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }), (function(event) { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + })); + if (dep) addRunDependency(dep); + }), + resizeListeners: [], + updateResizeListeners: (function() { + var canvas = Module["canvas"]; + Browser.resizeListeners.forEach((function(listener) { + listener(canvas.width, canvas.height); + })); + }), + setCanvasSize: (function(width, height, noUpdates) { + var canvas = Module["canvas"]; + Browser.updateCanvasDimensions(canvas, width, height); + if (!noUpdates) Browser.updateResizeListeners(); + }), + windowedWidth: 0, + windowedHeight: 0, + setFullscreenCanvasSize: (function() { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags | 8388608; + HEAP32[SDL.screen >> 2] = flags; + } + Browser.updateResizeListeners(); + }), + setWindowedCanvasSize: (function() { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags & ~8388608; + HEAP32[SDL.screen >> 2] = flags; + } + 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 _environ = STATICTOP; +STATICTOP += 16; +function ___buildEnvironment(env) { + var MAX_ENV_VALUES = 64; + var TOTAL_ENV_SIZE = 1024; + var poolPtr; + var envPtr; + if (!___buildEnvironment.called) { + ___buildEnvironment.called = true; + ENV["USER"] = ENV["LOGNAME"] = "web_user"; + ENV["PATH"] = "/"; + ENV["PWD"] = "/"; + ENV["HOME"] = "/home/web_user"; + ENV["LANG"] = "C.UTF-8"; + ENV["_"] = Module["thisProgram"]; + poolPtr = staticAlloc(TOTAL_ENV_SIZE); + envPtr = staticAlloc(MAX_ENV_VALUES * 4); + HEAP32[envPtr >> 2] = poolPtr; + HEAP32[_environ >> 2] = envPtr; + } else { + envPtr = HEAP32[_environ >> 2]; + poolPtr = HEAP32[envPtr >> 2]; + } + var strings = []; + var totalSize = 0; + for (var key in env) { + if (typeof env[key] === "string") { + var line = key + "=" + env[key]; + strings.push(line); + totalSize += line.length; + } + } + if (totalSize > TOTAL_ENV_SIZE) { + throw new Error("Environment size exceeded TOTAL_ENV_SIZE!"); + } + var ptrSize = 4; + for (var i = 0; i < strings.length; i++) { + var line = strings[i]; + writeAsciiToMemory(line, poolPtr); + HEAP32[envPtr + i * ptrSize >> 2] = poolPtr; + poolPtr += line.length + 1; + } + HEAP32[envPtr + strings.length * ptrSize >> 2] = 0; +} +var ENV = {}; +function _getenv(name) { + if (name === 0) return 0; + name = Pointer_stringify(name); + if (!ENV.hasOwnProperty(name)) return 0; + if (_getenv.ret) _free(_getenv.ret); + _getenv.ret = allocateUTF8(ENV[name]); + return _getenv.ret; +} +function _putenv(string) { + if (string === 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + string = Pointer_stringify(string); + var splitPoint = string.indexOf("="); + if (string === "" || string.indexOf("=") === -1) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + var name = string.slice(0, splitPoint); + var value = string.slice(splitPoint + 1); + if (!(name in ENV) || ENV[name] !== value) { + ENV[name] = value; + ___buildEnvironment(ENV); + } + return 0; +} +function _SDL_RWFromConstMem(mem, size) { + var id = SDL.rwops.length; + SDL.rwops.push({ + bytes: mem, + count: size + }); + return id; +} +function _TTF_FontHeight(font) { + var fontData = SDL.fonts[font]; + return fontData.size; +} +function _TTF_SizeText(font, text, w, h) { + var fontData = SDL.fonts[font]; + if (w) { + HEAP32[w >> 2] = SDL.estimateTextWidth(fontData, Pointer_stringify(text)); + } + if (h) { + HEAP32[h >> 2] = fontData.size; + } + return 0; +} +function _TTF_RenderText_Solid(font, text, color) { + text = Pointer_stringify(text) || " "; + var fontData = SDL.fonts[font]; + var w = SDL.estimateTextWidth(fontData, text); + var h = fontData.size; + color = SDL.loadColorToCSSRGB(color); + var fontString = SDL.makeFontString(h, fontData.name); + var surf = SDL.makeSurface(w, h, 0, false, "text:" + text); + var surfData = SDL.surfaces[surf]; + surfData.ctx.save(); + surfData.ctx.fillStyle = color; + surfData.ctx.font = fontString; + surfData.ctx.textBaseline = "bottom"; + surfData.ctx.fillText(text, 0, h | 0); + surfData.ctx.restore(); + return surf; +} +function _Mix_HaltMusic() { + var audio = SDL.music.audio; + if (audio) { + audio.src = audio.src; + audio.currentPosition = 0; + audio.pause(); + } + SDL.music.audio = null; + if (SDL.hookMusicFinished) { + Module["dynCall_v"](SDL.hookMusicFinished); + } + return 0; +} +function _Mix_PlayMusic(id, loops) { + if (SDL.music.audio) { + if (!SDL.music.audio.paused) Module.printErr("Music is already playing. " + SDL.music.source); + SDL.music.audio.pause(); + } + var info = SDL.audios[id]; + var audio; + if (info.webAudio) { + audio = {}; + audio.resource = info; + audio.paused = false; + audio.currentPosition = 0; + audio.play = (function() { + SDL.playWebAudio(this); + }); + audio.pause = (function() { + SDL.pauseWebAudio(this); + }); + } else if (info.audio) { + audio = info.audio; + } + audio["onended"] = (function() { + if (SDL.music.audio == this) _Mix_HaltMusic(); + }); + audio.loop = loops != 0; + audio.volume = SDL.music.volume; + SDL.music.audio = audio; + audio.play(); + return 0; +} +function _Mix_FreeChunk(id) { + SDL.audios[id] = null; +} +function _Mix_LoadWAV_RW(rwopsID, freesrc) { + var rwops = SDL.rwops[rwopsID]; + if (rwops === undefined) return 0; + var filename = ""; + var audio; + var webAudio; + var bytes; + if (rwops.filename !== undefined) { + filename = PATH.resolve(rwops.filename); + var raw = Module["preloadedAudios"][filename]; + if (!raw) { + if (raw === null) Module.printErr("Trying to reuse preloaded audio, but freePreloadedMediaOnUse is set!"); + if (!Module.noAudioDecoding) warnOnce("Cannot find preloaded audio " + filename); + try { + bytes = FS.readFile(filename); + } catch (e) { + Module.printErr("Couldn't find file for: " + filename); + return 0; + } + } + if (Module["freePreloadedMediaOnUse"]) { + Module["preloadedAudios"][filename] = null; + } + audio = raw; + } else if (rwops.bytes !== undefined) { + if (SDL.webAudioAvailable()) bytes = HEAPU8.buffer.slice(rwops.bytes, rwops.bytes + rwops.count); else bytes = HEAPU8.subarray(rwops.bytes, rwops.bytes + rwops.count); + } else { + return 0; + } + var arrayBuffer = bytes ? bytes.buffer || bytes : bytes; + var canPlayWithWebAudio = Module["SDL_canPlayWithWebAudio"] === undefined || Module["SDL_canPlayWithWebAudio"](filename, arrayBuffer); + if (bytes !== undefined && SDL.webAudioAvailable() && canPlayWithWebAudio) { + audio = undefined; + webAudio = {}; + webAudio.onDecodeComplete = []; + function onDecodeComplete(data) { + webAudio.decodedBuffer = data; + webAudio.onDecodeComplete.forEach((function(e) { + e(); + })); + webAudio.onDecodeComplete = undefined; + } + SDL.audioContext["decodeAudioData"](arrayBuffer, onDecodeComplete); + } else if (audio === undefined && bytes) { + var blob = new Blob([ bytes ], { + type: rwops.mimetype + }); + var url = URL.createObjectURL(blob); + audio = new Audio; + audio.src = url; + audio.mozAudioChannelType = "content"; + } + var id = SDL.audios.length; + SDL.audios.push({ + source: filename, + audio: audio, + webAudio: webAudio + }); + return id; +} +function _Mix_PlayChannel(channel, id, loops) { + var info = SDL.audios[id]; + if (!info) return -1; + if (!info.audio && !info.webAudio) return -1; + if (channel == -1) { + for (var i = SDL.channelMinimumNumber; i < SDL.numChannels; i++) { + if (!SDL.channels[i].audio) { + channel = i; + break; + } + } + if (channel == -1) { + Module.printErr("All " + SDL.numChannels + " channels in use!"); + return -1; + } + } + var channelInfo = SDL.channels[channel]; + var audio; + if (info.webAudio) { + audio = {}; + audio.resource = info; + audio.paused = false; + audio.currentPosition = 0; + audio.play = (function() { + SDL.playWebAudio(this); + }); + audio.pause = (function() { + SDL.pauseWebAudio(this); + }); + } else { + audio = info.audio.cloneNode(true); + audio.numChannels = info.audio.numChannels; + audio.frequency = info.audio.frequency; + } + audio["onended"] = function SDL_audio_onended() { + if (channelInfo.audio == this) { + channelInfo.audio.paused = true; + channelInfo.audio = null; + } + if (SDL.channelFinished) getFuncWrapper(SDL.channelFinished, "vi")(channel); + }; + channelInfo.audio = audio; + audio.loop = loops != 0; + audio.volume = channelInfo.volume; + audio.play(); + return channel; +} +function _SDL_PauseAudio(pauseOn) { + if (!SDL.audio) { + return; + } + if (pauseOn) { + if (SDL.audio.timer !== undefined) { + clearTimeout(SDL.audio.timer); + SDL.audio.numAudioTimersPending = 0; + SDL.audio.timer = undefined; + } + } else if (!SDL.audio.timer) { + SDL.audio.numAudioTimersPending = 1; + SDL.audio.timer = Browser.safeSetTimeout(SDL.audio.caller, 1); + } + SDL.audio.paused = pauseOn; +} +function _SDL_CloseAudio() { + if (SDL.audio) { + _SDL_PauseAudio(1); + _free(SDL.audio.buffer); + SDL.audio = null; + SDL.allocateChannels(0); + } +} +function _SDL_LockSurface(surf) { + var surfData = SDL.surfaces[surf]; + surfData.locked++; + if (surfData.locked > 1) return 0; + if (!surfData.buffer) { + surfData.buffer = _malloc(surfData.width * surfData.height * 4); + HEAP32[surf + 20 >> 2] = surfData.buffer; + } + HEAP32[surf + 20 >> 2] = surfData.buffer; + if (surf == SDL.screen && Module.screenIsReadOnly && surfData.image) return 0; + if (SDL.defaults.discardOnLock) { + if (!surfData.image) { + surfData.image = surfData.ctx.createImageData(surfData.width, surfData.height); + } + if (!SDL.defaults.opaqueFrontBuffer) return; + } else { + surfData.image = surfData.ctx.getImageData(0, 0, surfData.width, surfData.height); + } + if (surf == SDL.screen && SDL.defaults.opaqueFrontBuffer) { + var data = surfData.image.data; + var num = data.length; + for (var i = 0; i < num / 4; i++) { + data[i * 4 + 3] = 255; + } + } + if (SDL.defaults.copyOnLock && !SDL.defaults.discardOnLock) { + if (surfData.isFlagSet(2097152)) { + throw "CopyOnLock is not supported for SDL_LockSurface with SDL_HWPALETTE flag set" + (new Error).stack; + } else { + HEAPU8.set(surfData.image.data, surfData.buffer); + } + } + return 0; +} +function _SDL_FreeRW(rwopsID) { + SDL.rwops[rwopsID] = null; + while (SDL.rwops.length > 0 && SDL.rwops[SDL.rwops.length - 1] === null) { + SDL.rwops.pop(); + } +} +function _IMG_Load_RW(rwopsID, freeSrc) { + try { + var cleanup = (function() { + if (rwops && freeSrc) _SDL_FreeRW(rwopsID); + }); + var rwops = SDL.rwops[rwopsID]; + if (rwops === undefined) { + return 0; + } + var filename = rwops.filename; + if (filename === undefined) { + warnOnce("Only file names that have been preloaded are supported for IMG_Load_RW. Consider using STB_IMAGE=1 if you want synchronous image decoding (see settings.js), or package files with --use-preload-plugins"); + return 0; + } + if (!raw) { + filename = PATH.resolve(filename); + var raw = Module["preloadedImages"][filename]; + if (!raw) { + if (raw === null) Module.printErr("Trying to reuse preloaded image, but freePreloadedMediaOnUse is set!"); + warnOnce("Cannot find preloaded image " + filename); + warnOnce("Cannot find preloaded image " + filename + ". Consider using STB_IMAGE=1 if you want synchronous image decoding (see settings.js), or package files with --use-preload-plugins"); + return 0; + } else if (Module["freePreloadedMediaOnUse"]) { + Module["preloadedImages"][filename] = null; + } + } + var surf = SDL.makeSurface(raw.width, raw.height, 0, false, "load:" + filename); + var surfData = SDL.surfaces[surf]; + surfData.ctx.globalCompositeOperation = "copy"; + if (!raw.rawData) { + surfData.ctx.drawImage(raw, 0, 0, raw.width, raw.height, 0, 0, raw.width, raw.height); + } else { + var imageData = surfData.ctx.getImageData(0, 0, surfData.width, surfData.height); + if (raw.bpp == 4) { + imageData.data.set(HEAPU8.subarray(raw.data, raw.data + raw.size)); + } else if (raw.bpp == 3) { + var pixels = raw.size / 3; + var data = imageData.data; + var sourcePtr = raw.data; + var destPtr = 0; + for (var i = 0; i < pixels; i++) { + data[destPtr++] = HEAPU8[sourcePtr++ >> 0]; + data[destPtr++] = HEAPU8[sourcePtr++ >> 0]; + data[destPtr++] = HEAPU8[sourcePtr++ >> 0]; + data[destPtr++] = 255; + } + } else if (raw.bpp == 2) { + var pixels = raw.size; + var data = imageData.data; + var sourcePtr = raw.data; + var destPtr = 0; + for (var i = 0; i < pixels; i++) { + var gray = HEAPU8[sourcePtr++ >> 0]; + var alpha = HEAPU8[sourcePtr++ >> 0]; + data[destPtr++] = gray; + data[destPtr++] = gray; + data[destPtr++] = gray; + data[destPtr++] = alpha; + } + } else if (raw.bpp == 1) { + var pixels = raw.size; + var data = imageData.data; + var sourcePtr = raw.data; + var destPtr = 0; + for (var i = 0; i < pixels; i++) { + var value = HEAPU8[sourcePtr++ >> 0]; + data[destPtr++] = value; + data[destPtr++] = value; + data[destPtr++] = value; + data[destPtr++] = 255; + } + } else { + Module.printErr("cannot handle bpp " + raw.bpp); + return 0; + } + surfData.ctx.putImageData(imageData, 0, 0); + } + surfData.ctx.globalCompositeOperation = "source-over"; + _SDL_LockSurface(surf); + surfData.locked--; + if (SDL.GL) { + surfData.canvas = surfData.ctx = null; + } + return surf; + } finally { + cleanup(); + } +} +function _SDL_RWFromFile(_name, mode) { + var id = SDL.rwops.length; + var name = Pointer_stringify(_name); + SDL.rwops.push({ + filename: name, + mimetype: Browser.getMimetype(name) + }); + return id; +} +function _IMG_Load(filename) { + var rwops = _SDL_RWFromFile(filename); + var result = _IMG_Load_RW(rwops, 1); + return result; +} +function _SDL_UpperBlitScaled(src, srcrect, dst, dstrect) { + return SDL.blitSurface(src, srcrect, dst, dstrect, true); +} +function _SDL_UpperBlit(src, srcrect, dst, dstrect) { + return SDL.blitSurface(src, srcrect, dst, dstrect, false); +} +function _SDL_GetTicks() { + return Date.now() - SDL.startTime | 0; +} +var SDL = { + defaults: { + width: 320, + height: 200, + copyOnLock: true, + discardOnLock: false, + opaqueFrontBuffer: true + }, + version: null, + surfaces: {}, + canvasPool: [], + events: [], + fonts: [ null ], + audios: [ null ], + rwops: [ null ], + music: { + audio: null, + volume: 1 + }, + mixerFrequency: 22050, + mixerFormat: 32784, + mixerNumChannels: 2, + mixerChunkSize: 1024, + channelMinimumNumber: 0, + GL: false, + glAttributes: { + 0: 3, + 1: 3, + 2: 2, + 3: 0, + 4: 0, + 5: 1, + 6: 16, + 7: 0, + 8: 0, + 9: 0, + 10: 0, + 11: 0, + 12: 0, + 13: 0, + 14: 0, + 15: 1, + 16: 0, + 17: 0, + 18: 0 + }, + keyboardState: null, + keyboardMap: {}, + canRequestFullscreen: false, + isRequestingFullscreen: false, + textInput: false, + startTime: null, + initFlags: 0, + buttonState: 0, + modState: 0, + DOMButtons: [ 0, 0, 0 ], + DOMEventToSDLEvent: {}, + TOUCH_DEFAULT_ID: 0, + eventHandler: null, + eventHandlerContext: null, + eventHandlerTemp: 0, + keyCodes: { + 16: 1249, + 17: 1248, + 18: 1250, + 20: 1081, + 33: 1099, + 34: 1102, + 35: 1101, + 36: 1098, + 37: 1104, + 38: 1106, + 39: 1103, + 40: 1105, + 44: 316, + 45: 1097, + 46: 127, + 91: 1251, + 93: 1125, + 96: 1122, + 97: 1113, + 98: 1114, + 99: 1115, + 100: 1116, + 101: 1117, + 102: 1118, + 103: 1119, + 104: 1120, + 105: 1121, + 106: 1109, + 107: 1111, + 109: 1110, + 110: 1123, + 111: 1108, + 112: 1082, + 113: 1083, + 114: 1084, + 115: 1085, + 116: 1086, + 117: 1087, + 118: 1088, + 119: 1089, + 120: 1090, + 121: 1091, + 122: 1092, + 123: 1093, + 124: 1128, + 125: 1129, + 126: 1130, + 127: 1131, + 128: 1132, + 129: 1133, + 130: 1134, + 131: 1135, + 132: 1136, + 133: 1137, + 134: 1138, + 135: 1139, + 144: 1107, + 160: 94, + 161: 33, + 162: 34, + 163: 35, + 164: 36, + 165: 37, + 166: 38, + 167: 95, + 168: 40, + 169: 41, + 170: 42, + 171: 43, + 172: 124, + 173: 45, + 174: 123, + 175: 125, + 176: 126, + 181: 127, + 182: 129, + 183: 128, + 188: 44, + 190: 46, + 191: 47, + 192: 96, + 219: 91, + 220: 92, + 221: 93, + 222: 39, + 224: 1251 + }, + scanCodes: { + 8: 42, + 9: 43, + 13: 40, + 27: 41, + 32: 44, + 35: 204, + 39: 53, + 44: 54, + 46: 55, + 47: 56, + 48: 39, + 49: 30, + 50: 31, + 51: 32, + 52: 33, + 53: 34, + 54: 35, + 55: 36, + 56: 37, + 57: 38, + 58: 203, + 59: 51, + 61: 46, + 91: 47, + 92: 49, + 93: 48, + 96: 52, + 97: 4, + 98: 5, + 99: 6, + 100: 7, + 101: 8, + 102: 9, + 103: 10, + 104: 11, + 105: 12, + 106: 13, + 107: 14, + 108: 15, + 109: 16, + 110: 17, + 111: 18, + 112: 19, + 113: 20, + 114: 21, + 115: 22, + 116: 23, + 117: 24, + 118: 25, + 119: 26, + 120: 27, + 121: 28, + 122: 29, + 127: 76, + 305: 224, + 308: 226, + 316: 70 + }, + loadRect: (function(rect) { + return { + x: HEAP32[rect + 0 >> 2], + y: HEAP32[rect + 4 >> 2], + w: HEAP32[rect + 8 >> 2], + h: HEAP32[rect + 12 >> 2] + }; + }), + updateRect: (function(rect, r) { + HEAP32[rect >> 2] = r.x; + HEAP32[rect + 4 >> 2] = r.y; + HEAP32[rect + 8 >> 2] = r.w; + HEAP32[rect + 12 >> 2] = r.h; + }), + intersectionOfRects: (function(first, second) { + var leftX = Math.max(first.x, second.x); + var leftY = Math.max(first.y, second.y); + var rightX = Math.min(first.x + first.w, second.x + second.w); + var rightY = Math.min(first.y + first.h, second.y + second.h); + return { + x: leftX, + y: leftY, + w: Math.max(leftX, rightX) - leftX, + h: Math.max(leftY, rightY) - leftY + }; + }), + checkPixelFormat: (function(fmt) { + var format = HEAP32[fmt >> 2]; + if (format != -2042224636) { + warnOnce("Unsupported pixel format!"); + } + }), + loadColorToCSSRGB: (function(color) { + var rgba = HEAP32[color >> 2]; + return "rgb(" + (rgba & 255) + "," + (rgba >> 8 & 255) + "," + (rgba >> 16 & 255) + ")"; + }), + loadColorToCSSRGBA: (function(color) { + var rgba = HEAP32[color >> 2]; + return "rgba(" + (rgba & 255) + "," + (rgba >> 8 & 255) + "," + (rgba >> 16 & 255) + "," + (rgba >> 24 & 255) / 255 + ")"; + }), + translateColorToCSSRGBA: (function(rgba) { + return "rgba(" + (rgba & 255) + "," + (rgba >> 8 & 255) + "," + (rgba >> 16 & 255) + "," + (rgba >>> 24) / 255 + ")"; + }), + translateRGBAToCSSRGBA: (function(r, g, b, a) { + return "rgba(" + (r & 255) + "," + (g & 255) + "," + (b & 255) + "," + (a & 255) / 255 + ")"; + }), + translateRGBAToColor: (function(r, g, b, a) { + return r | g << 8 | b << 16 | a << 24; + }), + makeSurface: (function(width, height, flags, usePageCanvas, source, rmask, gmask, bmask, amask) { + flags = flags || 0; + var is_SDL_HWSURFACE = flags & 1; + var is_SDL_HWPALETTE = flags & 2097152; + var is_SDL_OPENGL = flags & 67108864; + var surf = _malloc(60); + var pixelFormat = _malloc(44); + var bpp = is_SDL_HWPALETTE ? 1 : 4; + var buffer = 0; + if (!is_SDL_HWSURFACE && !is_SDL_OPENGL) { + buffer = _malloc(width * height * 4); + } + HEAP32[surf >> 2] = flags; + HEAP32[surf + 4 >> 2] = pixelFormat; + HEAP32[surf + 8 >> 2] = width; + HEAP32[surf + 12 >> 2] = height; + HEAP32[surf + 16 >> 2] = width * bpp; + HEAP32[surf + 20 >> 2] = buffer; + HEAP32[surf + 36 >> 2] = 0; + HEAP32[surf + 40 >> 2] = 0; + HEAP32[surf + 44 >> 2] = Module["canvas"].width; + HEAP32[surf + 48 >> 2] = Module["canvas"].height; + HEAP32[surf + 56 >> 2] = 1; + HEAP32[pixelFormat >> 2] = -2042224636; + HEAP32[pixelFormat + 4 >> 2] = 0; + HEAP8[pixelFormat + 8 >> 0] = bpp * 8; + HEAP8[pixelFormat + 9 >> 0] = bpp; + HEAP32[pixelFormat + 12 >> 2] = rmask || 255; + HEAP32[pixelFormat + 16 >> 2] = gmask || 65280; + HEAP32[pixelFormat + 20 >> 2] = bmask || 16711680; + HEAP32[pixelFormat + 24 >> 2] = amask || 4278190080; + SDL.GL = SDL.GL || is_SDL_OPENGL; + var canvas; + if (!usePageCanvas) { + if (SDL.canvasPool.length > 0) { + canvas = SDL.canvasPool.pop(); + } else { + canvas = document.createElement("canvas"); + } + canvas.width = width; + canvas.height = height; + } else { + canvas = Module["canvas"]; + } + var webGLContextAttributes = { + antialias: SDL.glAttributes[13] != 0 && SDL.glAttributes[14] > 1, + depth: SDL.glAttributes[6] > 0, + stencil: SDL.glAttributes[7] > 0, + alpha: SDL.glAttributes[3] > 0 + }; + var ctx = Browser.createContext(canvas, is_SDL_OPENGL, usePageCanvas, webGLContextAttributes); + SDL.surfaces[surf] = { + width: width, + height: height, + canvas: canvas, + ctx: ctx, + surf: surf, + buffer: buffer, + pixelFormat: pixelFormat, + alpha: 255, + flags: flags, + locked: 0, + usePageCanvas: usePageCanvas, + source: source, + isFlagSet: (function(flag) { + return flags & flag; + }) + }; + return surf; + }), + copyIndexedColorData: (function(surfData, rX, rY, rW, rH) { + if (!surfData.colors) { + return; + } + var fullWidth = Module["canvas"].width; + var fullHeight = Module["canvas"].height; + var startX = rX || 0; + var startY = rY || 0; + var endX = (rW || fullWidth - startX) + startX; + var endY = (rH || fullHeight - startY) + startY; + var buffer = surfData.buffer; + if (!surfData.image.data32) { + surfData.image.data32 = new Uint32Array(surfData.image.data.buffer); + } + var data32 = surfData.image.data32; + var colors32 = surfData.colors32; + for (var y = startY; y < endY; ++y) { + var base = y * fullWidth; + for (var x = startX; x < endX; ++x) { + data32[base + x] = colors32[HEAPU8[buffer + base + x >> 0]]; + } + } + }), + freeSurface: (function(surf) { + var refcountPointer = surf + 56; + var refcount = HEAP32[refcountPointer >> 2]; + if (refcount > 1) { + HEAP32[refcountPointer >> 2] = refcount - 1; + return; + } + var info = SDL.surfaces[surf]; + if (!info.usePageCanvas && info.canvas) SDL.canvasPool.push(info.canvas); + if (info.buffer) _free(info.buffer); + _free(info.pixelFormat); + _free(surf); + SDL.surfaces[surf] = null; + if (surf === SDL.screen) { + SDL.screen = null; + } + }), + blitSurface__deps: [ "SDL_LockSurface" ], + blitSurface: (function(src, srcrect, dst, dstrect, scale) { + var srcData = SDL.surfaces[src]; + var dstData = SDL.surfaces[dst]; + var sr, dr; + if (srcrect) { + sr = SDL.loadRect(srcrect); + } else { + sr = { + x: 0, + y: 0, + w: srcData.width, + h: srcData.height + }; + } + if (dstrect) { + dr = SDL.loadRect(dstrect); + } else { + dr = { + x: 0, + y: 0, + w: srcData.width, + h: srcData.height + }; + } + if (dstData.clipRect) { + var widthScale = !scale || sr.w === 0 ? 1 : sr.w / dr.w; + var heightScale = !scale || sr.h === 0 ? 1 : sr.h / dr.h; + dr = SDL.intersectionOfRects(dstData.clipRect, dr); + sr.w = dr.w * widthScale; + sr.h = dr.h * heightScale; + if (dstrect) { + SDL.updateRect(dstrect, dr); + } + } + var blitw, blith; + if (scale) { + blitw = dr.w; + blith = dr.h; + } else { + blitw = sr.w; + blith = sr.h; + } + if (sr.w === 0 || sr.h === 0 || blitw === 0 || blith === 0) { + return 0; + } + var oldAlpha = dstData.ctx.globalAlpha; + dstData.ctx.globalAlpha = srcData.alpha / 255; + dstData.ctx.drawImage(srcData.canvas, sr.x, sr.y, sr.w, sr.h, dr.x, dr.y, blitw, blith); + dstData.ctx.globalAlpha = oldAlpha; + if (dst != SDL.screen) { + warnOnce("WARNING: copying canvas data to memory for compatibility"); + _SDL_LockSurface(dst); + dstData.locked--; + } + return 0; + }), + downFingers: {}, + savedKeydown: null, + receiveEvent: (function(event) { + function unpressAllPressedKeys() { + for (var code in SDL.keyboardMap) { + SDL.events.push({ + type: "keyup", + keyCode: SDL.keyboardMap[code] + }); + } + } + switch (event.type) { + case "touchstart": + case "touchmove": + { + event.preventDefault(); + var touches = []; + if (event.type === "touchstart") { + for (var i = 0; i < event.touches.length; i++) { + var touch = event.touches[i]; + if (SDL.downFingers[touch.identifier] != true) { + SDL.downFingers[touch.identifier] = true; + touches.push(touch); + } + } + } else { + touches = event.touches; + } + var firstTouch = touches[0]; + if (firstTouch) { + if (event.type == "touchstart") { + SDL.DOMButtons[0] = 1; + } + var mouseEventType; + switch (event.type) { + case "touchstart": + mouseEventType = "mousedown"; + break; + case "touchmove": + mouseEventType = "mousemove"; + break; + } + var mouseEvent = { + type: mouseEventType, + button: 0, + pageX: firstTouch.clientX, + pageY: firstTouch.clientY + }; + SDL.events.push(mouseEvent); + } + for (var i = 0; i < touches.length; i++) { + var touch = touches[i]; + SDL.events.push({ + type: event.type, + touch: touch + }); + } + break; + } + case "touchend": + { + event.preventDefault(); + for (var i = 0; i < event.changedTouches.length; i++) { + var touch = event.changedTouches[i]; + if (SDL.downFingers[touch.identifier] === true) { + delete SDL.downFingers[touch.identifier]; + } + } + var mouseEvent = { + type: "mouseup", + button: 0, + pageX: event.changedTouches[0].clientX, + pageY: event.changedTouches[0].clientY + }; + SDL.DOMButtons[0] = 0; + SDL.events.push(mouseEvent); + for (var i = 0; i < event.changedTouches.length; i++) { + var touch = event.changedTouches[i]; + SDL.events.push({ + type: "touchend", + touch: touch + }); + } + break; + } + case "DOMMouseScroll": + case "mousewheel": + case "wheel": + var delta = -Browser.getMouseWheelDelta(event); + delta = delta == 0 ? 0 : delta > 0 ? Math.max(delta, 1) : Math.min(delta, -1); + var button = delta > 0 ? 3 : 4; + SDL.events.push({ + type: "mousedown", + button: button, + pageX: event.pageX, + pageY: event.pageY + }); + SDL.events.push({ + type: "mouseup", + button: button, + pageX: event.pageX, + pageY: event.pageY + }); + SDL.events.push({ + type: "wheel", + deltaX: 0, + deltaY: delta + }); + event.preventDefault(); + break; + case "mousemove": + if (SDL.DOMButtons[0] === 1) { + SDL.events.push({ + type: "touchmove", + touch: { + identifier: 0, + deviceID: -1, + pageX: event.pageX, + pageY: event.pageY + } + }); + } + if (Browser.pointerLock) { + if ("mozMovementX" in event) { + event["movementX"] = event["mozMovementX"]; + event["movementY"] = event["mozMovementY"]; + } + if (event["movementX"] == 0 && event["movementY"] == 0) { + event.preventDefault(); + return; + } + } + case "keydown": + case "keyup": + case "keypress": + case "mousedown": + case "mouseup": + if (event.type !== "keydown" || !SDL.unicode && !SDL.textInput || event.keyCode === 8 || event.keyCode === 9) { + event.preventDefault(); + } + if (event.type == "mousedown") { + SDL.DOMButtons[event.button] = 1; + SDL.events.push({ + type: "touchstart", + touch: { + identifier: 0, + deviceID: -1, + pageX: event.pageX, + pageY: event.pageY + } + }); + } else if (event.type == "mouseup") { + if (!SDL.DOMButtons[event.button]) { + return; + } + SDL.events.push({ + type: "touchend", + touch: { + identifier: 0, + deviceID: -1, + pageX: event.pageX, + pageY: event.pageY + } + }); + SDL.DOMButtons[event.button] = 0; + } + if (event.type === "keydown" || event.type === "mousedown") { + SDL.canRequestFullscreen = true; + } else if (event.type === "keyup" || event.type === "mouseup") { + if (SDL.isRequestingFullscreen) { + Module["requestFullscreen"](true, true); + SDL.isRequestingFullscreen = false; + } + SDL.canRequestFullscreen = false; + } + if (event.type === "keypress" && SDL.savedKeydown) { + SDL.savedKeydown.keypressCharCode = event.charCode; + SDL.savedKeydown = null; + } else if (event.type === "keydown") { + SDL.savedKeydown = event; + } + if (event.type !== "keypress" || SDL.textInput) { + SDL.events.push(event); + } + break; + case "mouseout": + for (var i = 0; i < 3; i++) { + if (SDL.DOMButtons[i]) { + SDL.events.push({ + type: "mouseup", + button: i, + pageX: event.pageX, + pageY: event.pageY + }); + SDL.DOMButtons[i] = 0; + } + } + event.preventDefault(); + break; + case "focus": + SDL.events.push(event); + event.preventDefault(); + break; + case "blur": + SDL.events.push(event); + unpressAllPressedKeys(); + event.preventDefault(); + break; + case "visibilitychange": + SDL.events.push({ + type: "visibilitychange", + visible: !document.hidden + }); + unpressAllPressedKeys(); + event.preventDefault(); + break; + case "unload": + if (Browser.mainLoop.runner) { + SDL.events.push(event); + Browser.mainLoop.runner(); + } + return; + case "resize": + SDL.events.push(event); + if (event.preventDefault) { + event.preventDefault(); + } + break; + } + if (SDL.events.length >= 1e4) { + Module.printErr("SDL event queue full, dropping events"); + SDL.events = SDL.events.slice(0, 1e4); + } + SDL.flushEventsToHandler(); + return; + }), + lookupKeyCodeForEvent: (function(event) { + var code = event.keyCode; + if (code >= 65 && code <= 90) { + code += 32; + } else { + code = SDL.keyCodes[event.keyCode] || event.keyCode; + if (event.location === KeyboardEvent.DOM_KEY_LOCATION_RIGHT && code >= (224 | 1 << 10) && code <= (227 | 1 << 10)) { + code += 4; + } + } + return code; + }), + handleEvent: (function(event) { + if (event.handled) return; + event.handled = true; + switch (event.type) { + case "touchstart": + case "touchend": + case "touchmove": + { + Browser.calculateMouseEvent(event); + break; + } + case "keydown": + case "keyup": + { + var down = event.type === "keydown"; + var code = SDL.lookupKeyCodeForEvent(event); + HEAP8[SDL.keyboardState + code >> 0] = down; + SDL.modState = (HEAP8[SDL.keyboardState + 1248 >> 0] ? 64 : 0) | (HEAP8[SDL.keyboardState + 1249 >> 0] ? 1 : 0) | (HEAP8[SDL.keyboardState + 1250 >> 0] ? 256 : 0) | (HEAP8[SDL.keyboardState + 1252 >> 0] ? 128 : 0) | (HEAP8[SDL.keyboardState + 1253 >> 0] ? 2 : 0) | (HEAP8[SDL.keyboardState + 1254 >> 0] ? 512 : 0); + if (down) { + SDL.keyboardMap[code] = event.keyCode; + } else { + delete SDL.keyboardMap[code]; + } + break; + } + case "mousedown": + case "mouseup": + if (event.type == "mousedown") { + SDL.buttonState |= 1 << event.button; + } else if (event.type == "mouseup") { + SDL.buttonState &= ~(1 << event.button); + } + case "mousemove": + { + Browser.calculateMouseEvent(event); + break; + } + } + }), + flushEventsToHandler: (function() { + if (!SDL.eventHandler) return; + while (SDL.pollEvent(SDL.eventHandlerTemp)) { + Module["dynCall_iii"](SDL.eventHandler, SDL.eventHandlerContext, SDL.eventHandlerTemp); + } + }), + pollEvent: (function(ptr) { + if (SDL.initFlags & 512 && SDL.joystickEventState) { + SDL.queryJoysticks(); + } + if (ptr) { + while (SDL.events.length > 0) { + if (SDL.makeCEvent(SDL.events.shift(), ptr) !== false) return 1; + } + return 0; + } else { + return SDL.events.length > 0; + } + }), + makeCEvent: (function(event, ptr) { + if (typeof event === "number") { + _memcpy(ptr, event, 28); + _free(event); + return; + } + SDL.handleEvent(event); + switch (event.type) { + case "keydown": + case "keyup": + { + var down = event.type === "keydown"; + var key = SDL.lookupKeyCodeForEvent(event); + var scan; + if (key >= 1024) { + scan = key - 1024; + } else { + scan = SDL.scanCodes[key] || key; + } + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP8[ptr + 8 >> 0] = down ? 1 : 0; + HEAP8[ptr + 9 >> 0] = 0; + HEAP32[ptr + 12 >> 2] = scan; + HEAP32[ptr + 16 >> 2] = key; + HEAP16[ptr + 20 >> 1] = SDL.modState; + HEAP32[ptr + 24 >> 2] = event.keypressCharCode || key; + break; + } + case "keypress": + { + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + var cStr = intArrayFromString(String.fromCharCode(event.charCode)); + for (var i = 0; i < cStr.length; ++i) { + HEAP8[ptr + (8 + i) >> 0] = cStr[i]; + } + break; + } + case "mousedown": + case "mouseup": + case "mousemove": + { + if (event.type != "mousemove") { + var down = event.type === "mousedown"; + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 4 >> 2] = 0; + HEAP32[ptr + 8 >> 2] = 0; + HEAP32[ptr + 12 >> 2] = 0; + HEAP8[ptr + 16 >> 0] = event.button + 1; + HEAP8[ptr + 17 >> 0] = down ? 1 : 0; + HEAP32[ptr + 20 >> 2] = Browser.mouseX; + HEAP32[ptr + 24 >> 2] = Browser.mouseY; + } else { + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 4 >> 2] = 0; + HEAP32[ptr + 8 >> 2] = 0; + HEAP32[ptr + 12 >> 2] = 0; + HEAP32[ptr + 16 >> 2] = SDL.buttonState; + HEAP32[ptr + 20 >> 2] = Browser.mouseX; + HEAP32[ptr + 24 >> 2] = Browser.mouseY; + HEAP32[ptr + 28 >> 2] = Browser.mouseMovementX; + HEAP32[ptr + 32 >> 2] = Browser.mouseMovementY; + } + break; + } + case "wheel": + { + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 16 >> 2] = event.deltaX; + HEAP32[ptr + 20 >> 2] = event.deltaY; + break; + } + case "touchstart": + case "touchend": + case "touchmove": + { + var touch = event.touch; + if (!Browser.touches[touch.identifier]) break; + var w = Module["canvas"].width; + var h = Module["canvas"].height; + var x = Browser.touches[touch.identifier].x / w; + var y = Browser.touches[touch.identifier].y / h; + var lx = Browser.lastTouches[touch.identifier].x / w; + var ly = Browser.lastTouches[touch.identifier].y / h; + var dx = x - lx; + var dy = y - ly; + if (touch["deviceID"] === undefined) touch.deviceID = SDL.TOUCH_DEFAULT_ID; + if (dx === 0 && dy === 0 && event.type === "touchmove") return false; + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 4 >> 2] = _SDL_GetTicks(); + tempI64 = [ touch.deviceID >>> 0, (tempDouble = touch.deviceID, +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 + 8 >> 2] = tempI64[0], HEAP32[ptr + 12 >> 2] = tempI64[1]; + tempI64 = [ touch.identifier >>> 0, (tempDouble = touch.identifier, +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 + 16 >> 2] = tempI64[0], HEAP32[ptr + 20 >> 2] = tempI64[1]; + HEAPF32[ptr + 24 >> 2] = x; + HEAPF32[ptr + 28 >> 2] = y; + HEAPF32[ptr + 32 >> 2] = dx; + HEAPF32[ptr + 36 >> 2] = dy; + if (touch.force !== undefined) { + HEAPF32[ptr + 40 >> 2] = touch.force; + } else { + HEAPF32[ptr + 40 >> 2] = event.type == "touchend" ? 0 : 1; + } + break; + } + case "unload": + { + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + break; + } + case "resize": + { + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 4 >> 2] = event.w; + HEAP32[ptr + 8 >> 2] = event.h; + break; + } + case "joystick_button_up": + case "joystick_button_down": + { + var state = event.type === "joystick_button_up" ? 0 : 1; + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP8[ptr + 4 >> 0] = event.index; + HEAP8[ptr + 5 >> 0] = event.button; + HEAP8[ptr + 6 >> 0] = state; + break; + } + case "joystick_axis_motion": + { + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP8[ptr + 4 >> 0] = event.index; + HEAP8[ptr + 5 >> 0] = event.axis; + HEAP32[ptr + 8 >> 2] = SDL.joystickAxisValueConversion(event.value); + break; + } + case "focus": + { + var SDL_WINDOWEVENT_FOCUS_GAINED = 12; + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 4 >> 2] = 0; + HEAP8[ptr + 8 >> 0] = SDL_WINDOWEVENT_FOCUS_GAINED; + break; + } + case "blur": + { + var SDL_WINDOWEVENT_FOCUS_LOST = 13; + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 4 >> 2] = 0; + HEAP8[ptr + 8 >> 0] = SDL_WINDOWEVENT_FOCUS_LOST; + break; + } + case "visibilitychange": + { + var SDL_WINDOWEVENT_SHOWN = 1; + var SDL_WINDOWEVENT_HIDDEN = 2; + var visibilityEventID = event.visible ? SDL_WINDOWEVENT_SHOWN : SDL_WINDOWEVENT_HIDDEN; + HEAP32[ptr >> 2] = SDL.DOMEventToSDLEvent[event.type]; + HEAP32[ptr + 4 >> 2] = 0; + HEAP8[ptr + 8 >> 0] = visibilityEventID; + break; + } + default: + throw "Unhandled SDL event: " + event.type; + } + }), + makeFontString: (function(height, fontName) { + if (fontName.charAt(0) != "'" && fontName.charAt(0) != '"') { + fontName = '"' + fontName + '"'; + } + return height + "px " + fontName + ", serif"; + }), + estimateTextWidth: (function(fontData, text) { + var h = fontData.size; + var fontString = SDL.makeFontString(h, fontData.name); + var tempCtx = SDL.ttfContext; + assert(tempCtx, "TTF_Init must have been called"); + tempCtx.save(); + tempCtx.font = fontString; + var ret = tempCtx.measureText(text).width | 0; + tempCtx.restore(); + return ret; + }), + allocateChannels: (function(num) { + if (SDL.numChannels && SDL.numChannels >= num && num != 0) return; + SDL.numChannels = num; + SDL.channels = []; + for (var i = 0; i < num; i++) { + SDL.channels[i] = { + audio: null, + volume: 1 + }; + } + }), + setGetVolume: (function(info, volume) { + if (!info) return 0; + var ret = info.volume * 128; + if (volume != -1) { + info.volume = Math.min(Math.max(volume, 0), 128) / 128; + if (info.audio) { + try { + info.audio.volume = info.volume; + if (info.audio.webAudioGainNode) info.audio.webAudioGainNode["gain"]["value"] = info.volume; + } catch (e) { + Module.printErr("setGetVolume failed to set audio volume: " + e); + } + } + } + return ret; + }), + setPannerPosition: (function(info, x, y, z) { + if (!info) return; + if (info.audio) { + if (info.audio.webAudioPannerNode) { + info.audio.webAudioPannerNode["setPosition"](x, y, z); + } + } + }), + playWebAudio: (function(audio) { + if (!audio) return; + if (audio.webAudioNode) return; + if (!SDL.webAudioAvailable()) return; + try { + var webAudio = audio.resource.webAudio; + audio.paused = false; + if (!webAudio.decodedBuffer) { + if (webAudio.onDecodeComplete === undefined) abort("Cannot play back audio object that was not loaded"); + webAudio.onDecodeComplete.push((function() { + if (!audio.paused) SDL.playWebAudio(audio); + })); + return; + } + audio.webAudioNode = SDL.audioContext["createBufferSource"](); + audio.webAudioNode["buffer"] = webAudio.decodedBuffer; + audio.webAudioNode["loop"] = audio.loop; + audio.webAudioNode["onended"] = (function() { + audio["onended"](); + }); + audio.webAudioPannerNode = SDL.audioContext["createPanner"](); + audio.webAudioPannerNode["setPosition"](0, 0, -.5); + audio.webAudioPannerNode["panningModel"] = "equalpower"; + audio.webAudioGainNode = SDL.audioContext["createGain"](); + audio.webAudioGainNode["gain"]["value"] = audio.volume; + audio.webAudioNode["connect"](audio.webAudioPannerNode); + audio.webAudioPannerNode["connect"](audio.webAudioGainNode); + audio.webAudioGainNode["connect"](SDL.audioContext["destination"]); + audio.webAudioNode["start"](0, audio.currentPosition); + audio.startTime = SDL.audioContext["currentTime"] - audio.currentPosition; + } catch (e) { + Module.printErr("playWebAudio failed: " + e); + } + }), + pauseWebAudio: (function(audio) { + if (!audio) return; + if (audio.webAudioNode) { + try { + audio.currentPosition = (SDL.audioContext["currentTime"] - audio.startTime) % audio.resource.webAudio.decodedBuffer.duration; + audio.webAudioNode["onended"] = undefined; + audio.webAudioNode.stop(0); + audio.webAudioNode = undefined; + } catch (e) { + Module.printErr("pauseWebAudio failed: " + e); + } + } + audio.paused = true; + }), + openAudioContext: (function() { + if (!SDL.audioContext) { + if (typeof AudioContext !== "undefined") SDL.audioContext = new AudioContext; else if (typeof webkitAudioContext !== "undefined") SDL.audioContext = new webkitAudioContext; + } + }), + webAudioAvailable: (function() { + return !!SDL.audioContext; + }), + fillWebAudioBufferFromHeap: (function(heapPtr, sizeSamplesPerChannel, dstAudioBuffer) { + var numChannels = SDL.audio.channels; + for (var c = 0; c < numChannels; ++c) { + var channelData = dstAudioBuffer["getChannelData"](c); + if (channelData.length != sizeSamplesPerChannel) { + throw "Web Audio output buffer length mismatch! Destination size: " + channelData.length + " samples vs expected " + sizeSamplesPerChannel + " samples!"; + } + if (SDL.audio.format == 32784) { + for (var j = 0; j < sizeSamplesPerChannel; ++j) { + channelData[j] = HEAP16[heapPtr + (j * numChannels + c) * 2 >> 1] / 32768; + } + } else if (SDL.audio.format == 8) { + for (var j = 0; j < sizeSamplesPerChannel; ++j) { + var v = HEAP8[heapPtr + (j * numChannels + c) >> 0]; + channelData[j] = (v >= 0 ? v - 128 : v + 128) / 128; + } + } else if (SDL.audio.format == 33056) { + for (var j = 0; j < sizeSamplesPerChannel; ++j) { + channelData[j] = HEAPF32[heapPtr + (j * numChannels + c) * 4 >> 2]; + } + } else { + throw "Invalid SDL audio format " + SDL.audio.format + "!"; + } + } + }), + debugSurface: (function(surfData) { + console.log("dumping surface " + [ surfData.surf, surfData.source, surfData.width, surfData.height ]); + var image = surfData.ctx.getImageData(0, 0, surfData.width, surfData.height); + var data = image.data; + var num = Math.min(surfData.width, surfData.height); + for (var i = 0; i < num; i++) { + console.log(" diagonal " + i + ":" + [ data[i * surfData.width * 4 + i * 4 + 0], data[i * surfData.width * 4 + i * 4 + 1], data[i * surfData.width * 4 + i * 4 + 2], data[i * surfData.width * 4 + i * 4 + 3] ]); + } + }), + joystickEventState: 1, + lastJoystickState: {}, + joystickNamePool: {}, + recordJoystickState: (function(joystick, state) { + var buttons = new Array(state.buttons.length); + for (var i = 0; i < state.buttons.length; i++) { + buttons[i] = SDL.getJoystickButtonState(state.buttons[i]); + } + SDL.lastJoystickState[joystick] = { + buttons: buttons, + axes: state.axes.slice(0), + timestamp: state.timestamp, + index: state.index, + id: state.id + }; + }), + getJoystickButtonState: (function(button) { + if (typeof button === "object") { + return button["pressed"]; + } else { + return button > 0; + } + }), + queryJoysticks: (function() { + for (var joystick in SDL.lastJoystickState) { + var state = SDL.getGamepad(joystick - 1); + var prevState = SDL.lastJoystickState[joystick]; + if (typeof state === "undefined") return; + if (typeof state.timestamp !== "number" || state.timestamp !== prevState.timestamp) { + var i; + for (i = 0; i < state.buttons.length; i++) { + var buttonState = SDL.getJoystickButtonState(state.buttons[i]); + if (buttonState !== prevState.buttons[i]) { + SDL.events.push({ + type: buttonState ? "joystick_button_down" : "joystick_button_up", + joystick: joystick, + index: joystick - 1, + button: i + }); + } + } + for (i = 0; i < state.axes.length; i++) { + if (state.axes[i] !== prevState.axes[i]) { + SDL.events.push({ + type: "joystick_axis_motion", + joystick: joystick, + index: joystick - 1, + axis: i, + value: state.axes[i] + }); + } + } + SDL.recordJoystickState(joystick, state); + } + } + }), + joystickAxisValueConversion: (function(value) { + value = Math.min(1, Math.max(value, -1)); + return Math.ceil((value + 1) * 32767.5 - 32768); + }), + getGamepads: (function() { + var fcn = navigator.getGamepads || navigator.webkitGamepads || navigator.mozGamepads || navigator.gamepads || navigator.webkitGetGamepads; + if (fcn !== undefined) { + return fcn.apply(navigator); + } else { + return []; + } + }), + getGamepad: (function(deviceIndex) { + var gamepads = SDL.getGamepads(); + if (gamepads.length > deviceIndex && deviceIndex >= 0) { + return gamepads[deviceIndex]; + } + return null; + }) +}; +function _SDL_GL_SwapBuffers() { + if (Browser.doSwapBuffers) Browser.doSwapBuffers(); +} +function ___cxa_allocate_exception(size) { + return _malloc(size); +} +function __ZSt18uncaught_exceptionv() { + return !!__ZSt18uncaught_exceptionv.uncaught_exception; +} +var EXCEPTIONS = { + last: 0, + caught: [], + infos: {}, + deAdjust: (function(adjusted) { + if (!adjusted || EXCEPTIONS.infos[adjusted]) return adjusted; + for (var key in EXCEPTIONS.infos) { + var ptr = +key; + var info = EXCEPTIONS.infos[ptr]; + if (info.adjusted === adjusted) { + return ptr; + } + } + return adjusted; + }), + addRef: (function(ptr) { + if (!ptr) return; + var info = EXCEPTIONS.infos[ptr]; + info.refcount++; + }), + decRef: (function(ptr) { + if (!ptr) return; + var info = EXCEPTIONS.infos[ptr]; + assert(info.refcount > 0); + info.refcount--; + if (info.refcount === 0 && !info.rethrown) { + if (info.destructor) { + Module["dynCall_vi"](info.destructor, ptr); + } + delete EXCEPTIONS.infos[ptr]; + ___cxa_free_exception(ptr); + } + }), + clearRef: (function(ptr) { + if (!ptr) return; + var info = EXCEPTIONS.infos[ptr]; + info.refcount = 0; + }) +}; +function ___cxa_begin_catch(ptr) { + var info = EXCEPTIONS.infos[ptr]; + if (info && !info.caught) { + info.caught = true; + __ZSt18uncaught_exceptionv.uncaught_exception--; + } + if (info) info.rethrown = false; + EXCEPTIONS.caught.push(ptr); + EXCEPTIONS.addRef(EXCEPTIONS.deAdjust(ptr)); + return ptr; +} +function ___cxa_free_exception(ptr) { + try { + return _free(ptr); + } catch (e) { + Module.printErr("exception during cxa_free_exception: " + e); + } +} +function ___cxa_end_catch() { + Module["setThrew"](0); + var ptr = EXCEPTIONS.caught.pop(); + if (ptr) { + EXCEPTIONS.decRef(EXCEPTIONS.deAdjust(ptr)); + EXCEPTIONS.last = 0; + } +} +function ___cxa_find_matching_catch_2() { + return ___cxa_find_matching_catch.apply(null, arguments); +} +function ___cxa_find_matching_catch_3() { + return ___cxa_find_matching_catch.apply(null, arguments); +} +function ___cxa_find_matching_catch_4() { + return ___cxa_find_matching_catch.apply(null, arguments); +} +function ___cxa_pure_virtual() { + ABORT = true; + throw "Pure virtual function called!"; +} +function ___cxa_rethrow() { + var ptr = EXCEPTIONS.caught.pop(); + ptr = EXCEPTIONS.deAdjust(ptr); + if (!EXCEPTIONS.infos[ptr].rethrown) { + EXCEPTIONS.caught.push(ptr); + EXCEPTIONS.infos[ptr].rethrown = true; + } + EXCEPTIONS.last = ptr; + throw ptr; +} +function ___resumeException(ptr) { + if (!EXCEPTIONS.last) { + EXCEPTIONS.last = ptr; + } + throw ptr; +} +function ___cxa_find_matching_catch() { + var thrown = EXCEPTIONS.last; + if (!thrown) { + return (setTempRet0(0), 0) | 0; + } + var info = EXCEPTIONS.infos[thrown]; + var throwntype = info.type; + if (!throwntype) { + return (setTempRet0(0), thrown) | 0; + } + var typeArray = Array.prototype.slice.call(arguments); + var pointer = Module["___cxa_is_pointer_type"](throwntype); + if (!___cxa_find_matching_catch.buffer) ___cxa_find_matching_catch.buffer = _malloc(4); + HEAP32[___cxa_find_matching_catch.buffer >> 2] = thrown; + thrown = ___cxa_find_matching_catch.buffer; + for (var i = 0; i < typeArray.length; i++) { + if (typeArray[i] && Module["___cxa_can_catch"](typeArray[i], throwntype, thrown)) { + thrown = HEAP32[thrown >> 2]; + info.adjusted = thrown; + return (setTempRet0(typeArray[i]), thrown) | 0; + } + } + thrown = HEAP32[thrown >> 2]; + return (setTempRet0(throwntype), thrown) | 0; +} +function ___cxa_throw(ptr, type, destructor) { + EXCEPTIONS.infos[ptr] = { + ptr: ptr, + adjusted: ptr, + type: type, + destructor: destructor, + refcount: 0, + caught: false, + rethrown: false + }; + EXCEPTIONS.last = ptr; + if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) { + __ZSt18uncaught_exceptionv.uncaught_exception = 1; + } else { + __ZSt18uncaught_exceptionv.uncaught_exception++; + } + throw ptr; +} +function ___gxx_personality_v0() {} +function ___lock() {} +function ___map_file(pathname, size) { + ___setErrNo(ERRNO_CODES.EPERM); + return -1; +} +var SYSCALLS = { + DEFAULT_POLLMASK: 5, + mappings: {}, + umask: 511, + calculateAt: (function(dirfd, path) { + if (path[0] !== "/") { + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = FS.getStream(dirfd); + if (!dirstream) throw new FS.ErrnoError(ERRNO_CODES.EBADF); + 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))) { + return -ERRNO_CODES.ENOTDIR; + } + 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; + HEAP32[buf + 36 >> 2] = stat.size; + HEAP32[buf + 40 >> 2] = 4096; + HEAP32[buf + 44 >> 2] = stat.blocks; + HEAP32[buf + 48 >> 2] = stat.atime.getTime() / 1e3 | 0; + HEAP32[buf + 52 >> 2] = 0; + HEAP32[buf + 56 >> 2] = stat.mtime.getTime() / 1e3 | 0; + HEAP32[buf + 60 >> 2] = 0; + HEAP32[buf + 64 >> 2] = stat.ctime.getTime() / 1e3 | 0; + HEAP32[buf + 68 >> 2] = 0; + HEAP32[buf + 72 >> 2] = stat.ino; + return 0; + }), + doMsync: (function(addr, stream, len, flags) { + var buffer = new Uint8Array(HEAPU8.subarray(addr, addr + len)); + FS.msync(stream, buffer, 0, len, flags); + }), + doMkdir: (function(path, mode) { + 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) { + switch (mode & 61440) { + case 32768: + case 8192: + case 24576: + case 4096: + case 49152: + break; + default: + return -ERRNO_CODES.EINVAL; + } + FS.mknod(path, mode, dev); + return 0; + }), + doReadlink: (function(path, buf, bufsize) { + if (bufsize <= 0) return -ERRNO_CODES.EINVAL; + var ret = FS.readlink(path); + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf + len]; + stringToUTF8(ret, buf, bufsize + 1); + HEAP8[buf + len] = endChar; + return len; + }), + doAccess: (function(path, amode) { + if (amode & ~7) { + return -ERRNO_CODES.EINVAL; + } + var node; + var lookup = FS.lookupPath(path, { + follow: true + }); + node = lookup.node; + var perms = ""; + if (amode & 4) perms += "r"; + if (amode & 2) perms += "w"; + if (amode & 1) perms += "x"; + if (perms && FS.nodePermissions(node, perms)) { + return -ERRNO_CODES.EACCES; + } + 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; + } + 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: 0, + get: (function(varargs) { + SYSCALLS.varargs += 4; + var ret = HEAP32[SYSCALLS.varargs - 4 >> 2]; + return ret; + }), + getStr: (function() { + var ret = Pointer_stringify(SYSCALLS.get()); + return ret; + }), + getStreamFromFD: (function() { + var stream = FS.getStream(SYSCALLS.get()); + if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF); + return stream; + }), + getSocketFromFD: (function() { + var socket = SOCKFS.getSocket(SYSCALLS.get()); + if (!socket) throw new FS.ErrnoError(ERRNO_CODES.EBADF); + return socket; + }), + getSocketAddress: (function(allowNull) { + var addrp = SYSCALLS.get(), addrlen = SYSCALLS.get(); + if (allowNull && addrp === 0) return null; + var info = __read_sockaddr(addrp, addrlen); + if (info.errno) throw new FS.ErrnoError(info.errno); + info.addr = DNS.lookup_addr(info.addr) || info.addr; + return info; + }), + get64: (function() { + var low = SYSCALLS.get(), high = SYSCALLS.get(); + if (low >= 0) assert(high === 0); else assert(high === -1); + return low; + }), + getZero: (function() { + assert(SYSCALLS.get() === 0); + }) +}; +function ___syscall10(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(); + FS.unlink(path); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +var SOCKFS = { + mount: (function(mount) { + Module["websocket"] = Module["websocket"] && "object" === typeof Module["websocket"] ? Module["websocket"] : {}; + Module["websocket"]._callbacks = {}; + Module["websocket"]["on"] = (function(event, callback) { + if ("function" === typeof callback) { + this._callbacks[event] = callback; + } + return this; + }); + Module["websocket"].emit = (function(event, param) { + if ("function" === typeof this._callbacks[event]) { + this._callbacks[event].call(this, param); + } + }); + return FS.createNode(null, "/", 16384 | 511, 0); + }), + createSocket: (function(family, type, protocol) { + var streaming = type == 1; + if (protocol) { + assert(streaming == (protocol == 6)); + } + var sock = { + family: family, + type: type, + protocol: protocol, + server: null, + error: null, + peers: {}, + pending: [], + recv_queue: [], + sock_ops: SOCKFS.websocket_sock_ops + }; + var name = SOCKFS.nextname(); + var node = FS.createNode(SOCKFS.root, name, 49152, 0); + node.sock = sock; + var stream = FS.createStream({ + path: name, + node: node, + flags: FS.modeStringToFlags("r+"), + seekable: false, + stream_ops: SOCKFS.stream_ops + }); + sock.stream = stream; + return sock; + }), + getSocket: (function(fd) { + var stream = FS.getStream(fd); + if (!stream || !FS.isSocket(stream.node.mode)) { + return null; + } + return stream.node.sock; + }), + stream_ops: { + poll: (function(stream) { + var sock = stream.node.sock; + return sock.sock_ops.poll(sock); + }), + ioctl: (function(stream, request, varargs) { + var sock = stream.node.sock; + return sock.sock_ops.ioctl(sock, request, varargs); + }), + read: (function(stream, buffer, offset, length, position) { + var sock = stream.node.sock; + var msg = sock.sock_ops.recvmsg(sock, length); + if (!msg) { + return 0; + } + buffer.set(msg.buffer, offset); + return msg.buffer.length; + }), + write: (function(stream, buffer, offset, length, position) { + var sock = stream.node.sock; + return sock.sock_ops.sendmsg(sock, buffer, offset, length); + }), + close: (function(stream) { + var sock = stream.node.sock; + sock.sock_ops.close(sock); + }) + }, + nextname: (function() { + if (!SOCKFS.nextname.current) { + SOCKFS.nextname.current = 0; + } + return "socket[" + SOCKFS.nextname.current++ + "]"; + }), + websocket_sock_ops: { + createPeer: (function(sock, addr, port) { + var ws; + if (typeof addr === "object") { + ws = addr; + addr = null; + port = null; + } + if (ws) { + if (ws._socket) { + addr = ws._socket.remoteAddress; + port = ws._socket.remotePort; + } else { + var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url); + if (!result) { + throw new Error("WebSocket URL must be in the format ws(s)://address:port"); + } + addr = result[1]; + port = parseInt(result[2], 10); + } + } else { + try { + var runtimeConfig = Module["websocket"] && "object" === typeof Module["websocket"]; + var url = "ws:#".replace("#", "//"); + if (runtimeConfig) { + if ("string" === typeof Module["websocket"]["url"]) { + url = Module["websocket"]["url"]; + } + } + if (url === "ws://" || url === "wss://") { + var parts = addr.split("/"); + url = url + parts[0] + ":" + port + "/" + parts.slice(1).join("/"); + } + var subProtocols = "binary"; + if (runtimeConfig) { + if ("string" === typeof Module["websocket"]["subprotocol"]) { + subProtocols = Module["websocket"]["subprotocol"]; + } + } + subProtocols = subProtocols.replace(/^ +| +$/g, "").split(/ *, */); + var opts = ENVIRONMENT_IS_NODE ? { + "protocol": subProtocols.toString() + } : subProtocols; + if (runtimeConfig && null === Module["websocket"]["subprotocol"]) { + subProtocols = "null"; + opts = undefined; + } + var WebSocketConstructor; + if (ENVIRONMENT_IS_NODE) { + WebSocketConstructor = require("ws"); + } else if (ENVIRONMENT_IS_WEB) { + WebSocketConstructor = window["WebSocket"]; + } else { + WebSocketConstructor = WebSocket; + } + ws = new WebSocketConstructor(url, opts); + ws.binaryType = "arraybuffer"; + } catch (e) { + throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH); + } + } + var peer = { + addr: addr, + port: port, + socket: ws, + dgram_send_queue: [] + }; + SOCKFS.websocket_sock_ops.addPeer(sock, peer); + SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer); + if (sock.type === 2 && typeof sock.sport !== "undefined") { + peer.dgram_send_queue.push(new Uint8Array([ 255, 255, 255, 255, "p".charCodeAt(0), "o".charCodeAt(0), "r".charCodeAt(0), "t".charCodeAt(0), (sock.sport & 65280) >> 8, sock.sport & 255 ])); + } + return peer; + }), + getPeer: (function(sock, addr, port) { + return sock.peers[addr + ":" + port]; + }), + addPeer: (function(sock, peer) { + sock.peers[peer.addr + ":" + peer.port] = peer; + }), + removePeer: (function(sock, peer) { + delete sock.peers[peer.addr + ":" + peer.port]; + }), + handlePeerEvents: (function(sock, peer) { + var first = true; + var handleOpen = (function() { + Module["websocket"].emit("open", sock.stream.fd); + try { + var queued = peer.dgram_send_queue.shift(); + while (queued) { + peer.socket.send(queued); + queued = peer.dgram_send_queue.shift(); + } + } catch (e) { + peer.socket.close(); + } + }); + function handleMessage(data) { + assert(typeof data !== "string" && data.byteLength !== undefined); + if (data.byteLength == 0) { + return; + } + data = new Uint8Array(data); + var wasfirst = first; + first = false; + if (wasfirst && data.length === 10 && data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 && data[4] === "p".charCodeAt(0) && data[5] === "o".charCodeAt(0) && data[6] === "r".charCodeAt(0) && data[7] === "t".charCodeAt(0)) { + var newport = data[8] << 8 | data[9]; + SOCKFS.websocket_sock_ops.removePeer(sock, peer); + peer.port = newport; + SOCKFS.websocket_sock_ops.addPeer(sock, peer); + return; + } + sock.recv_queue.push({ + addr: peer.addr, + port: peer.port, + data: data + }); + Module["websocket"].emit("message", sock.stream.fd); + } + if (ENVIRONMENT_IS_NODE) { + peer.socket.on("open", handleOpen); + peer.socket.on("message", (function(data, flags) { + if (!flags.binary) { + return; + } + handleMessage((new Uint8Array(data)).buffer); + })); + peer.socket.on("close", (function() { + Module["websocket"].emit("close", sock.stream.fd); + })); + peer.socket.on("error", (function(error) { + sock.error = ERRNO_CODES.ECONNREFUSED; + Module["websocket"].emit("error", [ sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused" ]); + })); + } else { + peer.socket.onopen = handleOpen; + peer.socket.onclose = (function() { + Module["websocket"].emit("close", sock.stream.fd); + }); + peer.socket.onmessage = function peer_socket_onmessage(event) { + handleMessage(event.data); + }; + peer.socket.onerror = (function(error) { + sock.error = ERRNO_CODES.ECONNREFUSED; + Module["websocket"].emit("error", [ sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused" ]); + }); + } + }), + poll: (function(sock) { + if (sock.type === 1 && sock.server) { + return sock.pending.length ? 64 | 1 : 0; + } + var mask = 0; + var dest = sock.type === 1 ? SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) : null; + if (sock.recv_queue.length || !dest || dest && dest.socket.readyState === dest.socket.CLOSING || dest && dest.socket.readyState === dest.socket.CLOSED) { + mask |= 64 | 1; + } + if (!dest || dest && dest.socket.readyState === dest.socket.OPEN) { + mask |= 4; + } + if (dest && dest.socket.readyState === dest.socket.CLOSING || dest && dest.socket.readyState === dest.socket.CLOSED) { + mask |= 16; + } + return mask; + }), + ioctl: (function(sock, request, arg) { + switch (request) { + case 21531: + var bytes = 0; + if (sock.recv_queue.length) { + bytes = sock.recv_queue[0].data.length; + } + HEAP32[arg >> 2] = bytes; + return 0; + default: + return ERRNO_CODES.EINVAL; + } + }), + close: (function(sock) { + if (sock.server) { + try { + sock.server.close(); + } catch (e) {} + sock.server = null; + } + var peers = Object.keys(sock.peers); + for (var i = 0; i < peers.length; i++) { + var peer = sock.peers[peers[i]]; + try { + peer.socket.close(); + } catch (e) {} + SOCKFS.websocket_sock_ops.removePeer(sock, peer); + } + return 0; + }), + bind: (function(sock, addr, port) { + if (typeof sock.saddr !== "undefined" || typeof sock.sport !== "undefined") { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + sock.saddr = addr; + sock.sport = port; + if (sock.type === 2) { + if (sock.server) { + sock.server.close(); + sock.server = null; + } + try { + sock.sock_ops.listen(sock, 0); + } catch (e) { + if (!(e instanceof FS.ErrnoError)) throw e; + if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e; + } + } + }), + connect: (function(sock, addr, port) { + if (sock.server) { + throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP); + } + if (typeof sock.daddr !== "undefined" && typeof sock.dport !== "undefined") { + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport); + if (dest) { + if (dest.socket.readyState === dest.socket.CONNECTING) { + throw new FS.ErrnoError(ERRNO_CODES.EALREADY); + } else { + throw new FS.ErrnoError(ERRNO_CODES.EISCONN); + } + } + } + var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); + sock.daddr = peer.addr; + sock.dport = peer.port; + throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS); + }), + listen: (function(sock, backlog) { + if (!ENVIRONMENT_IS_NODE) { + throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP); + } + if (sock.server) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + var WebSocketServer = require("ws").Server; + var host = sock.saddr; + sock.server = new WebSocketServer({ + host: host, + port: sock.sport + }); + Module["websocket"].emit("listen", sock.stream.fd); + sock.server.on("connection", (function(ws) { + if (sock.type === 1) { + var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol); + var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws); + newsock.daddr = peer.addr; + newsock.dport = peer.port; + sock.pending.push(newsock); + Module["websocket"].emit("connection", newsock.stream.fd); + } else { + SOCKFS.websocket_sock_ops.createPeer(sock, ws); + Module["websocket"].emit("connection", sock.stream.fd); + } + })); + sock.server.on("closed", (function() { + Module["websocket"].emit("close", sock.stream.fd); + sock.server = null; + })); + sock.server.on("error", (function(error) { + sock.error = ERRNO_CODES.EHOSTUNREACH; + Module["websocket"].emit("error", [ sock.stream.fd, sock.error, "EHOSTUNREACH: Host is unreachable" ]); + })); + }), + accept: (function(listensock) { + if (!listensock.server) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + var newsock = listensock.pending.shift(); + newsock.stream.flags = listensock.stream.flags; + return newsock; + }), + getname: (function(sock, peer) { + var addr, port; + if (peer) { + if (sock.daddr === undefined || sock.dport === undefined) { + throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN); + } + addr = sock.daddr; + port = sock.dport; + } else { + addr = sock.saddr || 0; + port = sock.sport || 0; + } + return { + addr: addr, + port: port + }; + }), + sendmsg: (function(sock, buffer, offset, length, addr, port) { + if (sock.type === 2) { + if (addr === undefined || port === undefined) { + addr = sock.daddr; + port = sock.dport; + } + if (addr === undefined || port === undefined) { + throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ); + } + } else { + addr = sock.daddr; + port = sock.dport; + } + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port); + if (sock.type === 1) { + if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN); + } else if (dest.socket.readyState === dest.socket.CONNECTING) { + throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); + } + } + if (ArrayBuffer.isView(buffer)) { + offset += buffer.byteOffset; + buffer = buffer.buffer; + } + var data; + data = buffer.slice(offset, offset + length); + if (sock.type === 2) { + if (!dest || dest.socket.readyState !== dest.socket.OPEN) { + if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); + } + dest.dgram_send_queue.push(data); + return length; + } + } + try { + dest.socket.send(data); + return length; + } catch (e) { + throw new FS.ErrnoError(ERRNO_CODES.EINVAL); + } + }), + recvmsg: (function(sock, length) { + if (sock.type === 1 && sock.server) { + throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN); + } + var queued = sock.recv_queue.shift(); + if (!queued) { + if (sock.type === 1) { + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport); + if (!dest) { + throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN); + } else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + return null; + } else { + throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); + } + } else { + throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); + } + } + var queuedLength = queued.data.byteLength || queued.data.length; + var queuedOffset = queued.data.byteOffset || 0; + var queuedBuffer = queued.data.buffer || queued.data; + var bytesRead = Math.min(length, queuedLength); + var res = { + buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead), + addr: queued.addr, + port: queued.port + }; + if (sock.type === 1 && bytesRead < queuedLength) { + var bytesRemaining = queuedLength - bytesRead; + queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining); + sock.recv_queue.unshift(queued); + } + return res; + }) + } +}; +function __inet_pton4_raw(str) { + var b = str.split("."); + for (var i = 0; i < 4; i++) { + var tmp = Number(b[i]); + if (isNaN(tmp)) return null; + b[i] = tmp; + } + return (b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24) >>> 0; +} +function __inet_pton6_raw(str) { + var words; + var w, offset, z; + var valid6regx = /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i; + var parts = []; + if (!valid6regx.test(str)) { + return null; + } + if (str === "::") { + return [ 0, 0, 0, 0, 0, 0, 0, 0 ]; + } + if (str.indexOf("::") === 0) { + str = str.replace("::", "Z:"); + } else { + str = str.replace("::", ":Z:"); + } + if (str.indexOf(".") > 0) { + str = str.replace(new RegExp("[.]", "g"), ":"); + words = str.split(":"); + words[words.length - 4] = parseInt(words[words.length - 4]) + parseInt(words[words.length - 3]) * 256; + words[words.length - 3] = parseInt(words[words.length - 2]) + parseInt(words[words.length - 1]) * 256; + words = words.slice(0, words.length - 2); + } else { + words = str.split(":"); + } + offset = 0; + z = 0; + for (w = 0; w < words.length; w++) { + if (typeof words[w] === "string") { + if (words[w] === "Z") { + for (z = 0; z < 8 - words.length + 1; z++) { + parts[w + z] = 0; + } + offset = z - 1; + } else { + parts[w + offset] = _htons(parseInt(words[w], 16)); + } + } else { + parts[w + offset] = words[w]; + } + } + return [ parts[1] << 16 | parts[0], parts[3] << 16 | parts[2], parts[5] << 16 | parts[4], parts[7] << 16 | parts[6] ]; +} +var DNS = { + address_map: { + id: 1, + addrs: {}, + names: {} + }, + lookup_name: (function(name) { + var res = __inet_pton4_raw(name); + if (res !== null) { + return name; + } + res = __inet_pton6_raw(name); + if (res !== null) { + return name; + } + var addr; + if (DNS.address_map.addrs[name]) { + addr = DNS.address_map.addrs[name]; + } else { + var id = DNS.address_map.id++; + assert(id < 65535, "exceeded max address mappings of 65535"); + addr = "172.29." + (id & 255) + "." + (id & 65280); + DNS.address_map.names[addr] = name; + DNS.address_map.addrs[name] = addr; + } + return addr; + }), + lookup_addr: (function(addr) { + if (DNS.address_map.names[addr]) { + return DNS.address_map.names[addr]; + } + return null; + }) +}; +function __inet_ntop4_raw(addr) { + return (addr & 255) + "." + (addr >> 8 & 255) + "." + (addr >> 16 & 255) + "." + (addr >> 24 & 255); +} +function __inet_ntop6_raw(ints) { + var str = ""; + var word = 0; + var longest = 0; + var lastzero = 0; + var zstart = 0; + var len = 0; + var i = 0; + var parts = [ ints[0] & 65535, ints[0] >> 16, ints[1] & 65535, ints[1] >> 16, ints[2] & 65535, ints[2] >> 16, ints[3] & 65535, ints[3] >> 16 ]; + var hasipv4 = true; + var v4part = ""; + for (i = 0; i < 5; i++) { + if (parts[i] !== 0) { + hasipv4 = false; + break; + } + } + if (hasipv4) { + v4part = __inet_ntop4_raw(parts[6] | parts[7] << 16); + if (parts[5] === -1) { + str = "::ffff:"; + str += v4part; + return str; + } + if (parts[5] === 0) { + str = "::"; + if (v4part === "0.0.0.0") v4part = ""; + if (v4part === "0.0.0.1") v4part = "1"; + str += v4part; + return str; + } + } + for (word = 0; word < 8; word++) { + if (parts[word] === 0) { + if (word - lastzero > 1) { + len = 0; + } + lastzero = word; + len++; + } + if (len > longest) { + longest = len; + zstart = word - longest + 1; + } + } + for (word = 0; word < 8; word++) { + if (longest > 1) { + if (parts[word] === 0 && word >= zstart && word < zstart + longest) { + if (word === zstart) { + str += ":"; + if (zstart === 0) str += ":"; + } + continue; + } + } + str += Number(_ntohs(parts[word] & 65535)).toString(16); + str += word < 7 ? ":" : ""; + } + return str; +} +function __read_sockaddr(sa, salen) { + var family = HEAP16[sa >> 1]; + var port = _ntohs(HEAP16[sa + 2 >> 1]); + var addr; + switch (family) { + case 2: + if (salen !== 16) { + return { + errno: ERRNO_CODES.EINVAL + }; + } + addr = HEAP32[sa + 4 >> 2]; + addr = __inet_ntop4_raw(addr); + break; + case 10: + if (salen !== 28) { + return { + errno: ERRNO_CODES.EINVAL + }; + } + addr = [ HEAP32[sa + 8 >> 2], HEAP32[sa + 12 >> 2], HEAP32[sa + 16 >> 2], HEAP32[sa + 20 >> 2] ]; + addr = __inet_ntop6_raw(addr); + break; + default: + return { + errno: ERRNO_CODES.EAFNOSUPPORT + }; + } + return { + family: family, + addr: addr, + port: port + }; +} +function __write_sockaddr(sa, family, addr, port) { + switch (family) { + case 2: + addr = __inet_pton4_raw(addr); + HEAP16[sa >> 1] = family; + HEAP32[sa + 4 >> 2] = addr; + HEAP16[sa + 2 >> 1] = _htons(port); + break; + case 10: + addr = __inet_pton6_raw(addr); + HEAP32[sa >> 2] = family; + HEAP32[sa + 8 >> 2] = addr[0]; + HEAP32[sa + 12 >> 2] = addr[1]; + HEAP32[sa + 16 >> 2] = addr[2]; + HEAP32[sa + 20 >> 2] = addr[3]; + HEAP16[sa + 2 >> 1] = _htons(port); + HEAP32[sa + 4 >> 2] = 0; + HEAP32[sa + 24 >> 2] = 0; + break; + default: + return { + errno: ERRNO_CODES.EAFNOSUPPORT + }; + } + return {}; +} +function ___syscall102(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var call = SYSCALLS.get(), socketvararg = SYSCALLS.get(); + SYSCALLS.varargs = socketvararg; + switch (call) { + case 1: + { + var domain = SYSCALLS.get(), type = SYSCALLS.get(), protocol = SYSCALLS.get(); + var sock = SOCKFS.createSocket(domain, type, protocol); + assert(sock.stream.fd < 64); + return sock.stream.fd; + } + case 2: + { + var sock = SYSCALLS.getSocketFromFD(), info = SYSCALLS.getSocketAddress(); + sock.sock_ops.bind(sock, info.addr, info.port); + return 0; + } + case 3: + { + var sock = SYSCALLS.getSocketFromFD(), info = SYSCALLS.getSocketAddress(); + sock.sock_ops.connect(sock, info.addr, info.port); + return 0; + } + case 4: + { + var sock = SYSCALLS.getSocketFromFD(), backlog = SYSCALLS.get(); + sock.sock_ops.listen(sock, backlog); + return 0; + } + case 5: + { + var sock = SYSCALLS.getSocketFromFD(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get(); + var newsock = sock.sock_ops.accept(sock); + if (addr) { + var res = __write_sockaddr(addr, newsock.family, DNS.lookup_name(newsock.daddr), newsock.dport); + assert(!res.errno); + } + return newsock.stream.fd; + } + case 6: + { + var sock = SYSCALLS.getSocketFromFD(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get(); + var res = __write_sockaddr(addr, sock.family, DNS.lookup_name(sock.saddr || "0.0.0.0"), sock.sport); + assert(!res.errno); + return 0; + } + case 7: + { + var sock = SYSCALLS.getSocketFromFD(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get(); + if (!sock.daddr) { + return -ERRNO_CODES.ENOTCONN; + } + var res = __write_sockaddr(addr, sock.family, DNS.lookup_name(sock.daddr), sock.dport); + assert(!res.errno); + return 0; + } + case 11: + { + var sock = SYSCALLS.getSocketFromFD(), message = SYSCALLS.get(), length = SYSCALLS.get(), flags = SYSCALLS.get(), dest = SYSCALLS.getSocketAddress(true); + if (!dest) { + return FS.write(sock.stream, HEAP8, message, length); + } else { + return sock.sock_ops.sendmsg(sock, HEAP8, message, length, dest.addr, dest.port); + } + } + case 12: + { + var sock = SYSCALLS.getSocketFromFD(), buf = SYSCALLS.get(), len = SYSCALLS.get(), flags = SYSCALLS.get(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get(); + var msg = sock.sock_ops.recvmsg(sock, len); + if (!msg) return 0; + if (addr) { + var res = __write_sockaddr(addr, sock.family, DNS.lookup_name(msg.addr), msg.port); + assert(!res.errno); + } + HEAPU8.set(msg.buffer, buf); + return msg.buffer.byteLength; + } + case 14: + { + return -ERRNO_CODES.ENOPROTOOPT; + } + case 15: + { + var sock = SYSCALLS.getSocketFromFD(), level = SYSCALLS.get(), optname = SYSCALLS.get(), optval = SYSCALLS.get(), optlen = SYSCALLS.get(); + if (level === 1) { + if (optname === 4) { + HEAP32[optval >> 2] = sock.error; + HEAP32[optlen >> 2] = 4; + sock.error = null; + return 0; + } + } + return -ERRNO_CODES.ENOPROTOOPT; + } + case 16: + { + var sock = SYSCALLS.getSocketFromFD(), message = SYSCALLS.get(), flags = SYSCALLS.get(); + var iov = HEAP32[message + 8 >> 2]; + var num = HEAP32[message + 12 >> 2]; + var addr, port; + var name = HEAP32[message >> 2]; + var namelen = HEAP32[message + 4 >> 2]; + if (name) { + var info = __read_sockaddr(name, namelen); + if (info.errno) return -info.errno; + port = info.port; + addr = DNS.lookup_addr(info.addr) || info.addr; + } + var total = 0; + for (var i = 0; i < num; i++) { + total += HEAP32[iov + (8 * i + 4) >> 2]; + } + var view = new Uint8Array(total); + var offset = 0; + for (var i = 0; i < num; i++) { + var iovbase = HEAP32[iov + (8 * i + 0) >> 2]; + var iovlen = HEAP32[iov + (8 * i + 4) >> 2]; + for (var j = 0; j < iovlen; j++) { + view[offset++] = HEAP8[iovbase + j >> 0]; + } + } + return sock.sock_ops.sendmsg(sock, view, 0, total, addr, port); + } + case 17: + { + var sock = SYSCALLS.getSocketFromFD(), message = SYSCALLS.get(), flags = SYSCALLS.get(); + var iov = HEAP32[message + 8 >> 2]; + var num = HEAP32[message + 12 >> 2]; + var total = 0; + for (var i = 0; i < num; i++) { + total += HEAP32[iov + (8 * i + 4) >> 2]; + } + var msg = sock.sock_ops.recvmsg(sock, total); + if (!msg) return 0; + var name = HEAP32[message >> 2]; + if (name) { + var res = __write_sockaddr(name, sock.family, DNS.lookup_name(msg.addr), msg.port); + assert(!res.errno); + } + var bytesRead = 0; + var bytesRemaining = msg.buffer.byteLength; + for (var i = 0; bytesRemaining > 0 && i < num; i++) { + var iovbase = HEAP32[iov + (8 * i + 0) >> 2]; + var iovlen = HEAP32[iov + (8 * i + 4) >> 2]; + if (!iovlen) { + continue; + } + var length = Math.min(iovlen, bytesRemaining); + var buf = msg.buffer.subarray(bytesRead, bytesRead + length); + HEAPU8.set(buf, iovbase + bytesRead); + bytesRead += length; + bytesRemaining -= length; + } + return bytesRead; + } + default: + abort("unsupported socketcall syscall " + call); + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall122(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var buf = SYSCALLS.get(); + if (!buf) return -ERRNO_CODES.EFAULT; + var layout = { + "sysname": 0, + "nodename": 65, + "domainname": 325, + "machine": 260, + "version": 195, + "release": 130, + "__size__": 390 + }; + function copyString(element, value) { + var offset = layout[element]; + writeAsciiToMemory(value, buf + offset); + } + copyString("sysname", "Emscripten"); + copyString("nodename", "emscripten"); + copyString("release", "1.0"); + copyString("version", "#1"); + copyString("machine", "x86-JS"); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall140(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get(); + var offset = offset_low; + FS.llseek(stream, offset, whence); + HEAP32[result >> 2] = stream.position; + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall142(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var nfds = SYSCALLS.get(), readfds = SYSCALLS.get(), writefds = SYSCALLS.get(), exceptfds = SYSCALLS.get(), timeout = SYSCALLS.get(); + assert(nfds <= 64, "nfds must be less than or equal to 64"); + assert(!exceptfds, "exceptfds not supported"); + var total = 0; + var srcReadLow = readfds ? HEAP32[readfds >> 2] : 0, srcReadHigh = readfds ? HEAP32[readfds + 4 >> 2] : 0; + var srcWriteLow = writefds ? HEAP32[writefds >> 2] : 0, srcWriteHigh = writefds ? HEAP32[writefds + 4 >> 2] : 0; + var srcExceptLow = exceptfds ? HEAP32[exceptfds >> 2] : 0, srcExceptHigh = exceptfds ? HEAP32[exceptfds + 4 >> 2] : 0; + var dstReadLow = 0, dstReadHigh = 0; + var dstWriteLow = 0, dstWriteHigh = 0; + var dstExceptLow = 0, dstExceptHigh = 0; + var allLow = (readfds ? HEAP32[readfds >> 2] : 0) | (writefds ? HEAP32[writefds >> 2] : 0) | (exceptfds ? HEAP32[exceptfds >> 2] : 0); + var allHigh = (readfds ? HEAP32[readfds + 4 >> 2] : 0) | (writefds ? HEAP32[writefds + 4 >> 2] : 0) | (exceptfds ? HEAP32[exceptfds + 4 >> 2] : 0); + function check(fd, low, high, val) { + return fd < 32 ? low & val : high & val; + } + for (var fd = 0; fd < nfds; fd++) { + var mask = 1 << fd % 32; + if (!check(fd, allLow, allHigh, mask)) { + continue; + } + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF); + var flags = SYSCALLS.DEFAULT_POLLMASK; + if (stream.stream_ops.poll) { + flags = stream.stream_ops.poll(stream); + } + if (flags & 1 && check(fd, srcReadLow, srcReadHigh, mask)) { + fd < 32 ? dstReadLow = dstReadLow | mask : dstReadHigh = dstReadHigh | mask; + total++; + } + if (flags & 4 && check(fd, srcWriteLow, srcWriteHigh, mask)) { + fd < 32 ? dstWriteLow = dstWriteLow | mask : dstWriteHigh = dstWriteHigh | mask; + total++; + } + if (flags & 2 && check(fd, srcExceptLow, srcExceptHigh, mask)) { + fd < 32 ? dstExceptLow = dstExceptLow | mask : dstExceptHigh = dstExceptHigh | mask; + total++; + } + } + if (readfds) { + HEAP32[readfds >> 2] = dstReadLow; + HEAP32[readfds + 4 >> 2] = dstReadHigh; + } + if (writefds) { + HEAP32[writefds >> 2] = dstWriteLow; + HEAP32[writefds + 4 >> 2] = dstWriteHigh; + } + if (exceptfds) { + HEAP32[exceptfds >> 2] = dstExceptLow; + HEAP32[exceptfds + 4 >> 2] = dstExceptHigh; + } + return total; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall145(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get(); + return SYSCALLS.doReadv(stream, iov, iovcnt); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall146(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get(); + return SYSCALLS.doWritev(stream, iov, iovcnt); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall15(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), mode = SYSCALLS.get(); + FS.chmod(path, mode); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall183(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var buf = SYSCALLS.get(), size = SYSCALLS.get(); + if (size === 0) return -ERRNO_CODES.EINVAL; + var cwd = FS.cwd(); + var cwdLengthInBytes = lengthBytesUTF8(cwd); + if (size < cwdLengthInBytes + 1) return -ERRNO_CODES.ERANGE; + stringToUTF8(cwd, buf, size); + return buf; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall192(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var addr = SYSCALLS.get(), len = SYSCALLS.get(), prot = SYSCALLS.get(), flags = SYSCALLS.get(), fd = SYSCALLS.get(), off = SYSCALLS.get(); + off <<= 12; + var ptr; + var allocated = false; + if (fd === -1) { + ptr = _memalign(PAGE_SIZE, len); + if (!ptr) return -ERRNO_CODES.ENOMEM; + _memset(ptr, 0, len); + allocated = true; + } else { + var info = FS.getStream(fd); + if (!info) return -ERRNO_CODES.EBADF; + var res = FS.mmap(info, HEAPU8, addr, len, off, prot, flags); + ptr = res.ptr; + allocated = res.allocated; + } + SYSCALLS.mappings[ptr] = { + malloc: ptr, + len: len, + allocated: allocated, + fd: fd, + flags: flags + }; + return ptr; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall193(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), zero = SYSCALLS.getZero(), length = SYSCALLS.get64(); + FS.truncate(path, length); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall194(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var fd = SYSCALLS.get(), zero = SYSCALLS.getZero(), length = SYSCALLS.get64(); + FS.ftruncate(fd, length); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall195(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), buf = SYSCALLS.get(); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall196(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), buf = SYSCALLS.get(); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall197(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), buf = SYSCALLS.get(); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall202(which, varargs) { + SYSCALLS.varargs = varargs; + try { + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall199() { + return ___syscall202.apply(null, arguments); +} +function ___syscall220(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), dirp = SYSCALLS.get(), count = SYSCALLS.get(); + if (!stream.getdents) { + stream.getdents = FS.readdir(stream.path); + } + var pos = 0; + while (stream.getdents.length > 0 && pos + 268 <= count) { + var id; + var type; + var name = stream.getdents.pop(); + if (name[0] === ".") { + id = 1; + type = 4; + } else { + var child = FS.lookupNode(stream.node, name); + id = child.id; + type = FS.isChrdev(child.mode) ? 2 : FS.isDir(child.mode) ? 4 : FS.isLink(child.mode) ? 10 : 8; + } + HEAP32[dirp + pos >> 2] = id; + HEAP32[dirp + pos + 4 >> 2] = stream.position; + HEAP16[dirp + pos + 8 >> 1] = 268; + HEAP8[dirp + pos + 10 >> 0] = type; + stringToUTF8(name, dirp + pos + 11, 256); + pos += 268; + } + return pos; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall221(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), cmd = SYSCALLS.get(); + switch (cmd) { + case 0: + { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -ERRNO_CODES.EINVAL; + } + var newStream; + newStream = FS.open(stream.path, stream.flags, 0, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; + case 3: + return stream.flags; + case 4: + { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 12: + case 12: + { + var arg = SYSCALLS.get(); + var offset = 0; + HEAP16[arg + offset >> 1] = 2; + return 0; + } + case 13: + case 14: + case 13: + case 14: + return 0; + case 16: + case 8: + return -ERRNO_CODES.EINVAL; + case 9: + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + default: + { + return -ERRNO_CODES.EINVAL; + } + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall268(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), size = SYSCALLS.get(), buf = SYSCALLS.get(); + assert(size === 64); + HEAP32[buf + 4 >> 2] = 4096; + HEAP32[buf + 40 >> 2] = 4096; + HEAP32[buf + 8 >> 2] = 1e6; + HEAP32[buf + 12 >> 2] = 5e5; + HEAP32[buf + 16 >> 2] = 5e5; + HEAP32[buf + 20 >> 2] = FS.nextInode; + HEAP32[buf + 24 >> 2] = 1e6; + HEAP32[buf + 28 >> 2] = 42; + HEAP32[buf + 44 >> 2] = 2; + HEAP32[buf + 36 >> 2] = 255; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall3(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), buf = SYSCALLS.get(), count = SYSCALLS.get(); + return FS.read(stream, HEAP8, buf, count); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall33(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), amode = SYSCALLS.get(); + return SYSCALLS.doAccess(path, amode); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall38(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var old_path = SYSCALLS.getStr(), new_path = SYSCALLS.getStr(); + FS.rename(old_path, new_path); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall39(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), mode = SYSCALLS.get(); + return SYSCALLS.doMkdir(path, mode); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall4(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), buf = SYSCALLS.get(), count = SYSCALLS.get(); + return FS.write(stream, HEAP8, buf, count); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall40(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(); + FS.rmdir(path); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall41(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var old = SYSCALLS.getStreamFromFD(); + return FS.open(old.path, old.flags, 0).fd; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +var PIPEFS = { + BUCKET_BUFFER_SIZE: 8192, + mount: (function(mount) { + return FS.createNode(null, "/", 16384 | 511, 0); + }), + createPipe: (function() { + var pipe = { + buckets: [] + }; + pipe.buckets.push({ + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: 0, + roffset: 0 + }); + var rName = PIPEFS.nextname(); + var wName = PIPEFS.nextname(); + var rNode = FS.createNode(PIPEFS.root, rName, 4096, 0); + var wNode = FS.createNode(PIPEFS.root, wName, 4096, 0); + rNode.pipe = pipe; + wNode.pipe = pipe; + var readableStream = FS.createStream({ + path: rName, + node: rNode, + flags: FS.modeStringToFlags("r"), + seekable: false, + stream_ops: PIPEFS.stream_ops + }); + rNode.stream = readableStream; + var writableStream = FS.createStream({ + path: wName, + node: wNode, + flags: FS.modeStringToFlags("w"), + seekable: false, + stream_ops: PIPEFS.stream_ops + }); + wNode.stream = writableStream; + return { + readable_fd: readableStream.fd, + writable_fd: writableStream.fd + }; + }), + stream_ops: { + poll: (function(stream) { + var pipe = stream.node.pipe; + if ((stream.flags & 2097155) === 1) { + return 256 | 4; + } else { + if (pipe.buckets.length > 0) { + for (var i = 0; i < pipe.buckets.length; i++) { + var bucket = pipe.buckets[i]; + if (bucket.offset - bucket.roffset > 0) { + return 64 | 1; + } + } + } + } + return 0; + }), + ioctl: (function(stream, request, varargs) { + return ERRNO_CODES.EINVAL; + }), + read: (function(stream, buffer, offset, length, position) { + var pipe = stream.node.pipe; + var currentLength = 0; + for (var i = 0; i < pipe.buckets.length; i++) { + var bucket = pipe.buckets[i]; + currentLength += bucket.offset - bucket.roffset; + } + assert(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer)); + var data = buffer.subarray(offset, offset + length); + if (length <= 0) { + return 0; + } + if (currentLength == 0) { + throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); + } + var toRead = Math.min(currentLength, length); + var totalRead = toRead; + var toRemove = 0; + for (var i = 0; i < pipe.buckets.length; i++) { + var currBucket = pipe.buckets[i]; + var bucketSize = currBucket.offset - currBucket.roffset; + if (toRead <= bucketSize) { + var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset); + if (toRead < bucketSize) { + tmpSlice = tmpSlice.subarray(0, toRead); + currBucket.roffset += toRead; + } else { + toRemove++; + } + data.set(tmpSlice); + break; + } else { + var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset); + data.set(tmpSlice); + data = data.subarray(tmpSlice.byteLength); + toRead -= tmpSlice.byteLength; + toRemove++; + } + } + if (toRemove && toRemove == pipe.buckets.length) { + toRemove--; + pipe.buckets[toRemove].offset = 0; + pipe.buckets[toRemove].roffset = 0; + } + pipe.buckets.splice(0, toRemove); + return totalRead; + }), + write: (function(stream, buffer, offset, length, position) { + var pipe = stream.node.pipe; + assert(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer)); + var data = buffer.subarray(offset, offset + length); + var dataLen = data.byteLength; + if (dataLen <= 0) { + return 0; + } + var currBucket = null; + if (pipe.buckets.length == 0) { + currBucket = { + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: 0, + roffset: 0 + }; + pipe.buckets.push(currBucket); + } else { + currBucket = pipe.buckets[pipe.buckets.length - 1]; + } + assert(currBucket.offset <= PIPEFS.BUCKET_BUFFER_SIZE); + var freeBytesInCurrBuffer = PIPEFS.BUCKET_BUFFER_SIZE - currBucket.offset; + if (freeBytesInCurrBuffer >= dataLen) { + currBucket.buffer.set(data, currBucket.offset); + currBucket.offset += dataLen; + return dataLen; + } else if (freeBytesInCurrBuffer > 0) { + currBucket.buffer.set(data.subarray(0, freeBytesInCurrBuffer), currBucket.offset); + currBucket.offset += freeBytesInCurrBuffer; + data = data.subarray(freeBytesInCurrBuffer, data.byteLength); + } + var numBuckets = data.byteLength / PIPEFS.BUCKET_BUFFER_SIZE | 0; + var remElements = data.byteLength % PIPEFS.BUCKET_BUFFER_SIZE; + for (var i = 0; i < numBuckets; i++) { + var newBucket = { + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: PIPEFS.BUCKET_BUFFER_SIZE, + roffset: 0 + }; + pipe.buckets.push(newBucket); + newBucket.buffer.set(data.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE)); + data = data.subarray(PIPEFS.BUCKET_BUFFER_SIZE, data.byteLength); + } + if (remElements > 0) { + var newBucket = { + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: data.byteLength, + roffset: 0 + }; + pipe.buckets.push(newBucket); + newBucket.buffer.set(data); + } + return dataLen; + }), + close: (function(stream) { + var pipe = stream.node.pipe; + pipe.buckets = null; + }) + }, + nextname: (function() { + if (!PIPEFS.nextname.current) { + PIPEFS.nextname.current = 0; + } + return "pipe[" + PIPEFS.nextname.current++ + "]"; + }) +}; +function ___syscall42(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var fdPtr = SYSCALLS.get(); + if (fdPtr == 0) { + throw new FS.ErrnoError(ERRNO_CODES.EFAULT); + } + var res = PIPEFS.createPipe(); + HEAP32[fdPtr >> 2] = res.readable_fd; + HEAP32[fdPtr + 4 >> 2] = res.writable_fd; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall5(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var pathname = SYSCALLS.getStr(), flags = SYSCALLS.get(), 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(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(), op = SYSCALLS.get(); + switch (op) { + case 21509: + case 21505: + { + if (!stream.tty) return -ERRNO_CODES.ENOTTY; + return 0; + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: + { + if (!stream.tty) return -ERRNO_CODES.ENOTTY; + return 0; + } + case 21519: + { + if (!stream.tty) return -ERRNO_CODES.ENOTTY; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0; + } + case 21520: + { + if (!stream.tty) return -ERRNO_CODES.ENOTTY; + return -ERRNO_CODES.EINVAL; + } + case 21531: + { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + case 21523: + { + if (!stream.tty) return -ERRNO_CODES.ENOTTY; + return 0; + } + case 21524: + { + if (!stream.tty) return -ERRNO_CODES.ENOTTY; + return 0; + } + default: + abort("bad ioctl syscall " + op); + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall6(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall77(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var who = SYSCALLS.get(), usage = SYSCALLS.get(); + _memset(usage, 0, 136); + HEAP32[usage >> 2] = 1; + HEAP32[usage + 4 >> 2] = 2; + HEAP32[usage + 8 >> 2] = 3; + HEAP32[usage + 12 >> 2] = 4; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall85(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var path = SYSCALLS.getStr(), buf = SYSCALLS.get(), bufsize = SYSCALLS.get(); + return SYSCALLS.doReadlink(path, buf, bufsize); + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___syscall91(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var addr = SYSCALLS.get(), len = SYSCALLS.get(); + var info = SYSCALLS.mappings[addr]; + if (!info) return 0; + if (len === info.len) { + var stream = FS.getStream(info.fd); + SYSCALLS.doMsync(addr, stream, len, info.flags); + FS.munmap(stream); + SYSCALLS.mappings[addr] = null; + if (info.allocated) { + _free(info.malloc); + } + } + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} +function ___unlock() {} +function _abort() { + Module["abort"](); +} +function _atexit(func, arg) { + warnOnce("atexit() called, but NO_EXIT_RUNTIME is set, so atexits() will not be called. set NO_EXIT_RUNTIME to 0 (see the FAQ)"); + __ATEXIT__.unshift({ + func: func, + arg: arg + }); +} +function _clock() { + if (_clock.start === undefined) _clock.start = Date.now(); + return (Date.now() - _clock.start) * (1e6 / 1e3) | 0; +} +function _emscripten_get_now_res() { + if (ENVIRONMENT_IS_NODE) { + return 1; + } else if (typeof dateNow !== "undefined" || (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && self["performance"] && self["performance"]["now"]) { + return 1e3; + } else { + return 1e3 * 1e3; + } +} +function _emscripten_get_now_is_monotonic() { + return ENVIRONMENT_IS_NODE || typeof dateNow !== "undefined" || (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && self["performance"] && self["performance"]["now"]; +} +function _clock_getres(clk_id, res) { + var nsec; + if (clk_id === 0) { + nsec = 1e3 * 1e3; + } else if (clk_id === 1 && _emscripten_get_now_is_monotonic()) { + nsec = _emscripten_get_now_res(); + } else { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + HEAP32[res >> 2] = nsec / 1e9 | 0; + HEAP32[res + 4 >> 2] = nsec; + return 0; +} +function _clock_gettime(clk_id, tp) { + var now; + if (clk_id === 0) { + now = Date.now(); + } else if (clk_id === 1 && _emscripten_get_now_is_monotonic()) { + now = _emscripten_get_now(); + } else { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + HEAP32[tp >> 2] = now / 1e3 | 0; + HEAP32[tp + 4 >> 2] = now % 1e3 * 1e3 * 1e3 | 0; + return 0; +} +function _difftime(time1, time0) { + return time1 - time0; +} +var DLFCN = { + error: null, + errorMsg: null, + loadedLibs: {}, + loadedLibNames: {} +}; +function _dlclose(handle) { + if (!DLFCN.loadedLibs[handle]) { + DLFCN.errorMsg = "Tried to dlclose() unopened handle: " + handle; + return 1; + } else { + var lib_record = DLFCN.loadedLibs[handle]; + if (--lib_record.refcount == 0) { + if (lib_record.module.cleanups) { + lib_record.module.cleanups.forEach((function(cleanup) { + cleanup(); + })); + } + delete DLFCN.loadedLibNames[lib_record.name]; + delete DLFCN.loadedLibs[handle]; + } + return 0; + } +} +function _dlopen(filename, flag) { + abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/kripken/emscripten/wiki/Linking"); + var searchpaths = []; + if (filename === 0) { + filename = "__self__"; + } else { + var strfilename = Pointer_stringify(filename); + var isValidFile = (function(filename) { + var target = FS.findObject(filename); + return target && !target.isFolder && !target.isDevice; + }); + if (isValidFile(strfilename)) { + filename = strfilename; + } else { + if (ENV["LD_LIBRARY_PATH"]) { + searchpaths = ENV["LD_LIBRARY_PATH"].split(":"); + } + for (var ident in searchpaths) { + var searchfile = PATH.join2(searchpaths[ident], strfilename); + if (isValidFile(searchfile)) { + filename = searchfile; + break; + } + } + } + } + if (DLFCN.loadedLibNames[filename]) { + var handle = DLFCN.loadedLibNames[filename]; + DLFCN.loadedLibs[handle].refcount++; + return handle; + } + if (filename === "__self__") { + var handle = -1; + var lib_module = Module; + } else { + var target = FS.findObject(filename); + if (!target || target.isFolder || target.isDevice) { + DLFCN.errorMsg = "Could not find dynamic lib: " + filename; + return 0; + } + FS.forceLoadFile(target); + var lib_module; + try { + var lib_data = FS.readFile(filename, { + encoding: "binary" + }); + if (!(lib_data instanceof Uint8Array)) lib_data = new Uint8Array(lib_data); + lib_module = loadWebAssemblyModule(lib_data); + } catch (e) { + Module.printErr("Error in loading dynamic library: " + e); + DLFCN.errorMsg = "Could not evaluate dynamic lib: " + filename + "\n" + e; + return 0; + } + var handle = 1; + for (var key in DLFCN.loadedLibs) { + if (DLFCN.loadedLibs.hasOwnProperty(key)) handle++; + } + if (flag & 256) { + for (var ident in lib_module) { + if (lib_module.hasOwnProperty(ident)) { + if (ident[0] == "_") { + Module[ident] = lib_module[ident]; + } + } + } + } + } + DLFCN.loadedLibs[handle] = { + refcount: 1, + name: filename, + module: lib_module + }; + DLFCN.loadedLibNames[filename] = handle; + return handle; +} +function _dlsym(handle, symbol) { + symbol = Pointer_stringify(symbol); + if (!DLFCN.loadedLibs[handle]) { + DLFCN.errorMsg = "Tried to dlsym() from an unopened handle: " + handle; + return 0; + } else { + var lib = DLFCN.loadedLibs[handle]; + symbol = "_" + symbol; + if (!lib.module.hasOwnProperty(symbol)) { + DLFCN.errorMsg = 'Tried to lookup unknown symbol "' + symbol + '" in dynamic lib: ' + lib.name; + return 0; + } else { + var result = lib.module[symbol]; + if (typeof result === "function") { + return addFunction(result); + } + return result; + } + } +} +function _emscripten_cancel_main_loop() { + Browser.mainLoop.pause(); + Browser.mainLoop.func = null; +} +var JSEvents = { + keyEvent: 0, + mouseEvent: 0, + wheelEvent: 0, + uiEvent: 0, + focusEvent: 0, + deviceOrientationEvent: 0, + deviceMotionEvent: 0, + fullscreenChangeEvent: 0, + pointerlockChangeEvent: 0, + visibilityChangeEvent: 0, + touchEvent: 0, + lastGamepadState: null, + lastGamepadStateFrame: null, + numGamepadsConnected: 0, + previousFullscreenElement: null, + previousScreenX: null, + previousScreenY: null, + removeEventListenersRegistered: false, + staticInit: (function() { + if (typeof window !== "undefined") { + window.addEventListener("gamepadconnected", (function() { + ++JSEvents.numGamepadsConnected; + })); + window.addEventListener("gamepaddisconnected", (function() { + --JSEvents.numGamepadsConnected; + })); + var firstState = navigator.getGamepads ? navigator.getGamepads() : navigator.webkitGetGamepads ? navigator.webkitGetGamepads() : null; + if (firstState) { + JSEvents.numGamepadsConnected = firstState.length; + } + } + }), + registerRemoveEventListeners: (function() { + if (!JSEvents.removeEventListenersRegistered) { + __ATEXIT__.push((function() { + for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) { + JSEvents._removeHandler(i); + } + })); + JSEvents.removeEventListenersRegistered = true; + } + }), + findEventTarget: (function(target) { + if (target) { + if (typeof target == "number") { + target = Pointer_stringify(target); + } + if (target == "#window") return window; else if (target == "#document") return document; else if (target == "#screen") return window.screen; else if (target == "#canvas") return Module["canvas"]; + if (typeof target == "string") return document.getElementById(target); else return target; + } else { + return window; + } + }), + deferredCalls: [], + deferCall: (function(targetFunction, precedence, argsList) { + function arraysHaveEqualContent(arrA, arrB) { + if (arrA.length != arrB.length) return false; + for (var i in arrA) { + if (arrA[i] != arrB[i]) return false; + } + return true; + } + for (var i in JSEvents.deferredCalls) { + var call = JSEvents.deferredCalls[i]; + if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) { + return; + } + } + JSEvents.deferredCalls.push({ + targetFunction: targetFunction, + precedence: precedence, + argsList: argsList + }); + JSEvents.deferredCalls.sort((function(x, y) { + return x.precedence < y.precedence; + })); + }), + removeDeferredCalls: (function(targetFunction) { + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + if (JSEvents.deferredCalls[i].targetFunction == targetFunction) { + JSEvents.deferredCalls.splice(i, 1); + --i; + } + } + }), + canPerformEventHandlerRequests: (function() { + return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls; + }), + runDeferredCalls: (function() { + if (!JSEvents.canPerformEventHandlerRequests()) { + return; + } + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + var call = JSEvents.deferredCalls[i]; + JSEvents.deferredCalls.splice(i, 1); + --i; + call.targetFunction.apply(this, call.argsList); + } + }), + inEventHandler: 0, + currentEventHandler: null, + eventHandlers: [], + isInternetExplorer: (function() { + return navigator.userAgent.indexOf("MSIE") !== -1 || navigator.appVersion.indexOf("Trident/") > 0; + }), + removeAllHandlersOnTarget: (function(target, eventTypeString) { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if (JSEvents.eventHandlers[i].target == target && (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) { + JSEvents._removeHandler(i--); + } + } + }), + _removeHandler: (function(i) { + var h = JSEvents.eventHandlers[i]; + h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture); + JSEvents.eventHandlers.splice(i, 1); + }), + registerOrRemoveHandler: (function(eventHandler) { + var jsEventHandler = function jsEventHandler(event) { + ++JSEvents.inEventHandler; + JSEvents.currentEventHandler = eventHandler; + JSEvents.runDeferredCalls(); + eventHandler.handlerFunc(event); + JSEvents.runDeferredCalls(); + --JSEvents.inEventHandler; + }; + if (eventHandler.callbackfunc) { + eventHandler.eventListenerFunc = jsEventHandler; + eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture); + JSEvents.eventHandlers.push(eventHandler); + JSEvents.registerRemoveEventListeners(); + } else { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if (JSEvents.eventHandlers[i].target == eventHandler.target && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) { + JSEvents._removeHandler(i--); + } + } + } + }), + registerKeyEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.keyEvent) { + JSEvents.keyEvent = _malloc(164); + } + var handlerFunc = (function(event) { + var e = event || window.event; + stringToUTF8(e.key ? e.key : "", JSEvents.keyEvent + 0, 32); + stringToUTF8(e.code ? e.code : "", JSEvents.keyEvent + 32, 32); + HEAP32[JSEvents.keyEvent + 64 >> 2] = e.location; + HEAP32[JSEvents.keyEvent + 68 >> 2] = e.ctrlKey; + HEAP32[JSEvents.keyEvent + 72 >> 2] = e.shiftKey; + HEAP32[JSEvents.keyEvent + 76 >> 2] = e.altKey; + HEAP32[JSEvents.keyEvent + 80 >> 2] = e.metaKey; + HEAP32[JSEvents.keyEvent + 84 >> 2] = e.repeat; + stringToUTF8(e.locale ? e.locale : "", JSEvents.keyEvent + 88, 32); + stringToUTF8(e.char ? e.char : "", JSEvents.keyEvent + 120, 32); + HEAP32[JSEvents.keyEvent + 152 >> 2] = e.charCode; + HEAP32[JSEvents.keyEvent + 156 >> 2] = e.keyCode; + HEAP32[JSEvents.keyEvent + 160 >> 2] = e.which; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.keyEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: JSEvents.isInternetExplorer() ? false : true, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + getBoundingClientRectOrZeros: (function(target) { + return target.getBoundingClientRect ? target.getBoundingClientRect() : { + left: 0, + top: 0 + }; + }), + fillMouseEventData: (function(eventStruct, e, target) { + HEAPF64[eventStruct >> 3] = JSEvents.tick(); + HEAP32[eventStruct + 8 >> 2] = e.screenX; + HEAP32[eventStruct + 12 >> 2] = e.screenY; + HEAP32[eventStruct + 16 >> 2] = e.clientX; + HEAP32[eventStruct + 20 >> 2] = e.clientY; + HEAP32[eventStruct + 24 >> 2] = e.ctrlKey; + HEAP32[eventStruct + 28 >> 2] = e.shiftKey; + HEAP32[eventStruct + 32 >> 2] = e.altKey; + HEAP32[eventStruct + 36 >> 2] = e.metaKey; + HEAP16[eventStruct + 40 >> 1] = e.button; + HEAP16[eventStruct + 42 >> 1] = e.buttons; + HEAP32[eventStruct + 44 >> 2] = e["movementX"] || e["mozMovementX"] || e["webkitMovementX"] || e.screenX - JSEvents.previousScreenX; + HEAP32[eventStruct + 48 >> 2] = e["movementY"] || e["mozMovementY"] || e["webkitMovementY"] || e.screenY - JSEvents.previousScreenY; + if (Module["canvas"]) { + var rect = Module["canvas"].getBoundingClientRect(); + HEAP32[eventStruct + 60 >> 2] = e.clientX - rect.left; + HEAP32[eventStruct + 64 >> 2] = e.clientY - rect.top; + } else { + HEAP32[eventStruct + 60 >> 2] = 0; + HEAP32[eventStruct + 64 >> 2] = 0; + } + if (target) { + var rect = JSEvents.getBoundingClientRectOrZeros(target); + HEAP32[eventStruct + 52 >> 2] = e.clientX - rect.left; + HEAP32[eventStruct + 56 >> 2] = e.clientY - rect.top; + } else { + HEAP32[eventStruct + 52 >> 2] = 0; + HEAP32[eventStruct + 56 >> 2] = 0; + } + if (e.type !== "wheel" && e.type !== "mousewheel") { + JSEvents.previousScreenX = e.screenX; + JSEvents.previousScreenY = e.screenY; + } + }), + registerMouseEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.mouseEvent) { + JSEvents.mouseEvent = _malloc(72); + } + target = JSEvents.findEventTarget(target); + var handlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillMouseEventData(JSEvents.mouseEvent, e, target); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.mouseEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: target, + allowsDeferredCalls: eventTypeString != "mousemove" && eventTypeString != "mouseenter" && eventTypeString != "mouseleave", + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + if (JSEvents.isInternetExplorer() && eventTypeString == "mousedown") eventHandler.allowsDeferredCalls = false; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + registerWheelEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.wheelEvent) { + JSEvents.wheelEvent = _malloc(104); + } + target = JSEvents.findEventTarget(target); + var wheelHandlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillMouseEventData(JSEvents.wheelEvent, e, target); + HEAPF64[JSEvents.wheelEvent + 72 >> 3] = e["deltaX"]; + HEAPF64[JSEvents.wheelEvent + 80 >> 3] = e["deltaY"]; + HEAPF64[JSEvents.wheelEvent + 88 >> 3] = e["deltaZ"]; + HEAP32[JSEvents.wheelEvent + 96 >> 2] = e["deltaMode"]; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.wheelEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var mouseWheelHandlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillMouseEventData(JSEvents.wheelEvent, e, target); + HEAPF64[JSEvents.wheelEvent + 72 >> 3] = e["wheelDeltaX"] || 0; + HEAPF64[JSEvents.wheelEvent + 80 >> 3] = -(e["wheelDeltaY"] ? e["wheelDeltaY"] : e["wheelDelta"]); + HEAPF64[JSEvents.wheelEvent + 88 >> 3] = 0; + HEAP32[JSEvents.wheelEvent + 96 >> 2] = 0; + var shouldCancel = Module["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); + }), + pageScrollPos: (function() { + if (window.pageXOffset > 0 || window.pageYOffset > 0) { + return [ window.pageXOffset, window.pageYOffset ]; + } + if (typeof document.documentElement.scrollLeft !== "undefined" || typeof document.documentElement.scrollTop !== "undefined") { + return [ document.documentElement.scrollLeft, document.documentElement.scrollTop ]; + } + return [ document.body.scrollLeft | 0, document.body.scrollTop | 0 ]; + }), + registerUiEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.uiEvent) { + JSEvents.uiEvent = _malloc(36); + } + if (eventTypeString == "scroll" && !target) { + target = document; + } else { + target = JSEvents.findEventTarget(target); + } + var handlerFunc = (function(event) { + var e = event || window.event; + if (e.target != target) { + return; + } + var scrollPos = JSEvents.pageScrollPos(); + HEAP32[JSEvents.uiEvent >> 2] = e.detail; + HEAP32[JSEvents.uiEvent + 4 >> 2] = document.body.clientWidth; + HEAP32[JSEvents.uiEvent + 8 >> 2] = document.body.clientHeight; + HEAP32[JSEvents.uiEvent + 12 >> 2] = window.innerWidth; + HEAP32[JSEvents.uiEvent + 16 >> 2] = window.innerHeight; + HEAP32[JSEvents.uiEvent + 20 >> 2] = window.outerWidth; + HEAP32[JSEvents.uiEvent + 24 >> 2] = window.outerHeight; + HEAP32[JSEvents.uiEvent + 28 >> 2] = scrollPos[0]; + HEAP32[JSEvents.uiEvent + 32 >> 2] = scrollPos[1]; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.uiEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + getNodeNameForTarget: (function(target) { + if (!target) return ""; + if (target == window) return "#window"; + if (target == window.screen) return "#screen"; + return target && target.nodeName ? target.nodeName : ""; + }), + registerFocusEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.focusEvent) { + JSEvents.focusEvent = _malloc(256); + } + var handlerFunc = (function(event) { + var e = event || window.event; + var nodeName = JSEvents.getNodeNameForTarget(e.target); + var id = e.target.id ? e.target.id : ""; + stringToUTF8(nodeName, JSEvents.focusEvent + 0, 128); + stringToUTF8(id, JSEvents.focusEvent + 128, 128); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.focusEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + tick: (function() { + if (window["performance"] && window["performance"]["now"]) return window["performance"]["now"](); else return Date.now(); + }), + registerDeviceOrientationEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.deviceOrientationEvent) { + JSEvents.deviceOrientationEvent = _malloc(40); + } + var handlerFunc = (function(event) { + var e = event || window.event; + HEAPF64[JSEvents.deviceOrientationEvent >> 3] = JSEvents.tick(); + HEAPF64[JSEvents.deviceOrientationEvent + 8 >> 3] = e.alpha; + HEAPF64[JSEvents.deviceOrientationEvent + 16 >> 3] = e.beta; + HEAPF64[JSEvents.deviceOrientationEvent + 24 >> 3] = e.gamma; + HEAP32[JSEvents.deviceOrientationEvent + 32 >> 2] = e.absolute; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.deviceOrientationEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + registerDeviceMotionEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.deviceMotionEvent) { + JSEvents.deviceMotionEvent = _malloc(80); + } + var handlerFunc = (function(event) { + var e = event || window.event; + HEAPF64[JSEvents.deviceMotionEvent >> 3] = JSEvents.tick(); + HEAPF64[JSEvents.deviceMotionEvent + 8 >> 3] = e.acceleration.x; + HEAPF64[JSEvents.deviceMotionEvent + 16 >> 3] = e.acceleration.y; + HEAPF64[JSEvents.deviceMotionEvent + 24 >> 3] = e.acceleration.z; + HEAPF64[JSEvents.deviceMotionEvent + 32 >> 3] = e.accelerationIncludingGravity.x; + HEAPF64[JSEvents.deviceMotionEvent + 40 >> 3] = e.accelerationIncludingGravity.y; + HEAPF64[JSEvents.deviceMotionEvent + 48 >> 3] = e.accelerationIncludingGravity.z; + HEAPF64[JSEvents.deviceMotionEvent + 56 >> 3] = e.rotationRate.alpha; + HEAPF64[JSEvents.deviceMotionEvent + 64 >> 3] = e.rotationRate.beta; + HEAPF64[JSEvents.deviceMotionEvent + 72 >> 3] = e.rotationRate.gamma; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.deviceMotionEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + screenOrientation: (function() { + if (!window.screen) return undefined; + return window.screen.orientation || window.screen.mozOrientation || window.screen.webkitOrientation || window.screen.msOrientation; + }), + fillOrientationChangeEventData: (function(eventStruct, e) { + var orientations = [ "portrait-primary", "portrait-secondary", "landscape-primary", "landscape-secondary" ]; + var orientations2 = [ "portrait", "portrait", "landscape", "landscape" ]; + var orientationString = JSEvents.screenOrientation(); + var orientation = orientations.indexOf(orientationString); + if (orientation == -1) { + orientation = orientations2.indexOf(orientationString); + } + HEAP32[eventStruct >> 2] = 1 << orientation; + HEAP32[eventStruct + 4 >> 2] = window.orientation; + }), + registerOrientationChangeEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.orientationChangeEvent) { + JSEvents.orientationChangeEvent = _malloc(8); + } + if (!target) { + target = window.screen; + } else { + target = JSEvents.findEventTarget(target); + } + var handlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillOrientationChangeEventData(JSEvents.orientationChangeEvent, e); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.orientationChangeEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + if (eventTypeString == "orientationchange" && window.screen.mozOrientation !== undefined) { + eventTypeString = "mozorientationchange"; + } + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + fullscreenEnabled: (function() { + return document.fullscreenEnabled || document.mozFullScreenEnabled || document.webkitFullscreenEnabled || document.msFullscreenEnabled; + }), + fillFullscreenChangeEventData: (function(eventStruct, e) { + var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement; + var isFullscreen = !!fullscreenElement; + HEAP32[eventStruct >> 2] = isFullscreen; + HEAP32[eventStruct + 4 >> 2] = JSEvents.fullscreenEnabled(); + 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; + } + }), + registerFullscreenChangeEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.fullscreenChangeEvent) { + JSEvents.fullscreenChangeEvent = _malloc(280); + } + if (!target) { + target = document; + } else { + target = JSEvents.findEventTarget(target); + } + var handlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillFullscreenChangeEventData(JSEvents.fullscreenChangeEvent, e); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.fullscreenChangeEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + resizeCanvasForFullscreen: (function(target, strategy) { + var restoreOldStyle = __registerRestoreOldStyle(target); + var cssWidth = strategy.softFullscreen ? window.innerWidth : screen.width; + var cssHeight = strategy.softFullscreen ? window.innerHeight : screen.height; + var rect = target.getBoundingClientRect(); + var windowedCssWidth = rect.right - rect.left; + var windowedCssHeight = rect.bottom - rect.top; + var windowedRttWidth = target.width; + var windowedRttHeight = target.height; + 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 (!target.style.backgroundColor) target.style.backgroundColor = "black"; + if (!document.body.style.backgroundColor) document.body.style.backgroundColor = "black"; + 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 ? window.devicePixelRatio : 1; + if (strategy.canvasResolutionScaleMode != 0) { + target.width = cssWidth * dpiScale; + target.height = cssHeight * dpiScale; + if (target.GLctxObject) target.GLctxObject.GLctx.viewport(0, 0, target.width, target.height); + } + return restoreOldStyle; + }), + requestFullscreen: (function(target, strategy) { + if (strategy.scaleMode != 0 || strategy.canvasResolutionScaleMode != 0) { + JSEvents.resizeCanvasForFullscreen(target, strategy); + } + if (target.requestFullscreen) { + target.requestFullscreen(); + } else if (target.msRequestFullscreen) { + target.msRequestFullscreen(); + } else if (target.mozRequestFullScreen) { + target.mozRequestFullScreen(); + } else if (target.mozRequestFullscreen) { + target.mozRequestFullscreen(); + } else if (target.webkitRequestFullscreen) { + target.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT); + } else { + if (typeof JSEvents.fullscreenEnabled() === "undefined") { + return -1; + } else { + return -3; + } + } + if (strategy.canvasResizedCallback) { + Module["dynCall_iiii"](strategy.canvasResizedCallback, 37, 0, strategy.canvasResizedCallbackUserData); + } + return 0; + }), + fillPointerlockChangeEventData: (function(eventStruct, e) { + var pointerLockElement = document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement || document.msPointerLockElement; + var isPointerlocked = !!pointerLockElement; + 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); + }), + registerPointerlockChangeEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.pointerlockChangeEvent) { + JSEvents.pointerlockChangeEvent = _malloc(260); + } + if (!target) { + target = document; + } else { + target = JSEvents.findEventTarget(target); + } + var handlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillPointerlockChangeEventData(JSEvents.pointerlockChangeEvent, e); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.pointerlockChangeEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + registerPointerlockErrorEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!target) { + target = document; + } else { + target = JSEvents.findEventTarget(target); + } + var handlerFunc = (function(event) { + var e = event || window.event; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, 0, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + requestPointerLock: (function(target) { + if (target.requestPointerLock) { + target.requestPointerLock(); + } else if (target.mozRequestPointerLock) { + target.mozRequestPointerLock(); + } else if (target.webkitRequestPointerLock) { + target.webkitRequestPointerLock(); + } else if (target.msRequestPointerLock) { + target.msRequestPointerLock(); + } else { + if (document.body.requestPointerLock || document.body.mozRequestPointerLock || document.body.webkitRequestPointerLock || document.body.msRequestPointerLock) { + return -3; + } else { + return -1; + } + } + return 0; + }), + fillVisibilityChangeEventData: (function(eventStruct, e) { + var visibilityStates = [ "hidden", "visible", "prerender", "unloaded" ]; + var visibilityState = visibilityStates.indexOf(document.visibilityState); + HEAP32[eventStruct >> 2] = document.hidden; + HEAP32[eventStruct + 4 >> 2] = visibilityState; + }), + registerVisibilityChangeEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.visibilityChangeEvent) { + JSEvents.visibilityChangeEvent = _malloc(8); + } + if (!target) { + target = document; + } else { + target = JSEvents.findEventTarget(target); + } + var handlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillVisibilityChangeEventData(JSEvents.visibilityChangeEvent, e); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.visibilityChangeEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + registerTouchEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.touchEvent) { + JSEvents.touchEvent = _malloc(1684); + } + target = JSEvents.findEventTarget(target); + var handlerFunc = (function(event) { + var e = event || window.event; + var touches = {}; + for (var i = 0; i < e.touches.length; ++i) { + var touch = e.touches[i]; + 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 ptr = JSEvents.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; + var canvasRect = Module["canvas"] ? Module["canvas"].getBoundingClientRect() : undefined; + var targetRect = JSEvents.getBoundingClientRectOrZeros(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; + if (canvasRect) { + HEAP32[ptr + 44 >> 2] = t.clientX - canvasRect.left; + HEAP32[ptr + 48 >> 2] = t.clientY - canvasRect.top; + } else { + HEAP32[ptr + 44 >> 2] = 0; + HEAP32[ptr + 48 >> 2] = 0; + } + HEAP32[ptr + 36 >> 2] = t.clientX - targetRect.left; + HEAP32[ptr + 40 >> 2] = t.clientY - targetRect.top; + ptr += 52; + if (++numTouches >= 32) { + break; + } + } + HEAP32[JSEvents.touchEvent >> 2] = numTouches; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.touchEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: target, + allowsDeferredCalls: eventTypeString == "touchstart" || eventTypeString == "touchend", + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + fillGamepadEventData: (function(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 { + 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); + }), + registerGamepadEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.gamepadEvent) { + JSEvents.gamepadEvent = _malloc(1432); + } + var handlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillGamepadEventData(JSEvents.gamepadEvent, e.gamepad); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.gamepadEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: true, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + registerBeforeUnloadEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + var handlerFunc = (function(event) { + var e = event || window.event; + var confirmationMessage = Module["dynCall_iiii"](callbackfunc, eventTypeId, 0, userData); + if (confirmationMessage) { + confirmationMessage = Pointer_stringify(confirmationMessage); + } + if (confirmationMessage) { + e.preventDefault(); + e.returnValue = confirmationMessage; + return confirmationMessage; + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + battery: (function() { + return navigator.battery || navigator.mozBattery || navigator.webkitBattery; + }), + fillBatteryEventData: (function(eventStruct, e) { + HEAPF64[eventStruct >> 3] = e.chargingTime; + HEAPF64[eventStruct + 8 >> 3] = e.dischargingTime; + HEAPF64[eventStruct + 16 >> 3] = e.level; + HEAP32[eventStruct + 24 >> 2] = e.charging; + }), + registerBatteryEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JSEvents.batteryEvent) { + JSEvents.batteryEvent = _malloc(32); + } + var handlerFunc = (function(event) { + var e = event || window.event; + JSEvents.fillBatteryEventData(JSEvents.batteryEvent, JSEvents.battery()); + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, JSEvents.batteryEvent, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }), + registerWebGlEventCallback: (function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!target) { + target = Module["canvas"]; + } + var handlerFunc = (function(event) { + var e = event || window.event; + var shouldCancel = Module["dynCall_iiii"](callbackfunc, eventTypeId, 0, userData); + if (shouldCancel) { + e.preventDefault(); + } + }); + var eventHandler = { + target: JSEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JSEvents.registerOrRemoveHandler(eventHandler); + }) +}; +var __currentFullscreenStrategy = {}; +function _emscripten_exit_fullscreen() { + if (typeof JSEvents.fullscreenEnabled() === "undefined") return -1; + JSEvents.removeDeferredCalls(JSEvents.requestFullscreen); + if (document.exitFullscreen) { + document.exitFullscreen(); + } else if (document.msExitFullscreen) { + document.msExitFullscreen(); + } else if (document.mozCancelFullScreen) { + document.mozCancelFullScreen(); + } else if (document.webkitExitFullscreen) { + document.webkitExitFullscreen(); + } else { + return -1; + } + if (__currentFullscreenStrategy.canvasResizedCallback) { + Module["dynCall_iiii"](__currentFullscreenStrategy.canvasResizedCallback, 37, 0, __currentFullscreenStrategy.canvasResizedCallbackUserData); + } + return 0; +} +function _emscripten_exit_pointerlock() { + JSEvents.removeDeferredCalls(JSEvents.requestPointerLock); + if (document.exitPointerLock) { + document.exitPointerLock(); + } else if (document.msExitPointerLock) { + document.msExitPointerLock(); + } else if (document.mozExitPointerLock) { + document.mozExitPointerLock(); + } else if (document.webkitExitPointerLock) { + document.webkitExitPointerLock(); + } else { + return -1; + } + return 0; +} +function _emscripten_get_fullscreen_status(fullscreenStatus) { + if (typeof JSEvents.fullscreenEnabled() === "undefined") return -1; + JSEvents.fillFullscreenChangeEventData(fullscreenStatus); + return 0; +} +function __emscripten_sample_gamepad_data() { + if (!JSEvents.numGamepadsConnected) return; + if (Browser.mainLoop.currentFrameNumber !== JSEvents.lastGamepadStateFrame || !Browser.mainLoop.currentFrameNumber) { + JSEvents.lastGamepadState = navigator.getGamepads ? navigator.getGamepads() : navigator.webkitGetGamepads ? navigator.webkitGetGamepads : null; + JSEvents.lastGamepadStateFrame = Browser.mainLoop.currentFrameNumber; + } +} +function _emscripten_get_gamepad_status(index, gamepadState) { + __emscripten_sample_gamepad_data(); + if (!JSEvents.lastGamepadState) return -1; + if (index < 0 || index >= JSEvents.lastGamepadState.length) return -5; + if (!JSEvents.lastGamepadState[index]) return -7; + JSEvents.fillGamepadEventData(gamepadState, JSEvents.lastGamepadState[index]); + return 0; +} +function _emscripten_get_main_loop_timing(mode, value) { + if (mode) HEAP32[mode >> 2] = Browser.mainLoop.timingMode; + if (value) HEAP32[value >> 2] = Browser.mainLoop.timingValue; +} +function _emscripten_get_num_gamepads() { + if (!JSEvents.numGamepadsConnected) return 0; + __emscripten_sample_gamepad_data(); + if (!JSEvents.lastGamepadState) return -1; + return JSEvents.lastGamepadState.length; +} +function _emscripten_has_threading_support() { + return 0; +} +function _emscripten_is_webgl_context_lost(target) { + if (!Module["ctx"]) return true; + return Module["ctx"].isContextLost(); +} +function __reallyNegative(x) { + return x < 0 || x === 0 && 1 / x === -Infinity; +} +function __formatString(format, varargs) { + assert((varargs & 3) === 0); + var textIndex = format; + var argIndex = varargs; + function prepVararg(ptr, type) { + if (type === "double" || type === "i64") { + if (ptr & 7) { + assert((ptr & 7) === 4); + ptr += 4; + } + } else { + assert((ptr & 3) === 0); + } + return ptr; + } + function getNextArg(type) { + var ret; + argIndex = prepVararg(argIndex, type); + if (type === "double") { + ret = HEAPF64[argIndex >> 3]; + argIndex += 8; + } else if (type == "i64") { + ret = [ HEAP32[argIndex >> 2], HEAP32[argIndex + 4 >> 2] ]; + argIndex += 8; + } else { + assert((argIndex & 3) === 0); + type = "i32"; + ret = HEAP32[argIndex >> 2]; + argIndex += 4; + } + return ret; + } + var ret = []; + var curr, next, currArg; + while (1) { + var startTextIndex = textIndex; + curr = HEAP8[textIndex >> 0]; + if (curr === 0) break; + next = HEAP8[textIndex + 1 >> 0]; + if (curr == 37) { + var flagAlwaysSigned = false; + var flagLeftAlign = false; + var flagAlternative = false; + var flagZeroPad = false; + var flagPadSign = false; + flagsLoop : while (1) { + switch (next) { + case 43: + flagAlwaysSigned = true; + break; + case 45: + flagLeftAlign = true; + break; + case 35: + flagAlternative = true; + break; + case 48: + if (flagZeroPad) { + break flagsLoop; + } else { + flagZeroPad = true; + break; + } + case 32: + flagPadSign = true; + break; + default: + break flagsLoop; + } + textIndex++; + next = HEAP8[textIndex + 1 >> 0]; + } + var width = 0; + if (next == 42) { + width = getNextArg("i32"); + textIndex++; + next = HEAP8[textIndex + 1 >> 0]; + } else { + while (next >= 48 && next <= 57) { + width = width * 10 + (next - 48); + textIndex++; + next = HEAP8[textIndex + 1 >> 0]; + } + } + var precisionSet = false, precision = -1; + if (next == 46) { + precision = 0; + precisionSet = true; + textIndex++; + next = HEAP8[textIndex + 1 >> 0]; + if (next == 42) { + precision = getNextArg("i32"); + textIndex++; + } else { + while (1) { + var precisionChr = HEAP8[textIndex + 1 >> 0]; + if (precisionChr < 48 || precisionChr > 57) break; + precision = precision * 10 + (precisionChr - 48); + textIndex++; + } + } + next = HEAP8[textIndex + 1 >> 0]; + } + if (precision < 0) { + precision = 6; + precisionSet = false; + } + var argSize; + switch (String.fromCharCode(next)) { + case "h": + var nextNext = HEAP8[textIndex + 2 >> 0]; + if (nextNext == 104) { + textIndex++; + argSize = 1; + } else { + argSize = 2; + } + break; + case "l": + var nextNext = HEAP8[textIndex + 2 >> 0]; + if (nextNext == 108) { + textIndex++; + argSize = 8; + } else { + argSize = 4; + } + break; + case "L": + case "q": + case "j": + argSize = 8; + break; + case "z": + case "t": + case "I": + argSize = 4; + break; + default: + argSize = null; + } + if (argSize) textIndex++; + next = HEAP8[textIndex + 1 >> 0]; + switch (String.fromCharCode(next)) { + case "d": + case "i": + case "u": + case "o": + case "x": + case "X": + case "p": + { + var signed = next == 100 || next == 105; + argSize = argSize || 4; + currArg = getNextArg("i" + argSize * 8); + var origArg = currArg; + var argText; + if (argSize == 8) { + currArg = makeBigInt(currArg[0], currArg[1], next == 117); + } + if (argSize <= 4) { + var limit = Math.pow(256, argSize) - 1; + currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8); + } + var currAbsArg = Math.abs(currArg); + var prefix = ""; + if (next == 100 || next == 105) { + if (argSize == 8 && typeof i64Math === "object") argText = i64Math.stringify(origArg[0], origArg[1], null); else argText = reSign(currArg, 8 * argSize, 1).toString(10); + } else if (next == 117) { + if (argSize == 8 && typeof i64Math === "object") argText = i64Math.stringify(origArg[0], origArg[1], true); else argText = unSign(currArg, 8 * argSize, 1).toString(10); + currArg = Math.abs(currArg); + } else if (next == 111) { + argText = (flagAlternative ? "0" : "") + currAbsArg.toString(8); + } else if (next == 120 || next == 88) { + prefix = flagAlternative && currArg != 0 ? "0x" : ""; + if (argSize == 8 && typeof i64Math === "object") { + if (origArg[1]) { + argText = (origArg[1] >>> 0).toString(16); + var lower = (origArg[0] >>> 0).toString(16); + while (lower.length < 8) lower = "0" + lower; + argText += lower; + } else { + argText = (origArg[0] >>> 0).toString(16); + } + } else if (currArg < 0) { + currArg = -currArg; + argText = (currAbsArg - 1).toString(16); + var buffer = []; + for (var i = 0; i < argText.length; i++) { + buffer.push((15 - parseInt(argText[i], 16)).toString(16)); + } + argText = buffer.join(""); + while (argText.length < argSize * 2) argText = "f" + argText; + } else { + argText = currAbsArg.toString(16); + } + if (next == 88) { + prefix = prefix.toUpperCase(); + argText = argText.toUpperCase(); + } + } else if (next == 112) { + if (currAbsArg === 0) { + argText = "(nil)"; + } else { + prefix = "0x"; + argText = currAbsArg.toString(16); + } + } + if (precisionSet) { + while (argText.length < precision) { + argText = "0" + argText; + } + } + if (currArg >= 0) { + if (flagAlwaysSigned) { + prefix = "+" + prefix; + } else if (flagPadSign) { + prefix = " " + prefix; + } + } + if (argText.charAt(0) == "-") { + prefix = "-" + prefix; + argText = argText.substr(1); + } + while (prefix.length + argText.length < width) { + if (flagLeftAlign) { + argText += " "; + } else { + if (flagZeroPad) { + argText = "0" + argText; + } else { + prefix = " " + prefix; + } + } + } + argText = prefix + argText; + argText.split("").forEach((function(chr) { + ret.push(chr.charCodeAt(0)); + })); + break; + } + case "f": + case "F": + case "e": + case "E": + case "g": + case "G": + { + currArg = getNextArg("double"); + var argText; + if (isNaN(currArg)) { + argText = "nan"; + flagZeroPad = false; + } else if (!isFinite(currArg)) { + argText = (currArg < 0 ? "-" : "") + "inf"; + flagZeroPad = false; + } else { + var isGeneral = false; + var effectivePrecision = Math.min(precision, 20); + if (next == 103 || next == 71) { + isGeneral = true; + precision = precision || 1; + var exponent = parseInt(currArg.toExponential(effectivePrecision).split("e")[1], 10); + if (precision > exponent && exponent >= -4) { + next = (next == 103 ? "f" : "F").charCodeAt(0); + precision -= exponent + 1; + } else { + next = (next == 103 ? "e" : "E").charCodeAt(0); + precision--; + } + effectivePrecision = Math.min(precision, 20); + } + if (next == 101 || next == 69) { + argText = currArg.toExponential(effectivePrecision); + if (/[eE][-+]\d$/.test(argText)) { + argText = argText.slice(0, -1) + "0" + argText.slice(-1); + } + } else if (next == 102 || next == 70) { + argText = currArg.toFixed(effectivePrecision); + if (currArg === 0 && __reallyNegative(currArg)) { + argText = "-" + argText; + } + } + var parts = argText.split("e"); + if (isGeneral && !flagAlternative) { + while (parts[0].length > 1 && parts[0].indexOf(".") != -1 && (parts[0].slice(-1) == "0" || parts[0].slice(-1) == ".")) { + parts[0] = parts[0].slice(0, -1); + } + } else { + if (flagAlternative && argText.indexOf(".") == -1) parts[0] += "."; + while (precision > effectivePrecision++) parts[0] += "0"; + } + argText = parts[0] + (parts.length > 1 ? "e" + parts[1] : ""); + if (next == 69) argText = argText.toUpperCase(); + if (currArg >= 0) { + if (flagAlwaysSigned) { + argText = "+" + argText; + } else if (flagPadSign) { + argText = " " + argText; + } + } + } + while (argText.length < width) { + if (flagLeftAlign) { + argText += " "; + } else { + if (flagZeroPad && (argText[0] == "-" || argText[0] == "+")) { + argText = argText[0] + "0" + argText.slice(1); + } else { + argText = (flagZeroPad ? "0" : " ") + argText; + } + } + } + if (next < 97) argText = argText.toUpperCase(); + argText.split("").forEach((function(chr) { + ret.push(chr.charCodeAt(0)); + })); + break; + } + case "s": + { + var arg = getNextArg("i8*"); + var argLength = arg ? _strlen(arg) : "(null)".length; + if (precisionSet) argLength = Math.min(argLength, precision); + if (!flagLeftAlign) { + while (argLength < width--) { + ret.push(32); + } + } + if (arg) { + for (var i = 0; i < argLength; i++) { + ret.push(HEAPU8[arg++ >> 0]); + } + } else { + ret = ret.concat(intArrayFromString("(null)".substr(0, argLength), true)); + } + if (flagLeftAlign) { + while (argLength < width--) { + ret.push(32); + } + } + break; + } + case "c": + { + if (flagLeftAlign) ret.push(getNextArg("i8")); + while (--width > 0) { + ret.push(32); + } + if (!flagLeftAlign) ret.push(getNextArg("i8")); + break; + } + case "n": + { + var ptr = getNextArg("i32*"); + HEAP32[ptr >> 2] = ret.length; + break; + } + case "%": + { + ret.push(curr); + break; + } + default: + { + for (var i = startTextIndex; i < textIndex + 2; i++) { + ret.push(HEAP8[i >> 0]); + } + } + } + textIndex += 2; + } else { + ret.push(curr); + textIndex += 1; + } + } + return ret; +} +function __emscripten_traverse_stack(args) { + if (!args || !args.callee || !args.callee.name) { + return [ null, "", "" ]; + } + var funstr = args.callee.toString(); + var funcname = args.callee.name; + var str = "("; + var first = true; + for (var i in args) { + var a = args[i]; + if (!first) { + str += ", "; + } + first = false; + if (typeof a === "number" || typeof a === "string") { + str += a; + } else { + str += "(" + typeof a + ")"; + } + } + str += ")"; + var caller = args.callee.caller; + args = caller ? caller.arguments : []; + if (first) str = ""; + return [ args, funcname, str ]; +} +function _emscripten_get_callstack_js(flags) { + var callstack = jsStackTrace(); + var iThisFunc = callstack.lastIndexOf("_emscripten_log"); + var iThisFunc2 = callstack.lastIndexOf("_emscripten_get_callstack"); + var iNextLine = callstack.indexOf("\n", Math.max(iThisFunc, iThisFunc2)) + 1; + callstack = callstack.slice(iNextLine); + if (flags & 8 && typeof emscripten_source_map === "undefined") { + warnOnce('Source map information is not available, emscripten_log with EM_LOG_C_STACK will be ignored. Build with "--pre-js $EMSCRIPTEN/src/emscripten-source-map.min.js" linker flag to add source map loading to code.'); + flags ^= 8; + flags |= 16; + } + var stack_args = null; + if (flags & 128) { + stack_args = __emscripten_traverse_stack(arguments); + while (stack_args[1].indexOf("_emscripten_") >= 0) stack_args = __emscripten_traverse_stack(stack_args[0]); + } + var lines = callstack.split("\n"); + callstack = ""; + var newFirefoxRe = new RegExp("\\s*(.*?)@(.*?):([0-9]+):([0-9]+)"); + var firefoxRe = new RegExp("\\s*(.*?)@(.*):(.*)(:(.*))?"); + var chromeRe = new RegExp("\\s*at (.*?) \\((.*):(.*):(.*)\\)"); + for (var l in lines) { + var line = lines[l]; + var jsSymbolName = ""; + var file = ""; + var lineno = 0; + var column = 0; + var parts = chromeRe.exec(line); + if (parts && parts.length == 5) { + jsSymbolName = parts[1]; + file = parts[2]; + lineno = parts[3]; + column = parts[4]; + } else { + parts = newFirefoxRe.exec(line); + if (!parts) parts = firefoxRe.exec(line); + if (parts && parts.length >= 4) { + jsSymbolName = parts[1]; + file = parts[2]; + lineno = parts[3]; + column = parts[4] | 0; + } else { + callstack += line + "\n"; + continue; + } + } + var cSymbolName = flags & 32 ? demangle(jsSymbolName) : jsSymbolName; + if (!cSymbolName) { + cSymbolName = jsSymbolName; + } + var haveSourceMap = false; + if (flags & 8) { + var orig = emscripten_source_map.originalPositionFor({ + line: lineno, + column: column + }); + haveSourceMap = orig && orig.source; + if (haveSourceMap) { + if (flags & 64) { + orig.source = orig.source.substring(orig.source.replace(/\\/g, "/").lastIndexOf("/") + 1); + } + callstack += " at " + cSymbolName + " (" + orig.source + ":" + orig.line + ":" + orig.column + ")\n"; + } + } + if (flags & 16 || !haveSourceMap) { + if (flags & 64) { + file = file.substring(file.replace(/\\/g, "/").lastIndexOf("/") + 1); + } + callstack += (haveSourceMap ? " = " + jsSymbolName : " at " + cSymbolName) + " (" + file + ":" + lineno + ":" + column + ")\n"; + } + if (flags & 128 && stack_args[0]) { + if (stack_args[1] == jsSymbolName && stack_args[2].length > 0) { + callstack = callstack.replace(/\s+$/, ""); + callstack += " with values: " + stack_args[1] + stack_args[2] + "\n"; + } + stack_args = __emscripten_traverse_stack(stack_args[0]); + } + } + callstack = callstack.replace(/\s+$/, ""); + return callstack; +} +function _emscripten_log_js(flags, str) { + if (flags & 24) { + str = str.replace(/\s+$/, ""); + str += (str.length > 0 ? "\n" : "") + _emscripten_get_callstack_js(flags); + } + if (flags & 1) { + if (flags & 4) { + console.error(str); + } else if (flags & 2) { + console.warn(str); + } else { + console.log(str); + } + } else if (flags & 6) { + Module.printErr(str); + } else { + Module.print(str); + } +} +function _emscripten_log(flags, varargs) { + var format = HEAP32[varargs >> 2]; + varargs += 4; + var str = ""; + if (format) { + var result = __formatString(format, varargs); + for (var i = 0; i < result.length; ++i) { + str += String.fromCharCode(result[i]); + } + } + _emscripten_log_js(flags, str); +} +function _emscripten_num_logical_cores() { + return 1; +} +function __setLetterbox(element, topBottom, leftRight) { + if (JSEvents.isInternetExplorer()) { + element.style.marginLeft = element.style.marginRight = leftRight + "px"; + element.style.marginTop = element.style.marginBottom = topBottom + "px"; + } else { + element.style.paddingLeft = element.style.paddingRight = leftRight + "px"; + element.style.paddingTop = element.style.paddingBottom = topBottom + "px"; + } +} +function _emscripten_do_request_fullscreen(target, strategy) { + if (typeof JSEvents.fullscreenEnabled() === "undefined") return -1; + if (!JSEvents.fullscreenEnabled()) return -3; + if (!target) target = "#canvas"; + target = JSEvents.findEventTarget(target); + if (!target) return -4; + if (!target.requestFullscreen && !target.msRequestFullscreen && !target.mozRequestFullScreen && !target.mozRequestFullscreen && !target.webkitRequestFullscreen) { + return -3; + } + var canPerformRequests = JSEvents.canPerformEventHandlerRequests(); + if (!canPerformRequests) { + if (strategy.deferUntilInEventHandler) { + JSEvents.deferCall(JSEvents.requestFullscreen, 1, [ target, strategy ]); + return 1; + } else { + return -2; + } + } + return JSEvents.requestFullscreen(target, strategy); +} +function _emscripten_request_fullscreen(target, deferUntilInEventHandler) { + var strategy = {}; + strategy.scaleMode = 0; + strategy.canvasResolutionScaleMode = 0; + strategy.filteringMode = 0; + strategy.deferUntilInEventHandler = deferUntilInEventHandler; + return _emscripten_do_request_fullscreen(target, strategy); +} +function _emscripten_request_pointerlock(target, deferUntilInEventHandler) { + if (!target) target = "#canvas"; + target = JSEvents.findEventTarget(target); + if (!target) return -4; + if (!target.requestPointerLock && !target.mozRequestPointerLock && !target.webkitRequestPointerLock && !target.msRequestPointerLock) { + return -1; + } + var canPerformRequests = JSEvents.canPerformEventHandlerRequests(); + if (!canPerformRequests) { + if (deferUntilInEventHandler) { + JSEvents.deferCall(JSEvents.requestPointerLock, 2, [ target ]); + return 1; + } else { + return -2; + } + } + return JSEvents.requestPointerLock(target); +} +function _emscripten_set_blur_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, 12, "blur"); + return 0; +} +function _emscripten_set_canvas_size(width, height) { + Browser.setCanvasSize(width, height); +} +function _emscripten_set_devicemotion_callback(userData, useCapture, callbackfunc) { + JSEvents.registerDeviceMotionEventCallback(window, userData, useCapture, callbackfunc, 17, "devicemotion"); + return 0; +} +function _emscripten_set_deviceorientation_callback(userData, useCapture, callbackfunc) { + JSEvents.registerDeviceOrientationEventCallback(window, userData, useCapture, callbackfunc, 16, "deviceorientation"); + return 0; +} +function _emscripten_set_focus_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, 13, "focus"); + return 0; +} +function _emscripten_set_fullscreenchange_callback(target, userData, useCapture, callbackfunc) { + if (typeof JSEvents.fullscreenEnabled() === "undefined") return -1; + if (!target) target = document; else { + target = JSEvents.findEventTarget(target); + if (!target) return -4; + } + JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "fullscreenchange"); + JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "mozfullscreenchange"); + JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "webkitfullscreenchange"); + JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "msfullscreenchange"); + return 0; +} +function _emscripten_set_keydown_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, 2, "keydown"); + return 0; +} +function _emscripten_set_keypress_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, 1, "keypress"); + return 0; +} +function _emscripten_set_keyup_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, 3, "keyup"); + return 0; +} +function _emscripten_set_mousedown_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, 5, "mousedown"); + return 0; +} +function _emscripten_set_mousemove_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, 8, "mousemove"); + return 0; +} +function _emscripten_set_mouseup_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, 6, "mouseup"); + return 0; +} +function _emscripten_set_touchcancel_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, 25, "touchcancel"); + return 0; +} +function _emscripten_set_touchend_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, 23, "touchend"); + return 0; +} +function _emscripten_set_touchmove_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, 24, "touchmove"); + return 0; +} +function _emscripten_set_touchstart_callback(target, userData, useCapture, callbackfunc) { + JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, 22, "touchstart"); + return 0; +} +function _emscripten_set_wheel_callback(target, userData, useCapture, callbackfunc) { + target = JSEvents.findEventTarget(target); + if (typeof target.onwheel !== "undefined") { + JSEvents.registerWheelEventCallback(target, userData, useCapture, callbackfunc, 9, "wheel"); + return 0; + } else if (typeof target.onmousewheel !== "undefined") { + JSEvents.registerWheelEventCallback(target, userData, useCapture, callbackfunc, 9, "mousewheel"); + return 0; + } else { + return -1; + } +} +var GL = { + counter: 1, + lastError: 0, + buffers: [], + mappedBuffers: {}, + programs: [], + framebuffers: [], + renderbuffers: [], + textures: [], + uniforms: [], + shaders: [], + vaos: [], + contexts: [], + currentContext: null, + offscreenCanvases: {}, + timerQueriesEXT: [], + queries: [], + samplers: [], + transformFeedbacks: [], + syncs: [], + byteSizeByTypeRoot: 5120, + byteSizeByType: [ 1, 1, 2, 2, 4, 4, 4, 2, 3, 4, 8 ], + programInfos: {}, + stringCache: {}, + stringiCache: {}, + tempFixedLengthArray: [], + packAlignment: 4, + unpackAlignment: 4, + init: (function() { + GL.miniTempBuffer = new Float32Array(GL.MINI_TEMP_BUFFER_SIZE); + for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) { + GL.miniTempBufferViews[i] = GL.miniTempBuffer.subarray(0, i + 1); + } + for (var i = 0; i < 32; i++) { + GL.tempFixedLengthArray.push(new Array(i)); + } + }), + 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, + miniTempBuffer: null, + miniTempBufferViews: [ 0 ], + getSource: (function(shader, count, string, length) { + var source = ""; + for (var i = 0; i < count; ++i) { + var frag; + if (length) { + var len = HEAP32[length + i * 4 >> 2]; + if (len < 0) { + frag = Pointer_stringify(HEAP32[string + i * 4 >> 2]); + } else { + frag = Pointer_stringify(HEAP32[string + i * 4 >> 2], len); + } + } else { + frag = Pointer_stringify(HEAP32[string + i * 4 >> 2]); + } + source += frag; + } + return source; + }), + createContext: (function(canvas, webGLContextAttributes) { + if (typeof webGLContextAttributes["majorVersion"] === "undefined" && typeof webGLContextAttributes["minorVersion"] === "undefined") { + if (typeof WebGL2RenderingContext !== "undefined") webGLContextAttributes["majorVersion"] = 2; else webGLContextAttributes["majorVersion"] = 1; + webGLContextAttributes["minorVersion"] = 0; + } + var ctx; + var errorInfo = "?"; + function onContextCreationError(event) { + errorInfo = event.statusMessage || errorInfo; + } + try { + canvas.addEventListener("webglcontextcreationerror", onContextCreationError, false); + try { + if (webGLContextAttributes["majorVersion"] == 1 && webGLContextAttributes["minorVersion"] == 0) { + ctx = canvas.getContext("webgl", webGLContextAttributes) || canvas.getContext("experimental-webgl", webGLContextAttributes); + } else if (webGLContextAttributes["majorVersion"] == 2 && webGLContextAttributes["minorVersion"] == 0) { + ctx = canvas.getContext("webgl2", webGLContextAttributes); + } else { + throw "Unsupported WebGL context version " + majorVersion + "." + minorVersion + "!"; + } + } finally { + canvas.removeEventListener("webglcontextcreationerror", onContextCreationError, false); + } + if (!ctx) throw ":("; + } catch (e) { + Module.print("Could not create canvas: " + [ errorInfo, e, JSON.stringify(webGLContextAttributes) ]); + return 0; + } + if (!ctx) return 0; + var context = GL.registerContext(ctx, webGLContextAttributes); + return context; + }), + registerContext: (function(ctx, webGLContextAttributes) { + var handle = GL.getNewId(GL.contexts); + var context = { + handle: handle, + attributes: webGLContextAttributes, + version: webGLContextAttributes["majorVersion"], + GLctx: ctx + }; + function getChromeVersion() { + var raw = navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./); + return raw ? parseInt(raw[2], 10) : false; + } + context.supportsWebGL2EntryPoints = context.version >= 2 && (getChromeVersion() === false || getChromeVersion() >= 58); + 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) { + var context = GL.contexts[contextHandle]; + if (!context) return false; + GLctx = Module.ctx = context.GLctx; + GL.currentContext = context; + return true; + }), + getContext: (function(contextHandle) { + return GL.contexts[contextHandle]; + }), + deleteContext: (function(contextHandle) { + if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null; + if (typeof JSEvents === "object") JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas); + if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; + GL.contexts[contextHandle] = null; + }), + initExtensions: (function(context) { + if (!context) context = GL.currentContext; + if (context.initExtensionsDone) return; + context.initExtensionsDone = true; + var GLctx = context.GLctx; + context.maxVertexAttribs = GLctx.getParameter(GLctx.MAX_VERTEX_ATTRIBS); + if (context.version < 2) { + var instancedArraysExt = GLctx.getExtension("ANGLE_instanced_arrays"); + if (instancedArraysExt) { + GLctx["vertexAttribDivisor"] = (function(index, divisor) { + instancedArraysExt["vertexAttribDivisorANGLE"](index, divisor); + }); + GLctx["drawArraysInstanced"] = (function(mode, first, count, primcount) { + instancedArraysExt["drawArraysInstancedANGLE"](mode, first, count, primcount); + }); + GLctx["drawElementsInstanced"] = (function(mode, count, type, indices, primcount) { + instancedArraysExt["drawElementsInstancedANGLE"](mode, count, type, indices, primcount); + }); + } + var vaoExt = GLctx.getExtension("OES_vertex_array_object"); + if (vaoExt) { + GLctx["createVertexArray"] = (function() { + return vaoExt["createVertexArrayOES"](); + }); + GLctx["deleteVertexArray"] = (function(vao) { + vaoExt["deleteVertexArrayOES"](vao); + }); + GLctx["bindVertexArray"] = (function(vao) { + vaoExt["bindVertexArrayOES"](vao); + }); + GLctx["isVertexArray"] = (function(vao) { + return vaoExt["isVertexArrayOES"](vao); + }); + } + var drawBuffersExt = GLctx.getExtension("WEBGL_draw_buffers"); + if (drawBuffersExt) { + GLctx["drawBuffers"] = (function(n, bufs) { + drawBuffersExt["drawBuffersWEBGL"](n, bufs); + }); + } + } + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query"); + var automaticallyEnabledExtensions = [ "OES_texture_float", "OES_texture_half_float", "OES_standard_derivatives", "OES_vertex_array_object", "WEBGL_compressed_texture_s3tc", "WEBGL_depth_texture", "OES_element_index_uint", "EXT_texture_filter_anisotropic", "ANGLE_instanced_arrays", "OES_texture_float_linear", "OES_texture_half_float_linear", "WEBGL_compressed_texture_atc", "WEBKIT_WEBGL_compressed_texture_pvrtc", "WEBGL_compressed_texture_pvrtc", "EXT_color_buffer_half_float", "WEBGL_color_buffer_float", "EXT_frag_depth", "EXT_sRGB", "WEBGL_draw_buffers", "WEBGL_shared_resources", "EXT_shader_texture_lod", "EXT_color_buffer_float" ]; + var exts = GLctx.getSupportedExtensions(); + if (exts && exts.length > 0) { + GLctx.getSupportedExtensions().forEach((function(ext) { + if (automaticallyEnabledExtensions.indexOf(ext) != -1) { + GLctx.getExtension(ext); + } + })); + } + }), + populateUniformTable: (function(program) { + var p = GL.programs[program]; + GL.programInfos[program] = { + uniforms: {}, + maxUniformLength: 0, + maxAttributeLength: -1, + maxUniformBlockNameLength: -1 + }; + var ptable = GL.programInfos[program]; + var utable = ptable.uniforms; + var numUniforms = GLctx.getProgramParameter(p, GLctx.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 (name.indexOf("]", name.length - 1) !== -1) { + var ls = name.lastIndexOf("["); + name = name.slice(0, ls); + } + var loc = GLctx.getUniformLocation(p, name); + if (loc != null) { + var id = GL.getNewId(GL.uniforms); + utable[name] = [ u.size, id ]; + GL.uniforms[id] = loc; + for (var j = 1; j < u.size; ++j) { + var n = name + "[" + j + "]"; + loc = GLctx.getUniformLocation(p, n); + id = GL.getNewId(GL.uniforms); + GL.uniforms[id] = loc; + } + } + } + }) +}; +function _emscripten_webgl_create_context(target, attributes) { + var contextAttributes = {}; + contextAttributes["alpha"] = !!HEAP32[attributes >> 2]; + contextAttributes["depth"] = !!HEAP32[attributes + 4 >> 2]; + contextAttributes["stencil"] = !!HEAP32[attributes + 8 >> 2]; + contextAttributes["antialias"] = !!HEAP32[attributes + 12 >> 2]; + contextAttributes["premultipliedAlpha"] = !!HEAP32[attributes + 16 >> 2]; + contextAttributes["preserveDrawingBuffer"] = !!HEAP32[attributes + 20 >> 2]; + contextAttributes["preferLowPowerToHighPerformance"] = !!HEAP32[attributes + 24 >> 2]; + contextAttributes["failIfMajorPerformanceCaveat"] = !!HEAP32[attributes + 28 >> 2]; + contextAttributes["majorVersion"] = HEAP32[attributes + 32 >> 2]; + contextAttributes["minorVersion"] = HEAP32[attributes + 36 >> 2]; + contextAttributes["explicitSwapControl"] = HEAP32[attributes + 44 >> 2]; + target = Pointer_stringify(target); + var canvas; + if ((!target || target === "#canvas") && Module["canvas"]) { + canvas = Module["canvas"].id ? GL.offscreenCanvases[Module["canvas"].id] || JSEvents.findEventTarget(Module["canvas"].id) : Module["canvas"]; + } else { + canvas = GL.offscreenCanvases[target] || JSEvents.findEventTarget(target); + } + if (!canvas) { + return 0; + } + if (contextAttributes["explicitSwapControl"]) { + console.error("emscripten_webgl_create_context failed: explicitSwapControl is not supported, please rebuild with -s OFFSCREENCANVAS_SUPPORT=1 to enable targeting the experimental OffscreenCanvas specification!"); + return 0; + } + var contextHandle = GL.createContext(canvas, contextAttributes); + return contextHandle; +} +function _emscripten_webgl_destroy_context(contextHandle) { + GL.deleteContext(contextHandle); +} +function _emscripten_webgl_enable_extension(contextHandle, extension) { + var context = GL.getContext(contextHandle); + var extString = Pointer_stringify(extension); + if (extString.indexOf("GL_") == 0) extString = extString.substr(3); + var ext = context.GLctx.getExtension(extString); + return ext ? 1 : 0; +} +function _emscripten_webgl_get_current_context() { + return GL.currentContext ? GL.currentContext.handle : 0; +} +function _emscripten_webgl_make_context_current(contextHandle) { + var success = GL.makeContextCurrent(contextHandle); + return success ? 0 : -5; +} +function __exit(status) { + Module["exit"](status); +} +function _exit(status) { + __exit(status); +} +function _flock(fd, operation) { + return 0; +} +function _gethostbyname(name) { + name = Pointer_stringify(name); + var ret = _malloc(20); + var nameBuf = _malloc(name.length + 1); + stringToUTF8(name, nameBuf, name.length + 1); + HEAP32[ret >> 2] = nameBuf; + var aliasesBuf = _malloc(4); + HEAP32[aliasesBuf >> 2] = 0; + HEAP32[ret + 4 >> 2] = aliasesBuf; + var afinet = 2; + HEAP32[ret + 8 >> 2] = afinet; + HEAP32[ret + 12 >> 2] = 4; + var addrListBuf = _malloc(12); + HEAP32[addrListBuf >> 2] = addrListBuf + 8; + HEAP32[addrListBuf + 4 >> 2] = 0; + HEAP32[addrListBuf + 8 >> 2] = __inet_pton4_raw(DNS.lookup_name(name)); + HEAP32[ret + 16 >> 2] = addrListBuf; + return ret; +} +function _gethostbyaddr(addr, addrlen, type) { + if (type !== 2) { + ___setErrNo(ERRNO_CODES.EAFNOSUPPORT); + return null; + } + addr = HEAP32[addr >> 2]; + var host = __inet_ntop4_raw(addr); + var lookup = DNS.lookup_addr(host); + if (lookup) { + host = lookup; + } + var hostp = allocate(intArrayFromString(host), "i8", ALLOC_STACK); + return _gethostbyname(hostp); +} +function _getpwuid(uid) { + return 0; +} +function _gettimeofday(ptr) { + var now = Date.now(); + HEAP32[ptr >> 2] = now / 1e3 | 0; + HEAP32[ptr + 4 >> 2] = now % 1e3 * 1e3 | 0; + return 0; +} +function _glActiveTexture(x0) { + GLctx["activeTexture"](x0); +} +function _glAttachShader(program, shader) { + GLctx.attachShader(GL.programs[program], GL.shaders[shader]); +} +function _glBeginQuery(target, id) { + GLctx["beginQuery"](target, id ? GL.queries[id] : null); +} +function _glBeginTransformFeedback(x0) { + GLctx["beginTransformFeedback"](x0); +} +function _glBindAttribLocation(program, index, name) { + name = Pointer_stringify(name); + GLctx.bindAttribLocation(GL.programs[program], index, name); +} +function _glBindBuffer(target, buffer) { + var bufferObj = buffer ? GL.buffers[buffer] : null; + if (target == 35051) { + GLctx.currentPixelPackBufferBinding = buffer; + } else if (target == 35052) { + GLctx.currentPixelUnpackBufferBinding = buffer; + } + GLctx.bindBuffer(target, bufferObj); +} +function _glBindBufferBase(target, index, buffer) { + var bufferObj = buffer ? GL.buffers[buffer] : null; + GLctx["bindBufferBase"](target, index, bufferObj); +} +function _glBindFramebuffer(target, framebuffer) { + GLctx.bindFramebuffer(target, framebuffer ? GL.framebuffers[framebuffer] : null); +} +function _glBindRenderbuffer(target, renderbuffer) { + GLctx.bindRenderbuffer(target, renderbuffer ? GL.renderbuffers[renderbuffer] : null); +} +function _glBindSampler(unit, sampler) { + GLctx["bindSampler"](unit, sampler ? GL.samplers[sampler] : null); +} +function _glBindTexture(target, texture) { + GLctx.bindTexture(target, texture ? GL.textures[texture] : null); +} +function _glBindTransformFeedback(target, id) { + var transformFeedback = id ? GL.transformFeedbacks[id] : null; + if (id && !transformFeedback) { + GL.recordError(1282); + return; + } + GLctx["bindTransformFeedback"](target, transformFeedback); +} +function _glBindVertexArray(vao) { + GLctx["bindVertexArray"](GL.vaos[vao]); +} +function _glBlendEquation(x0) { + GLctx["blendEquation"](x0); +} +function _glBlendEquationSeparate(x0, x1) { + GLctx["blendEquationSeparate"](x0, x1); +} +function _glBlendFuncSeparate(x0, x1, x2, x3) { + GLctx["blendFuncSeparate"](x0, x1, x2, x3); +} +function _glBlitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) { + GLctx["blitFramebuffer"](x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); +} +function _glBufferData(target, size, data, usage) { + if (!data) { + GLctx.bufferData(target, size, usage); + } else { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.bufferData(target, HEAPU8, usage, data, size); + return; + } + GLctx.bufferData(target, HEAPU8.subarray(data, data + size), usage); + } +} +function _glBufferSubData(target, offset, size, data) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.bufferSubData(target, offset, HEAPU8, data, size); + return; + } + GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size)); +} +function _glCheckFramebufferStatus(x0) { + return GLctx["checkFramebufferStatus"](x0); +} +function _glClear(x0) { + GLctx["clear"](x0); +} +function _glClearColor(x0, x1, x2, x3) { + GLctx["clearColor"](x0, x1, x2, x3); +} +function _glClearDepthf(x0) { + GLctx["clearDepth"](x0); +} +function _glClearStencil(x0) { + GLctx["clearStencil"](x0); +} +function _glClientWaitSync(sync, flags, timeoutLo, timeoutHi) { + timeoutLo = timeoutLo >>> 0; + timeoutHi = timeoutHi >>> 0; + var timeout = timeoutLo == 4294967295 && timeoutHi == 4294967295 ? -1 : makeBigInt(timeoutLo, timeoutHi, true); + return GLctx.clientWaitSync(GL.syncs[sync], flags, timeout); +} +function _glColorMask(red, green, blue, alpha) { + GLctx.colorMask(!!red, !!green, !!blue, !!alpha); +} +function _glCompileShader(shader) { + GLctx.compileShader(GL.shaders[shader]); +} +function _glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, HEAPU8, data, imageSize); + return; + } + GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, data ? HEAPU8.subarray(data, data + imageSize) : null); +} +function _glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize); + return; + } + GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, data ? HEAPU8.subarray(data, data + imageSize) : null); +} +function _glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx["compressedTexSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize); + } else { + GLctx["compressedTexSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, data ? HEAPU8.subarray(data, data + imageSize) : null); + } +} +function _glCopyBufferSubData(x0, x1, x2, x3, x4) { + GLctx["copyBufferSubData"](x0, x1, x2, x3, x4); +} +function _glCopyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7) { + GLctx["copyTexImage2D"](x0, x1, x2, x3, x4, x5, x6, x7); +} +function _glCopyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7) { + GLctx["copyTexSubImage2D"](x0, x1, x2, x3, x4, x5, x6, x7); +} +function _glCreateProgram() { + var id = GL.getNewId(GL.programs); + var program = GLctx.createProgram(); + program.name = id; + GL.programs[id] = program; + return id; +} +function _glCreateShader(shaderType) { + var id = GL.getNewId(GL.shaders); + GL.shaders[id] = GLctx.createShader(shaderType); + return id; +} +function _glCullFace(x0) { + GLctx["cullFace"](x0); +} +function _glDeleteBuffers(n, buffers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[buffers + i * 4 >> 2]; + var buffer = GL.buffers[id]; + if (!buffer) continue; + GLctx.deleteBuffer(buffer); + buffer.name = 0; + GL.buffers[id] = null; + if (id == GL.currArrayBuffer) GL.currArrayBuffer = 0; + if (id == GL.currElementArrayBuffer) GL.currElementArrayBuffer = 0; + } +} +function _glDeleteFramebuffers(n, framebuffers) { + for (var i = 0; i < n; ++i) { + var id = HEAP32[framebuffers + i * 4 >> 2]; + var framebuffer = GL.framebuffers[id]; + if (!framebuffer) continue; + GLctx.deleteFramebuffer(framebuffer); + framebuffer.name = 0; + GL.framebuffers[id] = null; + } +} +function _glDeleteProgram(id) { + if (!id) return; + var program = GL.programs[id]; + if (!program) { + GL.recordError(1281); + return; + } + GLctx.deleteProgram(program); + program.name = 0; + GL.programs[id] = null; + GL.programInfos[id] = null; +} +function _glDeleteQueries(n, ids) { + for (var i = 0; i < n; i++) { + var id = HEAP32[ids + i * 4 >> 2]; + var query = GL.queries[id]; + if (!query) continue; + GLctx["deleteQuery"](query); + GL.queries[id] = null; + } +} +function _glDeleteRenderbuffers(n, renderbuffers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[renderbuffers + i * 4 >> 2]; + var renderbuffer = GL.renderbuffers[id]; + if (!renderbuffer) continue; + GLctx.deleteRenderbuffer(renderbuffer); + renderbuffer.name = 0; + GL.renderbuffers[id] = null; + } +} +function _glDeleteSamplers(n, samplers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[samplers + i * 4 >> 2]; + var sampler = GL.samplers[id]; + if (!sampler) continue; + GLctx["deleteSampler"](sampler); + sampler.name = 0; + GL.samplers[id] = null; + } +} +function _glDeleteShader(id) { + if (!id) return; + var shader = GL.shaders[id]; + if (!shader) { + GL.recordError(1281); + return; + } + GLctx.deleteShader(shader); + GL.shaders[id] = null; +} +function _glDeleteSync(id) { + if (!id) return; + var sync = GL.syncs[id]; + if (!sync) { + GL.recordError(1281); + return; + } + GLctx.deleteSync(sync); + sync.name = 0; + GL.syncs[id] = null; +} +function _glDeleteTextures(n, textures) { + for (var i = 0; i < n; i++) { + var id = HEAP32[textures + i * 4 >> 2]; + var texture = GL.textures[id]; + if (!texture) continue; + GLctx.deleteTexture(texture); + texture.name = 0; + GL.textures[id] = null; + } +} +function _glDeleteTransformFeedbacks(n, ids) { + for (var i = 0; i < n; i++) { + var id = HEAP32[ids + i * 4 >> 2]; + var transformFeedback = GL.transformFeedbacks[id]; + if (!transformFeedback) continue; + GLctx["deleteTransformFeedback"](transformFeedback); + transformFeedback.name = 0; + GL.transformFeedbacks[id] = null; + } +} +function _glDeleteVertexArrays(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 _glDepthFunc(x0) { + GLctx["depthFunc"](x0); +} +function _glDepthMask(flag) { + GLctx.depthMask(!!flag); +} +function _glDetachShader(program, shader) { + GLctx.detachShader(GL.programs[program], GL.shaders[shader]); +} +function _glDisable(x0) { + GLctx["disable"](x0); +} +function _glDisableVertexAttribArray(index) { + GLctx.disableVertexAttribArray(index); +} +function _glDrawArrays(mode, first, count) { + GLctx.drawArrays(mode, first, count); +} +function _glDrawArraysInstanced(mode, first, count, primcount) { + GLctx["drawArraysInstanced"](mode, first, count, primcount); +} +function _glDrawBuffers(n, bufs) { + var bufArray = GL.tempFixedLengthArray[n]; + for (var i = 0; i < n; i++) { + bufArray[i] = HEAP32[bufs + i * 4 >> 2]; + } + GLctx["drawBuffers"](bufArray); +} +function _glDrawElements(mode, count, type, indices) { + GLctx.drawElements(mode, count, type, indices); +} +function _glDrawElementsInstanced(mode, count, type, indices, primcount) { + GLctx["drawElementsInstanced"](mode, count, type, indices, primcount); +} +function _glEnable(x0) { + GLctx["enable"](x0); +} +function _glEnableVertexAttribArray(index) { + GLctx.enableVertexAttribArray(index); +} +function _glEndQuery(x0) { + GLctx["endQuery"](x0); +} +function _glEndTransformFeedback() { + GLctx["endTransformFeedback"](); +} +function _glFenceSync(condition, flags) { + var sync = GLctx.fenceSync(condition, flags); + if (sync) { + var id = GL.getNewId(GL.syncs); + sync.name = id; + GL.syncs[id] = sync; + return id; + } else { + return 0; + } +} +function _glFinish() { + GLctx["finish"](); +} +function _glFlush() { + GLctx["flush"](); +} +function emscriptenWebGLGetBufferBinding(target) { + switch (target) { + case 34962: + target = 34964; + break; + case 34963: + target = 34965; + break; + case 35051: + target = 35053; + break; + case 35052: + target = 35055; + break; + case 35982: + target = 35983; + break; + case 36662: + target = 36662; + break; + case 36663: + target = 36663; + break; + case 35345: + target = 35368; + break; + } + var buffer = GLctx.getParameter(target); + if (buffer) return buffer.name | 0; else return 0; +} +function emscriptenWebGLValidateMapBufferTarget(target) { + switch (target) { + case 34962: + case 34963: + case 36662: + case 36663: + case 35051: + case 35052: + case 35882: + case 35982: + case 35345: + return true; + default: + return false; + } +} +function _glFlushMappedBufferRange(target, offset, length) { + if (!emscriptenWebGLValidateMapBufferTarget(target)) { + GL.recordError(1280); + Module.printErr("GL_INVALID_ENUM in glFlushMappedBufferRange"); + return; + } + var mapping = GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)]; + if (!mapping) { + GL.recordError(1282); + Module.printError("buffer was never mapped in glFlushMappedBufferRange"); + return; + } + if (!(mapping.access & 16)) { + GL.recordError(1282); + Module.printError("buffer was not mapped with GL_MAP_FLUSH_EXPLICIT_BIT in glFlushMappedBufferRange"); + return; + } + if (offset < 0 || length < 0 || offset + length > mapping.length) { + GL.recordError(1281); + Module.printError("invalid range in glFlushMappedBufferRange"); + return; + } + GLctx.bufferSubData(target, mapping.offset, HEAPU8.subarray(mapping.mem + offset, mapping.mem + offset + length)); +} +function _glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) { + GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, GL.renderbuffers[renderbuffer]); +} +function _glFramebufferTexture2D(target, attachment, textarget, texture, level) { + GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level); +} +function _glFramebufferTextureLayer(target, attachment, texture, level, layer) { + GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer); +} +function _glFrontFace(x0) { + GLctx["frontFace"](x0); +} +function _glGenBuffers(n, buffers) { + for (var i = 0; i < n; i++) { + var buffer = GLctx.createBuffer(); + if (!buffer) { + GL.recordError(1282); + while (i < n) HEAP32[buffers + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.buffers); + buffer.name = id; + GL.buffers[id] = buffer; + HEAP32[buffers + i * 4 >> 2] = id; + } +} +function _glGenFramebuffers(n, ids) { + for (var i = 0; i < n; ++i) { + var framebuffer = GLctx.createFramebuffer(); + if (!framebuffer) { + GL.recordError(1282); + while (i < n) HEAP32[ids + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.framebuffers); + framebuffer.name = id; + GL.framebuffers[id] = framebuffer; + HEAP32[ids + i * 4 >> 2] = id; + } +} +function _glGenQueries(n, ids) { + for (var i = 0; i < n; i++) { + var query = GLctx["createQuery"](); + if (!query) { + GL.recordError(1282); + while (i < n) HEAP32[ids + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.queries); + query.name = id; + GL.queries[id] = query; + HEAP32[ids + i * 4 >> 2] = id; + } +} +function _glGenRenderbuffers(n, renderbuffers) { + for (var i = 0; i < n; i++) { + var renderbuffer = GLctx.createRenderbuffer(); + if (!renderbuffer) { + GL.recordError(1282); + while (i < n) HEAP32[renderbuffers + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.renderbuffers); + renderbuffer.name = id; + GL.renderbuffers[id] = renderbuffer; + HEAP32[renderbuffers + i * 4 >> 2] = id; + } +} +function _glGenSamplers(n, samplers) { + for (var i = 0; i < n; i++) { + var sampler = GLctx["createSampler"](); + if (!sampler) { + GL.recordError(1282); + while (i < n) HEAP32[samplers + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.samplers); + sampler.name = id; + GL.samplers[id] = sampler; + HEAP32[samplers + i * 4 >> 2] = id; + } +} +function _glGenTextures(n, textures) { + for (var i = 0; i < n; i++) { + var texture = GLctx.createTexture(); + if (!texture) { + GL.recordError(1282); + while (i < n) HEAP32[textures + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.textures); + texture.name = id; + GL.textures[id] = texture; + HEAP32[textures + i * 4 >> 2] = id; + } +} +function _glGenTransformFeedbacks(n, ids) { + for (var i = 0; i < n; i++) { + var transformFeedback = GLctx["createTransformFeedback"](); + if (!transformFeedback) { + GL.recordError(1282); + while (i < n) HEAP32[ids + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.transformFeedbacks); + transformFeedback.name = id; + GL.transformFeedbacks[id] = transformFeedback; + HEAP32[ids + i * 4 >> 2] = id; + } +} +function _glGenVertexArrays(n, arrays) { + for (var i = 0; i < n; i++) { + var vao = GLctx["createVertexArray"](); + if (!vao) { + GL.recordError(1282); + while (i < n) HEAP32[arrays + i++ * 4 >> 2] = 0; + return; + } + var id = GL.getNewId(GL.vaos); + vao.name = id; + GL.vaos[id] = vao; + HEAP32[arrays + i * 4 >> 2] = id; + } +} +function _glGenerateMipmap(x0) { + GLctx["generateMipmap"](x0); +} +function _glGetActiveAttrib(program, index, bufSize, length, size, type, name) { + program = GL.programs[program]; + var info = GLctx.getActiveAttrib(program, index); + if (!info) return; + if (bufSize > 0 && name) { + var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize); + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[length >> 2] = 0; + } + if (size) HEAP32[size >> 2] = info.size; + if (type) HEAP32[type >> 2] = info.type; +} +function _glGetActiveUniform(program, index, bufSize, length, size, type, name) { + program = GL.programs[program]; + var info = GLctx.getActiveUniform(program, index); + if (!info) return; + if (bufSize > 0 && name) { + var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize); + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[length >> 2] = 0; + } + if (size) HEAP32[size >> 2] = info.size; + if (type) HEAP32[type >> 2] = info.type; +} +function _glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName) { + program = GL.programs[program]; + var result = GLctx["getActiveUniformBlockName"](program, uniformBlockIndex); + if (!result) return; + if (uniformBlockName && bufSize > 0) { + var numBytesWrittenExclNull = stringToUTF8(result, uniformBlockName, bufSize); + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[length >> 2] = 0; + } +} +function _glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params) { + if (!params) { + GL.recordError(1281); + return; + } + program = GL.programs[program]; + switch (pname) { + case 35393: + var name = GLctx["getActiveUniformBlockName"](program, uniformBlockIndex); + HEAP32[params >> 2] = name.length + 1; + return; + default: + var result = GLctx["getActiveUniformBlockParameter"](program, uniformBlockIndex, pname); + if (!result) return; + if (typeof result == "number") { + HEAP32[params >> 2] = result; + } else { + for (var i = 0; i < result.length; i++) { + HEAP32[params + i * 4 >> 2] = result[i]; + } + } + } +} +function _glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params) { + if (!params) { + GL.recordError(1281); + return; + } + if (uniformCount > 0 && uniformIndices == 0) { + GL.recordError(1281); + return; + } + program = GL.programs[program]; + var ids = []; + for (var i = 0; i < uniformCount; i++) { + ids.push(HEAP32[uniformIndices + i * 4 >> 2]); + } + var result = GLctx["getActiveUniforms"](program, ids, pname); + if (!result) return; + var len = result.length; + for (var i = 0; i < len; i++) { + HEAP32[params + i * 4 >> 2] = result[i]; + } +} +function _glGetAttribLocation(program, name) { + program = GL.programs[program]; + name = Pointer_stringify(name); + return GLctx.getAttribLocation(program, name); +} +function _glGetError() { + if (GL.lastError) { + var error = GL.lastError; + GL.lastError = 0; + return error; + } else { + return GLctx.getError(); + } +} +function _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 emscriptenWebGLGetIndexed(target, index, data, type) { + if (!data) { + GL.recordError(1281); + return; + } + var result = GLctx["getIndexedParameter"](target, index); + var ret; + switch (typeof result) { + case "boolean": + ret = result ? 1 : 0; + break; + case "number": + ret = result; + break; + case "object": + if (result === null) { + switch (target) { + case 35983: + case 35368: + ret = 0; + break; + default: + { + GL.recordError(1280); + return; + } + } + } else if (result instanceof WebGLBuffer) { + ret = result.name | 0; + } else { + GL.recordError(1280); + return; + } + break; + default: + GL.recordError(1280); + return; + } + switch (type) { + case "Integer64": + tempI64 = [ ret >>> 0, (tempDouble = ret, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], HEAP32[data >> 2] = tempI64[0], HEAP32[data + 4 >> 2] = tempI64[1]; + break; + case "Integer": + HEAP32[data >> 2] = ret; + break; + case "Float": + HEAPF32[data >> 2] = ret; + break; + case "Boolean": + HEAP8[data >> 0] = ret ? 1 : 0; + break; + default: + throw "internal emscriptenWebGLGetIndexed() error, bad type: " + type; + } +} +function _glGetIntegeri_v(target, index, data) { + emscriptenWebGLGetIndexed(target, index, data, "Integer"); +} +function emscriptenWebGLGet(name_, p, type) { + if (!p) { + GL.recordError(1281); + return; + } + var ret = undefined; + switch (name_) { + case 36346: + ret = 1; + break; + case 36344: + if (type !== "Integer" && type !== "Integer64") { + GL.recordError(1280); + } + return; + case 34814: + case 36345: + ret = 0; + break; + case 34466: + var formats = GLctx.getParameter(34467); + ret = formats.length; + break; + case 33309: + if (GLctx.canvas.GLctxObject.version < 2) { + GL.recordError(1282); + return; + } + var exts = GLctx.getSupportedExtensions(); + ret = 2 * exts.length; + break; + case 33307: + case 33308: + if (GLctx.canvas.GLctxObject.version < 2) { + GL.recordError(1280); + return; + } + ret = name_ == 33307 ? 3 : 0; + break; + } + if (ret === undefined) { + var result = GLctx.getParameter(name_); + switch (typeof result) { + case "number": + ret = result; + break; + case "boolean": + ret = result ? 1 : 0; + break; + case "string": + GL.recordError(1280); + return; + case "object": + if (result === null) { + switch (name_) { + case 34964: + case 35725: + case 34965: + case 36006: + case 36007: + case 32873: + case 34229: + case 35097: + case 36389: + case 34068: + { + ret = 0; + break; + } + default: + { + GL.recordError(1280); + return; + } + } + } else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) { + for (var i = 0; i < result.length; ++i) { + switch (type) { + case "Integer": + HEAP32[p + i * 4 >> 2] = result[i]; + break; + case "Float": + HEAPF32[p + i * 4 >> 2] = result[i]; + break; + case "Boolean": + HEAP8[p + i >> 0] = result[i] ? 1 : 0; + break; + default: + throw "internal glGet error, bad type: " + type; + } + } + return; + } else if (result instanceof WebGLBuffer || result instanceof WebGLProgram || result instanceof WebGLFramebuffer || result instanceof WebGLRenderbuffer || result instanceof WebGLQuery || result instanceof WebGLSampler || result instanceof WebGLSync || result instanceof WebGLTransformFeedback || result instanceof WebGLVertexArrayObject || result instanceof WebGLTexture) { + ret = result.name | 0; + } else { + GL.recordError(1280); + return; + } + break; + default: + GL.recordError(1280); + return; + } + } + switch (type) { + case "Integer64": + tempI64 = [ ret >>> 0, (tempDouble = ret, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], HEAP32[p >> 2] = tempI64[0], HEAP32[p + 4 >> 2] = tempI64[1]; + break; + case "Integer": + HEAP32[p >> 2] = ret; + break; + case "Float": + HEAPF32[p >> 2] = ret; + break; + case "Boolean": + HEAP8[p >> 0] = ret ? 1 : 0; + break; + default: + throw "internal glGet error, bad type: " + type; + } +} +function _glGetIntegerv(name_, p) { + emscriptenWebGLGet(name_, p, "Integer"); +} +function _glGetProgramBinary(program, bufSize, length, binaryFormat, binary) { + GL.recordError(1282); +} +function _glGetProgramInfoLog(program, maxLength, length, infoLog) { + var log = GLctx.getProgramInfoLog(GL.programs[program]); + if (log === null) log = "(unknown error)"; + if (maxLength > 0 && infoLog) { + var numBytesWrittenExclNull = stringToUTF8(log, infoLog, maxLength); + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[length >> 2] = 0; + } +} +function _glGetProgramiv(program, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (program >= GL.counter) { + GL.recordError(1281); + return; + } + var ptable = GL.programInfos[program]; + if (!ptable) { + GL.recordError(1282); + return; + } + if (pname == 35716) { + var log = GLctx.getProgramInfoLog(GL.programs[program]); + if (log === null) log = "(unknown error)"; + HEAP32[p >> 2] = log.length + 1; + } else if (pname == 35719) { + HEAP32[p >> 2] = ptable.maxUniformLength; + } else if (pname == 35722) { + if (ptable.maxAttributeLength == -1) { + program = GL.programs[program]; + var numAttribs = GLctx.getProgramParameter(program, GLctx.ACTIVE_ATTRIBUTES); + ptable.maxAttributeLength = 0; + for (var i = 0; i < numAttribs; ++i) { + var activeAttrib = GLctx.getActiveAttrib(program, i); + ptable.maxAttributeLength = Math.max(ptable.maxAttributeLength, activeAttrib.name.length + 1); + } + } + HEAP32[p >> 2] = ptable.maxAttributeLength; + } else if (pname == 35381) { + if (ptable.maxUniformBlockNameLength == -1) { + program = GL.programs[program]; + var numBlocks = GLctx.getProgramParameter(program, GLctx.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 _glGetRenderbufferParameteriv(target, pname, params) { + if (!params) { + GL.recordError(1281); + return; + } + HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname); +} +function _glGetShaderInfoLog(shader, maxLength, length, infoLog) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + if (maxLength > 0 && infoLog) { + var numBytesWrittenExclNull = stringToUTF8(log, infoLog, maxLength); + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[length >> 2] = 0; + } +} +function _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 _glGetShaderSource(shader, bufSize, length, source) { + var result = GLctx.getShaderSource(GL.shaders[shader]); + if (!result) return; + if (bufSize > 0 && source) { + var numBytesWrittenExclNull = stringToUTF8(result, source, bufSize); + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } else { + if (length) HEAP32[length >> 2] = 0; + } +} +function _glGetShaderiv(shader, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (pname == 35716) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + HEAP32[p >> 2] = log.length + 1; + } else if (pname == 35720) { + var source = GLctx.getShaderSource(GL.shaders[shader]); + var sourceLength = source === null || source.length == 0 ? 0 : source.length + 1; + HEAP32[p >> 2] = sourceLength; + } else { + HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname); + } +} +function _glGetString(name_) { + if (GL.stringCache[name_]) return GL.stringCache[name_]; + var ret; + switch (name_) { + case 7936: + case 7937: + case 37445: + case 37446: + ret = allocate(intArrayFromString(GLctx.getParameter(name_)), "i8", ALLOC_NORMAL); + break; + case 7938: + var glVersion = GLctx.getParameter(GLctx.VERSION); + if (GLctx.canvas.GLctxObject.version >= 2) glVersion = "OpenGL ES 3.0 (" + glVersion + ")"; else { + glVersion = "OpenGL ES 2.0 (" + glVersion + ")"; + } + ret = allocate(intArrayFromString(glVersion), "i8", ALLOC_NORMAL); + break; + case 7939: + var exts = GLctx.getSupportedExtensions(); + var gl_exts = []; + for (var i = 0; i < exts.length; ++i) { + gl_exts.push(exts[i]); + gl_exts.push("GL_" + exts[i]); + } + ret = allocate(intArrayFromString(gl_exts.join(" ")), "i8", ALLOC_NORMAL); + break; + case 35724: + var glslVersion = GLctx.getParameter(GLctx.SHADING_LANGUAGE_VERSION); + var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/; + var ver_num = glslVersion.match(ver_re); + if (ver_num !== null) { + if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0"; + glslVersion = "OpenGL ES GLSL ES " + ver_num[1] + " (" + glslVersion + ")"; + } + ret = allocate(intArrayFromString(glslVersion), "i8", ALLOC_NORMAL); + break; + default: + GL.recordError(1280); + return 0; + } + GL.stringCache[name_] = ret; + return ret; +} +function _glGetStringi(name, index) { + if (GLctx.canvas.GLctxObject.version < 2) { + GL.recordError(1282); + return 0; + } + var stringiCache = GL.stringiCache[name]; + if (stringiCache) { + if (index < 0 || index >= stringiCache.length) { + GL.recordError(1281); + return 0; + } + return stringiCache[index]; + } + switch (name) { + case 7939: + var exts = GLctx.getSupportedExtensions(); + var gl_exts = []; + for (var i = 0; i < exts.length; ++i) { + gl_exts.push(allocate(intArrayFromString(exts[i]), "i8", ALLOC_NORMAL)); + gl_exts.push(allocate(intArrayFromString("GL_" + exts[i]), "i8", ALLOC_NORMAL)); + } + stringiCache = GL.stringiCache[name] = gl_exts; + if (index < 0 || index >= stringiCache.length) { + GL.recordError(1281); + return 0; + } + return stringiCache[index]; + default: + GL.recordError(1280); + return 0; + } +} +function _glGetTexParameteriv(target, pname, params) { + if (!params) { + GL.recordError(1281); + return; + } + HEAP32[params >> 2] = GLctx.getTexParameter(target, pname); +} +function _glGetUniformBlockIndex(program, uniformBlockName) { + program = GL.programs[program]; + uniformBlockName = Pointer_stringify(uniformBlockName); + return GLctx["getUniformBlockIndex"](program, uniformBlockName); +} +function _glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices) { + if (!uniformIndices) { + GL.recordError(1281); + return; + } + if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) { + GL.recordError(1281); + return; + } + program = GL.programs[program]; + var names = []; + for (var i = 0; i < uniformCount; i++) names.push(Pointer_stringify(HEAP32[uniformNames + i * 4 >> 2])); + var result = GLctx["getUniformIndices"](program, names); + if (!result) return; + var len = result.length; + for (var i = 0; i < len; i++) { + HEAP32[uniformIndices + i * 4 >> 2] = result[i]; + } +} +function _glGetUniformLocation(program, name) { + name = Pointer_stringify(name); + var arrayOffset = 0; + if (name.indexOf("]", name.length - 1) !== -1) { + var ls = name.lastIndexOf("["); + var arrayIndex = name.slice(ls + 1, -1); + if (arrayIndex.length > 0) { + arrayOffset = parseInt(arrayIndex); + if (arrayOffset < 0) { + return -1; + } + } + name = name.slice(0, ls); + } + var ptable = GL.programInfos[program]; + if (!ptable) { + return -1; + } + var utable = ptable.uniforms; + var uniformInfo = utable[name]; + if (uniformInfo && arrayOffset < uniformInfo[0]) { + return uniformInfo[1] + arrayOffset; + } else { + return -1; + } +} +function emscriptenWebGLGetUniform(program, location, params, type) { + if (!params) { + GL.recordError(1281); + return; + } + var data = GLctx.getUniform(GL.programs[program], GL.uniforms[location]); + if (typeof data == "number" || typeof data == "boolean") { + switch (type) { + case "Integer": + HEAP32[params >> 2] = data; + break; + case "Float": + 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 "Integer": + HEAP32[params + i * 4 >> 2] = data[i]; + break; + case "Float": + HEAPF32[params + i * 4 >> 2] = data[i]; + break; + default: + throw "internal emscriptenWebGLGetUniform() error, bad type: " + type; + } + } + } +} +function _glGetUniformiv(program, location, params) { + emscriptenWebGLGetUniform(program, location, params, "Integer"); +} +function emscriptenWebGLGetVertexAttrib(index, pname, params, type) { + if (!params) { + GL.recordError(1281); + return; + } + var data = GLctx.getVertexAttrib(index, pname); + if (pname == 34975) { + HEAP32[params >> 2] = data["name"]; + } else if (typeof data == "number" || typeof data == "boolean") { + switch (type) { + case "Integer": + HEAP32[params >> 2] = data; + break; + case "Float": + HEAPF32[params >> 2] = data; + break; + case "FloatToInteger": + 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 "Integer": + HEAP32[params + i * 4 >> 2] = data[i]; + break; + case "Float": + HEAPF32[params + i * 4 >> 2] = data[i]; + break; + case "FloatToInteger": + HEAP32[params + i * 4 >> 2] = Math.fround(data[i]); + break; + default: + throw "internal emscriptenWebGLGetVertexAttrib() error, bad type: " + type; + } + } + } +} +function _glGetVertexAttribiv(index, pname, params) { + emscriptenWebGLGetVertexAttrib(index, pname, params, "FloatToInteger"); +} +function _glInvalidateFramebuffer(target, numAttachments, attachments) { + var list = GL.tempFixedLengthArray[numAttachments]; + for (var i = 0; i < numAttachments; i++) { + list[i] = HEAP32[attachments + i * 4 >> 2]; + } + GLctx["invalidateFramebuffer"](target, list); +} +function _glIsEnabled(x0) { + return GLctx["isEnabled"](x0); +} +function _glIsVertexArray(array) { + var vao = GL.vaos[array]; + if (!vao) return 0; + return GLctx["isVertexArray"](vao); +} +function _glLinkProgram(program) { + GLctx.linkProgram(GL.programs[program]); + GL.programInfos[program] = null; + GL.populateUniformTable(program); +} +function _glMapBufferRange(target, offset, length, access) { + if (access != 26 && access != 10) { + Module.printErr("glMapBufferRange is only supported when access is MAP_WRITE|INVALIDATE_BUFFER"); + return 0; + } + if (!emscriptenWebGLValidateMapBufferTarget(target)) { + GL.recordError(1280); + Module.printErr("GL_INVALID_ENUM in glMapBufferRange"); + return 0; + } + var mem = _malloc(length); + if (!mem) return 0; + GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)] = { + offset: offset, + length: length, + mem: mem, + access: access + }; + return mem; +} +function _glPixelStorei(pname, param) { + if (pname == 3333) { + GL.packAlignment = param; + } else if (pname == 3317) { + GL.unpackAlignment = param; + } + GLctx.pixelStorei(pname, param); +} +function _glPolygonOffset(x0, x1) { + GLctx["polygonOffset"](x0, x1); +} +function _glProgramBinary(program, binaryFormat, binary, length) { + GL.recordError(1280); +} +function _glProgramParameteri(program, pname, value) { + GL.recordError(1280); +} +function _glReadBuffer(x0) { + GLctx["readBuffer"](x0); +} +function emscriptenWebGLComputeImageSize(width, height, sizePerPixel, alignment) { + function roundedToNextMultipleOf(x, y) { + return Math.floor((x + y - 1) / y) * y; + } + var plainRowSize = width * sizePerPixel; + var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment); + return height <= 0 ? 0 : (height - 1) * alignedRowSize + plainRowSize; +} +function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) { + var sizePerPixel; + var numChannels; + switch (format) { + case 6406: + case 6409: + case 6402: + case 6403: + case 36244: + numChannels = 1; + break; + case 6410: + case 33319: + case 33320: + numChannels = 2; + break; + case 6407: + case 35904: + case 36248: + numChannels = 3; + break; + case 6408: + case 35906: + case 36249: + numChannels = 4; + break; + default: + GL.recordError(1280); + return null; + } + switch (type) { + case 5121: + case 5120: + sizePerPixel = numChannels * 1; + break; + case 5123: + case 36193: + case 5131: + case 5122: + sizePerPixel = numChannels * 2; + break; + case 5125: + case 5126: + case 5124: + sizePerPixel = numChannels * 4; + break; + case 34042: + case 35902: + case 33640: + case 35899: + case 34042: + sizePerPixel = 4; + break; + case 33635: + case 32819: + case 32820: + sizePerPixel = 2; + break; + default: + GL.recordError(1280); + return null; + } + var bytes = emscriptenWebGLComputeImageSize(width, height, sizePerPixel, GL.unpackAlignment); + switch (type) { + case 5120: + return HEAP8.subarray(pixels, pixels + bytes); + case 5121: + return HEAPU8.subarray(pixels, pixels + bytes); + case 5122: + return HEAP16.subarray(pixels >> 1, pixels + bytes >> 1); + case 5124: + return HEAP32.subarray(pixels >> 2, pixels + bytes >> 2); + case 5126: + return HEAPF32.subarray(pixels >> 2, pixels + bytes >> 2); + case 5125: + case 34042: + case 35902: + case 33640: + case 35899: + case 34042: + return HEAPU32.subarray(pixels >> 2, pixels + bytes >> 2); + case 5123: + case 33635: + case 32819: + case 32820: + case 36193: + case 5131: + return HEAPU16.subarray(pixels >> 1, pixels + bytes >> 1); + default: + GL.recordError(1280); + return null; + } +} +function emscriptenWebGLGetHeapForType(type) { + switch (type) { + case 5120: + return HEAP8; + case 5121: + return HEAPU8; + case 5122: + return HEAP16; + case 5123: + case 33635: + case 32819: + case 32820: + case 36193: + case 5131: + return HEAPU16; + case 5124: + return HEAP32; + case 5125: + case 34042: + case 35902: + case 33640: + case 35899: + case 34042: + return HEAPU32; + case 5126: + return HEAPF32; + default: + return null; + } +} +function emscriptenWebGLGetShiftForType(type) { + switch (type) { + case 5120: + case 5121: + return 0; + case 5122: + case 5123: + case 33635: + case 32819: + case 32820: + case 36193: + case 5131: + return 1; + case 5124: + case 5126: + case 5125: + case 34042: + case 35902: + case 33640: + case 35899: + case 34042: + return 2; + default: + return 0; + } +} +function _glReadPixels(x, y, width, height, format, type, pixels) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + if (GLctx.currentPixelPackBufferBinding) { + GLctx.readPixels(x, y, width, height, format, type, pixels); + } else { + GLctx.readPixels(x, y, width, height, format, type, emscriptenWebGLGetHeapForType(type), pixels >> emscriptenWebGLGetShiftForType(type)); + } + return; + } + var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format); + if (!pixelData) { + GL.recordError(1280); + return; + } + GLctx.readPixels(x, y, width, height, format, type, pixelData); +} +function _glRenderbufferStorage(x0, x1, x2, x3) { + GLctx["renderbufferStorage"](x0, x1, x2, x3); +} +function _glRenderbufferStorageMultisample(x0, x1, x2, x3, x4) { + GLctx["renderbufferStorageMultisample"](x0, x1, x2, x3, x4); +} +function _glSamplerParameteri(sampler, pname, param) { + GLctx["samplerParameteri"](sampler ? GL.samplers[sampler] : null, pname, param); +} +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 _glStencilFuncSeparate(x0, x1, x2, x3) { + GLctx["stencilFuncSeparate"](x0, x1, x2, x3); +} +function _glStencilMask(x0) { + GLctx["stencilMask"](x0); +} +function _glStencilOpSeparate(x0, x1, x2, x3) { + GLctx["stencilOpSeparate"](x0, x1, x2, x3); +} +function _glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels); + } else if (pixels != 0) { + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, emscriptenWebGLGetHeapForType(type), pixels >> emscriptenWebGLGetShiftForType(type)); + } else { + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, null); + } + return; + } + var pixelData = null; + if (pixels) pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat); + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixelData); +} +function _glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, pixels); + } else if (pixels != 0) { + GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, emscriptenWebGLGetHeapForType(type), pixels >> emscriptenWebGLGetShiftForType(type)); + } else { + GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, null); + } +} +function _glTexParameterf(x0, x1, x2) { + GLctx["texParameterf"](x0, x1, x2); +} +function _glTexParameteri(x0, x1, x2) { + GLctx["texParameteri"](x0, x1, x2); +} +function _glTexParameteriv(target, pname, params) { + var param = HEAP32[params >> 2]; + GLctx.texParameteri(target, pname, param); +} +function _glTexStorage2D(x0, x1, x2, x3, x4) { + GLctx["texStorage2D"](x0, x1, x2, x3, x4); +} +function _glTexStorage3D(x0, x1, x2, x3, x4, x5) { + GLctx["texStorage3D"](x0, x1, x2, x3, x4, x5); +} +function _glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } else if (pixels != 0) { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, emscriptenWebGLGetHeapForType(type), pixels >> emscriptenWebGLGetShiftForType(type)); + } else { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, null); + } + return; + } + 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 _glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + } else if (pixels != 0) { + GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, emscriptenWebGLGetHeapForType(type), pixels >> emscriptenWebGLGetShiftForType(type)); + } else { + GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null); + } +} +function _glTransformFeedbackVaryings(program, count, varyings, bufferMode) { + program = GL.programs[program]; + var vars = []; + for (var i = 0; i < count; i++) vars.push(Pointer_stringify(HEAP32[varyings + i * 4 >> 2])); + GLctx["transformFeedbackVaryings"](program, vars, bufferMode); +} +function _glUniform1fv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform1fv(GL.uniforms[location], HEAPF32, value >> 2, count); + return; + } + var view; + if (count <= GL.MINI_TEMP_BUFFER_SIZE) { + view = GL.miniTempBufferViews[count - 1]; + for (var i = 0; i < count; ++i) { + view[i] = HEAPF32[value + 4 * i >> 2]; + } + } else { + view = HEAPF32.subarray(value >> 2, value + count * 4 >> 2); + } + GLctx.uniform1fv(GL.uniforms[location], view); +} +function _glUniform1i(location, v0) { + GLctx.uniform1i(GL.uniforms[location], v0); +} +function _glUniform1iv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform1iv(GL.uniforms[location], HEAP32, value >> 2, count); + return; + } + GLctx.uniform1iv(GL.uniforms[location], HEAP32.subarray(value >> 2, value + count * 4 >> 2)); +} +function _glUniform1uiv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform1uiv(GL.uniforms[location], HEAPU32, value >> 2, count); + } else { + GLctx.uniform1uiv(GL.uniforms[location], HEAPU32.subarray(value >> 2, value + count * 4 >> 2)); + } +} +function _glUniform2fv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform2fv(GL.uniforms[location], HEAPF32, value >> 2, count * 2); + return; + } + var view; + if (2 * count <= GL.MINI_TEMP_BUFFER_SIZE) { + view = GL.miniTempBufferViews[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 { + view = HEAPF32.subarray(value >> 2, value + count * 8 >> 2); + } + GLctx.uniform2fv(GL.uniforms[location], view); +} +function _glUniform2iv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform2iv(GL.uniforms[location], HEAP32, value >> 2, count * 2); + return; + } + GLctx.uniform2iv(GL.uniforms[location], HEAP32.subarray(value >> 2, value + count * 8 >> 2)); +} +function _glUniform2uiv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform2uiv(GL.uniforms[location], HEAPU32, value >> 2, count * 2); + } else { + GLctx.uniform2uiv(GL.uniforms[location], HEAPU32.subarray(value >> 2, value + count * 8 >> 2)); + } +} +function _glUniform3fv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform3fv(GL.uniforms[location], HEAPF32, value >> 2, count * 3); + return; + } + var view; + if (3 * count <= GL.MINI_TEMP_BUFFER_SIZE) { + view = GL.miniTempBufferViews[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 { + view = HEAPF32.subarray(value >> 2, value + count * 12 >> 2); + } + GLctx.uniform3fv(GL.uniforms[location], view); +} +function _glUniform3iv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform3iv(GL.uniforms[location], HEAP32, value >> 2, count * 3); + return; + } + GLctx.uniform3iv(GL.uniforms[location], HEAP32.subarray(value >> 2, value + count * 12 >> 2)); +} +function _glUniform3uiv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform3uiv(GL.uniforms[location], HEAPU32, value >> 2, count * 3); + } else { + GLctx.uniform3uiv(GL.uniforms[location], HEAPU32.subarray(value >> 2, value + count * 12 >> 2)); + } +} +function _glUniform4fv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform4fv(GL.uniforms[location], HEAPF32, value >> 2, count * 4); + return; + } + var view; + if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) { + view = GL.miniTempBufferViews[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 { + view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2); + } + GLctx.uniform4fv(GL.uniforms[location], view); +} +function _glUniform4iv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform4iv(GL.uniforms[location], HEAP32, value >> 2, count * 4); + return; + } + GLctx.uniform4iv(GL.uniforms[location], HEAP32.subarray(value >> 2, value + count * 16 >> 2)); +} +function _glUniform4uiv(location, count, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniform4uiv(GL.uniforms[location], HEAPU32, value >> 2, count * 4); + } else { + GLctx.uniform4uiv(GL.uniforms[location], HEAPU32.subarray(value >> 2, value + count * 16 >> 2)); + } +} +function _glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) { + program = GL.programs[program]; + GLctx["uniformBlockBinding"](program, uniformBlockIndex, uniformBlockBinding); +} +function _glUniformMatrix3fv(location, count, transpose, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniformMatrix3fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 9); + return; + } + var view; + if (9 * count <= GL.MINI_TEMP_BUFFER_SIZE) { + view = GL.miniTempBufferViews[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 { + view = HEAPF32.subarray(value >> 2, value + count * 36 >> 2); + } + GLctx.uniformMatrix3fv(GL.uniforms[location], !!transpose, view); +} +function _glUniformMatrix4fv(location, count, transpose, value) { + if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.uniformMatrix4fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 16); + return; + } + var view; + if (16 * count <= GL.MINI_TEMP_BUFFER_SIZE) { + view = GL.miniTempBufferViews[16 * count - 1]; + for (var i = 0; i < 16 * count; i += 16) { + 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]; + view[i + 9] = HEAPF32[value + (4 * i + 36) >> 2]; + view[i + 10] = HEAPF32[value + (4 * i + 40) >> 2]; + view[i + 11] = HEAPF32[value + (4 * i + 44) >> 2]; + view[i + 12] = HEAPF32[value + (4 * i + 48) >> 2]; + view[i + 13] = HEAPF32[value + (4 * i + 52) >> 2]; + view[i + 14] = HEAPF32[value + (4 * i + 56) >> 2]; + view[i + 15] = HEAPF32[value + (4 * i + 60) >> 2]; + } + } else { + view = HEAPF32.subarray(value >> 2, value + count * 64 >> 2); + } + GLctx.uniformMatrix4fv(GL.uniforms[location], !!transpose, view); +} +function _glUnmapBuffer(target) { + if (!emscriptenWebGLValidateMapBufferTarget(target)) { + GL.recordError(1280); + Module.printErr("GL_INVALID_ENUM in glUnmapBuffer"); + return 0; + } + var buffer = emscriptenWebGLGetBufferBinding(target); + var mapping = GL.mappedBuffers[buffer]; + if (!mapping) { + GL.recordError(1282); + Module.printError("buffer was never mapped in glUnmapBuffer"); + return 0; + } + GL.mappedBuffers[buffer] = null; + if (!(mapping.access & 16)) if (GL.currentContext.supportsWebGL2EntryPoints) { + GLctx.bufferSubData(target, mapping.offset, HEAPU8, mapping.mem, mapping.length); + } else { + GLctx.bufferSubData(target, mapping.offset, HEAPU8.subarray(mapping.mem, mapping.mem + mapping.length)); + } + _free(mapping.mem); + return 1; +} +function _glUseProgram(program) { + GLctx.useProgram(program ? GL.programs[program] : null); +} +function _glValidateProgram(program) { + GLctx.validateProgram(GL.programs[program]); +} +function _glVertexAttrib4f(x0, x1, x2, x3, x4) { + GLctx["vertexAttrib4f"](x0, x1, x2, x3, x4); +} +function _glVertexAttrib4fv(index, v) { + GLctx.vertexAttrib4f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2], HEAPF32[v + 12 >> 2]); +} +function _glVertexAttribIPointer(index, size, type, stride, ptr) { + var cb = GL.currentContext.clientBuffers[index]; + assert(cb, index); + if (!GL.currArrayBuffer) { + cb.size = size; + cb.type = type; + cb.normalized = false; + cb.stride = stride; + cb.ptr = ptr; + cb.clientside = true; + return; + } + cb.clientside = false; + GLctx.vertexAttribIPointer(index, size, type, stride, ptr); +} +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); +} +var ___tm_current = STATICTOP; +STATICTOP += 48; +var ___tm_timezone = allocate(intArrayFromString("GMT"), "i8", ALLOC_STATIC); +function _gmtime_r(time, tmPtr) { + var date = new Date(HEAP32[time >> 2] * 1e3); + HEAP32[tmPtr >> 2] = date.getUTCSeconds(); + HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes(); + HEAP32[tmPtr + 8 >> 2] = date.getUTCHours(); + HEAP32[tmPtr + 12 >> 2] = date.getUTCDate(); + HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth(); + HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900; + HEAP32[tmPtr + 24 >> 2] = date.getUTCDay(); + HEAP32[tmPtr + 36 >> 2] = 0; + HEAP32[tmPtr + 32 >> 2] = 0; + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0; + HEAP32[tmPtr + 28 >> 2] = yday; + HEAP32[tmPtr + 40 >> 2] = ___tm_timezone; + return tmPtr; +} +function _gmtime(time) { + return _gmtime_r(time, ___tm_current); +} +function _inet_addr(ptr) { + var addr = __inet_pton4_raw(Pointer_stringify(ptr)); + if (addr === null) { + return -1; + } + return addr; +} +var _llvm_ceil_f32 = Math_ceil; +var _llvm_ceil_f64 = Math_ceil; +var cttz_i8 = allocate([ 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 ], "i8", ALLOC_STATIC); +function _llvm_cttz_i32(x) { + x = x | 0; + var ret = 0; + ret = HEAP8[cttz_i8 + (x & 255) >> 0] | 0; + if ((ret | 0) < 8) return ret | 0; + ret = HEAP8[cttz_i8 + (x >> 8 & 255) >> 0] | 0; + if ((ret | 0) < 8) return ret + 8 | 0; + ret = HEAP8[cttz_i8 + (x >> 16 & 255) >> 0] | 0; + if ((ret | 0) < 8) return ret + 16 | 0; + return (HEAP8[cttz_i8 + (x >>> 24) >> 0] | 0) + 24 | 0; +} +function _llvm_eh_typeid_for(type) { + return type; +} +function _llvm_exp2_f32(x) { + return Math.pow(2, x); +} +var _llvm_fabs_f32 = Math_abs; +var _llvm_fabs_f64 = Math_abs; +var _llvm_floor_f32 = Math_floor; +var _llvm_floor_f64 = Math_floor; +var _llvm_pow_f32 = Math_pow; +var _llvm_pow_f64 = Math_pow; +function _llvm_trap() { + abort("trap!"); +} +var _tzname = STATICTOP; +STATICTOP += 16; +var _daylight = STATICTOP; +STATICTOP += 16; +var _timezone = STATICTOP; +STATICTOP += 16; +function _tzset() { + if (_tzset.called) return; + _tzset.called = true; + HEAP32[_timezone >> 2] = (new Date).getTimezoneOffset() * 60; + var winter = new Date(2e3, 0, 1); + var summer = new Date(2e3, 6, 1); + HEAP32[_daylight >> 2] = Number(winter.getTimezoneOffset() != summer.getTimezoneOffset()); + function extractZone(date) { + var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/); + return match ? match[1] : "GMT"; + } + var winterName = extractZone(winter); + var summerName = extractZone(summer); + var winterNamePtr = allocate(intArrayFromString(winterName), "i8", ALLOC_NORMAL); + var summerNamePtr = allocate(intArrayFromString(summerName), "i8", ALLOC_NORMAL); + if (summer.getTimezoneOffset() < winter.getTimezoneOffset()) { + HEAP32[_tzname >> 2] = winterNamePtr; + HEAP32[_tzname + 4 >> 2] = summerNamePtr; + } else { + HEAP32[_tzname >> 2] = summerNamePtr; + HEAP32[_tzname + 4 >> 2] = winterNamePtr; + } +} +function _localtime_r(time, tmPtr) { + _tzset(); + var date = new Date(HEAP32[time >> 2] * 1e3); + HEAP32[tmPtr >> 2] = date.getSeconds(); + HEAP32[tmPtr + 4 >> 2] = date.getMinutes(); + HEAP32[tmPtr + 8 >> 2] = date.getHours(); + HEAP32[tmPtr + 12 >> 2] = date.getDate(); + HEAP32[tmPtr + 16 >> 2] = date.getMonth(); + HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900; + HEAP32[tmPtr + 24 >> 2] = date.getDay(); + var start = new Date(date.getFullYear(), 0, 1); + var yday = (date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24) | 0; + HEAP32[tmPtr + 28 >> 2] = yday; + HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60); + var summerOffset = (new Date(2e3, 6, 1)).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; + HEAP32[tmPtr + 32 >> 2] = dst; + var zonePtr = HEAP32[_tzname + (dst ? 4 : 0) >> 2]; + HEAP32[tmPtr + 40 >> 2] = zonePtr; + return tmPtr; +} +function _localtime(time) { + return _localtime_r(time, ___tm_current); +} +function _longjmp(env, value) { + Module["setThrew"](env, value || 1); + throw "longjmp"; +} +function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.set(HEAPU8.subarray(src, src + num), dest); + return dest; +} +function _mktime(tmPtr) { + _tzset(); + var date = new Date(HEAP32[tmPtr + 20 >> 2] + 1900, HEAP32[tmPtr + 16 >> 2], HEAP32[tmPtr + 12 >> 2], HEAP32[tmPtr + 8 >> 2], HEAP32[tmPtr + 4 >> 2], HEAP32[tmPtr >> 2], 0); + var dst = HEAP32[tmPtr + 32 >> 2]; + var guessedOffset = date.getTimezoneOffset(); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = (new Date(2e3, 6, 1)).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dstOffset = Math.min(winterOffset, summerOffset); + if (dst < 0) { + HEAP32[tmPtr + 32 >> 2] = Number(summerOffset != winterOffset && dstOffset == guessedOffset); + } else if (dst > 0 != (dstOffset == guessedOffset)) { + var nonDstOffset = Math.max(winterOffset, summerOffset); + var trueOffset = dst > 0 ? dstOffset : nonDstOffset; + date.setTime(date.getTime() + (trueOffset - guessedOffset) * 6e4); + } + HEAP32[tmPtr + 24 >> 2] = date.getDay(); + var yday = (date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24) | 0; + HEAP32[tmPtr + 28 >> 2] = yday; + return date.getTime() / 1e3 | 0; +} +function _pthread_attr_destroy(attr) { + return 0; +} +function _pthread_attr_init(attr) { + return 0; +} +function _pthread_cond_destroy() { + return 0; +} +function _pthread_cond_init() { + return 0; +} +function _pthread_cond_signal() { + return 0; +} +function _pthread_cond_timedwait() { + return 0; +} +function _pthread_cond_wait() { + return 0; +} +function _pthread_create() { + return 11; +} +function _pthread_detach() {} +var PTHREAD_SPECIFIC = {}; +function _pthread_getspecific(key) { + return PTHREAD_SPECIFIC[key] || 0; +} +var PTHREAD_SPECIFIC_NEXT_KEY = 1; +function _pthread_key_create(key, destructor) { + if (key == 0) { + return ERRNO_CODES.EINVAL; + } + HEAP32[key >> 2] = PTHREAD_SPECIFIC_NEXT_KEY; + PTHREAD_SPECIFIC[PTHREAD_SPECIFIC_NEXT_KEY] = 0; + PTHREAD_SPECIFIC_NEXT_KEY++; + return 0; +} +function _pthread_key_delete(key) { + if (key in PTHREAD_SPECIFIC) { + delete PTHREAD_SPECIFIC[key]; + return 0; + } + return ERRNO_CODES.EINVAL; +} +function _pthread_mutex_destroy() {} +function _pthread_mutex_init() {} +function _pthread_mutexattr_destroy() {} +function _pthread_mutexattr_init() {} +function _pthread_mutexattr_setprotocol() {} +function _pthread_mutexattr_settype() {} +function _pthread_once(ptr, func) { + if (!_pthread_once.seen) _pthread_once.seen = {}; + if (ptr in _pthread_once.seen) return; + Module["dynCall_v"](func); + _pthread_once.seen[ptr] = 1; +} +function _pthread_rwlock_init() { + return 0; +} +function _pthread_rwlock_rdlock() { + return 0; +} +function _pthread_rwlock_unlock() { + return 0; +} +function _pthread_rwlock_wrlock() { + return 0; +} +function _pthread_setspecific(key, value) { + if (!(key in PTHREAD_SPECIFIC)) { + return ERRNO_CODES.EINVAL; + } + PTHREAD_SPECIFIC[key] = value; + return 0; +} +function _sched_yield() { + return 0; +} +function _setenv(envname, envval, overwrite) { + if (envname === 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + var name = Pointer_stringify(envname); + var val = Pointer_stringify(envval); + if (name === "" || name.indexOf("=") !== -1) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + if (ENV.hasOwnProperty(name) && !overwrite) return 0; + ENV[name] = val; + ___buildEnvironment(ENV); + return 0; +} +function _sigaction(signum, act, oldact) { + Module.printErr("Calling stub instead of sigaction()"); + return 0; +} +function _sigemptyset(set) { + HEAP32[set >> 2] = 0; + 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 ? Pointer_stringify(tm_zone) : "" + }; + var pattern = Pointer_stringify(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" + }; + 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) { + var day = new Date(date.tm_year + 1900, date.tm_mon + 1, date.tm_mday, 0, 0, 0, 0); + return day.getDay() || 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) { + var day = new Date(date.tm_year + 1900, date.tm_mon + 1, date.tm_mday, 0, 0, 0, 0); + return day.getDay(); + }), + "%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 _sysconf(name) { + switch (name) { + case 30: + return PAGE_SIZE; + case 85: + var maxHeapSize = 2 * 1024 * 1024 * 1024 - 65536; + return maxHeapSize / PAGE_SIZE; + case 132: + case 133: + case 12: + case 137: + case 138: + case 15: + case 235: + case 16: + case 17: + case 18: + case 19: + case 20: + case 149: + case 13: + case 10: + case 236: + case 153: + case 9: + case 21: + case 22: + case 159: + case 154: + case 14: + case 77: + case 78: + case 139: + case 80: + case 81: + case 82: + case 68: + case 67: + case 164: + case 11: + case 29: + case 47: + case 48: + case 95: + case 52: + case 51: + case 46: + return 200809; + case 79: + return 0; + case 27: + case 246: + case 127: + case 128: + case 23: + case 24: + case 160: + case 161: + case 181: + case 182: + case 242: + case 183: + case 184: + case 243: + case 244: + case 245: + case 165: + case 178: + case 179: + case 49: + case 50: + case 168: + case 169: + case 175: + case 170: + case 171: + case 172: + case 97: + case 76: + case 32: + case 173: + case 35: + return -1; + case 176: + case 177: + case 7: + case 155: + case 8: + case 157: + case 125: + case 126: + case 92: + case 93: + case 129: + case 130: + case 131: + case 94: + case 91: + return 1; + case 74: + case 60: + case 69: + case 70: + case 4: + return 1024; + case 31: + case 42: + case 72: + return 32; + case 87: + case 26: + case 33: + return 2147483647; + case 34: + case 1: + return 47839; + case 38: + case 36: + return 99; + case 43: + case 37: + return 2048; + case 0: + return 2097152; + case 3: + return 65536; + case 28: + return 32768; + case 44: + return 32767; + case 75: + return 16384; + case 39: + return 1e3; + case 89: + return 700; + case 71: + return 256; + case 40: + return 255; + case 2: + return 100; + case 180: + return 64; + case 25: + return 20; + case 5: + return 16; + case 6: + return 6; + case 73: + return 4; + case 84: + { + if (typeof navigator === "object") return navigator["hardwareConcurrency"] || 1; + return 1; + } + } + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; +} +function _time(ptr) { + var ret = Date.now() / 1e3 | 0; + if (ptr) { + HEAP32[ptr >> 2] = ret; + } + return ret; +} +function _unsetenv(name) { + if (name === 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + name = Pointer_stringify(name); + if (name === "" || name.indexOf("=") !== -1) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + if (ENV.hasOwnProperty(name)) { + delete ENV[name]; + ___buildEnvironment(ENV); + } + return 0; +} +function _utime(path, times) { + var time; + if (times) { + var offset = 4; + time = HEAP32[times + offset >> 2]; + time *= 1e3; + } else { + time = Date.now(); + } + path = Pointer_stringify(path); + try { + FS.utime(path, time, time); + return 0; + } catch (e) { + FS.handleFSError(e); + return -1; + } +} +FS.staticInit(); +__ATINIT__.unshift((function() { + if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); +})); +__ATMAIN__.push((function() { + FS.ignorePermissions = false; +})); +__ATEXIT__.push((function() { + FS.quit(); +})); +Module["FS_createPath"] = FS.createPath; +Module["FS_createDataFile"] = FS.createDataFile; +__ATINIT__.unshift((function() { + TTY.init(); +})); +__ATEXIT__.push((function() { + TTY.shutdown(); +})); +if (ENVIRONMENT_IS_NODE) { + var fs = require("fs"); + var NODEJS_PATH = require("path"); + NODEFS.staticInit(); +} +Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas, vrDevice) { + Module.printErr("Module.requestFullScreen is deprecated. Please call Module.requestFullscreen instead."); + Module["requestFullScreen"] = Module["requestFullscreen"]; + Browser.requestFullScreen(lockPointer, resizeCanvas, vrDevice); +}; +Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas, vrDevice) { + Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice); +}; +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); +}; +if (ENVIRONMENT_IS_NODE) { + _emscripten_get_now = function _emscripten_get_now_actual() { + var t = process["hrtime"](); + return t[0] * 1e3 + t[1] / 1e6; + }; +} else if (typeof dateNow !== "undefined") { + _emscripten_get_now = dateNow; +} else if (typeof self === "object" && self["performance"] && typeof self["performance"]["now"] === "function") { + _emscripten_get_now = (function() { + return self["performance"]["now"](); + }); +} else if (typeof performance === "object" && typeof performance["now"] === "function") { + _emscripten_get_now = (function() { + return performance["now"](); + }); +} else { + _emscripten_get_now = Date.now; +} +___buildEnvironment(ENV); +__ATINIT__.push((function() { + SOCKFS.root = FS.mount(SOCKFS, {}, null); +})); +__ATINIT__.push((function() { + PIPEFS.root = FS.mount(PIPEFS, {}, null); +})); +JSEvents.staticInit(); +var GLctx; +GL.init(); +DYNAMICTOP_PTR = staticAlloc(4); +STACK_BASE = STACKTOP = alignMemory(STATICTOP); +STACK_MAX = STACK_BASE + TOTAL_STACK; +DYNAMIC_BASE = alignMemory(STACK_MAX); +HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE; +staticSealed = true; +assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack"); +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 nullFunc_dddi(x) { + Module["printErr"]("Invalid function pointer called with signature 'dddi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ddi(x) { + Module["printErr"]("Invalid function pointer called with signature 'ddi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_dfi(x) { + Module["printErr"]("Invalid function pointer called with signature 'dfi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_di(x) { + Module["printErr"]("Invalid function pointer called with signature 'di'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_diddi(x) { + Module["printErr"]("Invalid function pointer called with signature 'diddi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_didi(x) { + Module["printErr"]("Invalid function pointer called with signature 'didi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_dii(x) { + Module["printErr"]("Invalid function pointer called with signature 'dii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_diii(x) { + Module["printErr"]("Invalid function pointer called with signature 'diii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_diiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'diiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_diji(x) { + Module["printErr"]("Invalid function pointer called with signature 'diji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_dji(x) { + Module["printErr"]("Invalid function pointer called with signature 'dji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_f(x) { + Module["printErr"]("Invalid function pointer called with signature 'f'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fdi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fdi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ff(x) { + Module["printErr"]("Invalid function pointer called with signature 'ff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fff(x) { + Module["printErr"]("Invalid function pointer called with signature 'fff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ffffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'ffffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fffifffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fffifffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'ffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fidi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fidi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fif(x) { + Module["printErr"]("Invalid function pointer called with signature 'fif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiff(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'fifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fii(x) { + Module["printErr"]("Invalid function pointer called with signature 'fii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiiiiiifiifif(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiiiiiifiifif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fiiiiiifiiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'fiiiiiifiiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_fji(x) { + Module["printErr"]("Invalid function pointer called with signature 'fji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_i(x) { + Module["printErr"]("Invalid function pointer called with signature 'i'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iddi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iddi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_idi(x) { + Module["printErr"]("Invalid function pointer called with signature 'idi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_idiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'idiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ifffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'ifffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'ifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'ifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ii(x) { + Module["printErr"]("Invalid function pointer called with signature 'ii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiddi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiddi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiddiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiddiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iidi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iidi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iidii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iidii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iidiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iidiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iif(x) { + Module["printErr"]("Invalid function pointer called with signature 'iif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iifff(x) { + Module["printErr"]("Invalid function pointer called with signature 'iifff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iifffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iifffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiffiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiffiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiidii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiidii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiidiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiidiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiifiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiifiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiidii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiidii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiifffffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiifffffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiifiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiifiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiifiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiifiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiifiiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiifiiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiifiiiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiifiiiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiifffiiifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiifffiiifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiffiiiiiiiiiffffiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiffiiiiiiiiiffffiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiffiiiiiiiiiffffiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiffiiiiiiiiiffffiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiffiiiiiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiffiiiiiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiifiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiifiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiifiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiifiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiij(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiijjiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiijjiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiij(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiijijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiijijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiijjii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiijjii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiijjiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiijjiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiij(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiijjii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiijjii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiijjiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiijjiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iij(x) { + Module["printErr"]("Invalid function pointer called with signature 'iij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iijjii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iijjii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iijjiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'iijjiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iijjji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iijjji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ij(x) { + Module["printErr"]("Invalid function pointer called with signature 'ij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_iji(x) { + Module["printErr"]("Invalid function pointer called with signature 'iji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'ijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ijiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'ijiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ijiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'ijiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ijiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'ijiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ijj(x) { + Module["printErr"]("Invalid function pointer called with signature 'ijj'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'ijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_j(x) { + Module["printErr"]("Invalid function pointer called with signature 'j'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jdi(x) { + Module["printErr"]("Invalid function pointer called with signature 'jdi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jdii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jdii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jfi(x) { + Module["printErr"]("Invalid function pointer called with signature 'jfi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_ji(x) { + Module["printErr"]("Invalid function pointer called with signature 'ji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jidi(x) { + Module["printErr"]("Invalid function pointer called with signature 'jidi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jidii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jidii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'jifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'jiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'jiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jijj(x) { + Module["printErr"]("Invalid function pointer called with signature 'jijj'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'jijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jji(x) { + Module["printErr"]("Invalid function pointer called with signature 'jji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jjii(x) { + Module["printErr"]("Invalid function pointer called with signature 'jjii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_jjjji(x) { + Module["printErr"]("Invalid function pointer called with signature 'jjjji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_v(x) { + Module["printErr"]("Invalid function pointer called with signature 'v'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vd(x) { + Module["printErr"]("Invalid function pointer called with signature 'vd'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vf(x) { + Module["printErr"]("Invalid function pointer called with signature 'vf'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vff(x) { + Module["printErr"]("Invalid function pointer called with signature 'vff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vffff(x) { + Module["printErr"]("Invalid function pointer called with signature 'vffff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vfi(x) { + Module["printErr"]("Invalid function pointer called with signature 'vfi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vi(x) { + Module["printErr"]("Invalid function pointer called with signature 'vi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vid(x) { + Module["printErr"]("Invalid function pointer called with signature 'vid'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vidi(x) { + Module["printErr"]("Invalid function pointer called with signature 'vidi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vidiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vidiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vif(x) { + Module["printErr"]("Invalid function pointer called with signature 'vif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viff(x) { + Module["printErr"]("Invalid function pointer called with signature 'viff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vifff(x) { + Module["printErr"]("Invalid function pointer called with signature 'vifff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viffff(x) { + Module["printErr"]("Invalid function pointer called with signature 'viffff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vifffffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'vifffffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viffffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viffffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viffffii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viffffii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vifffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'vifffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vifffii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vifffii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viffii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viffii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viffiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viffiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'vifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vifiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vifiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viidi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viidi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viidii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viidii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viif(x) { + Module["printErr"]("Invalid function pointer called with signature 'viif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiff(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viifff(x) { + Module["printErr"]("Invalid function pointer called with signature 'viifff'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viifffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viifffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiffii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiffii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viifiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viifiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiffii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiffii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiififfi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiififfi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiififi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiififi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiifiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiifiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiffffii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiffffii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiifiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiifiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiifiiiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiifiiiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiffi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiffi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiffii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiffii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiifi(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiifi'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiif(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiif'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiiifii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiiifii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiiiiiiiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiiiiiiiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiiiijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiiiijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiij(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiijiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiijiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiijjiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiijjiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiijjii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiijjii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiijjiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiijjiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viij(x) { + Module["printErr"]("Invalid function pointer called with signature 'viij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijiijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijiijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijjii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijjii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijjiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijjiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viijjji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viijjji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vij(x) { + Module["printErr"]("Invalid function pointer called with signature 'vij'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_viji(x) { + Module["printErr"]("Invalid function pointer called with signature 'viji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vijii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vijii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vijiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vijiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vijiji(x) { + Module["printErr"]("Invalid function pointer called with signature 'vijiji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vijijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'vijijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vijji(x) { + Module["printErr"]("Invalid function pointer called with signature 'vijji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vijjii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vijjii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vijjji(x) { + Module["printErr"]("Invalid function pointer called with signature 'vijjji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vjiiii(x) { + Module["printErr"]("Invalid function pointer called with signature 'vjiiii'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +function nullFunc_vjji(x) { + Module["printErr"]("Invalid function pointer called with signature 'vjji'. 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)"); + Module["printErr"]("Build with ASSERTIONS=2 for more info."); + abort(x); +} +Module["wasmTableSize"] = 88587; +Module["wasmMaxTableSize"] = 88587; +function invoke_dddi(index, a1, a2, a3) { + try { + return Module["dynCall_dddi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ddi(index, a1, a2) { + try { + return Module["dynCall_ddi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_dfi(index, a1, a2) { + try { + return Module["dynCall_dfi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_di(index, a1) { + try { + return Module["dynCall_di"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_diddi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_diddi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_didi(index, a1, a2, a3) { + try { + return Module["dynCall_didi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_dii(index, a1, a2) { + try { + return Module["dynCall_dii"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_diii(index, a1, a2, a3) { + try { + return Module["dynCall_diii"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_diiii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_diiii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_diji(index, a1, a2, a3, a4) { + try { + return Module["dynCall_diji"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_dji(index, a1, a2, a3) { + try { + return Module["dynCall_dji"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_f(index) { + try { + return Module["dynCall_f"](index); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fdi(index, a1, a2) { + try { + return Module["dynCall_fdi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ff(index, a1) { + try { + return Module["dynCall_ff"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fff(index, a1, a2) { + try { + return Module["dynCall_fff"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ffffi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_ffffi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fffi(index, a1, a2, a3) { + try { + return Module["dynCall_fffi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fffifffi(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_fffifffi"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ffi(index, a1, a2) { + try { + return Module["dynCall_ffi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fi(index, a1) { + try { + return Module["dynCall_fi"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fidi(index, a1, a2, a3) { + try { + return Module["dynCall_fidi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fif(index, a1, a2) { + try { + return Module["dynCall_fif"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiff(index, a1, a2, a3) { + try { + return Module["dynCall_fiff"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiffi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_fiffi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fifi(index, a1, a2, a3) { + try { + return Module["dynCall_fifi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fifii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_fifii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fii(index, a1, a2) { + try { + return Module["dynCall_fii"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiifi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_fiifi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiifii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_fiifii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiii(index, a1, a2, a3) { + try { + return Module["dynCall_fiii"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiiii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_fiiii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiiiif(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_fiiiif"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiiiii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_fiiiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiiiiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_fiiiiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiiiiiifiifif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + try { + return Module["dynCall_fiiiiiifiifif"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fiiiiiifiiiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + try { + return Module["dynCall_fiiiiiifiiiif"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_fji(index, a1, a2, a3) { + try { + return Module["dynCall_fji"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_i(index) { + try { + return Module["dynCall_i"](index); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iddi(index, a1, a2, a3) { + try { + return Module["dynCall_iddi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_idi(index, a1, a2) { + try { + return Module["dynCall_idi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_idiii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_idiii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ifffi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_ifffi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iffi(index, a1, a2, a3) { + try { + return Module["dynCall_iffi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ifi(index, a1, a2) { + try { + return Module["dynCall_ifi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ifiii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_ifiii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ii(index, a1) { + try { + return Module["dynCall_ii"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiddi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iiddi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiddiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiddiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iidi(index, a1, a2, a3) { + try { + return Module["dynCall_iidi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iidii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iidii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iidiii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iidiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iif(index, a1, a2) { + try { + return Module["dynCall_iif"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iifff(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iifff"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iifffi(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iifffi"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiffi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iiffi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiffiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiffiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iifi(index, a1, a2, a3) { + try { + return Module["dynCall_iifi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iifii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iifii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iifiii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iifiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iii(index, a1, a2) { + try { + return Module["dynCall_iii"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiidii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iiidii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiidiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiidiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiif(index, a1, a2, a3) { + try { + return Module["dynCall_iiif"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiifi(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iiifi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiifii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iiifii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiifiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiifiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiifiiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iiifiiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiii(index, a1, a2, a3) { + try { + return Module["dynCall_iiii"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiidii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiiidii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiifffffi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + return Module["dynCall_iiiifffffi"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiifi(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iiiifi"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiifii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiiifii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiifiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iiiifiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiifiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_iiiifiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + return Module["dynCall_iiiifiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iiiii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiifi(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiiiifi"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_iiiiifiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiifiiiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + return Module["dynCall_iiiiifiiiif"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiifiiiiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + return Module["dynCall_iiiiifiiiiif"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iiiiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiifffiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { + try { + return Module["dynCall_iiiiiifffiiifiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiffiiiiiiiiiffffiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) { + try { + return Module["dynCall_iiiiiiffiiiiiiiiiffffiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiffiiiiiiiiiffffiiii(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) { + try { + return Module["dynCall_iiiiiiffiiiiiiiiiffffiiii"](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); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiffiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) { + try { + return Module["dynCall_iiiiiiffiiiiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiifiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + return Module["dynCall_iiiiiifiif"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + return Module["dynCall_iiiiiifiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiiiiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiifiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + return Module["dynCall_iiiiiiifiif"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_iiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + return Module["dynCall_iiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + return Module["dynCall_iiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + return Module["dynCall_iiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + try { + return Module["dynCall_iiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + try { + return Module["dynCall_iiiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiij(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiiiij"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiiji(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iiiiiji"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiijjiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + try { + return Module["dynCall_iiiiijjiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiij(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iiiij"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiiji(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiiiji"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiijii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iiiijii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiijiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_iiiijiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiijijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + return Module["dynCall_iiiijijii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + return Module["dynCall_iiiijjii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiijjiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + return Module["dynCall_iiiijjiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiij(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iiij"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiiji(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iiiji"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiijii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iiijii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiijiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iiijiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiijji(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iiijji"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_iiijjii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiijjiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + return Module["dynCall_iiijjiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iij(index, a1, a2, a3) { + try { + return Module["dynCall_iij"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iiji(index, a1, a2, a3, a4) { + try { + return Module["dynCall_iiji"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iijii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_iijii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iijiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iijiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iijji(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_iijji"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iijjii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_iijjii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_iijjiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iijjji(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_iijjji"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ij(index, a1, a2) { + try { + return Module["dynCall_ij"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_iji(index, a1, a2, a3) { + try { + return Module["dynCall_iji"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ijiii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_ijiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ijiiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_ijiiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ijiiiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_ijiiiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ijiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + return Module["dynCall_ijiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ijj(index, a1, a2, a3, a4) { + try { + return Module["dynCall_ijj"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ijji(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_ijji"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_j(index) { + try { + return Module["dynCall_j"](index); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jdi(index, a1, a2) { + try { + return Module["dynCall_jdi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jdii(index, a1, a2, a3) { + try { + return Module["dynCall_jdii"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jfi(index, a1, a2) { + try { + return Module["dynCall_jfi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_ji(index, a1) { + try { + return Module["dynCall_ji"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jidi(index, a1, a2, a3) { + try { + return Module["dynCall_jidi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jidii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_jidii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jifi(index, a1, a2, a3) { + try { + return Module["dynCall_jifi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jii(index, a1, a2) { + try { + return Module["dynCall_jii"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jiii(index, a1, a2, a3) { + try { + return Module["dynCall_jiii"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jiiii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_jiiii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jiiiii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_jiiiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jiiiiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_jiiiiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + return Module["dynCall_jiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jiiji(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_jiiji"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jiji(index, a1, a2, a3, a4) { + try { + return Module["dynCall_jiji"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jijii(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_jijii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jijiii(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_jijiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jijj(index, a1, a2, a3, a4, a5) { + try { + return Module["dynCall_jijj"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jijji(index, a1, a2, a3, a4, a5, a6) { + try { + return Module["dynCall_jijji"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jji(index, a1, a2, a3) { + try { + return Module["dynCall_jji"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jjii(index, a1, a2, a3, a4) { + try { + return Module["dynCall_jjii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_jjjji(index, a1, a2, a3, a4, a5, a6, a7) { + try { + return Module["dynCall_jjjji"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_v(index) { + try { + Module["dynCall_v"](index); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vd(index, a1) { + try { + Module["dynCall_vd"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vf(index, a1) { + try { + Module["dynCall_vf"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vff(index, a1, a2) { + try { + Module["dynCall_vff"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vffff(index, a1, a2, a3, a4) { + try { + Module["dynCall_vffff"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vfi(index, a1, a2) { + try { + Module["dynCall_vfi"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vi(index, a1) { + try { + Module["dynCall_vi"](index, a1); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vid(index, a1, a2) { + try { + Module["dynCall_vid"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vidi(index, a1, a2, a3) { + try { + Module["dynCall_vidi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vidiii(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_vidiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vif(index, a1, a2) { + try { + Module["dynCall_vif"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viff(index, a1, a2, a3) { + try { + Module["dynCall_viff"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vifff(index, a1, a2, a3, a4) { + try { + Module["dynCall_vifff"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viffff(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viffff"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vifffffi(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_vifffffi"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viffffi(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viffffi"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viffffii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viffffii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vifffi(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_vifffi"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vifffii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_vifffii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viffi(index, a1, a2, a3, a4) { + try { + Module["dynCall_viffi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viffii(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viffii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viffiii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viffiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vifi(index, a1, a2, a3) { + try { + Module["dynCall_vifi"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vifii(index, a1, a2, a3, a4) { + try { + Module["dynCall_vifii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vifiiii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_vifiiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vii(index, a1, a2) { + try { + Module["dynCall_vii"](index, a1, a2); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viidi(index, a1, a2, a3, a4) { + try { + Module["dynCall_viidi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viidii(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viidii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viif(index, a1, a2, a3) { + try { + Module["dynCall_viif"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiff(index, a1, a2, a3, a4) { + try { + Module["dynCall_viiff"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viifff(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viifff"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viifffi(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viifffi"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiffi(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viiffi"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiffii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viiffii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viifi(index, a1, a2, a3, a4) { + try { + Module["dynCall_viifi"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viifii(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viifii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viifiii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viifiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viifiiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viifiiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viii(index, a1, a2, a3) { + try { + Module["dynCall_viii"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiffi(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viiiffi"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiffii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiiffii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiifi(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viiifi"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiififfi(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viiififfi"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiififi(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiififi"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiifii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viiifii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiifiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiifiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viiifiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiii(index, a1, a2, a3, a4) { + try { + Module["dynCall_viiii"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiif(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viiiif"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiffffii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + Module["dynCall_viiiiffffii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiifii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiiifii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiifiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viiiifiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiifiiiiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + Module["dynCall_viiiifiiiiif"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiii(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viiiii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiif(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viiiiif"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiffi(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viiiiiffi"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiffii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viiiiiffii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiifi(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiiiifi"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viiiiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiif(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiiiiif"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiiiiii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + Module["dynCall_viiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + Module["dynCall_viiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiiifii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + try { + Module["dynCall_viiiiiiiiiiifii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + try { + Module["dynCall_viiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { + try { + Module["dynCall_viiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { + try { + Module["dynCall_viiiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { + try { + Module["dynCall_viiiiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) { + try { + Module["dynCall_viiiiiiiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { + try { + Module["dynCall_viiiiiiiiiji"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + Module["dynCall_viiiiiiiji"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + Module["dynCall_viiiiiiijii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiij(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiiiij"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viiiiijii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiiji(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viiiiji"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viiiijii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiijiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + Module["dynCall_viiiijiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + Module["dynCall_viiiijjiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiiji(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viiiji"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiijji(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viiijji"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viiijjii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + Module["dynCall_viiijjiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viij(index, a1, a2, a3, a4) { + try { + Module["dynCall_viij"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viiji(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_viiji"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_viijii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viijiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijiijiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { + try { + Module["dynCall_viijiijiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijijii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viijijii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijijiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + try { + Module["dynCall_viijijiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijji(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_viijji"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijjii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_viijjii"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viijjiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viijjji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_viijjji"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vij(index, a1, a2, a3) { + try { + Module["dynCall_vij"](index, a1, a2, a3); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_viji(index, a1, a2, a3, a4) { + try { + Module["dynCall_viji"](index, a1, a2, a3, a4); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vijii(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_vijii"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vijiii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_vijiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vijiji(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_vijiji"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vijijji(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + try { + Module["dynCall_vijijji"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vijji(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_vijji"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vijjii(index, a1, a2, a3, a4, a5, a6, a7) { + try { + Module["dynCall_vijjii"](index, a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vijjji(index, a1, a2, a3, a4, a5, a6, a7, a8) { + try { + Module["dynCall_vijjji"](index, a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vjiiii(index, a1, a2, a3, a4, a5, a6) { + try { + Module["dynCall_vjiiii"](index, a1, a2, a3, a4, a5, a6); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +function invoke_vjji(index, a1, a2, a3, a4, a5) { + try { + Module["dynCall_vjji"](index, a1, a2, a3, a4, a5); + } catch (e) { + if (typeof e !== "number" && e !== "longjmp") throw e; + Module["setThrew"](1, 0); + } +} +Module.asmGlobalArg = {}; +Module.asmLibraryArg = { + "abort": abort, + "assert": assert, + "enlargeMemory": enlargeMemory, + "getTotalMemory": getTotalMemory, + "abortOnCannotGrowMemory": abortOnCannotGrowMemory, + "abortStackOverflow": abortStackOverflow, + "nullFunc_dddi": nullFunc_dddi, + "nullFunc_ddi": nullFunc_ddi, + "nullFunc_dfi": nullFunc_dfi, + "nullFunc_di": nullFunc_di, + "nullFunc_diddi": nullFunc_diddi, + "nullFunc_didi": nullFunc_didi, + "nullFunc_dii": nullFunc_dii, + "nullFunc_diii": nullFunc_diii, + "nullFunc_diiii": nullFunc_diiii, + "nullFunc_diji": nullFunc_diji, + "nullFunc_dji": nullFunc_dji, + "nullFunc_f": nullFunc_f, + "nullFunc_fdi": nullFunc_fdi, + "nullFunc_ff": nullFunc_ff, + "nullFunc_fff": nullFunc_fff, + "nullFunc_ffffi": nullFunc_ffffi, + "nullFunc_fffi": nullFunc_fffi, + "nullFunc_fffifffi": nullFunc_fffifffi, + "nullFunc_ffi": nullFunc_ffi, + "nullFunc_fi": nullFunc_fi, + "nullFunc_fidi": nullFunc_fidi, + "nullFunc_fif": nullFunc_fif, + "nullFunc_fiff": nullFunc_fiff, + "nullFunc_fiffi": nullFunc_fiffi, + "nullFunc_fifi": nullFunc_fifi, + "nullFunc_fifii": nullFunc_fifii, + "nullFunc_fii": nullFunc_fii, + "nullFunc_fiifi": nullFunc_fiifi, + "nullFunc_fiifii": nullFunc_fiifii, + "nullFunc_fiii": nullFunc_fiii, + "nullFunc_fiiii": nullFunc_fiiii, + "nullFunc_fiiiif": nullFunc_fiiiif, + "nullFunc_fiiiii": nullFunc_fiiiii, + "nullFunc_fiiiiii": nullFunc_fiiiiii, + "nullFunc_fiiiiiifiifif": nullFunc_fiiiiiifiifif, + "nullFunc_fiiiiiifiiiif": nullFunc_fiiiiiifiiiif, + "nullFunc_fji": nullFunc_fji, + "nullFunc_i": nullFunc_i, + "nullFunc_iddi": nullFunc_iddi, + "nullFunc_idi": nullFunc_idi, + "nullFunc_idiii": nullFunc_idiii, + "nullFunc_ifffi": nullFunc_ifffi, + "nullFunc_iffi": nullFunc_iffi, + "nullFunc_ifi": nullFunc_ifi, + "nullFunc_ifiii": nullFunc_ifiii, + "nullFunc_ii": nullFunc_ii, + "nullFunc_iiddi": nullFunc_iiddi, + "nullFunc_iiddiii": nullFunc_iiddiii, + "nullFunc_iidi": nullFunc_iidi, + "nullFunc_iidii": nullFunc_iidii, + "nullFunc_iidiii": nullFunc_iidiii, + "nullFunc_iif": nullFunc_iif, + "nullFunc_iifff": nullFunc_iifff, + "nullFunc_iifffi": nullFunc_iifffi, + "nullFunc_iiffi": nullFunc_iiffi, + "nullFunc_iiffiii": nullFunc_iiffiii, + "nullFunc_iifi": nullFunc_iifi, + "nullFunc_iifii": nullFunc_iifii, + "nullFunc_iifiii": nullFunc_iifiii, + "nullFunc_iii": nullFunc_iii, + "nullFunc_iiidii": nullFunc_iiidii, + "nullFunc_iiidiii": nullFunc_iiidiii, + "nullFunc_iiif": nullFunc_iiif, + "nullFunc_iiifi": nullFunc_iiifi, + "nullFunc_iiifii": nullFunc_iiifii, + "nullFunc_iiifiii": nullFunc_iiifiii, + "nullFunc_iiifiiii": nullFunc_iiifiiii, + "nullFunc_iiii": nullFunc_iiii, + "nullFunc_iiiidii": nullFunc_iiiidii, + "nullFunc_iiiifffffi": nullFunc_iiiifffffi, + "nullFunc_iiiifi": nullFunc_iiiifi, + "nullFunc_iiiifii": nullFunc_iiiifii, + "nullFunc_iiiifiii": nullFunc_iiiifiii, + "nullFunc_iiiifiiii": nullFunc_iiiifiiii, + "nullFunc_iiiifiiiii": nullFunc_iiiifiiiii, + "nullFunc_iiiii": nullFunc_iiiii, + "nullFunc_iiiiifi": nullFunc_iiiiifi, + "nullFunc_iiiiifiii": nullFunc_iiiiifiii, + "nullFunc_iiiiifiiiif": nullFunc_iiiiifiiiif, + "nullFunc_iiiiifiiiiif": nullFunc_iiiiifiiiiif, + "nullFunc_iiiiii": nullFunc_iiiiii, + "nullFunc_iiiiiifffiiifiii": nullFunc_iiiiiifffiiifiii, + "nullFunc_iiiiiiffiiiiiiiiiffffiii": nullFunc_iiiiiiffiiiiiiiiiffffiii, + "nullFunc_iiiiiiffiiiiiiiiiffffiiii": nullFunc_iiiiiiffiiiiiiiiiffffiiii, + "nullFunc_iiiiiiffiiiiiiiiiiiiiii": nullFunc_iiiiiiffiiiiiiiiiiiiiii, + "nullFunc_iiiiiifiif": nullFunc_iiiiiifiif, + "nullFunc_iiiiiifiii": nullFunc_iiiiiifiii, + "nullFunc_iiiiiii": nullFunc_iiiiiii, + "nullFunc_iiiiiiifiif": nullFunc_iiiiiiifiif, + "nullFunc_iiiiiiii": nullFunc_iiiiiiii, + "nullFunc_iiiiiiiii": nullFunc_iiiiiiiii, + "nullFunc_iiiiiiiiii": nullFunc_iiiiiiiiii, + "nullFunc_iiiiiiiiiii": nullFunc_iiiiiiiiiii, + "nullFunc_iiiiiiiiiiii": nullFunc_iiiiiiiiiiii, + "nullFunc_iiiiiiiiiiiii": nullFunc_iiiiiiiiiiiii, + "nullFunc_iiiiiiiiiiiiii": nullFunc_iiiiiiiiiiiiii, + "nullFunc_iiiiij": nullFunc_iiiiij, + "nullFunc_iiiiiji": nullFunc_iiiiiji, + "nullFunc_iiiiijjiiiii": nullFunc_iiiiijjiiiii, + "nullFunc_iiiij": nullFunc_iiiij, + "nullFunc_iiiiji": nullFunc_iiiiji, + "nullFunc_iiiijii": nullFunc_iiiijii, + "nullFunc_iiiijiii": nullFunc_iiiijiii, + "nullFunc_iiiijijii": nullFunc_iiiijijii, + "nullFunc_iiiijjii": nullFunc_iiiijjii, + "nullFunc_iiiijjiiii": nullFunc_iiiijjiiii, + "nullFunc_iiij": nullFunc_iiij, + "nullFunc_iiiji": nullFunc_iiiji, + "nullFunc_iiijii": nullFunc_iiijii, + "nullFunc_iiijiii": nullFunc_iiijiii, + "nullFunc_iiijji": nullFunc_iiijji, + "nullFunc_iiijjii": nullFunc_iiijjii, + "nullFunc_iiijjiiii": nullFunc_iiijjiiii, + "nullFunc_iij": nullFunc_iij, + "nullFunc_iiji": nullFunc_iiji, + "nullFunc_iijii": nullFunc_iijii, + "nullFunc_iijiii": nullFunc_iijiii, + "nullFunc_iijji": nullFunc_iijji, + "nullFunc_iijjii": nullFunc_iijjii, + "nullFunc_iijjiii": nullFunc_iijjiii, + "nullFunc_iijjji": nullFunc_iijjji, + "nullFunc_ij": nullFunc_ij, + "nullFunc_iji": nullFunc_iji, + "nullFunc_ijiii": nullFunc_ijiii, + "nullFunc_ijiiii": nullFunc_ijiiii, + "nullFunc_ijiiiii": nullFunc_ijiiiii, + "nullFunc_ijiiiiii": nullFunc_ijiiiiii, + "nullFunc_ijj": nullFunc_ijj, + "nullFunc_ijji": nullFunc_ijji, + "nullFunc_j": nullFunc_j, + "nullFunc_jdi": nullFunc_jdi, + "nullFunc_jdii": nullFunc_jdii, + "nullFunc_jfi": nullFunc_jfi, + "nullFunc_ji": nullFunc_ji, + "nullFunc_jidi": nullFunc_jidi, + "nullFunc_jidii": nullFunc_jidii, + "nullFunc_jifi": nullFunc_jifi, + "nullFunc_jii": nullFunc_jii, + "nullFunc_jiii": nullFunc_jiii, + "nullFunc_jiiii": nullFunc_jiiii, + "nullFunc_jiiiii": nullFunc_jiiiii, + "nullFunc_jiiiiii": nullFunc_jiiiiii, + "nullFunc_jiiiiiiiiii": nullFunc_jiiiiiiiiii, + "nullFunc_jiiji": nullFunc_jiiji, + "nullFunc_jiji": nullFunc_jiji, + "nullFunc_jijii": nullFunc_jijii, + "nullFunc_jijiii": nullFunc_jijiii, + "nullFunc_jijj": nullFunc_jijj, + "nullFunc_jijji": nullFunc_jijji, + "nullFunc_jji": nullFunc_jji, + "nullFunc_jjii": nullFunc_jjii, + "nullFunc_jjjji": nullFunc_jjjji, + "nullFunc_v": nullFunc_v, + "nullFunc_vd": nullFunc_vd, + "nullFunc_vf": nullFunc_vf, + "nullFunc_vff": nullFunc_vff, + "nullFunc_vffff": nullFunc_vffff, + "nullFunc_vfi": nullFunc_vfi, + "nullFunc_vi": nullFunc_vi, + "nullFunc_vid": nullFunc_vid, + "nullFunc_vidi": nullFunc_vidi, + "nullFunc_vidiii": nullFunc_vidiii, + "nullFunc_vif": nullFunc_vif, + "nullFunc_viff": nullFunc_viff, + "nullFunc_vifff": nullFunc_vifff, + "nullFunc_viffff": nullFunc_viffff, + "nullFunc_vifffffi": nullFunc_vifffffi, + "nullFunc_viffffi": nullFunc_viffffi, + "nullFunc_viffffii": nullFunc_viffffii, + "nullFunc_vifffi": nullFunc_vifffi, + "nullFunc_vifffii": nullFunc_vifffii, + "nullFunc_viffi": nullFunc_viffi, + "nullFunc_viffii": nullFunc_viffii, + "nullFunc_viffiii": nullFunc_viffiii, + "nullFunc_vifi": nullFunc_vifi, + "nullFunc_vifii": nullFunc_vifii, + "nullFunc_vifiiii": nullFunc_vifiiii, + "nullFunc_vii": nullFunc_vii, + "nullFunc_viidi": nullFunc_viidi, + "nullFunc_viidii": nullFunc_viidii, + "nullFunc_viif": nullFunc_viif, + "nullFunc_viiff": nullFunc_viiff, + "nullFunc_viifff": nullFunc_viifff, + "nullFunc_viifffi": nullFunc_viifffi, + "nullFunc_viiffi": nullFunc_viiffi, + "nullFunc_viiffii": nullFunc_viiffii, + "nullFunc_viifi": nullFunc_viifi, + "nullFunc_viifii": nullFunc_viifii, + "nullFunc_viifiii": nullFunc_viifiii, + "nullFunc_viifiiii": nullFunc_viifiiii, + "nullFunc_viii": nullFunc_viii, + "nullFunc_viiiffi": nullFunc_viiiffi, + "nullFunc_viiiffii": nullFunc_viiiffii, + "nullFunc_viiifi": nullFunc_viiifi, + "nullFunc_viiififfi": nullFunc_viiififfi, + "nullFunc_viiififi": nullFunc_viiififi, + "nullFunc_viiifii": nullFunc_viiifii, + "nullFunc_viiifiii": nullFunc_viiifiii, + "nullFunc_viiifiiiii": nullFunc_viiifiiiii, + "nullFunc_viiii": nullFunc_viiii, + "nullFunc_viiiif": nullFunc_viiiif, + "nullFunc_viiiiffffii": nullFunc_viiiiffffii, + "nullFunc_viiiifii": nullFunc_viiiifii, + "nullFunc_viiiifiii": nullFunc_viiiifiii, + "nullFunc_viiiifiiiiif": nullFunc_viiiifiiiiif, + "nullFunc_viiiii": nullFunc_viiiii, + "nullFunc_viiiiif": nullFunc_viiiiif, + "nullFunc_viiiiiffi": nullFunc_viiiiiffi, + "nullFunc_viiiiiffii": nullFunc_viiiiiffii, + "nullFunc_viiiiifi": nullFunc_viiiiifi, + "nullFunc_viiiiii": nullFunc_viiiiii, + "nullFunc_viiiiiif": nullFunc_viiiiiif, + "nullFunc_viiiiiii": nullFunc_viiiiiii, + "nullFunc_viiiiiiii": nullFunc_viiiiiiii, + "nullFunc_viiiiiiiii": nullFunc_viiiiiiiii, + "nullFunc_viiiiiiiiii": nullFunc_viiiiiiiiii, + "nullFunc_viiiiiiiiiii": nullFunc_viiiiiiiiiii, + "nullFunc_viiiiiiiiiiifii": nullFunc_viiiiiiiiiiifii, + "nullFunc_viiiiiiiiiiii": nullFunc_viiiiiiiiiiii, + "nullFunc_viiiiiiiiiiiii": nullFunc_viiiiiiiiiiiii, + "nullFunc_viiiiiiiiiiiiii": nullFunc_viiiiiiiiiiiiii, + "nullFunc_viiiiiiiiiiiiiii": nullFunc_viiiiiiiiiiiiiii, + "nullFunc_viiiiiiiiiiiiiiiiii": nullFunc_viiiiiiiiiiiiiiiiii, + "nullFunc_viiiiiiiiiji": nullFunc_viiiiiiiiiji, + "nullFunc_viiiiiiiji": nullFunc_viiiiiiiji, + "nullFunc_viiiiiiijii": nullFunc_viiiiiiijii, + "nullFunc_viiiiij": nullFunc_viiiiij, + "nullFunc_viiiiijii": nullFunc_viiiiijii, + "nullFunc_viiiiji": nullFunc_viiiiji, + "nullFunc_viiiijii": nullFunc_viiiijii, + "nullFunc_viiiijiiii": nullFunc_viiiijiiii, + "nullFunc_viiiijjiii": nullFunc_viiiijjiii, + "nullFunc_viiiji": nullFunc_viiiji, + "nullFunc_viiijji": nullFunc_viiijji, + "nullFunc_viiijjii": nullFunc_viiijjii, + "nullFunc_viiijjiii": nullFunc_viiijjiii, + "nullFunc_viij": nullFunc_viij, + "nullFunc_viiji": nullFunc_viiji, + "nullFunc_viijii": nullFunc_viijii, + "nullFunc_viijiiii": nullFunc_viijiiii, + "nullFunc_viijiijiii": nullFunc_viijiijiii, + "nullFunc_viijijii": nullFunc_viijijii, + "nullFunc_viijijiii": nullFunc_viijijiii, + "nullFunc_viijji": nullFunc_viijji, + "nullFunc_viijjii": nullFunc_viijjii, + "nullFunc_viijjiii": nullFunc_viijjiii, + "nullFunc_viijjji": nullFunc_viijjji, + "nullFunc_vij": nullFunc_vij, + "nullFunc_viji": nullFunc_viji, + "nullFunc_vijii": nullFunc_vijii, + "nullFunc_vijiii": nullFunc_vijiii, + "nullFunc_vijiji": nullFunc_vijiji, + "nullFunc_vijijji": nullFunc_vijijji, + "nullFunc_vijji": nullFunc_vijji, + "nullFunc_vijjii": nullFunc_vijjii, + "nullFunc_vijjji": nullFunc_vijjji, + "nullFunc_vjiiii": nullFunc_vjiiii, + "nullFunc_vjji": nullFunc_vjji, + "invoke_dddi": invoke_dddi, + "invoke_ddi": invoke_ddi, + "invoke_dfi": invoke_dfi, + "invoke_di": invoke_di, + "invoke_diddi": invoke_diddi, + "invoke_didi": invoke_didi, + "invoke_dii": invoke_dii, + "invoke_diii": invoke_diii, + "invoke_diiii": invoke_diiii, + "invoke_diji": invoke_diji, + "invoke_dji": invoke_dji, + "invoke_f": invoke_f, + "invoke_fdi": invoke_fdi, + "invoke_ff": invoke_ff, + "invoke_fff": invoke_fff, + "invoke_ffffi": invoke_ffffi, + "invoke_fffi": invoke_fffi, + "invoke_fffifffi": invoke_fffifffi, + "invoke_ffi": invoke_ffi, + "invoke_fi": invoke_fi, + "invoke_fidi": invoke_fidi, + "invoke_fif": invoke_fif, + "invoke_fiff": invoke_fiff, + "invoke_fiffi": invoke_fiffi, + "invoke_fifi": invoke_fifi, + "invoke_fifii": invoke_fifii, + "invoke_fii": invoke_fii, + "invoke_fiifi": invoke_fiifi, + "invoke_fiifii": invoke_fiifii, + "invoke_fiii": invoke_fiii, + "invoke_fiiii": invoke_fiiii, + "invoke_fiiiif": invoke_fiiiif, + "invoke_fiiiii": invoke_fiiiii, + "invoke_fiiiiii": invoke_fiiiiii, + "invoke_fiiiiiifiifif": invoke_fiiiiiifiifif, + "invoke_fiiiiiifiiiif": invoke_fiiiiiifiiiif, + "invoke_fji": invoke_fji, + "invoke_i": invoke_i, + "invoke_iddi": invoke_iddi, + "invoke_idi": invoke_idi, + "invoke_idiii": invoke_idiii, + "invoke_ifffi": invoke_ifffi, + "invoke_iffi": invoke_iffi, + "invoke_ifi": invoke_ifi, + "invoke_ifiii": invoke_ifiii, + "invoke_ii": invoke_ii, + "invoke_iiddi": invoke_iiddi, + "invoke_iiddiii": invoke_iiddiii, + "invoke_iidi": invoke_iidi, + "invoke_iidii": invoke_iidii, + "invoke_iidiii": invoke_iidiii, + "invoke_iif": invoke_iif, + "invoke_iifff": invoke_iifff, + "invoke_iifffi": invoke_iifffi, + "invoke_iiffi": invoke_iiffi, + "invoke_iiffiii": invoke_iiffiii, + "invoke_iifi": invoke_iifi, + "invoke_iifii": invoke_iifii, + "invoke_iifiii": invoke_iifiii, + "invoke_iii": invoke_iii, + "invoke_iiidii": invoke_iiidii, + "invoke_iiidiii": invoke_iiidiii, + "invoke_iiif": invoke_iiif, + "invoke_iiifi": invoke_iiifi, + "invoke_iiifii": invoke_iiifii, + "invoke_iiifiii": invoke_iiifiii, + "invoke_iiifiiii": invoke_iiifiiii, + "invoke_iiii": invoke_iiii, + "invoke_iiiidii": invoke_iiiidii, + "invoke_iiiifffffi": invoke_iiiifffffi, + "invoke_iiiifi": invoke_iiiifi, + "invoke_iiiifii": invoke_iiiifii, + "invoke_iiiifiii": invoke_iiiifiii, + "invoke_iiiifiiii": invoke_iiiifiiii, + "invoke_iiiifiiiii": invoke_iiiifiiiii, + "invoke_iiiii": invoke_iiiii, + "invoke_iiiiifi": invoke_iiiiifi, + "invoke_iiiiifiii": invoke_iiiiifiii, + "invoke_iiiiifiiiif": invoke_iiiiifiiiif, + "invoke_iiiiifiiiiif": invoke_iiiiifiiiiif, + "invoke_iiiiii": invoke_iiiiii, + "invoke_iiiiiifffiiifiii": invoke_iiiiiifffiiifiii, + "invoke_iiiiiiffiiiiiiiiiffffiii": invoke_iiiiiiffiiiiiiiiiffffiii, + "invoke_iiiiiiffiiiiiiiiiffffiiii": invoke_iiiiiiffiiiiiiiiiffffiiii, + "invoke_iiiiiiffiiiiiiiiiiiiiii": invoke_iiiiiiffiiiiiiiiiiiiiii, + "invoke_iiiiiifiif": invoke_iiiiiifiif, + "invoke_iiiiiifiii": invoke_iiiiiifiii, + "invoke_iiiiiii": invoke_iiiiiii, + "invoke_iiiiiiifiif": invoke_iiiiiiifiif, + "invoke_iiiiiiii": invoke_iiiiiiii, + "invoke_iiiiiiiii": invoke_iiiiiiiii, + "invoke_iiiiiiiiii": invoke_iiiiiiiiii, + "invoke_iiiiiiiiiii": invoke_iiiiiiiiiii, + "invoke_iiiiiiiiiiii": invoke_iiiiiiiiiiii, + "invoke_iiiiiiiiiiiii": invoke_iiiiiiiiiiiii, + "invoke_iiiiiiiiiiiiii": invoke_iiiiiiiiiiiiii, + "invoke_iiiiij": invoke_iiiiij, + "invoke_iiiiiji": invoke_iiiiiji, + "invoke_iiiiijjiiiii": invoke_iiiiijjiiiii, + "invoke_iiiij": invoke_iiiij, + "invoke_iiiiji": invoke_iiiiji, + "invoke_iiiijii": invoke_iiiijii, + "invoke_iiiijiii": invoke_iiiijiii, + "invoke_iiiijijii": invoke_iiiijijii, + "invoke_iiiijjii": invoke_iiiijjii, + "invoke_iiiijjiiii": invoke_iiiijjiiii, + "invoke_iiij": invoke_iiij, + "invoke_iiiji": invoke_iiiji, + "invoke_iiijii": invoke_iiijii, + "invoke_iiijiii": invoke_iiijiii, + "invoke_iiijji": invoke_iiijji, + "invoke_iiijjii": invoke_iiijjii, + "invoke_iiijjiiii": invoke_iiijjiiii, + "invoke_iij": invoke_iij, + "invoke_iiji": invoke_iiji, + "invoke_iijii": invoke_iijii, + "invoke_iijiii": invoke_iijiii, + "invoke_iijji": invoke_iijji, + "invoke_iijjii": invoke_iijjii, + "invoke_iijjiii": invoke_iijjiii, + "invoke_iijjji": invoke_iijjji, + "invoke_ij": invoke_ij, + "invoke_iji": invoke_iji, + "invoke_ijiii": invoke_ijiii, + "invoke_ijiiii": invoke_ijiiii, + "invoke_ijiiiii": invoke_ijiiiii, + "invoke_ijiiiiii": invoke_ijiiiiii, + "invoke_ijj": invoke_ijj, + "invoke_ijji": invoke_ijji, + "invoke_j": invoke_j, + "invoke_jdi": invoke_jdi, + "invoke_jdii": invoke_jdii, + "invoke_jfi": invoke_jfi, + "invoke_ji": invoke_ji, + "invoke_jidi": invoke_jidi, + "invoke_jidii": invoke_jidii, + "invoke_jifi": invoke_jifi, + "invoke_jii": invoke_jii, + "invoke_jiii": invoke_jiii, + "invoke_jiiii": invoke_jiiii, + "invoke_jiiiii": invoke_jiiiii, + "invoke_jiiiiii": invoke_jiiiiii, + "invoke_jiiiiiiiiii": invoke_jiiiiiiiiii, + "invoke_jiiji": invoke_jiiji, + "invoke_jiji": invoke_jiji, + "invoke_jijii": invoke_jijii, + "invoke_jijiii": invoke_jijiii, + "invoke_jijj": invoke_jijj, + "invoke_jijji": invoke_jijji, + "invoke_jji": invoke_jji, + "invoke_jjii": invoke_jjii, + "invoke_jjjji": invoke_jjjji, + "invoke_v": invoke_v, + "invoke_vd": invoke_vd, + "invoke_vf": invoke_vf, + "invoke_vff": invoke_vff, + "invoke_vffff": invoke_vffff, + "invoke_vfi": invoke_vfi, + "invoke_vi": invoke_vi, + "invoke_vid": invoke_vid, + "invoke_vidi": invoke_vidi, + "invoke_vidiii": invoke_vidiii, + "invoke_vif": invoke_vif, + "invoke_viff": invoke_viff, + "invoke_vifff": invoke_vifff, + "invoke_viffff": invoke_viffff, + "invoke_vifffffi": invoke_vifffffi, + "invoke_viffffi": invoke_viffffi, + "invoke_viffffii": invoke_viffffii, + "invoke_vifffi": invoke_vifffi, + "invoke_vifffii": invoke_vifffii, + "invoke_viffi": invoke_viffi, + "invoke_viffii": invoke_viffii, + "invoke_viffiii": invoke_viffiii, + "invoke_vifi": invoke_vifi, + "invoke_vifii": invoke_vifii, + "invoke_vifiiii": invoke_vifiiii, + "invoke_vii": invoke_vii, + "invoke_viidi": invoke_viidi, + "invoke_viidii": invoke_viidii, + "invoke_viif": invoke_viif, + "invoke_viiff": invoke_viiff, + "invoke_viifff": invoke_viifff, + "invoke_viifffi": invoke_viifffi, + "invoke_viiffi": invoke_viiffi, + "invoke_viiffii": invoke_viiffii, + "invoke_viifi": invoke_viifi, + "invoke_viifii": invoke_viifii, + "invoke_viifiii": invoke_viifiii, + "invoke_viifiiii": invoke_viifiiii, + "invoke_viii": invoke_viii, + "invoke_viiiffi": invoke_viiiffi, + "invoke_viiiffii": invoke_viiiffii, + "invoke_viiifi": invoke_viiifi, + "invoke_viiififfi": invoke_viiififfi, + "invoke_viiififi": invoke_viiififi, + "invoke_viiifii": invoke_viiifii, + "invoke_viiifiii": invoke_viiifiii, + "invoke_viiifiiiii": invoke_viiifiiiii, + "invoke_viiii": invoke_viiii, + "invoke_viiiif": invoke_viiiif, + "invoke_viiiiffffii": invoke_viiiiffffii, + "invoke_viiiifii": invoke_viiiifii, + "invoke_viiiifiii": invoke_viiiifiii, + "invoke_viiiifiiiiif": invoke_viiiifiiiiif, + "invoke_viiiii": invoke_viiiii, + "invoke_viiiiif": invoke_viiiiif, + "invoke_viiiiiffi": invoke_viiiiiffi, + "invoke_viiiiiffii": invoke_viiiiiffii, + "invoke_viiiiifi": invoke_viiiiifi, + "invoke_viiiiii": invoke_viiiiii, + "invoke_viiiiiif": invoke_viiiiiif, + "invoke_viiiiiii": invoke_viiiiiii, + "invoke_viiiiiiii": invoke_viiiiiiii, + "invoke_viiiiiiiii": invoke_viiiiiiiii, + "invoke_viiiiiiiiii": invoke_viiiiiiiiii, + "invoke_viiiiiiiiiii": invoke_viiiiiiiiiii, + "invoke_viiiiiiiiiiifii": invoke_viiiiiiiiiiifii, + "invoke_viiiiiiiiiiii": invoke_viiiiiiiiiiii, + "invoke_viiiiiiiiiiiii": invoke_viiiiiiiiiiiii, + "invoke_viiiiiiiiiiiiii": invoke_viiiiiiiiiiiiii, + "invoke_viiiiiiiiiiiiiii": invoke_viiiiiiiiiiiiiii, + "invoke_viiiiiiiiiiiiiiiiii": invoke_viiiiiiiiiiiiiiiiii, + "invoke_viiiiiiiiiji": invoke_viiiiiiiiiji, + "invoke_viiiiiiiji": invoke_viiiiiiiji, + "invoke_viiiiiiijii": invoke_viiiiiiijii, + "invoke_viiiiij": invoke_viiiiij, + "invoke_viiiiijii": invoke_viiiiijii, + "invoke_viiiiji": invoke_viiiiji, + "invoke_viiiijii": invoke_viiiijii, + "invoke_viiiijiiii": invoke_viiiijiiii, + "invoke_viiiijjiii": invoke_viiiijjiii, + "invoke_viiiji": invoke_viiiji, + "invoke_viiijji": invoke_viiijji, + "invoke_viiijjii": invoke_viiijjii, + "invoke_viiijjiii": invoke_viiijjiii, + "invoke_viij": invoke_viij, + "invoke_viiji": invoke_viiji, + "invoke_viijii": invoke_viijii, + "invoke_viijiiii": invoke_viijiiii, + "invoke_viijiijiii": invoke_viijiijiii, + "invoke_viijijii": invoke_viijijii, + "invoke_viijijiii": invoke_viijijiii, + "invoke_viijji": invoke_viijji, + "invoke_viijjii": invoke_viijjii, + "invoke_viijjiii": invoke_viijjiii, + "invoke_viijjji": invoke_viijjji, + "invoke_vij": invoke_vij, + "invoke_viji": invoke_viji, + "invoke_vijii": invoke_vijii, + "invoke_vijiii": invoke_vijiii, + "invoke_vijiji": invoke_vijiji, + "invoke_vijijji": invoke_vijijji, + "invoke_vijji": invoke_vijji, + "invoke_vijjii": invoke_vijjii, + "invoke_vijjji": invoke_vijjji, + "invoke_vjiiii": invoke_vjiiii, + "invoke_vjji": invoke_vjji, + "_IMG_Load": _IMG_Load, + "_IMG_Load_RW": _IMG_Load_RW, + "_JS_Cursor_SetImage": _JS_Cursor_SetImage, + "_JS_Cursor_SetShow": _JS_Cursor_SetShow, + "_JS_Eval_ClearTimeout": _JS_Eval_ClearTimeout, + "_JS_Eval_SetTimeout": _JS_Eval_SetTimeout, + "_JS_FileSystem_SetSyncInterval": _JS_FileSystem_SetSyncInterval, + "_JS_FileSystem_Sync": _JS_FileSystem_Sync, + "_JS_Log_StackTrace": _JS_Log_StackTrace, + "_JS_Profiler_InjectJobs": _JS_Profiler_InjectJobs, + "_JS_Sound_Create_Channel": _JS_Sound_Create_Channel, + "_JS_Sound_GetLength": _JS_Sound_GetLength, + "_JS_Sound_GetLoadState": _JS_Sound_GetLoadState, + "_JS_Sound_Init": _JS_Sound_Init, + "_JS_Sound_Load": _JS_Sound_Load, + "_JS_Sound_Load_PCM": _JS_Sound_Load_PCM, + "_JS_Sound_Play": _JS_Sound_Play, + "_JS_Sound_ReleaseInstance": _JS_Sound_ReleaseInstance, + "_JS_Sound_ResumeIfNeeded": _JS_Sound_ResumeIfNeeded, + "_JS_Sound_Set3D": _JS_Sound_Set3D, + "_JS_Sound_SetListenerOrientation": _JS_Sound_SetListenerOrientation, + "_JS_Sound_SetListenerPosition": _JS_Sound_SetListenerPosition, + "_JS_Sound_SetLoop": _JS_Sound_SetLoop, + "_JS_Sound_SetLoopPoints": _JS_Sound_SetLoopPoints, + "_JS_Sound_SetPitch": _JS_Sound_SetPitch, + "_JS_Sound_SetPosition": _JS_Sound_SetPosition, + "_JS_Sound_SetVolume": _JS_Sound_SetVolume, + "_JS_Sound_Stop": _JS_Sound_Stop, + "_JS_SystemInfo_GetBrowserName": _JS_SystemInfo_GetBrowserName, + "_JS_SystemInfo_GetBrowserVersionString": _JS_SystemInfo_GetBrowserVersionString, + "_JS_SystemInfo_GetCurrentCanvasHeight": _JS_SystemInfo_GetCurrentCanvasHeight, + "_JS_SystemInfo_GetCurrentCanvasWidth": _JS_SystemInfo_GetCurrentCanvasWidth, + "_JS_SystemInfo_GetDocumentURL": _JS_SystemInfo_GetDocumentURL, + "_JS_SystemInfo_GetGPUInfo": _JS_SystemInfo_GetGPUInfo, + "_JS_SystemInfo_GetHeight": _JS_SystemInfo_GetHeight, + "_JS_SystemInfo_GetLanguage": _JS_SystemInfo_GetLanguage, + "_JS_SystemInfo_GetMemory": _JS_SystemInfo_GetMemory, + "_JS_SystemInfo_GetOS": _JS_SystemInfo_GetOS, + "_JS_SystemInfo_GetWidth": _JS_SystemInfo_GetWidth, + "_JS_SystemInfo_HasCursorLock": _JS_SystemInfo_HasCursorLock, + "_JS_SystemInfo_HasFullscreen": _JS_SystemInfo_HasFullscreen, + "_JS_SystemInfo_HasWebGL": _JS_SystemInfo_HasWebGL, + "_JS_WebGL_InitContextAttributes": _JS_WebGL_InitContextAttributes, + "_JS_WebRequest_Abort": _JS_WebRequest_Abort, + "_JS_WebRequest_Create": _JS_WebRequest_Create, + "_JS_WebRequest_GetResponseHeaders": _JS_WebRequest_GetResponseHeaders, + "_JS_WebRequest_Release": _JS_WebRequest_Release, + "_JS_WebRequest_Send": _JS_WebRequest_Send, + "_JS_WebRequest_SetProgressHandler": _JS_WebRequest_SetProgressHandler, + "_JS_WebRequest_SetRequestHeader": _JS_WebRequest_SetRequestHeader, + "_JS_WebRequest_SetResponseHandler": _JS_WebRequest_SetResponseHandler, + "_JS_WebRequest_SetTimeout": _JS_WebRequest_SetTimeout, + "_Mix_FreeChunk": _Mix_FreeChunk, + "_Mix_HaltMusic": _Mix_HaltMusic, + "_Mix_LoadWAV_RW": _Mix_LoadWAV_RW, + "_Mix_PlayChannel": _Mix_PlayChannel, + "_Mix_PlayMusic": _Mix_PlayMusic, + "_SDL_CloseAudio": _SDL_CloseAudio, + "_SDL_FreeRW": _SDL_FreeRW, + "_SDL_GL_SwapBuffers": _SDL_GL_SwapBuffers, + "_SDL_GetTicks": _SDL_GetTicks, + "_SDL_LockSurface": _SDL_LockSurface, + "_SDL_PauseAudio": _SDL_PauseAudio, + "_SDL_RWFromConstMem": _SDL_RWFromConstMem, + "_SDL_RWFromFile": _SDL_RWFromFile, + "_SDL_UpperBlit": _SDL_UpperBlit, + "_SDL_UpperBlitScaled": _SDL_UpperBlitScaled, + "_TTF_FontHeight": _TTF_FontHeight, + "_TTF_RenderText_Solid": _TTF_RenderText_Solid, + "_TTF_SizeText": _TTF_SizeText, + "__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv, + "___buildEnvironment": ___buildEnvironment, + "___cxa_allocate_exception": ___cxa_allocate_exception, + "___cxa_begin_catch": ___cxa_begin_catch, + "___cxa_end_catch": ___cxa_end_catch, + "___cxa_find_matching_catch": ___cxa_find_matching_catch, + "___cxa_find_matching_catch_2": ___cxa_find_matching_catch_2, + "___cxa_find_matching_catch_3": ___cxa_find_matching_catch_3, + "___cxa_find_matching_catch_4": ___cxa_find_matching_catch_4, + "___cxa_free_exception": ___cxa_free_exception, + "___cxa_pure_virtual": ___cxa_pure_virtual, + "___cxa_rethrow": ___cxa_rethrow, + "___cxa_throw": ___cxa_throw, + "___gxx_personality_v0": ___gxx_personality_v0, + "___lock": ___lock, + "___map_file": ___map_file, + "___resumeException": ___resumeException, + "___setErrNo": ___setErrNo, + "___syscall10": ___syscall10, + "___syscall102": ___syscall102, + "___syscall122": ___syscall122, + "___syscall140": ___syscall140, + "___syscall142": ___syscall142, + "___syscall145": ___syscall145, + "___syscall146": ___syscall146, + "___syscall15": ___syscall15, + "___syscall183": ___syscall183, + "___syscall192": ___syscall192, + "___syscall193": ___syscall193, + "___syscall194": ___syscall194, + "___syscall195": ___syscall195, + "___syscall196": ___syscall196, + "___syscall197": ___syscall197, + "___syscall199": ___syscall199, + "___syscall202": ___syscall202, + "___syscall220": ___syscall220, + "___syscall221": ___syscall221, + "___syscall268": ___syscall268, + "___syscall3": ___syscall3, + "___syscall33": ___syscall33, + "___syscall38": ___syscall38, + "___syscall39": ___syscall39, + "___syscall4": ___syscall4, + "___syscall40": ___syscall40, + "___syscall41": ___syscall41, + "___syscall42": ___syscall42, + "___syscall5": ___syscall5, + "___syscall54": ___syscall54, + "___syscall6": ___syscall6, + "___syscall77": ___syscall77, + "___syscall85": ___syscall85, + "___syscall91": ___syscall91, + "___unlock": ___unlock, + "__addDays": __addDays, + "__arraySum": __arraySum, + "__emscripten_sample_gamepad_data": __emscripten_sample_gamepad_data, + "__emscripten_traverse_stack": __emscripten_traverse_stack, + "__exit": __exit, + "__formatString": __formatString, + "__inet_ntop4_raw": __inet_ntop4_raw, + "__inet_ntop6_raw": __inet_ntop6_raw, + "__inet_pton4_raw": __inet_pton4_raw, + "__inet_pton6_raw": __inet_pton6_raw, + "__isLeapYear": __isLeapYear, + "__read_sockaddr": __read_sockaddr, + "__reallyNegative": __reallyNegative, + "__setLetterbox": __setLetterbox, + "__write_sockaddr": __write_sockaddr, + "_abort": _abort, + "_atexit": _atexit, + "_clock": _clock, + "_clock_getres": _clock_getres, + "_clock_gettime": _clock_gettime, + "_difftime": _difftime, + "_dlclose": _dlclose, + "_dlopen": _dlopen, + "_dlsym": _dlsym, + "_emscripten_asm_const_i": _emscripten_asm_const_i, + "_emscripten_asm_const_id": _emscripten_asm_const_id, + "_emscripten_cancel_main_loop": _emscripten_cancel_main_loop, + "_emscripten_do_request_fullscreen": _emscripten_do_request_fullscreen, + "_emscripten_exit_fullscreen": _emscripten_exit_fullscreen, + "_emscripten_exit_pointerlock": _emscripten_exit_pointerlock, + "_emscripten_get_callstack_js": _emscripten_get_callstack_js, + "_emscripten_get_fullscreen_status": _emscripten_get_fullscreen_status, + "_emscripten_get_gamepad_status": _emscripten_get_gamepad_status, + "_emscripten_get_main_loop_timing": _emscripten_get_main_loop_timing, + "_emscripten_get_now": _emscripten_get_now, + "_emscripten_get_now_is_monotonic": _emscripten_get_now_is_monotonic, + "_emscripten_get_now_res": _emscripten_get_now_res, + "_emscripten_get_num_gamepads": _emscripten_get_num_gamepads, + "_emscripten_has_threading_support": _emscripten_has_threading_support, + "_emscripten_is_webgl_context_lost": _emscripten_is_webgl_context_lost, + "_emscripten_log": _emscripten_log, + "_emscripten_log_js": _emscripten_log_js, + "_emscripten_memcpy_big": _emscripten_memcpy_big, + "_emscripten_num_logical_cores": _emscripten_num_logical_cores, + "_emscripten_request_fullscreen": _emscripten_request_fullscreen, + "_emscripten_request_pointerlock": _emscripten_request_pointerlock, + "_emscripten_set_blur_callback": _emscripten_set_blur_callback, + "_emscripten_set_canvas_size": _emscripten_set_canvas_size, + "_emscripten_set_devicemotion_callback": _emscripten_set_devicemotion_callback, + "_emscripten_set_deviceorientation_callback": _emscripten_set_deviceorientation_callback, + "_emscripten_set_focus_callback": _emscripten_set_focus_callback, + "_emscripten_set_fullscreenchange_callback": _emscripten_set_fullscreenchange_callback, + "_emscripten_set_keydown_callback": _emscripten_set_keydown_callback, + "_emscripten_set_keypress_callback": _emscripten_set_keypress_callback, + "_emscripten_set_keyup_callback": _emscripten_set_keyup_callback, + "_emscripten_set_main_loop": _emscripten_set_main_loop, + "_emscripten_set_main_loop_timing": _emscripten_set_main_loop_timing, + "_emscripten_set_mousedown_callback": _emscripten_set_mousedown_callback, + "_emscripten_set_mousemove_callback": _emscripten_set_mousemove_callback, + "_emscripten_set_mouseup_callback": _emscripten_set_mouseup_callback, + "_emscripten_set_touchcancel_callback": _emscripten_set_touchcancel_callback, + "_emscripten_set_touchend_callback": _emscripten_set_touchend_callback, + "_emscripten_set_touchmove_callback": _emscripten_set_touchmove_callback, + "_emscripten_set_touchstart_callback": _emscripten_set_touchstart_callback, + "_emscripten_set_wheel_callback": _emscripten_set_wheel_callback, + "_emscripten_webgl_create_context": _emscripten_webgl_create_context, + "_emscripten_webgl_destroy_context": _emscripten_webgl_destroy_context, + "_emscripten_webgl_enable_extension": _emscripten_webgl_enable_extension, + "_emscripten_webgl_get_current_context": _emscripten_webgl_get_current_context, + "_emscripten_webgl_make_context_current": _emscripten_webgl_make_context_current, + "_exit": _exit, + "_flock": _flock, + "_getenv": _getenv, + "_gethostbyaddr": _gethostbyaddr, + "_gethostbyname": _gethostbyname, + "_getpwuid": _getpwuid, + "_gettimeofday": _gettimeofday, + "_glActiveTexture": _glActiveTexture, + "_glAttachShader": _glAttachShader, + "_glBeginQuery": _glBeginQuery, + "_glBeginTransformFeedback": _glBeginTransformFeedback, + "_glBindAttribLocation": _glBindAttribLocation, + "_glBindBuffer": _glBindBuffer, + "_glBindBufferBase": _glBindBufferBase, + "_glBindFramebuffer": _glBindFramebuffer, + "_glBindRenderbuffer": _glBindRenderbuffer, + "_glBindSampler": _glBindSampler, + "_glBindTexture": _glBindTexture, + "_glBindTransformFeedback": _glBindTransformFeedback, + "_glBindVertexArray": _glBindVertexArray, + "_glBlendEquation": _glBlendEquation, + "_glBlendEquationSeparate": _glBlendEquationSeparate, + "_glBlendFuncSeparate": _glBlendFuncSeparate, + "_glBlitFramebuffer": _glBlitFramebuffer, + "_glBufferData": _glBufferData, + "_glBufferSubData": _glBufferSubData, + "_glCheckFramebufferStatus": _glCheckFramebufferStatus, + "_glClear": _glClear, + "_glClearColor": _glClearColor, + "_glClearDepthf": _glClearDepthf, + "_glClearStencil": _glClearStencil, + "_glClientWaitSync": _glClientWaitSync, + "_glColorMask": _glColorMask, + "_glCompileShader": _glCompileShader, + "_glCompressedTexImage2D": _glCompressedTexImage2D, + "_glCompressedTexSubImage2D": _glCompressedTexSubImage2D, + "_glCompressedTexSubImage3D": _glCompressedTexSubImage3D, + "_glCopyBufferSubData": _glCopyBufferSubData, + "_glCopyTexImage2D": _glCopyTexImage2D, + "_glCopyTexSubImage2D": _glCopyTexSubImage2D, + "_glCreateProgram": _glCreateProgram, + "_glCreateShader": _glCreateShader, + "_glCullFace": _glCullFace, + "_glDeleteBuffers": _glDeleteBuffers, + "_glDeleteFramebuffers": _glDeleteFramebuffers, + "_glDeleteProgram": _glDeleteProgram, + "_glDeleteQueries": _glDeleteQueries, + "_glDeleteRenderbuffers": _glDeleteRenderbuffers, + "_glDeleteSamplers": _glDeleteSamplers, + "_glDeleteShader": _glDeleteShader, + "_glDeleteSync": _glDeleteSync, + "_glDeleteTextures": _glDeleteTextures, + "_glDeleteTransformFeedbacks": _glDeleteTransformFeedbacks, + "_glDeleteVertexArrays": _glDeleteVertexArrays, + "_glDepthFunc": _glDepthFunc, + "_glDepthMask": _glDepthMask, + "_glDetachShader": _glDetachShader, + "_glDisable": _glDisable, + "_glDisableVertexAttribArray": _glDisableVertexAttribArray, + "_glDrawArrays": _glDrawArrays, + "_glDrawArraysInstanced": _glDrawArraysInstanced, + "_glDrawBuffers": _glDrawBuffers, + "_glDrawElements": _glDrawElements, + "_glDrawElementsInstanced": _glDrawElementsInstanced, + "_glEnable": _glEnable, + "_glEnableVertexAttribArray": _glEnableVertexAttribArray, + "_glEndQuery": _glEndQuery, + "_glEndTransformFeedback": _glEndTransformFeedback, + "_glFenceSync": _glFenceSync, + "_glFinish": _glFinish, + "_glFlush": _glFlush, + "_glFlushMappedBufferRange": _glFlushMappedBufferRange, + "_glFramebufferRenderbuffer": _glFramebufferRenderbuffer, + "_glFramebufferTexture2D": _glFramebufferTexture2D, + "_glFramebufferTextureLayer": _glFramebufferTextureLayer, + "_glFrontFace": _glFrontFace, + "_glGenBuffers": _glGenBuffers, + "_glGenFramebuffers": _glGenFramebuffers, + "_glGenQueries": _glGenQueries, + "_glGenRenderbuffers": _glGenRenderbuffers, + "_glGenSamplers": _glGenSamplers, + "_glGenTextures": _glGenTextures, + "_glGenTransformFeedbacks": _glGenTransformFeedbacks, + "_glGenVertexArrays": _glGenVertexArrays, + "_glGenerateMipmap": _glGenerateMipmap, + "_glGetActiveAttrib": _glGetActiveAttrib, + "_glGetActiveUniform": _glGetActiveUniform, + "_glGetActiveUniformBlockName": _glGetActiveUniformBlockName, + "_glGetActiveUniformBlockiv": _glGetActiveUniformBlockiv, + "_glGetActiveUniformsiv": _glGetActiveUniformsiv, + "_glGetAttribLocation": _glGetAttribLocation, + "_glGetError": _glGetError, + "_glGetFramebufferAttachmentParameteriv": _glGetFramebufferAttachmentParameteriv, + "_glGetIntegeri_v": _glGetIntegeri_v, + "_glGetIntegerv": _glGetIntegerv, + "_glGetProgramBinary": _glGetProgramBinary, + "_glGetProgramInfoLog": _glGetProgramInfoLog, + "_glGetProgramiv": _glGetProgramiv, + "_glGetRenderbufferParameteriv": _glGetRenderbufferParameteriv, + "_glGetShaderInfoLog": _glGetShaderInfoLog, + "_glGetShaderPrecisionFormat": _glGetShaderPrecisionFormat, + "_glGetShaderSource": _glGetShaderSource, + "_glGetShaderiv": _glGetShaderiv, + "_glGetString": _glGetString, + "_glGetStringi": _glGetStringi, + "_glGetTexParameteriv": _glGetTexParameteriv, + "_glGetUniformBlockIndex": _glGetUniformBlockIndex, + "_glGetUniformIndices": _glGetUniformIndices, + "_glGetUniformLocation": _glGetUniformLocation, + "_glGetUniformiv": _glGetUniformiv, + "_glGetVertexAttribiv": _glGetVertexAttribiv, + "_glInvalidateFramebuffer": _glInvalidateFramebuffer, + "_glIsEnabled": _glIsEnabled, + "_glIsVertexArray": _glIsVertexArray, + "_glLinkProgram": _glLinkProgram, + "_glMapBufferRange": _glMapBufferRange, + "_glPixelStorei": _glPixelStorei, + "_glPolygonOffset": _glPolygonOffset, + "_glProgramBinary": _glProgramBinary, + "_glProgramParameteri": _glProgramParameteri, + "_glReadBuffer": _glReadBuffer, + "_glReadPixels": _glReadPixels, + "_glRenderbufferStorage": _glRenderbufferStorage, + "_glRenderbufferStorageMultisample": _glRenderbufferStorageMultisample, + "_glSamplerParameteri": _glSamplerParameteri, + "_glScissor": _glScissor, + "_glShaderSource": _glShaderSource, + "_glStencilFuncSeparate": _glStencilFuncSeparate, + "_glStencilMask": _glStencilMask, + "_glStencilOpSeparate": _glStencilOpSeparate, + "_glTexImage2D": _glTexImage2D, + "_glTexImage3D": _glTexImage3D, + "_glTexParameterf": _glTexParameterf, + "_glTexParameteri": _glTexParameteri, + "_glTexParameteriv": _glTexParameteriv, + "_glTexStorage2D": _glTexStorage2D, + "_glTexStorage3D": _glTexStorage3D, + "_glTexSubImage2D": _glTexSubImage2D, + "_glTexSubImage3D": _glTexSubImage3D, + "_glTransformFeedbackVaryings": _glTransformFeedbackVaryings, + "_glUniform1fv": _glUniform1fv, + "_glUniform1i": _glUniform1i, + "_glUniform1iv": _glUniform1iv, + "_glUniform1uiv": _glUniform1uiv, + "_glUniform2fv": _glUniform2fv, + "_glUniform2iv": _glUniform2iv, + "_glUniform2uiv": _glUniform2uiv, + "_glUniform3fv": _glUniform3fv, + "_glUniform3iv": _glUniform3iv, + "_glUniform3uiv": _glUniform3uiv, + "_glUniform4fv": _glUniform4fv, + "_glUniform4iv": _glUniform4iv, + "_glUniform4uiv": _glUniform4uiv, + "_glUniformBlockBinding": _glUniformBlockBinding, + "_glUniformMatrix3fv": _glUniformMatrix3fv, + "_glUniformMatrix4fv": _glUniformMatrix4fv, + "_glUnmapBuffer": _glUnmapBuffer, + "_glUseProgram": _glUseProgram, + "_glValidateProgram": _glValidateProgram, + "_glVertexAttrib4f": _glVertexAttrib4f, + "_glVertexAttrib4fv": _glVertexAttrib4fv, + "_glVertexAttribIPointer": _glVertexAttribIPointer, + "_glVertexAttribPointer": _glVertexAttribPointer, + "_glViewport": _glViewport, + "_gmtime": _gmtime, + "_gmtime_r": _gmtime_r, + "_inet_addr": _inet_addr, + "_llvm_ceil_f32": _llvm_ceil_f32, + "_llvm_ceil_f64": _llvm_ceil_f64, + "_llvm_cttz_i32": _llvm_cttz_i32, + "_llvm_eh_typeid_for": _llvm_eh_typeid_for, + "_llvm_exp2_f32": _llvm_exp2_f32, + "_llvm_fabs_f32": _llvm_fabs_f32, + "_llvm_fabs_f64": _llvm_fabs_f64, + "_llvm_floor_f32": _llvm_floor_f32, + "_llvm_floor_f64": _llvm_floor_f64, + "_llvm_pow_f32": _llvm_pow_f32, + "_llvm_pow_f64": _llvm_pow_f64, + "_llvm_trap": _llvm_trap, + "_localtime": _localtime, + "_localtime_r": _localtime_r, + "_longjmp": _longjmp, + "_mktime": _mktime, + "_pthread_attr_destroy": _pthread_attr_destroy, + "_pthread_attr_init": _pthread_attr_init, + "_pthread_cond_destroy": _pthread_cond_destroy, + "_pthread_cond_init": _pthread_cond_init, + "_pthread_cond_signal": _pthread_cond_signal, + "_pthread_cond_timedwait": _pthread_cond_timedwait, + "_pthread_cond_wait": _pthread_cond_wait, + "_pthread_create": _pthread_create, + "_pthread_detach": _pthread_detach, + "_pthread_getspecific": _pthread_getspecific, + "_pthread_key_create": _pthread_key_create, + "_pthread_key_delete": _pthread_key_delete, + "_pthread_mutex_destroy": _pthread_mutex_destroy, + "_pthread_mutex_init": _pthread_mutex_init, + "_pthread_mutexattr_destroy": _pthread_mutexattr_destroy, + "_pthread_mutexattr_init": _pthread_mutexattr_init, + "_pthread_mutexattr_setprotocol": _pthread_mutexattr_setprotocol, + "_pthread_mutexattr_settype": _pthread_mutexattr_settype, + "_pthread_once": _pthread_once, + "_pthread_rwlock_init": _pthread_rwlock_init, + "_pthread_rwlock_rdlock": _pthread_rwlock_rdlock, + "_pthread_rwlock_unlock": _pthread_rwlock_unlock, + "_pthread_rwlock_wrlock": _pthread_rwlock_wrlock, + "_pthread_setspecific": _pthread_setspecific, + "_putenv": _putenv, + "_sched_yield": _sched_yield, + "_setenv": _setenv, + "_sigaction": _sigaction, + "_sigemptyset": _sigemptyset, + "_strftime": _strftime, + "_sysconf": _sysconf, + "_time": _time, + "_tzset": _tzset, + "_unsetenv": _unsetenv, + "_utime": _utime, + "emscriptenWebGLComputeImageSize": emscriptenWebGLComputeImageSize, + "emscriptenWebGLGet": emscriptenWebGLGet, + "emscriptenWebGLGetBufferBinding": emscriptenWebGLGetBufferBinding, + "emscriptenWebGLGetHeapForType": emscriptenWebGLGetHeapForType, + "emscriptenWebGLGetIndexed": emscriptenWebGLGetIndexed, + "emscriptenWebGLGetShiftForType": emscriptenWebGLGetShiftForType, + "emscriptenWebGLGetTexPixelData": emscriptenWebGLGetTexPixelData, + "emscriptenWebGLGetUniform": emscriptenWebGLGetUniform, + "emscriptenWebGLGetVertexAttrib": emscriptenWebGLGetVertexAttrib, + "emscriptenWebGLValidateMapBufferTarget": emscriptenWebGLValidateMapBufferTarget, + "DYNAMICTOP_PTR": DYNAMICTOP_PTR, + "tempDoublePtr": tempDoublePtr, + "ABORT": ABORT, + "STACKTOP": STACKTOP, + "STACK_MAX": STACK_MAX, + "cttz_i8": cttz_i8, + "_environ": _environ +}; +var asm = Module["asm"](Module.asmGlobalArg, Module.asmLibraryArg, buffer); +var real__InjectProfilerSample = asm["_InjectProfilerSample"]; +asm["_InjectProfilerSample"] = (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 real__InjectProfilerSample.apply(null, arguments); +}); +var real__SendMessage = asm["_SendMessage"]; +asm["_SendMessage"] = (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 real__SendMessage.apply(null, arguments); +}); +var real__SendMessageFloat = asm["_SendMessageFloat"]; +asm["_SendMessageFloat"] = (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 real__SendMessageFloat.apply(null, arguments); +}); +var real__SendMessageString = asm["_SendMessageString"]; +asm["_SendMessageString"] = (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 real__SendMessageString.apply(null, arguments); +}); +var real__SetFullscreen = asm["_SetFullscreen"]; +asm["_SetFullscreen"] = (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 real__SetFullscreen.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AIScriptingClasses_cpp = asm["__GLOBAL__sub_I_AIScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_AIScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_AIScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ARScriptingClasses_cpp = asm["__GLOBAL__sub_I_ARScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_ARScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_ARScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AccessibilityScriptingClasses_cpp = asm["__GLOBAL__sub_I_AccessibilityScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_AccessibilityScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_AccessibilityScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AnimationClip_cpp = asm["__GLOBAL__sub_I_AnimationClip_cpp"]; +asm["__GLOBAL__sub_I_AnimationClip_cpp"] = (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 real___GLOBAL__sub_I_AnimationClip_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AnimationScriptingClasses_cpp = asm["__GLOBAL__sub_I_AnimationScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_AnimationScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_AnimationScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AppDomain_cpp = asm["__GLOBAL__sub_I_AppDomain_cpp"]; +asm["__GLOBAL__sub_I_AppDomain_cpp"] = (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 real___GLOBAL__sub_I_AppDomain_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ArrayMetadata_cpp = asm["__GLOBAL__sub_I_ArrayMetadata_cpp"]; +asm["__GLOBAL__sub_I_ArrayMetadata_cpp"] = (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 real___GLOBAL__sub_I_ArrayMetadata_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Assembly_cpp = asm["__GLOBAL__sub_I_Assembly_cpp"]; +asm["__GLOBAL__sub_I_Assembly_cpp"] = (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 real___GLOBAL__sub_I_Assembly_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Assembly_cpp_95986 = asm["__GLOBAL__sub_I_Assembly_cpp_95986"]; +asm["__GLOBAL__sub_I_Assembly_cpp_95986"] = (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 real___GLOBAL__sub_I_Assembly_cpp_95986.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AssetBundleFileSystem_cpp = asm["__GLOBAL__sub_I_AssetBundleFileSystem_cpp"]; +asm["__GLOBAL__sub_I_AssetBundleFileSystem_cpp"] = (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 real___GLOBAL__sub_I_AssetBundleFileSystem_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AssetBundleScriptingClasses_cpp = asm["__GLOBAL__sub_I_AssetBundleScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_AssetBundleScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_AssetBundleScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_AudioScriptingClasses_cpp = asm["__GLOBAL__sub_I_AudioScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_AudioScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_AudioScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Avatar_cpp = asm["__GLOBAL__sub_I_Avatar_cpp"]; +asm["__GLOBAL__sub_I_Avatar_cpp"] = (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 real___GLOBAL__sub_I_Avatar_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_BoehmGC_cpp = asm["__GLOBAL__sub_I_BoehmGC_cpp"]; +asm["__GLOBAL__sub_I_BoehmGC_cpp"] = (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 real___GLOBAL__sub_I_BoehmGC_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_COMEntryPoints_cpp = asm["__GLOBAL__sub_I_COMEntryPoints_cpp"]; +asm["__GLOBAL__sub_I_COMEntryPoints_cpp"] = (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 real___GLOBAL__sub_I_COMEntryPoints_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Class_cpp = asm["__GLOBAL__sub_I_Class_cpp"]; +asm["__GLOBAL__sub_I_Class_cpp"] = (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 real___GLOBAL__sub_I_Class_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ClothScriptingClasses_cpp = asm["__GLOBAL__sub_I_ClothScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_ClothScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_ClothScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Console_cpp = asm["__GLOBAL__sub_I_Console_cpp"]; +asm["__GLOBAL__sub_I_Console_cpp"] = (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 real___GLOBAL__sub_I_Console_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ConstraintJob_cpp = asm["__GLOBAL__sub_I_ConstraintJob_cpp"]; +asm["__GLOBAL__sub_I_ConstraintJob_cpp"] = (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 real___GLOBAL__sub_I_ConstraintJob_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ConstraintManager_cpp = asm["__GLOBAL__sub_I_ConstraintManager_cpp"]; +asm["__GLOBAL__sub_I_ConstraintManager_cpp"] = (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 real___GLOBAL__sub_I_ConstraintManager_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_DirectorScriptingClasses_cpp = asm["__GLOBAL__sub_I_DirectorScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_DirectorScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_DirectorScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Environment_cpp = asm["__GLOBAL__sub_I_Environment_cpp"]; +asm["__GLOBAL__sub_I_Environment_cpp"] = (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 real___GLOBAL__sub_I_Environment_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Error_cpp = asm["__GLOBAL__sub_I_Error_cpp"]; +asm["__GLOBAL__sub_I_Error_cpp"] = (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 real___GLOBAL__sub_I_Error_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp = asm["__GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp"]; +asm["__GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp"] = (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 real___GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp = asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp"]; +asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp"] = (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 real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp = asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp"]; +asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp"] = (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 real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp = asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp"]; +asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp"] = (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 real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp = asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp"]; +asm["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp"] = (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 real___GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp = asm["__GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp"]; +asm["__GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp"] = (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 real___GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_External_Yoga_Yoga_0_cpp = asm["__GLOBAL__sub_I_External_Yoga_Yoga_0_cpp"]; +asm["__GLOBAL__sub_I_External_Yoga_Yoga_0_cpp"] = (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 real___GLOBAL__sub_I_External_Yoga_Yoga_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_File_cpp = asm["__GLOBAL__sub_I_File_cpp"]; +asm["__GLOBAL__sub_I_File_cpp"] = (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 real___GLOBAL__sub_I_File_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_GCHandle_cpp = asm["__GLOBAL__sub_I_GCHandle_cpp"]; +asm["__GLOBAL__sub_I_GCHandle_cpp"] = (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 real___GLOBAL__sub_I_GCHandle_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_GarbageCollector_cpp = asm["__GLOBAL__sub_I_GarbageCollector_cpp"]; +asm["__GLOBAL__sub_I_GarbageCollector_cpp"] = (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 real___GLOBAL__sub_I_GarbageCollector_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_GenericMetadata_cpp = asm["__GLOBAL__sub_I_GenericMetadata_cpp"]; +asm["__GLOBAL__sub_I_GenericMetadata_cpp"] = (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 real___GLOBAL__sub_I_GenericMetadata_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_GenericMethod_cpp = asm["__GLOBAL__sub_I_GenericMethod_cpp"]; +asm["__GLOBAL__sub_I_GenericMethod_cpp"] = (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 real___GLOBAL__sub_I_GenericMethod_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_GfxDeviceNull_cpp = asm["__GLOBAL__sub_I_GfxDeviceNull_cpp"]; +asm["__GLOBAL__sub_I_GfxDeviceNull_cpp"] = (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 real___GLOBAL__sub_I_GfxDeviceNull_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_GridScriptingClasses_cpp = asm["__GLOBAL__sub_I_GridScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_GridScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_GridScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_IMGUIScriptingClasses_cpp = asm["__GLOBAL__sub_I_IMGUIScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_IMGUIScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_IMGUIScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Il2CppCodeRegistration_cpp = asm["__GLOBAL__sub_I_Il2CppCodeRegistration_cpp"]; +asm["__GLOBAL__sub_I_Il2CppCodeRegistration_cpp"] = (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 real___GLOBAL__sub_I_Il2CppCodeRegistration_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Image_cpp = asm["__GLOBAL__sub_I_Image_cpp"]; +asm["__GLOBAL__sub_I_Image_cpp"] = (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 real___GLOBAL__sub_I_Image_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_InputScriptingClasses_cpp = asm["__GLOBAL__sub_I_InputScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_InputScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_InputScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Interlocked_cpp = asm["__GLOBAL__sub_I_Interlocked_cpp"]; +asm["__GLOBAL__sub_I_Interlocked_cpp"] = (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 real___GLOBAL__sub_I_Interlocked_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_LibraryLoader_cpp = asm["__GLOBAL__sub_I_LibraryLoader_cpp"]; +asm["__GLOBAL__sub_I_LibraryLoader_cpp"] = (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 real___GLOBAL__sub_I_LibraryLoader_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_LineRenderer_cpp = asm["__GLOBAL__sub_I_LineRenderer_cpp"]; +asm["__GLOBAL__sub_I_LineRenderer_cpp"] = (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 real___GLOBAL__sub_I_LineRenderer_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_LogAssert_cpp = asm["__GLOBAL__sub_I_LogAssert_cpp"]; +asm["__GLOBAL__sub_I_LogAssert_cpp"] = (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 real___GLOBAL__sub_I_LogAssert_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_MemoryMapImpl_cpp = asm["__GLOBAL__sub_I_MemoryMapImpl_cpp"]; +asm["__GLOBAL__sub_I_MemoryMapImpl_cpp"] = (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 real___GLOBAL__sub_I_MemoryMapImpl_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_MemoryMappedFile_cpp = asm["__GLOBAL__sub_I_MemoryMappedFile_cpp"]; +asm["__GLOBAL__sub_I_MemoryMappedFile_cpp"] = (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 real___GLOBAL__sub_I_MemoryMappedFile_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_MetadataCache_cpp = asm["__GLOBAL__sub_I_MetadataCache_cpp"]; +asm["__GLOBAL__sub_I_MetadataCache_cpp"] = (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 real___GLOBAL__sub_I_MetadataCache_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AI_0_cpp = asm["__GLOBAL__sub_I_Modules_AI_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_AI_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_AI_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AI_Builder_0_cpp = asm["__GLOBAL__sub_I_Modules_AI_Builder_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_AI_Builder_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_AI_Builder_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AI_Crowd_0_cpp = asm["__GLOBAL__sub_I_Modules_AI_Crowd_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_AI_Crowd_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_AI_Crowd_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp = asm["__GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp = asm["__GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp = asm["__GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp = asm["__GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp"]; +asm["__GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp"] = (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 real___GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Audio_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_Audio_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Audio_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Audio_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Audio_Public_1_cpp = asm["__GLOBAL__sub_I_Modules_Audio_Public_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_Audio_Public_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_Audio_Public_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Audio_Public_3_cpp = asm["__GLOBAL__sub_I_Modules_Audio_Public_3_cpp"]; +asm["__GLOBAL__sub_I_Modules_Audio_Public_3_cpp"] = (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 real___GLOBAL__sub_I_Modules_Audio_Public_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Grid_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_Grid_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Grid_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Grid_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_IMGUI_0_cpp = asm["__GLOBAL__sub_I_Modules_IMGUI_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_IMGUI_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_IMGUI_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_IMGUI_1_cpp = asm["__GLOBAL__sub_I_Modules_IMGUI_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_IMGUI_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_IMGUI_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Physics2D_0_cpp = asm["__GLOBAL__sub_I_Modules_Physics2D_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Physics2D_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Physics2D_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp = asm["__GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp = asm["__GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Profiler_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_Profiler_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Profiler_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Profiler_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Profiler_Public_1_cpp = asm["__GLOBAL__sub_I_Modules_Profiler_Public_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_Profiler_Public_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_Profiler_Public_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp = asm["__GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp = asm["__GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp = asm["__GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Terrain_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_Terrain_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Terrain_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Terrain_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Terrain_Public_1_cpp = asm["__GLOBAL__sub_I_Modules_Terrain_Public_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_Terrain_Public_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_Terrain_Public_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Terrain_Public_2_cpp = asm["__GLOBAL__sub_I_Modules_Terrain_Public_2_cpp"]; +asm["__GLOBAL__sub_I_Modules_Terrain_Public_2_cpp"] = (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 real___GLOBAL__sub_I_Modules_Terrain_Public_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Terrain_VR_0_cpp = asm["__GLOBAL__sub_I_Modules_Terrain_VR_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Terrain_VR_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Terrain_VR_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp = asm["__GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Tilemap_0_cpp = asm["__GLOBAL__sub_I_Modules_Tilemap_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Tilemap_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Tilemap_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_UIElements_0_cpp = asm["__GLOBAL__sub_I_Modules_UIElements_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_UIElements_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_UIElements_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp = asm["__GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp = asm["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_VFX_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_VFX_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_VFX_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_VFX_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_VFX_Public_1_cpp = asm["__GLOBAL__sub_I_Modules_VFX_Public_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_VFX_Public_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_VFX_Public_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_VFX_Public_2_cpp = asm["__GLOBAL__sub_I_Modules_VFX_Public_2_cpp"]; +asm["__GLOBAL__sub_I_Modules_VFX_Public_2_cpp"] = (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 real___GLOBAL__sub_I_Modules_VFX_Public_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp = asm["__GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Video_Public_0_cpp = asm["__GLOBAL__sub_I_Modules_Video_Public_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Video_Public_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Video_Public_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp = asm["__GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp"]; +asm["__GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp"] = (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 real___GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp = asm["__GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp"]; +asm["__GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp"] = (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 real___GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_NativeDelegateMethodCache_cpp = asm["__GLOBAL__sub_I_NativeDelegateMethodCache_cpp"]; +asm["__GLOBAL__sub_I_NativeDelegateMethodCache_cpp"] = (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 real___GLOBAL__sub_I_NativeDelegateMethodCache_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ParticleSystemGeometryJob_cpp = asm["__GLOBAL__sub_I_ParticleSystemGeometryJob_cpp"]; +asm["__GLOBAL__sub_I_ParticleSystemGeometryJob_cpp"] = (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 real___GLOBAL__sub_I_ParticleSystemGeometryJob_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ParticleSystemRenderer_cpp = asm["__GLOBAL__sub_I_ParticleSystemRenderer_cpp"]; +asm["__GLOBAL__sub_I_ParticleSystemRenderer_cpp"] = (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 real___GLOBAL__sub_I_ParticleSystemRenderer_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp = asm["__GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Path_cpp = asm["__GLOBAL__sub_I_Path_cpp"]; +asm["__GLOBAL__sub_I_Path_cpp"] = (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 real___GLOBAL__sub_I_Path_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp = asm["__GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp"]; +asm["__GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp"] = (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 real___GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Physics2DScriptingClasses_cpp = asm["__GLOBAL__sub_I_Physics2DScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_Physics2DScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_Physics2DScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_PhysicsQuery_cpp = asm["__GLOBAL__sub_I_PhysicsQuery_cpp"]; +asm["__GLOBAL__sub_I_PhysicsQuery_cpp"] = (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 real___GLOBAL__sub_I_PhysicsQuery_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_PhysicsScene_cpp = asm["__GLOBAL__sub_I_PhysicsScene_cpp"]; +asm["__GLOBAL__sub_I_PhysicsScene_cpp"] = (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 real___GLOBAL__sub_I_PhysicsScene_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_PhysicsScriptingClasses_cpp = asm["__GLOBAL__sub_I_PhysicsScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_PhysicsScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_PhysicsScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp = asm["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp"]; +asm["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp"] = (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 real___GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp = asm["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp"]; +asm["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp"] = (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 real___GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_RCW_cpp = asm["__GLOBAL__sub_I_RCW_cpp"]; +asm["__GLOBAL__sub_I_RCW_cpp"] = (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 real___GLOBAL__sub_I_RCW_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Reflection_cpp = asm["__GLOBAL__sub_I_Reflection_cpp"]; +asm["__GLOBAL__sub_I_Reflection_cpp"] = (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 real___GLOBAL__sub_I_Reflection_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp = asm["__GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp = asm["__GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp = asm["__GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Allocator_1_cpp = asm["__GLOBAL__sub_I_Runtime_Allocator_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Allocator_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Allocator_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Allocator_2_cpp = asm["__GLOBAL__sub_I_Runtime_Allocator_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Allocator_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Allocator_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_0_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_1_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_2_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_3_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_5_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_5_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_5_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_5_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_6_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_6_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_6_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_6_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_Director_0_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_Director_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_Director_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_Director_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Animation_Director_1_cpp = asm["__GLOBAL__sub_I_Runtime_Animation_Director_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Animation_Director_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Animation_Director_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Application_0_cpp = asm["__GLOBAL__sub_I_Runtime_Application_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Application_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Application_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_BaseClasses_0_cpp = asm["__GLOBAL__sub_I_Runtime_BaseClasses_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_BaseClasses_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_BaseClasses_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_BaseClasses_1_cpp = asm["__GLOBAL__sub_I_Runtime_BaseClasses_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_BaseClasses_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_BaseClasses_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_BaseClasses_2_cpp = asm["__GLOBAL__sub_I_Runtime_BaseClasses_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_BaseClasses_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_BaseClasses_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_BaseClasses_3_cpp = asm["__GLOBAL__sub_I_Runtime_BaseClasses_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_BaseClasses_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_BaseClasses_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Burst_0_cpp = asm["__GLOBAL__sub_I_Runtime_Burst_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Burst_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Burst_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_0_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_1_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_2_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_3_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_4_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_4_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_4_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_4_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_5_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_5_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_5_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_5_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_6_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_6_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_6_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_6_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_7_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_7_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_7_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_7_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp = asm["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Cloth_0_cpp = asm["__GLOBAL__sub_I_Runtime_Cloth_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Cloth_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Cloth_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Containers_0_cpp = asm["__GLOBAL__sub_I_Runtime_Containers_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Containers_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Containers_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp = asm["__GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Director_Core_1_cpp = asm["__GLOBAL__sub_I_Runtime_Director_Core_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Director_Core_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Director_Core_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Dynamics_0_cpp = asm["__GLOBAL__sub_I_Runtime_Dynamics_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Dynamics_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Dynamics_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Dynamics_1_cpp = asm["__GLOBAL__sub_I_Runtime_Dynamics_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Dynamics_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Dynamics_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Dynamics_3_cpp = asm["__GLOBAL__sub_I_Runtime_Dynamics_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Dynamics_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Dynamics_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp = asm["__GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Export_0_cpp = asm["__GLOBAL__sub_I_Runtime_Export_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Export_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Export_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_File_0_cpp = asm["__GLOBAL__sub_I_Runtime_File_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_File_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_File_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_GameCode_0_cpp = asm["__GLOBAL__sub_I_Runtime_GameCode_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_GameCode_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_GameCode_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Geometry_1_cpp = asm["__GLOBAL__sub_I_Runtime_Geometry_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Geometry_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Geometry_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Geometry_2_cpp = asm["__GLOBAL__sub_I_Runtime_Geometry_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Geometry_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Geometry_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_GfxDevice_0_cpp = asm["__GLOBAL__sub_I_Runtime_GfxDevice_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_GfxDevice_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_GfxDevice_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_GfxDevice_1_cpp = asm["__GLOBAL__sub_I_Runtime_GfxDevice_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_GfxDevice_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_GfxDevice_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_GfxDevice_2_cpp = asm["__GLOBAL__sub_I_Runtime_GfxDevice_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_GfxDevice_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_GfxDevice_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_GfxDevice_3_cpp = asm["__GLOBAL__sub_I_Runtime_GfxDevice_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_GfxDevice_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_GfxDevice_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_0_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_10_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_10_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_10_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_10_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_11_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_11_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_11_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_11_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_1_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_2_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_5_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_5_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_5_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_5_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_6_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_6_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_6_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_6_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_7_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_7_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_7_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_7_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_8_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_8_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_8_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_8_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_9_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_9_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_9_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_9_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp = asm["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Input_0_cpp = asm["__GLOBAL__sub_I_Runtime_Input_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Input_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Input_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Interfaces_0_cpp = asm["__GLOBAL__sub_I_Runtime_Interfaces_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Interfaces_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Interfaces_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Interfaces_1_cpp = asm["__GLOBAL__sub_I_Runtime_Interfaces_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Interfaces_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Interfaces_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Interfaces_2_cpp = asm["__GLOBAL__sub_I_Runtime_Interfaces_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Interfaces_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Interfaces_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Jobs_0_cpp = asm["__GLOBAL__sub_I_Runtime_Jobs_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Jobs_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Jobs_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Jobs_1_cpp = asm["__GLOBAL__sub_I_Runtime_Jobs_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Jobs_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Jobs_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp = asm["__GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Math_2_cpp = asm["__GLOBAL__sub_I_Runtime_Math_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Math_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Math_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Math_Random_0_cpp = asm["__GLOBAL__sub_I_Runtime_Math_Random_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Math_Random_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Math_Random_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Misc_0_cpp = asm["__GLOBAL__sub_I_Runtime_Misc_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Misc_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Misc_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Misc_1_cpp = asm["__GLOBAL__sub_I_Runtime_Misc_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Misc_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Misc_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Misc_2_cpp = asm["__GLOBAL__sub_I_Runtime_Misc_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Misc_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Misc_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Misc_3_cpp = asm["__GLOBAL__sub_I_Runtime_Misc_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Misc_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Misc_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Misc_4_cpp = asm["__GLOBAL__sub_I_Runtime_Misc_4_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Misc_4_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Misc_4_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Misc_5_cpp = asm["__GLOBAL__sub_I_Runtime_Misc_5_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Misc_5_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Misc_5_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Modules_0_cpp = asm["__GLOBAL__sub_I_Runtime_Modules_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Modules_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Modules_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Mono_0_cpp = asm["__GLOBAL__sub_I_Runtime_Mono_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Mono_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Mono_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp = asm["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp = asm["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Network_0_cpp = asm["__GLOBAL__sub_I_Runtime_Network_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Network_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Network_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp = asm["__GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp = asm["__GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp = asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp = asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp = asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp = asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp = asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp = asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_PluginInterface_0_cpp = asm["__GLOBAL__sub_I_Runtime_PluginInterface_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_PluginInterface_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_PluginInterface_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_PreloadManager_0_cpp = asm["__GLOBAL__sub_I_Runtime_PreloadManager_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_PreloadManager_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_PreloadManager_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Profiler_0_cpp = asm["__GLOBAL__sub_I_Runtime_Profiler_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Profiler_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Profiler_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Profiler_1_cpp = asm["__GLOBAL__sub_I_Runtime_Profiler_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Profiler_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Profiler_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Profiler_2_cpp = asm["__GLOBAL__sub_I_Runtime_Profiler_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Profiler_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Profiler_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp = asm["__GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_SceneManager_0_cpp = asm["__GLOBAL__sub_I_Runtime_SceneManager_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_SceneManager_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_SceneManager_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp = asm["__GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Scripting_0_cpp = asm["__GLOBAL__sub_I_Runtime_Scripting_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Scripting_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Scripting_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Scripting_3_cpp = asm["__GLOBAL__sub_I_Runtime_Scripting_3_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Scripting_3_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Scripting_3_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp = asm["__GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Serialize_0_cpp = asm["__GLOBAL__sub_I_Runtime_Serialize_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Serialize_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Serialize_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp = asm["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp = asm["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Shaders_0_cpp = asm["__GLOBAL__sub_I_Runtime_Shaders_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Shaders_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Shaders_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Shaders_1_cpp = asm["__GLOBAL__sub_I_Runtime_Shaders_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Shaders_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Shaders_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Shaders_2_cpp = asm["__GLOBAL__sub_I_Runtime_Shaders_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Shaders_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Shaders_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp = asm["__GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp = asm["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp = asm["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Streaming_0_cpp = asm["__GLOBAL__sub_I_Runtime_Streaming_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Streaming_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Streaming_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Streaming_1_cpp = asm["__GLOBAL__sub_I_Runtime_Streaming_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Streaming_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Streaming_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp = asm["__GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Transform_0_cpp = asm["__GLOBAL__sub_I_Runtime_Transform_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Transform_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Transform_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Transform_1_cpp = asm["__GLOBAL__sub_I_Runtime_Transform_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Transform_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Transform_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_UI_0_cpp = asm["__GLOBAL__sub_I_Runtime_UI_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_UI_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_UI_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_UI_1_cpp = asm["__GLOBAL__sub_I_Runtime_UI_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_UI_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_UI_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_UI_2_cpp = asm["__GLOBAL__sub_I_Runtime_UI_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_UI_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_UI_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Utilities_2_cpp = asm["__GLOBAL__sub_I_Runtime_Utilities_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Utilities_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Utilities_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Utilities_5_cpp = asm["__GLOBAL__sub_I_Runtime_Utilities_5_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Utilities_5_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Utilities_5_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Utilities_6_cpp = asm["__GLOBAL__sub_I_Runtime_Utilities_6_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Utilities_6_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Utilities_6_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Utilities_7_cpp = asm["__GLOBAL__sub_I_Runtime_Utilities_7_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Utilities_7_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Utilities_7_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Utilities_8_cpp = asm["__GLOBAL__sub_I_Runtime_Utilities_8_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Utilities_8_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Utilities_8_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Utilities_9_cpp = asm["__GLOBAL__sub_I_Runtime_Utilities_9_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Utilities_9_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Utilities_9_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_VR_0_cpp = asm["__GLOBAL__sub_I_Runtime_VR_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_VR_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_VR_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_VR_2_cpp = asm["__GLOBAL__sub_I_Runtime_VR_2_cpp"]; +asm["__GLOBAL__sub_I_Runtime_VR_2_cpp"] = (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 real___GLOBAL__sub_I_Runtime_VR_2_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp = asm["__GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Vehicles_0_cpp = asm["__GLOBAL__sub_I_Runtime_Vehicles_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Vehicles_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Vehicles_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_Video_0_cpp = asm["__GLOBAL__sub_I_Runtime_Video_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_Video_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_Video_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp = asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp = asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp"]; +asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp"] = (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 real___GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp = asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp = asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp"]; +asm["__GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp"] = (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 real___GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_cpp = asm["__GLOBAL__sub_I_Runtime_cpp"]; +asm["__GLOBAL__sub_I_Runtime_cpp"] = (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 real___GLOBAL__sub_I_Runtime_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Runtime_cpp_96605 = asm["__GLOBAL__sub_I_Runtime_cpp_96605"]; +asm["__GLOBAL__sub_I_Runtime_cpp_96605"] = (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 real___GLOBAL__sub_I_Runtime_cpp_96605.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Shader_cpp = asm["__GLOBAL__sub_I_Shader_cpp"]; +asm["__GLOBAL__sub_I_Shader_cpp"] = (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 real___GLOBAL__sub_I_Shader_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Shadows_cpp = asm["__GLOBAL__sub_I_Shadows_cpp"]; +asm["__GLOBAL__sub_I_Shadows_cpp"] = (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 real___GLOBAL__sub_I_Shadows_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ShapeModule_cpp = asm["__GLOBAL__sub_I_ShapeModule_cpp"]; +asm["__GLOBAL__sub_I_ShapeModule_cpp"] = (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 real___GLOBAL__sub_I_ShapeModule_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SkinnedMeshRendererManager_cpp = asm["__GLOBAL__sub_I_SkinnedMeshRendererManager_cpp"]; +asm["__GLOBAL__sub_I_SkinnedMeshRendererManager_cpp"] = (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 real___GLOBAL__sub_I_SkinnedMeshRendererManager_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Socket_cpp = asm["__GLOBAL__sub_I_Socket_cpp"]; +asm["__GLOBAL__sub_I_Socket_cpp"] = (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 real___GLOBAL__sub_I_Socket_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SparseTextureGLES_cpp = asm["__GLOBAL__sub_I_SparseTextureGLES_cpp"]; +asm["__GLOBAL__sub_I_SparseTextureGLES_cpp"] = (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 real___GLOBAL__sub_I_SparseTextureGLES_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SpriteRendererJobs_cpp = asm["__GLOBAL__sub_I_SpriteRendererJobs_cpp"]; +asm["__GLOBAL__sub_I_SpriteRendererJobs_cpp"] = (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 real___GLOBAL__sub_I_SpriteRendererJobs_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_StackTrace_cpp = asm["__GLOBAL__sub_I_StackTrace_cpp"]; +asm["__GLOBAL__sub_I_StackTrace_cpp"] = (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 real___GLOBAL__sub_I_StackTrace_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_String_cpp = asm["__GLOBAL__sub_I_String_cpp"]; +asm["__GLOBAL__sub_I_String_cpp"] = (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 real___GLOBAL__sub_I_String_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SwCollision_cpp = asm["__GLOBAL__sub_I_SwCollision_cpp"]; +asm["__GLOBAL__sub_I_SwCollision_cpp"] = (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 real___GLOBAL__sub_I_SwCollision_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SwFactory_cpp = asm["__GLOBAL__sub_I_SwFactory_cpp"]; +asm["__GLOBAL__sub_I_SwFactory_cpp"] = (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 real___GLOBAL__sub_I_SwFactory_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SwInterCollision_cpp = asm["__GLOBAL__sub_I_SwInterCollision_cpp"]; +asm["__GLOBAL__sub_I_SwInterCollision_cpp"] = (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 real___GLOBAL__sub_I_SwInterCollision_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SwSelfCollision_cpp = asm["__GLOBAL__sub_I_SwSelfCollision_cpp"]; +asm["__GLOBAL__sub_I_SwSelfCollision_cpp"] = (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 real___GLOBAL__sub_I_SwSelfCollision_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_SwSolverKernel_cpp = asm["__GLOBAL__sub_I_SwSolverKernel_cpp"]; +asm["__GLOBAL__sub_I_SwSolverKernel_cpp"] = (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 real___GLOBAL__sub_I_SwSolverKernel_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_TerrainScriptingClasses_cpp = asm["__GLOBAL__sub_I_TerrainScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_TerrainScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_TerrainScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_TextCoreScriptingClasses_cpp = asm["__GLOBAL__sub_I_TextCoreScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_TextCoreScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_TextCoreScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_TextRenderingScriptingClasses_cpp = asm["__GLOBAL__sub_I_TextRenderingScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_TextRenderingScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_TextRenderingScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_ThreadImpl_cpp = asm["__GLOBAL__sub_I_ThreadImpl_cpp"]; +asm["__GLOBAL__sub_I_ThreadImpl_cpp"] = (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 real___GLOBAL__sub_I_ThreadImpl_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Thread_cpp = asm["__GLOBAL__sub_I_Thread_cpp"]; +asm["__GLOBAL__sub_I_Thread_cpp"] = (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 real___GLOBAL__sub_I_Thread_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Thread_cpp_95153 = asm["__GLOBAL__sub_I_Thread_cpp_95153"]; +asm["__GLOBAL__sub_I_Thread_cpp_95153"] = (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 real___GLOBAL__sub_I_Thread_cpp_95153.apply(null, arguments); +}); +var real___GLOBAL__sub_I_TilemapScriptingClasses_cpp = asm["__GLOBAL__sub_I_TilemapScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_TilemapScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_TilemapScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_TrailRenderer_cpp = asm["__GLOBAL__sub_I_TrailRenderer_cpp"]; +asm["__GLOBAL__sub_I_TrailRenderer_cpp"] = (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 real___GLOBAL__sub_I_TrailRenderer_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_TransformFeedbackSkinning_cpp = asm["__GLOBAL__sub_I_TransformFeedbackSkinning_cpp"]; +asm["__GLOBAL__sub_I_TransformFeedbackSkinning_cpp"] = (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 real___GLOBAL__sub_I_TransformFeedbackSkinning_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Transform_cpp = asm["__GLOBAL__sub_I_Transform_cpp"]; +asm["__GLOBAL__sub_I_Transform_cpp"] = (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 real___GLOBAL__sub_I_Transform_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_UIElementsScriptingClasses_cpp = asm["__GLOBAL__sub_I_UIElementsScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_UIElementsScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_UIElementsScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_UIScriptingClasses_cpp = asm["__GLOBAL__sub_I_UIScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_UIScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_UIScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_UnityAdsSettings_cpp = asm["__GLOBAL__sub_I_UnityAdsSettings_cpp"]; +asm["__GLOBAL__sub_I_UnityAdsSettings_cpp"] = (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 real___GLOBAL__sub_I_UnityAdsSettings_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp = asm["__GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp = asm["__GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_UnsafeUtility_bindings_cpp = asm["__GLOBAL__sub_I_UnsafeUtility_bindings_cpp"]; +asm["__GLOBAL__sub_I_UnsafeUtility_bindings_cpp"] = (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 real___GLOBAL__sub_I_UnsafeUtility_bindings_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_VFXScriptingClasses_cpp = asm["__GLOBAL__sub_I_VFXScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_VFXScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_VFXScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_VRScriptingClasses_cpp = asm["__GLOBAL__sub_I_VRScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_VRScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_VRScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_VideoScriptingClasses_cpp = asm["__GLOBAL__sub_I_VideoScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_VideoScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_VideoScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_Wind_cpp = asm["__GLOBAL__sub_I_Wind_cpp"]; +asm["__GLOBAL__sub_I_Wind_cpp"] = (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 real___GLOBAL__sub_I_Wind_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_XRScriptingClasses_cpp = asm["__GLOBAL__sub_I_XRScriptingClasses_cpp"]; +asm["__GLOBAL__sub_I_XRScriptingClasses_cpp"] = (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 real___GLOBAL__sub_I_XRScriptingClasses_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp = asm["__GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp"]; +asm["__GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp"] = (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 real___GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp = asm["__GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp"]; +asm["__GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp"] = (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 real___GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_clipmuscle_cpp = asm["__GLOBAL__sub_I_clipmuscle_cpp"]; +asm["__GLOBAL__sub_I_clipmuscle_cpp"] = (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 real___GLOBAL__sub_I_clipmuscle_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_threadpool_ms_cpp = asm["__GLOBAL__sub_I_threadpool_ms_cpp"]; +asm["__GLOBAL__sub_I_threadpool_ms_cpp"] = (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 real___GLOBAL__sub_I_threadpool_ms_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_threadpool_ms_io_cpp = asm["__GLOBAL__sub_I_threadpool_ms_io_cpp"]; +asm["__GLOBAL__sub_I_threadpool_ms_io_cpp"] = (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 real___GLOBAL__sub_I_threadpool_ms_io_cpp.apply(null, arguments); +}); +var real___GLOBAL__sub_I_umbra_cpp = asm["__GLOBAL__sub_I_umbra_cpp"]; +asm["__GLOBAL__sub_I_umbra_cpp"] = (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 real___GLOBAL__sub_I_umbra_cpp.apply(null, arguments); +}); +var real____cxa_can_catch = asm["___cxa_can_catch"]; +asm["___cxa_can_catch"] = (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 real____cxa_can_catch.apply(null, arguments); +}); +var real____cxa_demangle = asm["___cxa_demangle"]; +asm["___cxa_demangle"] = (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 real____cxa_demangle.apply(null, arguments); +}); +var real____cxa_is_pointer_type = asm["___cxa_is_pointer_type"]; +asm["___cxa_is_pointer_type"] = (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 real____cxa_is_pointer_type.apply(null, arguments); +}); +var real____cxx_global_var_init = asm["___cxx_global_var_init"]; +asm["___cxx_global_var_init"] = (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 real____cxx_global_var_init.apply(null, arguments); +}); +var real____cxx_global_var_init_109 = asm["___cxx_global_var_init_109"]; +asm["___cxx_global_var_init_109"] = (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 real____cxx_global_var_init_109.apply(null, arguments); +}); +var real____cxx_global_var_init_11 = asm["___cxx_global_var_init_11"]; +asm["___cxx_global_var_init_11"] = (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 real____cxx_global_var_init_11.apply(null, arguments); +}); +var real____cxx_global_var_init_110 = asm["___cxx_global_var_init_110"]; +asm["___cxx_global_var_init_110"] = (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 real____cxx_global_var_init_110.apply(null, arguments); +}); +var real____cxx_global_var_init_110_4202 = asm["___cxx_global_var_init_110_4202"]; +asm["___cxx_global_var_init_110_4202"] = (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 real____cxx_global_var_init_110_4202.apply(null, arguments); +}); +var real____cxx_global_var_init_111 = asm["___cxx_global_var_init_111"]; +asm["___cxx_global_var_init_111"] = (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 real____cxx_global_var_init_111.apply(null, arguments); +}); +var real____cxx_global_var_init_111_5625 = asm["___cxx_global_var_init_111_5625"]; +asm["___cxx_global_var_init_111_5625"] = (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 real____cxx_global_var_init_111_5625.apply(null, arguments); +}); +var real____cxx_global_var_init_112 = asm["___cxx_global_var_init_112"]; +asm["___cxx_global_var_init_112"] = (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 real____cxx_global_var_init_112.apply(null, arguments); +}); +var real____cxx_global_var_init_120 = asm["___cxx_global_var_init_120"]; +asm["___cxx_global_var_init_120"] = (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 real____cxx_global_var_init_120.apply(null, arguments); +}); +var real____cxx_global_var_init_121 = asm["___cxx_global_var_init_121"]; +asm["___cxx_global_var_init_121"] = (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 real____cxx_global_var_init_121.apply(null, arguments); +}); +var real____cxx_global_var_init_122 = asm["___cxx_global_var_init_122"]; +asm["___cxx_global_var_init_122"] = (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 real____cxx_global_var_init_122.apply(null, arguments); +}); +var real____cxx_global_var_init_127 = asm["___cxx_global_var_init_127"]; +asm["___cxx_global_var_init_127"] = (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 real____cxx_global_var_init_127.apply(null, arguments); +}); +var real____cxx_global_var_init_128 = asm["___cxx_global_var_init_128"]; +asm["___cxx_global_var_init_128"] = (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 real____cxx_global_var_init_128.apply(null, arguments); +}); +var real____cxx_global_var_init_13 = asm["___cxx_global_var_init_13"]; +asm["___cxx_global_var_init_13"] = (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 real____cxx_global_var_init_13.apply(null, arguments); +}); +var real____cxx_global_var_init_14 = asm["___cxx_global_var_init_14"]; +asm["___cxx_global_var_init_14"] = (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 real____cxx_global_var_init_14.apply(null, arguments); +}); +var real____cxx_global_var_init_145 = asm["___cxx_global_var_init_145"]; +asm["___cxx_global_var_init_145"] = (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 real____cxx_global_var_init_145.apply(null, arguments); +}); +var real____cxx_global_var_init_159 = asm["___cxx_global_var_init_159"]; +asm["___cxx_global_var_init_159"] = (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 real____cxx_global_var_init_159.apply(null, arguments); +}); +var real____cxx_global_var_init_159_7516 = asm["___cxx_global_var_init_159_7516"]; +asm["___cxx_global_var_init_159_7516"] = (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 real____cxx_global_var_init_159_7516.apply(null, arguments); +}); +var real____cxx_global_var_init_16 = asm["___cxx_global_var_init_16"]; +asm["___cxx_global_var_init_16"] = (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 real____cxx_global_var_init_16.apply(null, arguments); +}); +var real____cxx_global_var_init_160 = asm["___cxx_global_var_init_160"]; +asm["___cxx_global_var_init_160"] = (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 real____cxx_global_var_init_160.apply(null, arguments); +}); +var real____cxx_global_var_init_161 = asm["___cxx_global_var_init_161"]; +asm["___cxx_global_var_init_161"] = (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 real____cxx_global_var_init_161.apply(null, arguments); +}); +var real____cxx_global_var_init_162 = asm["___cxx_global_var_init_162"]; +asm["___cxx_global_var_init_162"] = (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 real____cxx_global_var_init_162.apply(null, arguments); +}); +var real____cxx_global_var_init_163 = asm["___cxx_global_var_init_163"]; +asm["___cxx_global_var_init_163"] = (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 real____cxx_global_var_init_163.apply(null, arguments); +}); +var real____cxx_global_var_init_164 = asm["___cxx_global_var_init_164"]; +asm["___cxx_global_var_init_164"] = (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 real____cxx_global_var_init_164.apply(null, arguments); +}); +var real____cxx_global_var_init_165 = asm["___cxx_global_var_init_165"]; +asm["___cxx_global_var_init_165"] = (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 real____cxx_global_var_init_165.apply(null, arguments); +}); +var real____cxx_global_var_init_166 = asm["___cxx_global_var_init_166"]; +asm["___cxx_global_var_init_166"] = (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 real____cxx_global_var_init_166.apply(null, arguments); +}); +var real____cxx_global_var_init_167 = asm["___cxx_global_var_init_167"]; +asm["___cxx_global_var_init_167"] = (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 real____cxx_global_var_init_167.apply(null, arguments); +}); +var real____cxx_global_var_init_168 = asm["___cxx_global_var_init_168"]; +asm["___cxx_global_var_init_168"] = (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 real____cxx_global_var_init_168.apply(null, arguments); +}); +var real____cxx_global_var_init_169 = asm["___cxx_global_var_init_169"]; +asm["___cxx_global_var_init_169"] = (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 real____cxx_global_var_init_169.apply(null, arguments); +}); +var real____cxx_global_var_init_16_4048 = asm["___cxx_global_var_init_16_4048"]; +asm["___cxx_global_var_init_16_4048"] = (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 real____cxx_global_var_init_16_4048.apply(null, arguments); +}); +var real____cxx_global_var_init_16_727 = asm["___cxx_global_var_init_16_727"]; +asm["___cxx_global_var_init_16_727"] = (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 real____cxx_global_var_init_16_727.apply(null, arguments); +}); +var real____cxx_global_var_init_16_7920 = asm["___cxx_global_var_init_16_7920"]; +asm["___cxx_global_var_init_16_7920"] = (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 real____cxx_global_var_init_16_7920.apply(null, arguments); +}); +var real____cxx_global_var_init_17 = asm["___cxx_global_var_init_17"]; +asm["___cxx_global_var_init_17"] = (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 real____cxx_global_var_init_17.apply(null, arguments); +}); +var real____cxx_global_var_init_170 = asm["___cxx_global_var_init_170"]; +asm["___cxx_global_var_init_170"] = (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 real____cxx_global_var_init_170.apply(null, arguments); +}); +var real____cxx_global_var_init_171 = asm["___cxx_global_var_init_171"]; +asm["___cxx_global_var_init_171"] = (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 real____cxx_global_var_init_171.apply(null, arguments); +}); +var real____cxx_global_var_init_172 = asm["___cxx_global_var_init_172"]; +asm["___cxx_global_var_init_172"] = (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 real____cxx_global_var_init_172.apply(null, arguments); +}); +var real____cxx_global_var_init_173 = asm["___cxx_global_var_init_173"]; +asm["___cxx_global_var_init_173"] = (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 real____cxx_global_var_init_173.apply(null, arguments); +}); +var real____cxx_global_var_init_173_7517 = asm["___cxx_global_var_init_173_7517"]; +asm["___cxx_global_var_init_173_7517"] = (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 real____cxx_global_var_init_173_7517.apply(null, arguments); +}); +var real____cxx_global_var_init_174 = asm["___cxx_global_var_init_174"]; +asm["___cxx_global_var_init_174"] = (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 real____cxx_global_var_init_174.apply(null, arguments); +}); +var real____cxx_global_var_init_174_7518 = asm["___cxx_global_var_init_174_7518"]; +asm["___cxx_global_var_init_174_7518"] = (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 real____cxx_global_var_init_174_7518.apply(null, arguments); +}); +var real____cxx_global_var_init_175 = asm["___cxx_global_var_init_175"]; +asm["___cxx_global_var_init_175"] = (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 real____cxx_global_var_init_175.apply(null, arguments); +}); +var real____cxx_global_var_init_175_7519 = asm["___cxx_global_var_init_175_7519"]; +asm["___cxx_global_var_init_175_7519"] = (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 real____cxx_global_var_init_175_7519.apply(null, arguments); +}); +var real____cxx_global_var_init_176 = asm["___cxx_global_var_init_176"]; +asm["___cxx_global_var_init_176"] = (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 real____cxx_global_var_init_176.apply(null, arguments); +}); +var real____cxx_global_var_init_176_7520 = asm["___cxx_global_var_init_176_7520"]; +asm["___cxx_global_var_init_176_7520"] = (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 real____cxx_global_var_init_176_7520.apply(null, arguments); +}); +var real____cxx_global_var_init_177 = asm["___cxx_global_var_init_177"]; +asm["___cxx_global_var_init_177"] = (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 real____cxx_global_var_init_177.apply(null, arguments); +}); +var real____cxx_global_var_init_177_7521 = asm["___cxx_global_var_init_177_7521"]; +asm["___cxx_global_var_init_177_7521"] = (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 real____cxx_global_var_init_177_7521.apply(null, arguments); +}); +var real____cxx_global_var_init_178 = asm["___cxx_global_var_init_178"]; +asm["___cxx_global_var_init_178"] = (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 real____cxx_global_var_init_178.apply(null, arguments); +}); +var real____cxx_global_var_init_178_7522 = asm["___cxx_global_var_init_178_7522"]; +asm["___cxx_global_var_init_178_7522"] = (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 real____cxx_global_var_init_178_7522.apply(null, arguments); +}); +var real____cxx_global_var_init_179 = asm["___cxx_global_var_init_179"]; +asm["___cxx_global_var_init_179"] = (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 real____cxx_global_var_init_179.apply(null, arguments); +}); +var real____cxx_global_var_init_179_7523 = asm["___cxx_global_var_init_179_7523"]; +asm["___cxx_global_var_init_179_7523"] = (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 real____cxx_global_var_init_179_7523.apply(null, arguments); +}); +var real____cxx_global_var_init_17_7921 = asm["___cxx_global_var_init_17_7921"]; +asm["___cxx_global_var_init_17_7921"] = (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 real____cxx_global_var_init_17_7921.apply(null, arguments); +}); +var real____cxx_global_var_init_180 = asm["___cxx_global_var_init_180"]; +asm["___cxx_global_var_init_180"] = (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 real____cxx_global_var_init_180.apply(null, arguments); +}); +var real____cxx_global_var_init_181 = asm["___cxx_global_var_init_181"]; +asm["___cxx_global_var_init_181"] = (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 real____cxx_global_var_init_181.apply(null, arguments); +}); +var real____cxx_global_var_init_182 = asm["___cxx_global_var_init_182"]; +asm["___cxx_global_var_init_182"] = (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 real____cxx_global_var_init_182.apply(null, arguments); +}); +var real____cxx_global_var_init_183 = asm["___cxx_global_var_init_183"]; +asm["___cxx_global_var_init_183"] = (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 real____cxx_global_var_init_183.apply(null, arguments); +}); +var real____cxx_global_var_init_184 = asm["___cxx_global_var_init_184"]; +asm["___cxx_global_var_init_184"] = (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 real____cxx_global_var_init_184.apply(null, arguments); +}); +var real____cxx_global_var_init_185 = asm["___cxx_global_var_init_185"]; +asm["___cxx_global_var_init_185"] = (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 real____cxx_global_var_init_185.apply(null, arguments); +}); +var real____cxx_global_var_init_186 = asm["___cxx_global_var_init_186"]; +asm["___cxx_global_var_init_186"] = (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 real____cxx_global_var_init_186.apply(null, arguments); +}); +var real____cxx_global_var_init_187 = asm["___cxx_global_var_init_187"]; +asm["___cxx_global_var_init_187"] = (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 real____cxx_global_var_init_187.apply(null, arguments); +}); +var real____cxx_global_var_init_188 = asm["___cxx_global_var_init_188"]; +asm["___cxx_global_var_init_188"] = (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 real____cxx_global_var_init_188.apply(null, arguments); +}); +var real____cxx_global_var_init_189 = asm["___cxx_global_var_init_189"]; +asm["___cxx_global_var_init_189"] = (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 real____cxx_global_var_init_189.apply(null, arguments); +}); +var real____cxx_global_var_init_18_7922 = asm["___cxx_global_var_init_18_7922"]; +asm["___cxx_global_var_init_18_7922"] = (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 real____cxx_global_var_init_18_7922.apply(null, arguments); +}); +var real____cxx_global_var_init_19 = asm["___cxx_global_var_init_19"]; +asm["___cxx_global_var_init_19"] = (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 real____cxx_global_var_init_19.apply(null, arguments); +}); +var real____cxx_global_var_init_190 = asm["___cxx_global_var_init_190"]; +asm["___cxx_global_var_init_190"] = (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 real____cxx_global_var_init_190.apply(null, arguments); +}); +var real____cxx_global_var_init_191 = asm["___cxx_global_var_init_191"]; +asm["___cxx_global_var_init_191"] = (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 real____cxx_global_var_init_191.apply(null, arguments); +}); +var real____cxx_global_var_init_192 = asm["___cxx_global_var_init_192"]; +asm["___cxx_global_var_init_192"] = (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 real____cxx_global_var_init_192.apply(null, arguments); +}); +var real____cxx_global_var_init_193 = asm["___cxx_global_var_init_193"]; +asm["___cxx_global_var_init_193"] = (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 real____cxx_global_var_init_193.apply(null, arguments); +}); +var real____cxx_global_var_init_194 = asm["___cxx_global_var_init_194"]; +asm["___cxx_global_var_init_194"] = (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 real____cxx_global_var_init_194.apply(null, arguments); +}); +var real____cxx_global_var_init_195 = asm["___cxx_global_var_init_195"]; +asm["___cxx_global_var_init_195"] = (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 real____cxx_global_var_init_195.apply(null, arguments); +}); +var real____cxx_global_var_init_196 = asm["___cxx_global_var_init_196"]; +asm["___cxx_global_var_init_196"] = (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 real____cxx_global_var_init_196.apply(null, arguments); +}); +var real____cxx_global_var_init_197 = asm["___cxx_global_var_init_197"]; +asm["___cxx_global_var_init_197"] = (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 real____cxx_global_var_init_197.apply(null, arguments); +}); +var real____cxx_global_var_init_198 = asm["___cxx_global_var_init_198"]; +asm["___cxx_global_var_init_198"] = (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 real____cxx_global_var_init_198.apply(null, arguments); +}); +var real____cxx_global_var_init_199 = asm["___cxx_global_var_init_199"]; +asm["___cxx_global_var_init_199"] = (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 real____cxx_global_var_init_199.apply(null, arguments); +}); +var real____cxx_global_var_init_19_7923 = asm["___cxx_global_var_init_19_7923"]; +asm["___cxx_global_var_init_19_7923"] = (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 real____cxx_global_var_init_19_7923.apply(null, arguments); +}); +var real____cxx_global_var_init_19_8116 = asm["___cxx_global_var_init_19_8116"]; +asm["___cxx_global_var_init_19_8116"] = (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 real____cxx_global_var_init_19_8116.apply(null, arguments); +}); +var real____cxx_global_var_init_1_7732 = asm["___cxx_global_var_init_1_7732"]; +asm["___cxx_global_var_init_1_7732"] = (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 real____cxx_global_var_init_1_7732.apply(null, arguments); +}); +var real____cxx_global_var_init_200 = asm["___cxx_global_var_init_200"]; +asm["___cxx_global_var_init_200"] = (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 real____cxx_global_var_init_200.apply(null, arguments); +}); +var real____cxx_global_var_init_201 = asm["___cxx_global_var_init_201"]; +asm["___cxx_global_var_init_201"] = (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 real____cxx_global_var_init_201.apply(null, arguments); +}); +var real____cxx_global_var_init_202 = asm["___cxx_global_var_init_202"]; +asm["___cxx_global_var_init_202"] = (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 real____cxx_global_var_init_202.apply(null, arguments); +}); +var real____cxx_global_var_init_203 = asm["___cxx_global_var_init_203"]; +asm["___cxx_global_var_init_203"] = (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 real____cxx_global_var_init_203.apply(null, arguments); +}); +var real____cxx_global_var_init_204 = asm["___cxx_global_var_init_204"]; +asm["___cxx_global_var_init_204"] = (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 real____cxx_global_var_init_204.apply(null, arguments); +}); +var real____cxx_global_var_init_205 = asm["___cxx_global_var_init_205"]; +asm["___cxx_global_var_init_205"] = (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 real____cxx_global_var_init_205.apply(null, arguments); +}); +var real____cxx_global_var_init_206 = asm["___cxx_global_var_init_206"]; +asm["___cxx_global_var_init_206"] = (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 real____cxx_global_var_init_206.apply(null, arguments); +}); +var real____cxx_global_var_init_207 = asm["___cxx_global_var_init_207"]; +asm["___cxx_global_var_init_207"] = (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 real____cxx_global_var_init_207.apply(null, arguments); +}); +var real____cxx_global_var_init_208 = asm["___cxx_global_var_init_208"]; +asm["___cxx_global_var_init_208"] = (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 real____cxx_global_var_init_208.apply(null, arguments); +}); +var real____cxx_global_var_init_209 = asm["___cxx_global_var_init_209"]; +asm["___cxx_global_var_init_209"] = (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 real____cxx_global_var_init_209.apply(null, arguments); +}); +var real____cxx_global_var_init_20_15986 = asm["___cxx_global_var_init_20_15986"]; +asm["___cxx_global_var_init_20_15986"] = (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 real____cxx_global_var_init_20_15986.apply(null, arguments); +}); +var real____cxx_global_var_init_20_7924 = asm["___cxx_global_var_init_20_7924"]; +asm["___cxx_global_var_init_20_7924"] = (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 real____cxx_global_var_init_20_7924.apply(null, arguments); +}); +var real____cxx_global_var_init_20_8117 = asm["___cxx_global_var_init_20_8117"]; +asm["___cxx_global_var_init_20_8117"] = (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 real____cxx_global_var_init_20_8117.apply(null, arguments); +}); +var real____cxx_global_var_init_21 = asm["___cxx_global_var_init_21"]; +asm["___cxx_global_var_init_21"] = (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 real____cxx_global_var_init_21.apply(null, arguments); +}); +var real____cxx_global_var_init_210 = asm["___cxx_global_var_init_210"]; +asm["___cxx_global_var_init_210"] = (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 real____cxx_global_var_init_210.apply(null, arguments); +}); +var real____cxx_global_var_init_21_730 = asm["___cxx_global_var_init_21_730"]; +asm["___cxx_global_var_init_21_730"] = (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 real____cxx_global_var_init_21_730.apply(null, arguments); +}); +var real____cxx_global_var_init_21_7925 = asm["___cxx_global_var_init_21_7925"]; +asm["___cxx_global_var_init_21_7925"] = (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 real____cxx_global_var_init_21_7925.apply(null, arguments); +}); +var real____cxx_global_var_init_22 = asm["___cxx_global_var_init_22"]; +asm["___cxx_global_var_init_22"] = (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 real____cxx_global_var_init_22.apply(null, arguments); +}); +var real____cxx_global_var_init_22_7926 = asm["___cxx_global_var_init_22_7926"]; +asm["___cxx_global_var_init_22_7926"] = (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 real____cxx_global_var_init_22_7926.apply(null, arguments); +}); +var real____cxx_global_var_init_22_8118 = asm["___cxx_global_var_init_22_8118"]; +asm["___cxx_global_var_init_22_8118"] = (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 real____cxx_global_var_init_22_8118.apply(null, arguments); +}); +var real____cxx_global_var_init_23 = asm["___cxx_global_var_init_23"]; +asm["___cxx_global_var_init_23"] = (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 real____cxx_global_var_init_23.apply(null, arguments); +}); +var real____cxx_global_var_init_23_8119 = asm["___cxx_global_var_init_23_8119"]; +asm["___cxx_global_var_init_23_8119"] = (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 real____cxx_global_var_init_23_8119.apply(null, arguments); +}); +var real____cxx_global_var_init_24_3154 = asm["___cxx_global_var_init_24_3154"]; +asm["___cxx_global_var_init_24_3154"] = (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 real____cxx_global_var_init_24_3154.apply(null, arguments); +}); +var real____cxx_global_var_init_24_7927 = asm["___cxx_global_var_init_24_7927"]; +asm["___cxx_global_var_init_24_7927"] = (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 real____cxx_global_var_init_24_7927.apply(null, arguments); +}); +var real____cxx_global_var_init_25 = asm["___cxx_global_var_init_25"]; +asm["___cxx_global_var_init_25"] = (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 real____cxx_global_var_init_25.apply(null, arguments); +}); +var real____cxx_global_var_init_26_2966 = asm["___cxx_global_var_init_26_2966"]; +asm["___cxx_global_var_init_26_2966"] = (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 real____cxx_global_var_init_26_2966.apply(null, arguments); +}); +var real____cxx_global_var_init_26_3155 = asm["___cxx_global_var_init_26_3155"]; +asm["___cxx_global_var_init_26_3155"] = (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 real____cxx_global_var_init_26_3155.apply(null, arguments); +}); +var real____cxx_global_var_init_26_3483 = asm["___cxx_global_var_init_26_3483"]; +asm["___cxx_global_var_init_26_3483"] = (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 real____cxx_global_var_init_26_3483.apply(null, arguments); +}); +var real____cxx_global_var_init_28_7904 = asm["___cxx_global_var_init_28_7904"]; +asm["___cxx_global_var_init_28_7904"] = (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 real____cxx_global_var_init_28_7904.apply(null, arguments); +}); +var real____cxx_global_var_init_29 = asm["___cxx_global_var_init_29"]; +asm["___cxx_global_var_init_29"] = (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 real____cxx_global_var_init_29.apply(null, arguments); +}); +var real____cxx_global_var_init_3057 = asm["___cxx_global_var_init_3057"]; +asm["___cxx_global_var_init_3057"] = (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 real____cxx_global_var_init_3057.apply(null, arguments); +}); +var real____cxx_global_var_init_30_7905 = asm["___cxx_global_var_init_30_7905"]; +asm["___cxx_global_var_init_30_7905"] = (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 real____cxx_global_var_init_30_7905.apply(null, arguments); +}); +var real____cxx_global_var_init_31 = asm["___cxx_global_var_init_31"]; +asm["___cxx_global_var_init_31"] = (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 real____cxx_global_var_init_31.apply(null, arguments); +}); +var real____cxx_global_var_init_32_7906 = asm["___cxx_global_var_init_32_7906"]; +asm["___cxx_global_var_init_32_7906"] = (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 real____cxx_global_var_init_32_7906.apply(null, arguments); +}); +var real____cxx_global_var_init_34 = asm["___cxx_global_var_init_34"]; +asm["___cxx_global_var_init_34"] = (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 real____cxx_global_var_init_34.apply(null, arguments); +}); +var real____cxx_global_var_init_34_11610 = asm["___cxx_global_var_init_34_11610"]; +asm["___cxx_global_var_init_34_11610"] = (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 real____cxx_global_var_init_34_11610.apply(null, arguments); +}); +var real____cxx_global_var_init_34_6007 = asm["___cxx_global_var_init_34_6007"]; +asm["___cxx_global_var_init_34_6007"] = (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 real____cxx_global_var_init_34_6007.apply(null, arguments); +}); +var real____cxx_global_var_init_35 = asm["___cxx_global_var_init_35"]; +asm["___cxx_global_var_init_35"] = (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 real____cxx_global_var_init_35.apply(null, arguments); +}); +var real____cxx_global_var_init_36 = asm["___cxx_global_var_init_36"]; +asm["___cxx_global_var_init_36"] = (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 real____cxx_global_var_init_36.apply(null, arguments); +}); +var real____cxx_global_var_init_36_6476 = asm["___cxx_global_var_init_36_6476"]; +asm["___cxx_global_var_init_36_6476"] = (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 real____cxx_global_var_init_36_6476.apply(null, arguments); +}); +var real____cxx_global_var_init_36_7915 = asm["___cxx_global_var_init_36_7915"]; +asm["___cxx_global_var_init_36_7915"] = (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 real____cxx_global_var_init_36_7915.apply(null, arguments); +}); +var real____cxx_global_var_init_37 = asm["___cxx_global_var_init_37"]; +asm["___cxx_global_var_init_37"] = (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 real____cxx_global_var_init_37.apply(null, arguments); +}); +var real____cxx_global_var_init_37_6477 = asm["___cxx_global_var_init_37_6477"]; +asm["___cxx_global_var_init_37_6477"] = (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 real____cxx_global_var_init_37_6477.apply(null, arguments); +}); +var real____cxx_global_var_init_37_7916 = asm["___cxx_global_var_init_37_7916"]; +asm["___cxx_global_var_init_37_7916"] = (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 real____cxx_global_var_init_37_7916.apply(null, arguments); +}); +var real____cxx_global_var_init_38 = asm["___cxx_global_var_init_38"]; +asm["___cxx_global_var_init_38"] = (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 real____cxx_global_var_init_38.apply(null, arguments); +}); +var real____cxx_global_var_init_38_11026 = asm["___cxx_global_var_init_38_11026"]; +asm["___cxx_global_var_init_38_11026"] = (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 real____cxx_global_var_init_38_11026.apply(null, arguments); +}); +var real____cxx_global_var_init_38_3480 = asm["___cxx_global_var_init_38_3480"]; +asm["___cxx_global_var_init_38_3480"] = (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 real____cxx_global_var_init_38_3480.apply(null, arguments); +}); +var real____cxx_global_var_init_38_6478 = asm["___cxx_global_var_init_38_6478"]; +asm["___cxx_global_var_init_38_6478"] = (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 real____cxx_global_var_init_38_6478.apply(null, arguments); +}); +var real____cxx_global_var_init_38_7917 = asm["___cxx_global_var_init_38_7917"]; +asm["___cxx_global_var_init_38_7917"] = (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 real____cxx_global_var_init_38_7917.apply(null, arguments); +}); +var real____cxx_global_var_init_39 = asm["___cxx_global_var_init_39"]; +asm["___cxx_global_var_init_39"] = (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 real____cxx_global_var_init_39.apply(null, arguments); +}); +var real____cxx_global_var_init_39_3481 = asm["___cxx_global_var_init_39_3481"]; +asm["___cxx_global_var_init_39_3481"] = (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 real____cxx_global_var_init_39_3481.apply(null, arguments); +}); +var real____cxx_global_var_init_39_6479 = asm["___cxx_global_var_init_39_6479"]; +asm["___cxx_global_var_init_39_6479"] = (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 real____cxx_global_var_init_39_6479.apply(null, arguments); +}); +var real____cxx_global_var_init_39_7918 = asm["___cxx_global_var_init_39_7918"]; +asm["___cxx_global_var_init_39_7918"] = (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 real____cxx_global_var_init_39_7918.apply(null, arguments); +}); +var real____cxx_global_var_init_3_5530 = asm["___cxx_global_var_init_3_5530"]; +asm["___cxx_global_var_init_3_5530"] = (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 real____cxx_global_var_init_3_5530.apply(null, arguments); +}); +var real____cxx_global_var_init_4 = asm["___cxx_global_var_init_4"]; +asm["___cxx_global_var_init_4"] = (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 real____cxx_global_var_init_4.apply(null, arguments); +}); +var real____cxx_global_var_init_40 = asm["___cxx_global_var_init_40"]; +asm["___cxx_global_var_init_40"] = (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 real____cxx_global_var_init_40.apply(null, arguments); +}); +var real____cxx_global_var_init_40_3482 = asm["___cxx_global_var_init_40_3482"]; +asm["___cxx_global_var_init_40_3482"] = (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 real____cxx_global_var_init_40_3482.apply(null, arguments); +}); +var real____cxx_global_var_init_40_6480 = asm["___cxx_global_var_init_40_6480"]; +asm["___cxx_global_var_init_40_6480"] = (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 real____cxx_global_var_init_40_6480.apply(null, arguments); +}); +var real____cxx_global_var_init_40_7919 = asm["___cxx_global_var_init_40_7919"]; +asm["___cxx_global_var_init_40_7919"] = (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 real____cxx_global_var_init_40_7919.apply(null, arguments); +}); +var real____cxx_global_var_init_41 = asm["___cxx_global_var_init_41"]; +asm["___cxx_global_var_init_41"] = (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 real____cxx_global_var_init_41.apply(null, arguments); +}); +var real____cxx_global_var_init_4149 = asm["___cxx_global_var_init_4149"]; +asm["___cxx_global_var_init_4149"] = (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 real____cxx_global_var_init_4149.apply(null, arguments); +}); +var real____cxx_global_var_init_41_6481 = asm["___cxx_global_var_init_41_6481"]; +asm["___cxx_global_var_init_41_6481"] = (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 real____cxx_global_var_init_41_6481.apply(null, arguments); +}); +var real____cxx_global_var_init_42 = asm["___cxx_global_var_init_42"]; +asm["___cxx_global_var_init_42"] = (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 real____cxx_global_var_init_42.apply(null, arguments); +}); +var real____cxx_global_var_init_425 = asm["___cxx_global_var_init_425"]; +asm["___cxx_global_var_init_425"] = (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 real____cxx_global_var_init_425.apply(null, arguments); +}); +var real____cxx_global_var_init_42_6482 = asm["___cxx_global_var_init_42_6482"]; +asm["___cxx_global_var_init_42_6482"] = (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 real____cxx_global_var_init_42_6482.apply(null, arguments); +}); +var real____cxx_global_var_init_43 = asm["___cxx_global_var_init_43"]; +asm["___cxx_global_var_init_43"] = (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 real____cxx_global_var_init_43.apply(null, arguments); +}); +var real____cxx_global_var_init_44 = asm["___cxx_global_var_init_44"]; +asm["___cxx_global_var_init_44"] = (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 real____cxx_global_var_init_44.apply(null, arguments); +}); +var real____cxx_global_var_init_44_6207 = asm["___cxx_global_var_init_44_6207"]; +asm["___cxx_global_var_init_44_6207"] = (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 real____cxx_global_var_init_44_6207.apply(null, arguments); +}); +var real____cxx_global_var_init_45 = asm["___cxx_global_var_init_45"]; +asm["___cxx_global_var_init_45"] = (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 real____cxx_global_var_init_45.apply(null, arguments); +}); +var real____cxx_global_var_init_45_11027 = asm["___cxx_global_var_init_45_11027"]; +asm["___cxx_global_var_init_45_11027"] = (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 real____cxx_global_var_init_45_11027.apply(null, arguments); +}); +var real____cxx_global_var_init_46 = asm["___cxx_global_var_init_46"]; +asm["___cxx_global_var_init_46"] = (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 real____cxx_global_var_init_46.apply(null, arguments); +}); +var real____cxx_global_var_init_46_11028 = asm["___cxx_global_var_init_46_11028"]; +asm["___cxx_global_var_init_46_11028"] = (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 real____cxx_global_var_init_46_11028.apply(null, arguments); +}); +var real____cxx_global_var_init_46_6730 = asm["___cxx_global_var_init_46_6730"]; +asm["___cxx_global_var_init_46_6730"] = (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 real____cxx_global_var_init_46_6730.apply(null, arguments); +}); +var real____cxx_global_var_init_47 = asm["___cxx_global_var_init_47"]; +asm["___cxx_global_var_init_47"] = (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 real____cxx_global_var_init_47.apply(null, arguments); +}); +var real____cxx_global_var_init_47_11029 = asm["___cxx_global_var_init_47_11029"]; +asm["___cxx_global_var_init_47_11029"] = (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 real____cxx_global_var_init_47_11029.apply(null, arguments); +}); +var real____cxx_global_var_init_47_731 = asm["___cxx_global_var_init_47_731"]; +asm["___cxx_global_var_init_47_731"] = (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 real____cxx_global_var_init_47_731.apply(null, arguments); +}); +var real____cxx_global_var_init_48 = asm["___cxx_global_var_init_48"]; +asm["___cxx_global_var_init_48"] = (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 real____cxx_global_var_init_48.apply(null, arguments); +}); +var real____cxx_global_var_init_48_729 = asm["___cxx_global_var_init_48_729"]; +asm["___cxx_global_var_init_48_729"] = (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 real____cxx_global_var_init_48_729.apply(null, arguments); +}); +var real____cxx_global_var_init_4_728 = asm["___cxx_global_var_init_4_728"]; +asm["___cxx_global_var_init_4_728"] = (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 real____cxx_global_var_init_4_728.apply(null, arguments); +}); +var real____cxx_global_var_init_5 = asm["___cxx_global_var_init_5"]; +asm["___cxx_global_var_init_5"] = (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 real____cxx_global_var_init_5.apply(null, arguments); +}); +var real____cxx_global_var_init_55 = asm["___cxx_global_var_init_55"]; +asm["___cxx_global_var_init_55"] = (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 real____cxx_global_var_init_55.apply(null, arguments); +}); +var real____cxx_global_var_init_5581 = asm["___cxx_global_var_init_5581"]; +asm["___cxx_global_var_init_5581"] = (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 real____cxx_global_var_init_5581.apply(null, arguments); +}); +var real____cxx_global_var_init_6006 = asm["___cxx_global_var_init_6006"]; +asm["___cxx_global_var_init_6006"] = (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 real____cxx_global_var_init_6006.apply(null, arguments); +}); +var real____cxx_global_var_init_65 = asm["___cxx_global_var_init_65"]; +asm["___cxx_global_var_init_65"] = (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 real____cxx_global_var_init_65.apply(null, arguments); +}); +var real____cxx_global_var_init_66 = asm["___cxx_global_var_init_66"]; +asm["___cxx_global_var_init_66"] = (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 real____cxx_global_var_init_66.apply(null, arguments); +}); +var real____cxx_global_var_init_67 = asm["___cxx_global_var_init_67"]; +asm["___cxx_global_var_init_67"] = (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 real____cxx_global_var_init_67.apply(null, arguments); +}); +var real____cxx_global_var_init_6718 = asm["___cxx_global_var_init_6718"]; +asm["___cxx_global_var_init_6718"] = (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 real____cxx_global_var_init_6718.apply(null, arguments); +}); +var real____cxx_global_var_init_6731 = asm["___cxx_global_var_init_6731"]; +asm["___cxx_global_var_init_6731"] = (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 real____cxx_global_var_init_6731.apply(null, arguments); +}); +var real____cxx_global_var_init_7 = asm["___cxx_global_var_init_7"]; +asm["___cxx_global_var_init_7"] = (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 real____cxx_global_var_init_7.apply(null, arguments); +}); +var real____cxx_global_var_init_73 = asm["___cxx_global_var_init_73"]; +asm["___cxx_global_var_init_73"] = (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 real____cxx_global_var_init_73.apply(null, arguments); +}); +var real____cxx_global_var_init_75 = asm["___cxx_global_var_init_75"]; +asm["___cxx_global_var_init_75"] = (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 real____cxx_global_var_init_75.apply(null, arguments); +}); +var real____cxx_global_var_init_75_8232 = asm["___cxx_global_var_init_75_8232"]; +asm["___cxx_global_var_init_75_8232"] = (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 real____cxx_global_var_init_75_8232.apply(null, arguments); +}); +var real____cxx_global_var_init_7731 = asm["___cxx_global_var_init_7731"]; +asm["___cxx_global_var_init_7731"] = (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 real____cxx_global_var_init_7731.apply(null, arguments); +}); +var real____cxx_global_var_init_78 = asm["___cxx_global_var_init_78"]; +asm["___cxx_global_var_init_78"] = (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 real____cxx_global_var_init_78.apply(null, arguments); +}); +var real____cxx_global_var_init_79 = asm["___cxx_global_var_init_79"]; +asm["___cxx_global_var_init_79"] = (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 real____cxx_global_var_init_79.apply(null, arguments); +}); +var real____cxx_global_var_init_79_4682 = asm["___cxx_global_var_init_79_4682"]; +asm["___cxx_global_var_init_79_4682"] = (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 real____cxx_global_var_init_79_4682.apply(null, arguments); +}); +var real____cxx_global_var_init_7_5458 = asm["___cxx_global_var_init_7_5458"]; +asm["___cxx_global_var_init_7_5458"] = (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 real____cxx_global_var_init_7_5458.apply(null, arguments); +}); +var real____cxx_global_var_init_80 = asm["___cxx_global_var_init_80"]; +asm["___cxx_global_var_init_80"] = (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 real____cxx_global_var_init_80.apply(null, arguments); +}); +var real____cxx_global_var_init_81 = asm["___cxx_global_var_init_81"]; +asm["___cxx_global_var_init_81"] = (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 real____cxx_global_var_init_81.apply(null, arguments); +}); +var real____cxx_global_var_init_82 = asm["___cxx_global_var_init_82"]; +asm["___cxx_global_var_init_82"] = (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 real____cxx_global_var_init_82.apply(null, arguments); +}); +var real____cxx_global_var_init_83 = asm["___cxx_global_var_init_83"]; +asm["___cxx_global_var_init_83"] = (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 real____cxx_global_var_init_83.apply(null, arguments); +}); +var real____errno_location = asm["___errno_location"]; +asm["___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 real____errno_location.apply(null, arguments); +}); +var real__fflush = asm["_fflush"]; +asm["_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 real__fflush.apply(null, arguments); +}); +var real__free = asm["_free"]; +asm["_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 real__free.apply(null, arguments); +}); +var real__htonl = asm["_htonl"]; +asm["_htonl"] = (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 real__htonl.apply(null, arguments); +}); +var real__htons = asm["_htons"]; +asm["_htons"] = (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 real__htons.apply(null, arguments); +}); +var real__llvm_bswap_i16 = asm["_llvm_bswap_i16"]; +asm["_llvm_bswap_i16"] = (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 real__llvm_bswap_i16.apply(null, arguments); +}); +var real__llvm_bswap_i32 = asm["_llvm_bswap_i32"]; +asm["_llvm_bswap_i32"] = (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 real__llvm_bswap_i32.apply(null, arguments); +}); +var real__llvm_ctlz_i64 = asm["_llvm_ctlz_i64"]; +asm["_llvm_ctlz_i64"] = (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 real__llvm_ctlz_i64.apply(null, arguments); +}); +var real__main = asm["_main"]; +asm["_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 real__main.apply(null, arguments); +}); +var real__malloc = asm["_malloc"]; +asm["_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 real__malloc.apply(null, arguments); +}); +var real__memalign = asm["_memalign"]; +asm["_memalign"] = (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 real__memalign.apply(null, arguments); +}); +var real__memmove = asm["_memmove"]; +asm["_memmove"] = (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 real__memmove.apply(null, arguments); +}); +var real__ntohs = asm["_ntohs"]; +asm["_ntohs"] = (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 real__ntohs.apply(null, arguments); +}); +var real__pthread_cond_broadcast = asm["_pthread_cond_broadcast"]; +asm["_pthread_cond_broadcast"] = (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 real__pthread_cond_broadcast.apply(null, arguments); +}); +var real__pthread_mutex_lock = asm["_pthread_mutex_lock"]; +asm["_pthread_mutex_lock"] = (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 real__pthread_mutex_lock.apply(null, arguments); +}); +var real__pthread_mutex_unlock = asm["_pthread_mutex_unlock"]; +asm["_pthread_mutex_unlock"] = (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 real__pthread_mutex_unlock.apply(null, arguments); +}); +var real__realloc = asm["_realloc"]; +asm["_realloc"] = (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 real__realloc.apply(null, arguments); +}); +var real__roundf = asm["_roundf"]; +asm["_roundf"] = (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 real__roundf.apply(null, arguments); +}); +var real__saveSetjmp = asm["_saveSetjmp"]; +asm["_saveSetjmp"] = (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 real__saveSetjmp.apply(null, arguments); +}); +var real__sbrk = asm["_sbrk"]; +asm["_sbrk"] = (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 real__sbrk.apply(null, arguments); +}); +var real__strlen = asm["_strlen"]; +asm["_strlen"] = (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 real__strlen.apply(null, arguments); +}); +var real__testSetjmp = asm["_testSetjmp"]; +asm["_testSetjmp"] = (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 real__testSetjmp.apply(null, arguments); +}); +var real_establishStackSpace = asm["establishStackSpace"]; +asm["establishStackSpace"] = (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 real_establishStackSpace.apply(null, arguments); +}); +var real_getTempRet0 = asm["getTempRet0"]; +asm["getTempRet0"] = (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 real_getTempRet0.apply(null, arguments); +}); +var real_setTempRet0 = asm["setTempRet0"]; +asm["setTempRet0"] = (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 real_setTempRet0.apply(null, arguments); +}); +var real_setThrew = asm["setThrew"]; +asm["setThrew"] = (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 real_setThrew.apply(null, arguments); +}); +var real_stackAlloc = asm["stackAlloc"]; +asm["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 real_stackAlloc.apply(null, arguments); +}); +var real_stackRestore = asm["stackRestore"]; +asm["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 real_stackRestore.apply(null, arguments); +}); +var real_stackSave = asm["stackSave"]; +asm["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 real_stackSave.apply(null, arguments); +}); +Module["asm"] = asm; +var _InjectProfilerSample = Module["_InjectProfilerSample"] = (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"]["_InjectProfilerSample"].apply(null, arguments); +}); +var _SendMessage = Module["_SendMessage"] = (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"]["_SendMessage"].apply(null, arguments); +}); +var _SendMessageFloat = Module["_SendMessageFloat"] = (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"]["_SendMessageFloat"].apply(null, arguments); +}); +var _SendMessageString = Module["_SendMessageString"] = (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"]["_SendMessageString"].apply(null, arguments); +}); +var _SetFullscreen = Module["_SetFullscreen"] = (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"]["_SetFullscreen"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AIScriptingClasses_cpp = Module["__GLOBAL__sub_I_AIScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_AIScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ARScriptingClasses_cpp = Module["__GLOBAL__sub_I_ARScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_ARScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AccessibilityScriptingClasses_cpp = Module["__GLOBAL__sub_I_AccessibilityScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_AccessibilityScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AnimationClip_cpp = Module["__GLOBAL__sub_I_AnimationClip_cpp"] = (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"]["__GLOBAL__sub_I_AnimationClip_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AnimationScriptingClasses_cpp = Module["__GLOBAL__sub_I_AnimationScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_AnimationScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AppDomain_cpp = Module["__GLOBAL__sub_I_AppDomain_cpp"] = (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"]["__GLOBAL__sub_I_AppDomain_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ArrayMetadata_cpp = Module["__GLOBAL__sub_I_ArrayMetadata_cpp"] = (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"]["__GLOBAL__sub_I_ArrayMetadata_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Assembly_cpp = Module["__GLOBAL__sub_I_Assembly_cpp"] = (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"]["__GLOBAL__sub_I_Assembly_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Assembly_cpp_95986 = Module["__GLOBAL__sub_I_Assembly_cpp_95986"] = (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"]["__GLOBAL__sub_I_Assembly_cpp_95986"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AssetBundleFileSystem_cpp = Module["__GLOBAL__sub_I_AssetBundleFileSystem_cpp"] = (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"]["__GLOBAL__sub_I_AssetBundleFileSystem_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AssetBundleScriptingClasses_cpp = Module["__GLOBAL__sub_I_AssetBundleScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_AssetBundleScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_AudioScriptingClasses_cpp = Module["__GLOBAL__sub_I_AudioScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_AudioScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Avatar_cpp = Module["__GLOBAL__sub_I_Avatar_cpp"] = (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"]["__GLOBAL__sub_I_Avatar_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_BoehmGC_cpp = Module["__GLOBAL__sub_I_BoehmGC_cpp"] = (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"]["__GLOBAL__sub_I_BoehmGC_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_COMEntryPoints_cpp = Module["__GLOBAL__sub_I_COMEntryPoints_cpp"] = (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"]["__GLOBAL__sub_I_COMEntryPoints_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Class_cpp = Module["__GLOBAL__sub_I_Class_cpp"] = (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"]["__GLOBAL__sub_I_Class_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ClothScriptingClasses_cpp = Module["__GLOBAL__sub_I_ClothScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_ClothScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Console_cpp = Module["__GLOBAL__sub_I_Console_cpp"] = (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"]["__GLOBAL__sub_I_Console_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ConstraintJob_cpp = Module["__GLOBAL__sub_I_ConstraintJob_cpp"] = (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"]["__GLOBAL__sub_I_ConstraintJob_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ConstraintManager_cpp = Module["__GLOBAL__sub_I_ConstraintManager_cpp"] = (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"]["__GLOBAL__sub_I_ConstraintManager_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_DirectorScriptingClasses_cpp = Module["__GLOBAL__sub_I_DirectorScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_DirectorScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Environment_cpp = Module["__GLOBAL__sub_I_Environment_cpp"] = (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"]["__GLOBAL__sub_I_Environment_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Error_cpp = Module["__GLOBAL__sub_I_Error_cpp"] = (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"]["__GLOBAL__sub_I_Error_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp = Module["__GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp"] = (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"]["__GLOBAL__sub_I_External_Box2D_Box2D_Dynamics_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp = Module["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp"] = (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"]["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp = Module["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp"] = (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"]["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp = Module["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp"] = (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"]["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp = Module["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp"] = (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"]["__GLOBAL__sub_I_External_Box2D_Box2D_Jobs_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp = Module["__GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp"] = (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"]["__GLOBAL__sub_I_External_ProphecySDK_BlitOperations_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_External_Yoga_Yoga_0_cpp = Module["__GLOBAL__sub_I_External_Yoga_Yoga_0_cpp"] = (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"]["__GLOBAL__sub_I_External_Yoga_Yoga_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_File_cpp = Module["__GLOBAL__sub_I_File_cpp"] = (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"]["__GLOBAL__sub_I_File_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_GCHandle_cpp = Module["__GLOBAL__sub_I_GCHandle_cpp"] = (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"]["__GLOBAL__sub_I_GCHandle_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_GarbageCollector_cpp = Module["__GLOBAL__sub_I_GarbageCollector_cpp"] = (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"]["__GLOBAL__sub_I_GarbageCollector_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_GenericMetadata_cpp = Module["__GLOBAL__sub_I_GenericMetadata_cpp"] = (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"]["__GLOBAL__sub_I_GenericMetadata_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_GenericMethod_cpp = Module["__GLOBAL__sub_I_GenericMethod_cpp"] = (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"]["__GLOBAL__sub_I_GenericMethod_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_GfxDeviceNull_cpp = Module["__GLOBAL__sub_I_GfxDeviceNull_cpp"] = (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"]["__GLOBAL__sub_I_GfxDeviceNull_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_GridScriptingClasses_cpp = Module["__GLOBAL__sub_I_GridScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_GridScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_IMGUIScriptingClasses_cpp = Module["__GLOBAL__sub_I_IMGUIScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_IMGUIScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Il2CppCodeRegistration_cpp = Module["__GLOBAL__sub_I_Il2CppCodeRegistration_cpp"] = (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"]["__GLOBAL__sub_I_Il2CppCodeRegistration_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Image_cpp = Module["__GLOBAL__sub_I_Image_cpp"] = (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"]["__GLOBAL__sub_I_Image_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_InputScriptingClasses_cpp = Module["__GLOBAL__sub_I_InputScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_InputScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Interlocked_cpp = Module["__GLOBAL__sub_I_Interlocked_cpp"] = (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"]["__GLOBAL__sub_I_Interlocked_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_LibraryLoader_cpp = Module["__GLOBAL__sub_I_LibraryLoader_cpp"] = (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"]["__GLOBAL__sub_I_LibraryLoader_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_LineRenderer_cpp = Module["__GLOBAL__sub_I_LineRenderer_cpp"] = (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"]["__GLOBAL__sub_I_LineRenderer_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_LogAssert_cpp = Module["__GLOBAL__sub_I_LogAssert_cpp"] = (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"]["__GLOBAL__sub_I_LogAssert_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_MemoryMapImpl_cpp = Module["__GLOBAL__sub_I_MemoryMapImpl_cpp"] = (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"]["__GLOBAL__sub_I_MemoryMapImpl_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_MemoryMappedFile_cpp = Module["__GLOBAL__sub_I_MemoryMappedFile_cpp"] = (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"]["__GLOBAL__sub_I_MemoryMappedFile_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_MetadataCache_cpp = Module["__GLOBAL__sub_I_MetadataCache_cpp"] = (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"]["__GLOBAL__sub_I_MetadataCache_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AI_0_cpp = Module["__GLOBAL__sub_I_Modules_AI_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AI_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AI_Builder_0_cpp = Module["__GLOBAL__sub_I_Modules_AI_Builder_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AI_Builder_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AI_Crowd_0_cpp = Module["__GLOBAL__sub_I_Modules_AI_Crowd_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AI_Crowd_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp = Module["__GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AI_NavMesh_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp = Module["__GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AI_Obstacles_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AssetBundle_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp = Module["__GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AssetBundle_Public_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp = Module["__GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp"] = (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"]["__GLOBAL__sub_I_Modules_AssetBundle_Public_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Audio_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_Audio_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Audio_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Audio_Public_1_cpp = Module["__GLOBAL__sub_I_Modules_Audio_Public_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Audio_Public_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Audio_Public_3_cpp = Module["__GLOBAL__sub_I_Modules_Audio_Public_3_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Audio_Public_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Grid_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_Grid_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Grid_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_IMGUI_0_cpp = Module["__GLOBAL__sub_I_Modules_IMGUI_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_IMGUI_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_IMGUI_1_cpp = Module["__GLOBAL__sub_I_Modules_IMGUI_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_IMGUI_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Physics2D_0_cpp = Module["__GLOBAL__sub_I_Modules_Physics2D_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Physics2D_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Physics2D_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp = Module["__GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Physics2D_Public_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp = Module["__GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Profiler_Dispatch_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Profiler_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_Profiler_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Profiler_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Profiler_Public_1_cpp = Module["__GLOBAL__sub_I_Modules_Profiler_Public_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Profiler_Public_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp = Module["__GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Profiler_Runtime_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp = Module["__GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_SpriteMask_Private_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp = Module["__GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_SpriteShape_Private_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Terrain_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_Terrain_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Terrain_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Terrain_Public_1_cpp = Module["__GLOBAL__sub_I_Modules_Terrain_Public_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Terrain_Public_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Terrain_Public_2_cpp = Module["__GLOBAL__sub_I_Modules_Terrain_Public_2_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Terrain_Public_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Terrain_VR_0_cpp = Module["__GLOBAL__sub_I_Modules_Terrain_VR_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Terrain_VR_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp = Module["__GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_TextCore_Native_FontEngine_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_TextRendering_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Tilemap_0_cpp = Module["__GLOBAL__sub_I_Modules_Tilemap_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Tilemap_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Tilemap_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_UIElements_0_cpp = Module["__GLOBAL__sub_I_Modules_UIElements_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_UIElements_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp = Module["__GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_UnityAnalytics_Dispatcher_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp = Module["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_UnityWebRequest_Public_DownloadHandler_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_VFX_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_VFX_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_VFX_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_VFX_Public_1_cpp = Module["__GLOBAL__sub_I_Modules_VFX_Public_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_VFX_Public_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_VFX_Public_2_cpp = Module["__GLOBAL__sub_I_Modules_VFX_Public_2_cpp"] = (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"]["__GLOBAL__sub_I_Modules_VFX_Public_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp = Module["__GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_VFX_Public_Systems_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Video_Public_0_cpp = Module["__GLOBAL__sub_I_Modules_Video_Public_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Video_Public_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp = Module["__GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp"] = (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"]["__GLOBAL__sub_I_Modules_Video_Public_Base_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp = Module["__GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp"] = (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"]["__GLOBAL__sub_I_Modules_XR_Subsystems_Input_Public_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_NativeDelegateMethodCache_cpp = Module["__GLOBAL__sub_I_NativeDelegateMethodCache_cpp"] = (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"]["__GLOBAL__sub_I_NativeDelegateMethodCache_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ParticleSystemGeometryJob_cpp = Module["__GLOBAL__sub_I_ParticleSystemGeometryJob_cpp"] = (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"]["__GLOBAL__sub_I_ParticleSystemGeometryJob_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ParticleSystemRenderer_cpp = Module["__GLOBAL__sub_I_ParticleSystemRenderer_cpp"] = (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"]["__GLOBAL__sub_I_ParticleSystemRenderer_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp = Module["__GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_ParticleSystemScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Path_cpp = Module["__GLOBAL__sub_I_Path_cpp"] = (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"]["__GLOBAL__sub_I_Path_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp = Module["__GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp"] = (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"]["__GLOBAL__sub_I_PhysX_Source_LowLevelCloth_src_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Physics2DScriptingClasses_cpp = Module["__GLOBAL__sub_I_Physics2DScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_Physics2DScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_PhysicsQuery_cpp = Module["__GLOBAL__sub_I_PhysicsQuery_cpp"] = (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"]["__GLOBAL__sub_I_PhysicsQuery_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_PhysicsScene_cpp = Module["__GLOBAL__sub_I_PhysicsScene_cpp"] = (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"]["__GLOBAL__sub_I_PhysicsScene_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_PhysicsScriptingClasses_cpp = Module["__GLOBAL__sub_I_PhysicsScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_PhysicsScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp = Module["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp"] = (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"]["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp = Module["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp"] = (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"]["__GLOBAL__sub_I_PlatformDependent_WebGL_Source_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_RCW_cpp = Module["__GLOBAL__sub_I_RCW_cpp"] = (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"]["__GLOBAL__sub_I_RCW_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Reflection_cpp = Module["__GLOBAL__sub_I_Reflection_cpp"] = (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"]["__GLOBAL__sub_I_Reflection_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp = Module["__GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_2D_Sorting_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp = Module["__GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_2D_SpriteAtlas_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp = Module["__GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_2D_SpriteTiling_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Allocator_1_cpp = Module["__GLOBAL__sub_I_Runtime_Allocator_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Allocator_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Allocator_2_cpp = Module["__GLOBAL__sub_I_Runtime_Allocator_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Allocator_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_0_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_1_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_2_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_3_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_5_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_5_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_5_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_6_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_6_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_6_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_Director_0_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_Director_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_Director_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Animation_Director_1_cpp = Module["__GLOBAL__sub_I_Runtime_Animation_Director_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Animation_Director_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Application_0_cpp = Module["__GLOBAL__sub_I_Runtime_Application_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Application_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_BaseClasses_0_cpp = Module["__GLOBAL__sub_I_Runtime_BaseClasses_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_BaseClasses_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_BaseClasses_1_cpp = Module["__GLOBAL__sub_I_Runtime_BaseClasses_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_BaseClasses_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_BaseClasses_2_cpp = Module["__GLOBAL__sub_I_Runtime_BaseClasses_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_BaseClasses_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_BaseClasses_3_cpp = Module["__GLOBAL__sub_I_Runtime_BaseClasses_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_BaseClasses_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Burst_0_cpp = Module["__GLOBAL__sub_I_Runtime_Burst_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Burst_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_0_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_1_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_2_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_3_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_4_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_4_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_4_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_5_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_5_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_5_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_6_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_6_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_6_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_7_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_7_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_7_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_Culling_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_RenderLayers_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp = Module["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Camera_RenderLoops_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Cloth_0_cpp = Module["__GLOBAL__sub_I_Runtime_Cloth_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Cloth_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Containers_0_cpp = Module["__GLOBAL__sub_I_Runtime_Containers_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Containers_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp = Module["__GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Core_Callbacks_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Director_Core_1_cpp = Module["__GLOBAL__sub_I_Runtime_Director_Core_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Director_Core_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Dynamics_0_cpp = Module["__GLOBAL__sub_I_Runtime_Dynamics_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Dynamics_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Dynamics_1_cpp = Module["__GLOBAL__sub_I_Runtime_Dynamics_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Dynamics_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Dynamics_3_cpp = Module["__GLOBAL__sub_I_Runtime_Dynamics_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Dynamics_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp = Module["__GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Dynamics_BatchCommands_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Export_0_cpp = Module["__GLOBAL__sub_I_Runtime_Export_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Export_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_File_0_cpp = Module["__GLOBAL__sub_I_Runtime_File_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_File_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_GameCode_0_cpp = Module["__GLOBAL__sub_I_Runtime_GameCode_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_GameCode_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Geometry_1_cpp = Module["__GLOBAL__sub_I_Runtime_Geometry_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Geometry_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Geometry_2_cpp = Module["__GLOBAL__sub_I_Runtime_Geometry_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Geometry_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_GfxDevice_0_cpp = Module["__GLOBAL__sub_I_Runtime_GfxDevice_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_GfxDevice_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_GfxDevice_1_cpp = Module["__GLOBAL__sub_I_Runtime_GfxDevice_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_GfxDevice_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_GfxDevice_2_cpp = Module["__GLOBAL__sub_I_Runtime_GfxDevice_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_GfxDevice_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_GfxDevice_3_cpp = Module["__GLOBAL__sub_I_Runtime_GfxDevice_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_GfxDevice_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_0_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_10_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_10_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_10_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_11_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_11_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_11_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_1_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_2_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_5_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_5_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_5_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_6_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_6_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_6_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_7_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_7_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_7_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_8_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_8_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_8_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_9_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_9_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_9_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_Billboard_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_CommandBuffer_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_LOD_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_Mesh_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_Mesh_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_Mesh_4_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_Mesh_5_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp = Module["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Graphics_ScriptableRenderLoop_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Input_0_cpp = Module["__GLOBAL__sub_I_Runtime_Input_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Input_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Interfaces_0_cpp = Module["__GLOBAL__sub_I_Runtime_Interfaces_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Interfaces_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Interfaces_1_cpp = Module["__GLOBAL__sub_I_Runtime_Interfaces_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Interfaces_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Interfaces_2_cpp = Module["__GLOBAL__sub_I_Runtime_Interfaces_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Interfaces_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Jobs_0_cpp = Module["__GLOBAL__sub_I_Runtime_Jobs_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Jobs_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Jobs_1_cpp = Module["__GLOBAL__sub_I_Runtime_Jobs_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Jobs_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp = Module["__GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Jobs_ScriptBindings_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Math_2_cpp = Module["__GLOBAL__sub_I_Runtime_Math_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Math_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Math_Random_0_cpp = Module["__GLOBAL__sub_I_Runtime_Math_Random_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Math_Random_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Misc_0_cpp = Module["__GLOBAL__sub_I_Runtime_Misc_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Misc_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Misc_1_cpp = Module["__GLOBAL__sub_I_Runtime_Misc_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Misc_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Misc_2_cpp = Module["__GLOBAL__sub_I_Runtime_Misc_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Misc_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Misc_3_cpp = Module["__GLOBAL__sub_I_Runtime_Misc_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Misc_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Misc_4_cpp = Module["__GLOBAL__sub_I_Runtime_Misc_4_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Misc_4_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Misc_5_cpp = Module["__GLOBAL__sub_I_Runtime_Misc_5_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Misc_5_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Modules_0_cpp = Module["__GLOBAL__sub_I_Runtime_Modules_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Modules_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Mono_0_cpp = Module["__GLOBAL__sub_I_Runtime_Mono_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Mono_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp = Module["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp = Module["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Mono_SerializationBackend_DirectMemoryAccess_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Network_0_cpp = Module["__GLOBAL__sub_I_Runtime_Network_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Network_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp = Module["__GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Network_PlayerCommunicator_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp = Module["__GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ParticleSystem_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp = Module["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp = Module["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp = Module["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp = Module["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp = Module["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_4_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp = Module["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ParticleSystem_Modules_5_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_PluginInterface_0_cpp = Module["__GLOBAL__sub_I_Runtime_PluginInterface_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_PluginInterface_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_PreloadManager_0_cpp = Module["__GLOBAL__sub_I_Runtime_PreloadManager_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_PreloadManager_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Profiler_0_cpp = Module["__GLOBAL__sub_I_Runtime_Profiler_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Profiler_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Profiler_1_cpp = Module["__GLOBAL__sub_I_Runtime_Profiler_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Profiler_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Profiler_2_cpp = Module["__GLOBAL__sub_I_Runtime_Profiler_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Profiler_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp = Module["__GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Profiler_ScriptBindings_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_SceneManager_0_cpp = Module["__GLOBAL__sub_I_Runtime_SceneManager_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_SceneManager_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp = Module["__GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_ScriptingBackend_Il2Cpp_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Scripting_0_cpp = Module["__GLOBAL__sub_I_Runtime_Scripting_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Scripting_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Scripting_3_cpp = Module["__GLOBAL__sub_I_Runtime_Scripting_3_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Scripting_3_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp = Module["__GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Scripting_ManagedReference_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Serialize_0_cpp = Module["__GLOBAL__sub_I_Runtime_Serialize_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Serialize_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp = Module["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp = Module["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Serialize_TransferFunctions_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Shaders_0_cpp = Module["__GLOBAL__sub_I_Runtime_Shaders_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Shaders_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Shaders_1_cpp = Module["__GLOBAL__sub_I_Runtime_Shaders_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Shaders_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Shaders_2_cpp = Module["__GLOBAL__sub_I_Runtime_Shaders_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Shaders_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp = Module["__GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Shaders_GpuPrograms_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp = Module["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp = Module["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Shaders_ShaderImpl_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Streaming_0_cpp = Module["__GLOBAL__sub_I_Runtime_Streaming_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Streaming_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Streaming_1_cpp = Module["__GLOBAL__sub_I_Runtime_Streaming_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Streaming_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp = Module["__GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_TerrainPhysics_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Transform_0_cpp = Module["__GLOBAL__sub_I_Runtime_Transform_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Transform_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Transform_1_cpp = Module["__GLOBAL__sub_I_Runtime_Transform_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Transform_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_UI_0_cpp = Module["__GLOBAL__sub_I_Runtime_UI_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_UI_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_UI_1_cpp = Module["__GLOBAL__sub_I_Runtime_UI_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_UI_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_UI_2_cpp = Module["__GLOBAL__sub_I_Runtime_UI_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_UI_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Utilities_2_cpp = Module["__GLOBAL__sub_I_Runtime_Utilities_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Utilities_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Utilities_5_cpp = Module["__GLOBAL__sub_I_Runtime_Utilities_5_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Utilities_5_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Utilities_6_cpp = Module["__GLOBAL__sub_I_Runtime_Utilities_6_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Utilities_6_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Utilities_7_cpp = Module["__GLOBAL__sub_I_Runtime_Utilities_7_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Utilities_7_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Utilities_8_cpp = Module["__GLOBAL__sub_I_Runtime_Utilities_8_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Utilities_8_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Utilities_9_cpp = Module["__GLOBAL__sub_I_Runtime_Utilities_9_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Utilities_9_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_VR_0_cpp = Module["__GLOBAL__sub_I_Runtime_VR_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_VR_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_VR_2_cpp = Module["__GLOBAL__sub_I_Runtime_VR_2_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_VR_2_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp = Module["__GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_VR_PluginInterface_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Vehicles_0_cpp = Module["__GLOBAL__sub_I_Runtime_Vehicles_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Vehicles_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_Video_0_cpp = Module["__GLOBAL__sub_I_Runtime_Video_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_Video_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp = Module["__GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_VirtualFileSystem_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp = Module["__GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_VirtualFileSystem_1_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp = Module["__GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_VirtualFileSystem_ArchiveFileSystem_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp = Module["__GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_VirtualFileSystem_MemoryFileSystem_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_cpp = Module["__GLOBAL__sub_I_Runtime_cpp"] = (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"]["__GLOBAL__sub_I_Runtime_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Runtime_cpp_96605 = Module["__GLOBAL__sub_I_Runtime_cpp_96605"] = (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"]["__GLOBAL__sub_I_Runtime_cpp_96605"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Shader_cpp = Module["__GLOBAL__sub_I_Shader_cpp"] = (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"]["__GLOBAL__sub_I_Shader_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Shadows_cpp = Module["__GLOBAL__sub_I_Shadows_cpp"] = (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"]["__GLOBAL__sub_I_Shadows_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ShapeModule_cpp = Module["__GLOBAL__sub_I_ShapeModule_cpp"] = (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"]["__GLOBAL__sub_I_ShapeModule_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SkinnedMeshRendererManager_cpp = Module["__GLOBAL__sub_I_SkinnedMeshRendererManager_cpp"] = (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"]["__GLOBAL__sub_I_SkinnedMeshRendererManager_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Socket_cpp = Module["__GLOBAL__sub_I_Socket_cpp"] = (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"]["__GLOBAL__sub_I_Socket_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SparseTextureGLES_cpp = Module["__GLOBAL__sub_I_SparseTextureGLES_cpp"] = (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"]["__GLOBAL__sub_I_SparseTextureGLES_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SpriteRendererJobs_cpp = Module["__GLOBAL__sub_I_SpriteRendererJobs_cpp"] = (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"]["__GLOBAL__sub_I_SpriteRendererJobs_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_StackTrace_cpp = Module["__GLOBAL__sub_I_StackTrace_cpp"] = (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"]["__GLOBAL__sub_I_StackTrace_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_String_cpp = Module["__GLOBAL__sub_I_String_cpp"] = (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"]["__GLOBAL__sub_I_String_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SwCollision_cpp = Module["__GLOBAL__sub_I_SwCollision_cpp"] = (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"]["__GLOBAL__sub_I_SwCollision_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SwFactory_cpp = Module["__GLOBAL__sub_I_SwFactory_cpp"] = (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"]["__GLOBAL__sub_I_SwFactory_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SwInterCollision_cpp = Module["__GLOBAL__sub_I_SwInterCollision_cpp"] = (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"]["__GLOBAL__sub_I_SwInterCollision_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SwSelfCollision_cpp = Module["__GLOBAL__sub_I_SwSelfCollision_cpp"] = (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"]["__GLOBAL__sub_I_SwSelfCollision_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_SwSolverKernel_cpp = Module["__GLOBAL__sub_I_SwSolverKernel_cpp"] = (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"]["__GLOBAL__sub_I_SwSolverKernel_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_TerrainScriptingClasses_cpp = Module["__GLOBAL__sub_I_TerrainScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_TerrainScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_TextCoreScriptingClasses_cpp = Module["__GLOBAL__sub_I_TextCoreScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_TextCoreScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_TextRenderingScriptingClasses_cpp = Module["__GLOBAL__sub_I_TextRenderingScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_TextRenderingScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_ThreadImpl_cpp = Module["__GLOBAL__sub_I_ThreadImpl_cpp"] = (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"]["__GLOBAL__sub_I_ThreadImpl_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Thread_cpp = Module["__GLOBAL__sub_I_Thread_cpp"] = (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"]["__GLOBAL__sub_I_Thread_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Thread_cpp_95153 = Module["__GLOBAL__sub_I_Thread_cpp_95153"] = (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"]["__GLOBAL__sub_I_Thread_cpp_95153"].apply(null, arguments); +}); +var __GLOBAL__sub_I_TilemapScriptingClasses_cpp = Module["__GLOBAL__sub_I_TilemapScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_TilemapScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_TrailRenderer_cpp = Module["__GLOBAL__sub_I_TrailRenderer_cpp"] = (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"]["__GLOBAL__sub_I_TrailRenderer_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_TransformFeedbackSkinning_cpp = Module["__GLOBAL__sub_I_TransformFeedbackSkinning_cpp"] = (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"]["__GLOBAL__sub_I_TransformFeedbackSkinning_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Transform_cpp = Module["__GLOBAL__sub_I_Transform_cpp"] = (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"]["__GLOBAL__sub_I_Transform_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_UIElementsScriptingClasses_cpp = Module["__GLOBAL__sub_I_UIElementsScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_UIElementsScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_UIScriptingClasses_cpp = Module["__GLOBAL__sub_I_UIScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_UIScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_UnityAdsSettings_cpp = Module["__GLOBAL__sub_I_UnityAdsSettings_cpp"] = (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"]["__GLOBAL__sub_I_UnityAdsSettings_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp = Module["__GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_UnityAnalyticsScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp = Module["__GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_UnityWebRequestScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_UnsafeUtility_bindings_cpp = Module["__GLOBAL__sub_I_UnsafeUtility_bindings_cpp"] = (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"]["__GLOBAL__sub_I_UnsafeUtility_bindings_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_VFXScriptingClasses_cpp = Module["__GLOBAL__sub_I_VFXScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_VFXScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_VRScriptingClasses_cpp = Module["__GLOBAL__sub_I_VRScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_VRScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_VideoScriptingClasses_cpp = Module["__GLOBAL__sub_I_VideoScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_VideoScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_Wind_cpp = Module["__GLOBAL__sub_I_Wind_cpp"] = (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"]["__GLOBAL__sub_I_Wind_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_XRScriptingClasses_cpp = Module["__GLOBAL__sub_I_XRScriptingClasses_cpp"] = (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"]["__GLOBAL__sub_I_XRScriptingClasses_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp = Module["__GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp"] = (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"]["__GLOBAL__sub_I_artifacts_WebGL_codegenerator_0_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp = Module["__GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp"] = (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"]["__GLOBAL__sub_I_artifacts_WebGL_modules_Core_WebGL_asmjs_dev_i_r_nothreads_15_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_clipmuscle_cpp = Module["__GLOBAL__sub_I_clipmuscle_cpp"] = (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"]["__GLOBAL__sub_I_clipmuscle_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_threadpool_ms_cpp = Module["__GLOBAL__sub_I_threadpool_ms_cpp"] = (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"]["__GLOBAL__sub_I_threadpool_ms_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_threadpool_ms_io_cpp = Module["__GLOBAL__sub_I_threadpool_ms_io_cpp"] = (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"]["__GLOBAL__sub_I_threadpool_ms_io_cpp"].apply(null, arguments); +}); +var __GLOBAL__sub_I_umbra_cpp = Module["__GLOBAL__sub_I_umbra_cpp"] = (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"]["__GLOBAL__sub_I_umbra_cpp"].apply(null, arguments); +}); +var ___cxa_can_catch = Module["___cxa_can_catch"] = (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"]["___cxa_can_catch"].apply(null, arguments); +}); +var ___cxa_demangle = Module["___cxa_demangle"] = (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"]["___cxa_demangle"].apply(null, arguments); +}); +var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = (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"]["___cxa_is_pointer_type"].apply(null, arguments); +}); +var ___cxx_global_var_init = Module["___cxx_global_var_init"] = (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"]["___cxx_global_var_init"].apply(null, arguments); +}); +var ___cxx_global_var_init_109 = Module["___cxx_global_var_init_109"] = (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"]["___cxx_global_var_init_109"].apply(null, arguments); +}); +var ___cxx_global_var_init_11 = Module["___cxx_global_var_init_11"] = (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"]["___cxx_global_var_init_11"].apply(null, arguments); +}); +var ___cxx_global_var_init_110 = Module["___cxx_global_var_init_110"] = (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"]["___cxx_global_var_init_110"].apply(null, arguments); +}); +var ___cxx_global_var_init_110_4202 = Module["___cxx_global_var_init_110_4202"] = (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"]["___cxx_global_var_init_110_4202"].apply(null, arguments); +}); +var ___cxx_global_var_init_111 = Module["___cxx_global_var_init_111"] = (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"]["___cxx_global_var_init_111"].apply(null, arguments); +}); +var ___cxx_global_var_init_111_5625 = Module["___cxx_global_var_init_111_5625"] = (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"]["___cxx_global_var_init_111_5625"].apply(null, arguments); +}); +var ___cxx_global_var_init_112 = Module["___cxx_global_var_init_112"] = (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"]["___cxx_global_var_init_112"].apply(null, arguments); +}); +var ___cxx_global_var_init_120 = Module["___cxx_global_var_init_120"] = (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"]["___cxx_global_var_init_120"].apply(null, arguments); +}); +var ___cxx_global_var_init_121 = Module["___cxx_global_var_init_121"] = (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"]["___cxx_global_var_init_121"].apply(null, arguments); +}); +var ___cxx_global_var_init_122 = Module["___cxx_global_var_init_122"] = (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"]["___cxx_global_var_init_122"].apply(null, arguments); +}); +var ___cxx_global_var_init_127 = Module["___cxx_global_var_init_127"] = (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"]["___cxx_global_var_init_127"].apply(null, arguments); +}); +var ___cxx_global_var_init_128 = Module["___cxx_global_var_init_128"] = (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"]["___cxx_global_var_init_128"].apply(null, arguments); +}); +var ___cxx_global_var_init_13 = Module["___cxx_global_var_init_13"] = (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"]["___cxx_global_var_init_13"].apply(null, arguments); +}); +var ___cxx_global_var_init_14 = Module["___cxx_global_var_init_14"] = (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"]["___cxx_global_var_init_14"].apply(null, arguments); +}); +var ___cxx_global_var_init_145 = Module["___cxx_global_var_init_145"] = (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"]["___cxx_global_var_init_145"].apply(null, arguments); +}); +var ___cxx_global_var_init_159 = Module["___cxx_global_var_init_159"] = (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"]["___cxx_global_var_init_159"].apply(null, arguments); +}); +var ___cxx_global_var_init_159_7516 = Module["___cxx_global_var_init_159_7516"] = (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"]["___cxx_global_var_init_159_7516"].apply(null, arguments); +}); +var ___cxx_global_var_init_16 = Module["___cxx_global_var_init_16"] = (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"]["___cxx_global_var_init_16"].apply(null, arguments); +}); +var ___cxx_global_var_init_160 = Module["___cxx_global_var_init_160"] = (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"]["___cxx_global_var_init_160"].apply(null, arguments); +}); +var ___cxx_global_var_init_161 = Module["___cxx_global_var_init_161"] = (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"]["___cxx_global_var_init_161"].apply(null, arguments); +}); +var ___cxx_global_var_init_162 = Module["___cxx_global_var_init_162"] = (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"]["___cxx_global_var_init_162"].apply(null, arguments); +}); +var ___cxx_global_var_init_163 = Module["___cxx_global_var_init_163"] = (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"]["___cxx_global_var_init_163"].apply(null, arguments); +}); +var ___cxx_global_var_init_164 = Module["___cxx_global_var_init_164"] = (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"]["___cxx_global_var_init_164"].apply(null, arguments); +}); +var ___cxx_global_var_init_165 = Module["___cxx_global_var_init_165"] = (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"]["___cxx_global_var_init_165"].apply(null, arguments); +}); +var ___cxx_global_var_init_166 = Module["___cxx_global_var_init_166"] = (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"]["___cxx_global_var_init_166"].apply(null, arguments); +}); +var ___cxx_global_var_init_167 = Module["___cxx_global_var_init_167"] = (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"]["___cxx_global_var_init_167"].apply(null, arguments); +}); +var ___cxx_global_var_init_168 = Module["___cxx_global_var_init_168"] = (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"]["___cxx_global_var_init_168"].apply(null, arguments); +}); +var ___cxx_global_var_init_169 = Module["___cxx_global_var_init_169"] = (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"]["___cxx_global_var_init_169"].apply(null, arguments); +}); +var ___cxx_global_var_init_16_4048 = Module["___cxx_global_var_init_16_4048"] = (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"]["___cxx_global_var_init_16_4048"].apply(null, arguments); +}); +var ___cxx_global_var_init_16_727 = Module["___cxx_global_var_init_16_727"] = (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"]["___cxx_global_var_init_16_727"].apply(null, arguments); +}); +var ___cxx_global_var_init_16_7920 = Module["___cxx_global_var_init_16_7920"] = (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"]["___cxx_global_var_init_16_7920"].apply(null, arguments); +}); +var ___cxx_global_var_init_17 = Module["___cxx_global_var_init_17"] = (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"]["___cxx_global_var_init_17"].apply(null, arguments); +}); +var ___cxx_global_var_init_170 = Module["___cxx_global_var_init_170"] = (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"]["___cxx_global_var_init_170"].apply(null, arguments); +}); +var ___cxx_global_var_init_171 = Module["___cxx_global_var_init_171"] = (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"]["___cxx_global_var_init_171"].apply(null, arguments); +}); +var ___cxx_global_var_init_172 = Module["___cxx_global_var_init_172"] = (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"]["___cxx_global_var_init_172"].apply(null, arguments); +}); +var ___cxx_global_var_init_173 = Module["___cxx_global_var_init_173"] = (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"]["___cxx_global_var_init_173"].apply(null, arguments); +}); +var ___cxx_global_var_init_173_7517 = Module["___cxx_global_var_init_173_7517"] = (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"]["___cxx_global_var_init_173_7517"].apply(null, arguments); +}); +var ___cxx_global_var_init_174 = Module["___cxx_global_var_init_174"] = (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"]["___cxx_global_var_init_174"].apply(null, arguments); +}); +var ___cxx_global_var_init_174_7518 = Module["___cxx_global_var_init_174_7518"] = (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"]["___cxx_global_var_init_174_7518"].apply(null, arguments); +}); +var ___cxx_global_var_init_175 = Module["___cxx_global_var_init_175"] = (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"]["___cxx_global_var_init_175"].apply(null, arguments); +}); +var ___cxx_global_var_init_175_7519 = Module["___cxx_global_var_init_175_7519"] = (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"]["___cxx_global_var_init_175_7519"].apply(null, arguments); +}); +var ___cxx_global_var_init_176 = Module["___cxx_global_var_init_176"] = (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"]["___cxx_global_var_init_176"].apply(null, arguments); +}); +var ___cxx_global_var_init_176_7520 = Module["___cxx_global_var_init_176_7520"] = (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"]["___cxx_global_var_init_176_7520"].apply(null, arguments); +}); +var ___cxx_global_var_init_177 = Module["___cxx_global_var_init_177"] = (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"]["___cxx_global_var_init_177"].apply(null, arguments); +}); +var ___cxx_global_var_init_177_7521 = Module["___cxx_global_var_init_177_7521"] = (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"]["___cxx_global_var_init_177_7521"].apply(null, arguments); +}); +var ___cxx_global_var_init_178 = Module["___cxx_global_var_init_178"] = (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"]["___cxx_global_var_init_178"].apply(null, arguments); +}); +var ___cxx_global_var_init_178_7522 = Module["___cxx_global_var_init_178_7522"] = (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"]["___cxx_global_var_init_178_7522"].apply(null, arguments); +}); +var ___cxx_global_var_init_179 = Module["___cxx_global_var_init_179"] = (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"]["___cxx_global_var_init_179"].apply(null, arguments); +}); +var ___cxx_global_var_init_179_7523 = Module["___cxx_global_var_init_179_7523"] = (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"]["___cxx_global_var_init_179_7523"].apply(null, arguments); +}); +var ___cxx_global_var_init_17_7921 = Module["___cxx_global_var_init_17_7921"] = (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"]["___cxx_global_var_init_17_7921"].apply(null, arguments); +}); +var ___cxx_global_var_init_180 = Module["___cxx_global_var_init_180"] = (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"]["___cxx_global_var_init_180"].apply(null, arguments); +}); +var ___cxx_global_var_init_181 = Module["___cxx_global_var_init_181"] = (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"]["___cxx_global_var_init_181"].apply(null, arguments); +}); +var ___cxx_global_var_init_182 = Module["___cxx_global_var_init_182"] = (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"]["___cxx_global_var_init_182"].apply(null, arguments); +}); +var ___cxx_global_var_init_183 = Module["___cxx_global_var_init_183"] = (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"]["___cxx_global_var_init_183"].apply(null, arguments); +}); +var ___cxx_global_var_init_184 = Module["___cxx_global_var_init_184"] = (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"]["___cxx_global_var_init_184"].apply(null, arguments); +}); +var ___cxx_global_var_init_185 = Module["___cxx_global_var_init_185"] = (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"]["___cxx_global_var_init_185"].apply(null, arguments); +}); +var ___cxx_global_var_init_186 = Module["___cxx_global_var_init_186"] = (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"]["___cxx_global_var_init_186"].apply(null, arguments); +}); +var ___cxx_global_var_init_187 = Module["___cxx_global_var_init_187"] = (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"]["___cxx_global_var_init_187"].apply(null, arguments); +}); +var ___cxx_global_var_init_188 = Module["___cxx_global_var_init_188"] = (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"]["___cxx_global_var_init_188"].apply(null, arguments); +}); +var ___cxx_global_var_init_189 = Module["___cxx_global_var_init_189"] = (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"]["___cxx_global_var_init_189"].apply(null, arguments); +}); +var ___cxx_global_var_init_18_7922 = Module["___cxx_global_var_init_18_7922"] = (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"]["___cxx_global_var_init_18_7922"].apply(null, arguments); +}); +var ___cxx_global_var_init_19 = Module["___cxx_global_var_init_19"] = (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"]["___cxx_global_var_init_19"].apply(null, arguments); +}); +var ___cxx_global_var_init_190 = Module["___cxx_global_var_init_190"] = (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"]["___cxx_global_var_init_190"].apply(null, arguments); +}); +var ___cxx_global_var_init_191 = Module["___cxx_global_var_init_191"] = (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"]["___cxx_global_var_init_191"].apply(null, arguments); +}); +var ___cxx_global_var_init_192 = Module["___cxx_global_var_init_192"] = (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"]["___cxx_global_var_init_192"].apply(null, arguments); +}); +var ___cxx_global_var_init_193 = Module["___cxx_global_var_init_193"] = (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"]["___cxx_global_var_init_193"].apply(null, arguments); +}); +var ___cxx_global_var_init_194 = Module["___cxx_global_var_init_194"] = (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"]["___cxx_global_var_init_194"].apply(null, arguments); +}); +var ___cxx_global_var_init_195 = Module["___cxx_global_var_init_195"] = (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"]["___cxx_global_var_init_195"].apply(null, arguments); +}); +var ___cxx_global_var_init_196 = Module["___cxx_global_var_init_196"] = (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"]["___cxx_global_var_init_196"].apply(null, arguments); +}); +var ___cxx_global_var_init_197 = Module["___cxx_global_var_init_197"] = (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"]["___cxx_global_var_init_197"].apply(null, arguments); +}); +var ___cxx_global_var_init_198 = Module["___cxx_global_var_init_198"] = (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"]["___cxx_global_var_init_198"].apply(null, arguments); +}); +var ___cxx_global_var_init_199 = Module["___cxx_global_var_init_199"] = (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"]["___cxx_global_var_init_199"].apply(null, arguments); +}); +var ___cxx_global_var_init_19_7923 = Module["___cxx_global_var_init_19_7923"] = (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"]["___cxx_global_var_init_19_7923"].apply(null, arguments); +}); +var ___cxx_global_var_init_19_8116 = Module["___cxx_global_var_init_19_8116"] = (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"]["___cxx_global_var_init_19_8116"].apply(null, arguments); +}); +var ___cxx_global_var_init_1_7732 = Module["___cxx_global_var_init_1_7732"] = (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"]["___cxx_global_var_init_1_7732"].apply(null, arguments); +}); +var ___cxx_global_var_init_200 = Module["___cxx_global_var_init_200"] = (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"]["___cxx_global_var_init_200"].apply(null, arguments); +}); +var ___cxx_global_var_init_201 = Module["___cxx_global_var_init_201"] = (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"]["___cxx_global_var_init_201"].apply(null, arguments); +}); +var ___cxx_global_var_init_202 = Module["___cxx_global_var_init_202"] = (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"]["___cxx_global_var_init_202"].apply(null, arguments); +}); +var ___cxx_global_var_init_203 = Module["___cxx_global_var_init_203"] = (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"]["___cxx_global_var_init_203"].apply(null, arguments); +}); +var ___cxx_global_var_init_204 = Module["___cxx_global_var_init_204"] = (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"]["___cxx_global_var_init_204"].apply(null, arguments); +}); +var ___cxx_global_var_init_205 = Module["___cxx_global_var_init_205"] = (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"]["___cxx_global_var_init_205"].apply(null, arguments); +}); +var ___cxx_global_var_init_206 = Module["___cxx_global_var_init_206"] = (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"]["___cxx_global_var_init_206"].apply(null, arguments); +}); +var ___cxx_global_var_init_207 = Module["___cxx_global_var_init_207"] = (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"]["___cxx_global_var_init_207"].apply(null, arguments); +}); +var ___cxx_global_var_init_208 = Module["___cxx_global_var_init_208"] = (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"]["___cxx_global_var_init_208"].apply(null, arguments); +}); +var ___cxx_global_var_init_209 = Module["___cxx_global_var_init_209"] = (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"]["___cxx_global_var_init_209"].apply(null, arguments); +}); +var ___cxx_global_var_init_20_15986 = Module["___cxx_global_var_init_20_15986"] = (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"]["___cxx_global_var_init_20_15986"].apply(null, arguments); +}); +var ___cxx_global_var_init_20_7924 = Module["___cxx_global_var_init_20_7924"] = (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"]["___cxx_global_var_init_20_7924"].apply(null, arguments); +}); +var ___cxx_global_var_init_20_8117 = Module["___cxx_global_var_init_20_8117"] = (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"]["___cxx_global_var_init_20_8117"].apply(null, arguments); +}); +var ___cxx_global_var_init_21 = Module["___cxx_global_var_init_21"] = (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"]["___cxx_global_var_init_21"].apply(null, arguments); +}); +var ___cxx_global_var_init_210 = Module["___cxx_global_var_init_210"] = (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"]["___cxx_global_var_init_210"].apply(null, arguments); +}); +var ___cxx_global_var_init_21_730 = Module["___cxx_global_var_init_21_730"] = (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"]["___cxx_global_var_init_21_730"].apply(null, arguments); +}); +var ___cxx_global_var_init_21_7925 = Module["___cxx_global_var_init_21_7925"] = (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"]["___cxx_global_var_init_21_7925"].apply(null, arguments); +}); +var ___cxx_global_var_init_22 = Module["___cxx_global_var_init_22"] = (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"]["___cxx_global_var_init_22"].apply(null, arguments); +}); +var ___cxx_global_var_init_22_7926 = Module["___cxx_global_var_init_22_7926"] = (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"]["___cxx_global_var_init_22_7926"].apply(null, arguments); +}); +var ___cxx_global_var_init_22_8118 = Module["___cxx_global_var_init_22_8118"] = (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"]["___cxx_global_var_init_22_8118"].apply(null, arguments); +}); +var ___cxx_global_var_init_23 = Module["___cxx_global_var_init_23"] = (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"]["___cxx_global_var_init_23"].apply(null, arguments); +}); +var ___cxx_global_var_init_23_8119 = Module["___cxx_global_var_init_23_8119"] = (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"]["___cxx_global_var_init_23_8119"].apply(null, arguments); +}); +var ___cxx_global_var_init_24_3154 = Module["___cxx_global_var_init_24_3154"] = (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"]["___cxx_global_var_init_24_3154"].apply(null, arguments); +}); +var ___cxx_global_var_init_24_7927 = Module["___cxx_global_var_init_24_7927"] = (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"]["___cxx_global_var_init_24_7927"].apply(null, arguments); +}); +var ___cxx_global_var_init_25 = Module["___cxx_global_var_init_25"] = (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"]["___cxx_global_var_init_25"].apply(null, arguments); +}); +var ___cxx_global_var_init_26_2966 = Module["___cxx_global_var_init_26_2966"] = (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"]["___cxx_global_var_init_26_2966"].apply(null, arguments); +}); +var ___cxx_global_var_init_26_3155 = Module["___cxx_global_var_init_26_3155"] = (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"]["___cxx_global_var_init_26_3155"].apply(null, arguments); +}); +var ___cxx_global_var_init_26_3483 = Module["___cxx_global_var_init_26_3483"] = (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"]["___cxx_global_var_init_26_3483"].apply(null, arguments); +}); +var ___cxx_global_var_init_28_7904 = Module["___cxx_global_var_init_28_7904"] = (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"]["___cxx_global_var_init_28_7904"].apply(null, arguments); +}); +var ___cxx_global_var_init_29 = Module["___cxx_global_var_init_29"] = (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"]["___cxx_global_var_init_29"].apply(null, arguments); +}); +var ___cxx_global_var_init_3057 = Module["___cxx_global_var_init_3057"] = (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"]["___cxx_global_var_init_3057"].apply(null, arguments); +}); +var ___cxx_global_var_init_30_7905 = Module["___cxx_global_var_init_30_7905"] = (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"]["___cxx_global_var_init_30_7905"].apply(null, arguments); +}); +var ___cxx_global_var_init_31 = Module["___cxx_global_var_init_31"] = (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"]["___cxx_global_var_init_31"].apply(null, arguments); +}); +var ___cxx_global_var_init_32_7906 = Module["___cxx_global_var_init_32_7906"] = (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"]["___cxx_global_var_init_32_7906"].apply(null, arguments); +}); +var ___cxx_global_var_init_34 = Module["___cxx_global_var_init_34"] = (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"]["___cxx_global_var_init_34"].apply(null, arguments); +}); +var ___cxx_global_var_init_34_11610 = Module["___cxx_global_var_init_34_11610"] = (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"]["___cxx_global_var_init_34_11610"].apply(null, arguments); +}); +var ___cxx_global_var_init_34_6007 = Module["___cxx_global_var_init_34_6007"] = (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"]["___cxx_global_var_init_34_6007"].apply(null, arguments); +}); +var ___cxx_global_var_init_35 = Module["___cxx_global_var_init_35"] = (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"]["___cxx_global_var_init_35"].apply(null, arguments); +}); +var ___cxx_global_var_init_36 = Module["___cxx_global_var_init_36"] = (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"]["___cxx_global_var_init_36"].apply(null, arguments); +}); +var ___cxx_global_var_init_36_6476 = Module["___cxx_global_var_init_36_6476"] = (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"]["___cxx_global_var_init_36_6476"].apply(null, arguments); +}); +var ___cxx_global_var_init_36_7915 = Module["___cxx_global_var_init_36_7915"] = (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"]["___cxx_global_var_init_36_7915"].apply(null, arguments); +}); +var ___cxx_global_var_init_37 = Module["___cxx_global_var_init_37"] = (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"]["___cxx_global_var_init_37"].apply(null, arguments); +}); +var ___cxx_global_var_init_37_6477 = Module["___cxx_global_var_init_37_6477"] = (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"]["___cxx_global_var_init_37_6477"].apply(null, arguments); +}); +var ___cxx_global_var_init_37_7916 = Module["___cxx_global_var_init_37_7916"] = (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"]["___cxx_global_var_init_37_7916"].apply(null, arguments); +}); +var ___cxx_global_var_init_38 = Module["___cxx_global_var_init_38"] = (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"]["___cxx_global_var_init_38"].apply(null, arguments); +}); +var ___cxx_global_var_init_38_11026 = Module["___cxx_global_var_init_38_11026"] = (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"]["___cxx_global_var_init_38_11026"].apply(null, arguments); +}); +var ___cxx_global_var_init_38_3480 = Module["___cxx_global_var_init_38_3480"] = (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"]["___cxx_global_var_init_38_3480"].apply(null, arguments); +}); +var ___cxx_global_var_init_38_6478 = Module["___cxx_global_var_init_38_6478"] = (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"]["___cxx_global_var_init_38_6478"].apply(null, arguments); +}); +var ___cxx_global_var_init_38_7917 = Module["___cxx_global_var_init_38_7917"] = (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"]["___cxx_global_var_init_38_7917"].apply(null, arguments); +}); +var ___cxx_global_var_init_39 = Module["___cxx_global_var_init_39"] = (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"]["___cxx_global_var_init_39"].apply(null, arguments); +}); +var ___cxx_global_var_init_39_3481 = Module["___cxx_global_var_init_39_3481"] = (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"]["___cxx_global_var_init_39_3481"].apply(null, arguments); +}); +var ___cxx_global_var_init_39_6479 = Module["___cxx_global_var_init_39_6479"] = (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"]["___cxx_global_var_init_39_6479"].apply(null, arguments); +}); +var ___cxx_global_var_init_39_7918 = Module["___cxx_global_var_init_39_7918"] = (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"]["___cxx_global_var_init_39_7918"].apply(null, arguments); +}); +var ___cxx_global_var_init_3_5530 = Module["___cxx_global_var_init_3_5530"] = (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"]["___cxx_global_var_init_3_5530"].apply(null, arguments); +}); +var ___cxx_global_var_init_4 = Module["___cxx_global_var_init_4"] = (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"]["___cxx_global_var_init_4"].apply(null, arguments); +}); +var ___cxx_global_var_init_40 = Module["___cxx_global_var_init_40"] = (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"]["___cxx_global_var_init_40"].apply(null, arguments); +}); +var ___cxx_global_var_init_40_3482 = Module["___cxx_global_var_init_40_3482"] = (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"]["___cxx_global_var_init_40_3482"].apply(null, arguments); +}); +var ___cxx_global_var_init_40_6480 = Module["___cxx_global_var_init_40_6480"] = (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"]["___cxx_global_var_init_40_6480"].apply(null, arguments); +}); +var ___cxx_global_var_init_40_7919 = Module["___cxx_global_var_init_40_7919"] = (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"]["___cxx_global_var_init_40_7919"].apply(null, arguments); +}); +var ___cxx_global_var_init_41 = Module["___cxx_global_var_init_41"] = (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"]["___cxx_global_var_init_41"].apply(null, arguments); +}); +var ___cxx_global_var_init_4149 = Module["___cxx_global_var_init_4149"] = (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"]["___cxx_global_var_init_4149"].apply(null, arguments); +}); +var ___cxx_global_var_init_41_6481 = Module["___cxx_global_var_init_41_6481"] = (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"]["___cxx_global_var_init_41_6481"].apply(null, arguments); +}); +var ___cxx_global_var_init_42 = Module["___cxx_global_var_init_42"] = (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"]["___cxx_global_var_init_42"].apply(null, arguments); +}); +var ___cxx_global_var_init_425 = Module["___cxx_global_var_init_425"] = (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"]["___cxx_global_var_init_425"].apply(null, arguments); +}); +var ___cxx_global_var_init_42_6482 = Module["___cxx_global_var_init_42_6482"] = (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"]["___cxx_global_var_init_42_6482"].apply(null, arguments); +}); +var ___cxx_global_var_init_43 = Module["___cxx_global_var_init_43"] = (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"]["___cxx_global_var_init_43"].apply(null, arguments); +}); +var ___cxx_global_var_init_44 = Module["___cxx_global_var_init_44"] = (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"]["___cxx_global_var_init_44"].apply(null, arguments); +}); +var ___cxx_global_var_init_44_6207 = Module["___cxx_global_var_init_44_6207"] = (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"]["___cxx_global_var_init_44_6207"].apply(null, arguments); +}); +var ___cxx_global_var_init_45 = Module["___cxx_global_var_init_45"] = (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"]["___cxx_global_var_init_45"].apply(null, arguments); +}); +var ___cxx_global_var_init_45_11027 = Module["___cxx_global_var_init_45_11027"] = (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"]["___cxx_global_var_init_45_11027"].apply(null, arguments); +}); +var ___cxx_global_var_init_46 = Module["___cxx_global_var_init_46"] = (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"]["___cxx_global_var_init_46"].apply(null, arguments); +}); +var ___cxx_global_var_init_46_11028 = Module["___cxx_global_var_init_46_11028"] = (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"]["___cxx_global_var_init_46_11028"].apply(null, arguments); +}); +var ___cxx_global_var_init_46_6730 = Module["___cxx_global_var_init_46_6730"] = (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"]["___cxx_global_var_init_46_6730"].apply(null, arguments); +}); +var ___cxx_global_var_init_47 = Module["___cxx_global_var_init_47"] = (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"]["___cxx_global_var_init_47"].apply(null, arguments); +}); +var ___cxx_global_var_init_47_11029 = Module["___cxx_global_var_init_47_11029"] = (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"]["___cxx_global_var_init_47_11029"].apply(null, arguments); +}); +var ___cxx_global_var_init_47_731 = Module["___cxx_global_var_init_47_731"] = (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"]["___cxx_global_var_init_47_731"].apply(null, arguments); +}); +var ___cxx_global_var_init_48 = Module["___cxx_global_var_init_48"] = (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"]["___cxx_global_var_init_48"].apply(null, arguments); +}); +var ___cxx_global_var_init_48_729 = Module["___cxx_global_var_init_48_729"] = (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"]["___cxx_global_var_init_48_729"].apply(null, arguments); +}); +var ___cxx_global_var_init_4_728 = Module["___cxx_global_var_init_4_728"] = (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"]["___cxx_global_var_init_4_728"].apply(null, arguments); +}); +var ___cxx_global_var_init_5 = Module["___cxx_global_var_init_5"] = (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"]["___cxx_global_var_init_5"].apply(null, arguments); +}); +var ___cxx_global_var_init_55 = Module["___cxx_global_var_init_55"] = (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"]["___cxx_global_var_init_55"].apply(null, arguments); +}); +var ___cxx_global_var_init_5581 = Module["___cxx_global_var_init_5581"] = (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"]["___cxx_global_var_init_5581"].apply(null, arguments); +}); +var ___cxx_global_var_init_6006 = Module["___cxx_global_var_init_6006"] = (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"]["___cxx_global_var_init_6006"].apply(null, arguments); +}); +var ___cxx_global_var_init_65 = Module["___cxx_global_var_init_65"] = (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"]["___cxx_global_var_init_65"].apply(null, arguments); +}); +var ___cxx_global_var_init_66 = Module["___cxx_global_var_init_66"] = (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"]["___cxx_global_var_init_66"].apply(null, arguments); +}); +var ___cxx_global_var_init_67 = Module["___cxx_global_var_init_67"] = (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"]["___cxx_global_var_init_67"].apply(null, arguments); +}); +var ___cxx_global_var_init_6718 = Module["___cxx_global_var_init_6718"] = (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"]["___cxx_global_var_init_6718"].apply(null, arguments); +}); +var ___cxx_global_var_init_6731 = Module["___cxx_global_var_init_6731"] = (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"]["___cxx_global_var_init_6731"].apply(null, arguments); +}); +var ___cxx_global_var_init_7 = Module["___cxx_global_var_init_7"] = (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"]["___cxx_global_var_init_7"].apply(null, arguments); +}); +var ___cxx_global_var_init_73 = Module["___cxx_global_var_init_73"] = (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"]["___cxx_global_var_init_73"].apply(null, arguments); +}); +var ___cxx_global_var_init_75 = Module["___cxx_global_var_init_75"] = (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"]["___cxx_global_var_init_75"].apply(null, arguments); +}); +var ___cxx_global_var_init_75_8232 = Module["___cxx_global_var_init_75_8232"] = (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"]["___cxx_global_var_init_75_8232"].apply(null, arguments); +}); +var ___cxx_global_var_init_7731 = Module["___cxx_global_var_init_7731"] = (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"]["___cxx_global_var_init_7731"].apply(null, arguments); +}); +var ___cxx_global_var_init_78 = Module["___cxx_global_var_init_78"] = (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"]["___cxx_global_var_init_78"].apply(null, arguments); +}); +var ___cxx_global_var_init_79 = Module["___cxx_global_var_init_79"] = (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"]["___cxx_global_var_init_79"].apply(null, arguments); +}); +var ___cxx_global_var_init_79_4682 = Module["___cxx_global_var_init_79_4682"] = (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"]["___cxx_global_var_init_79_4682"].apply(null, arguments); +}); +var ___cxx_global_var_init_7_5458 = Module["___cxx_global_var_init_7_5458"] = (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"]["___cxx_global_var_init_7_5458"].apply(null, arguments); +}); +var ___cxx_global_var_init_80 = Module["___cxx_global_var_init_80"] = (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"]["___cxx_global_var_init_80"].apply(null, arguments); +}); +var ___cxx_global_var_init_81 = Module["___cxx_global_var_init_81"] = (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"]["___cxx_global_var_init_81"].apply(null, arguments); +}); +var ___cxx_global_var_init_82 = Module["___cxx_global_var_init_82"] = (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"]["___cxx_global_var_init_82"].apply(null, arguments); +}); +var ___cxx_global_var_init_83 = Module["___cxx_global_var_init_83"] = (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"]["___cxx_global_var_init_83"].apply(null, arguments); +}); +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); +}); +var _emscripten_replace_memory = Module["_emscripten_replace_memory"] = (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_replace_memory"].apply(null, arguments); +}); +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); +}); +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); +}); +var _htonl = Module["_htonl"] = (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"]["_htonl"].apply(null, arguments); +}); +var _htons = Module["_htons"] = (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"]["_htons"].apply(null, arguments); +}); +var _llvm_bswap_i16 = Module["_llvm_bswap_i16"] = (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"]["_llvm_bswap_i16"].apply(null, arguments); +}); +var _llvm_bswap_i32 = Module["_llvm_bswap_i32"] = (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"]["_llvm_bswap_i32"].apply(null, arguments); +}); +var _llvm_ctlz_i64 = Module["_llvm_ctlz_i64"] = (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"]["_llvm_ctlz_i64"].apply(null, arguments); +}); +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); +}); +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); +}); +var _memalign = Module["_memalign"] = (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"]["_memalign"].apply(null, arguments); +}); +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); +}); +var _memmove = Module["_memmove"] = (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"]["_memmove"].apply(null, arguments); +}); +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); +}); +var _ntohs = Module["_ntohs"] = (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"]["_ntohs"].apply(null, arguments); +}); +var _pthread_cond_broadcast = Module["_pthread_cond_broadcast"] = (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"]["_pthread_cond_broadcast"].apply(null, arguments); +}); +var _pthread_mutex_lock = Module["_pthread_mutex_lock"] = (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"]["_pthread_mutex_lock"].apply(null, arguments); +}); +var _pthread_mutex_unlock = Module["_pthread_mutex_unlock"] = (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"]["_pthread_mutex_unlock"].apply(null, arguments); +}); +var _realloc = Module["_realloc"] = (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"]["_realloc"].apply(null, arguments); +}); +var _roundf = Module["_roundf"] = (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"]["_roundf"].apply(null, arguments); +}); +var _saveSetjmp = Module["_saveSetjmp"] = (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"]["_saveSetjmp"].apply(null, arguments); +}); +var _sbrk = Module["_sbrk"] = (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"]["_sbrk"].apply(null, arguments); +}); +var _strlen = Module["_strlen"] = (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"]["_strlen"].apply(null, arguments); +}); +var _testSetjmp = Module["_testSetjmp"] = (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"]["_testSetjmp"].apply(null, arguments); +}); +var establishStackSpace = Module["establishStackSpace"] = (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"]["establishStackSpace"].apply(null, arguments); +}); +var getTempRet0 = Module["getTempRet0"] = (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"]["getTempRet0"].apply(null, arguments); +}); +var runPostSets = Module["runPostSets"] = (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"]["runPostSets"].apply(null, arguments); +}); +var setTempRet0 = Module["setTempRet0"] = (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"]["setTempRet0"].apply(null, arguments); +}); +var setThrew = Module["setThrew"] = (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"]["setThrew"].apply(null, arguments); +}); +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); +}); +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); +}); +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); +}); +var dynCall_dddi = Module["dynCall_dddi"] = (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_dddi"].apply(null, arguments); +}); +var dynCall_ddi = Module["dynCall_ddi"] = (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_ddi"].apply(null, arguments); +}); +var dynCall_dfi = Module["dynCall_dfi"] = (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_dfi"].apply(null, arguments); +}); +var dynCall_di = Module["dynCall_di"] = (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_di"].apply(null, arguments); +}); +var dynCall_diddi = Module["dynCall_diddi"] = (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_diddi"].apply(null, arguments); +}); +var dynCall_didi = Module["dynCall_didi"] = (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_didi"].apply(null, arguments); +}); +var dynCall_dii = Module["dynCall_dii"] = (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_dii"].apply(null, arguments); +}); +var dynCall_diii = Module["dynCall_diii"] = (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_diii"].apply(null, arguments); +}); +var dynCall_diiii = Module["dynCall_diiii"] = (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_diiii"].apply(null, arguments); +}); +var dynCall_diji = Module["dynCall_diji"] = (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_diji"].apply(null, arguments); +}); +var dynCall_dji = Module["dynCall_dji"] = (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_dji"].apply(null, arguments); +}); +var dynCall_f = Module["dynCall_f"] = (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_f"].apply(null, arguments); +}); +var dynCall_fdi = Module["dynCall_fdi"] = (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_fdi"].apply(null, arguments); +}); +var dynCall_ff = Module["dynCall_ff"] = (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_ff"].apply(null, arguments); +}); +var dynCall_fff = Module["dynCall_fff"] = (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_fff"].apply(null, arguments); +}); +var dynCall_ffffi = Module["dynCall_ffffi"] = (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_ffffi"].apply(null, arguments); +}); +var dynCall_fffi = Module["dynCall_fffi"] = (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_fffi"].apply(null, arguments); +}); +var dynCall_fffifffi = Module["dynCall_fffifffi"] = (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_fffifffi"].apply(null, arguments); +}); +var dynCall_ffi = Module["dynCall_ffi"] = (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_ffi"].apply(null, arguments); +}); +var dynCall_fi = Module["dynCall_fi"] = (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_fi"].apply(null, arguments); +}); +var dynCall_fidi = Module["dynCall_fidi"] = (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_fidi"].apply(null, arguments); +}); +var dynCall_fif = Module["dynCall_fif"] = (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_fif"].apply(null, arguments); +}); +var dynCall_fiff = Module["dynCall_fiff"] = (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_fiff"].apply(null, arguments); +}); +var dynCall_fiffi = Module["dynCall_fiffi"] = (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_fiffi"].apply(null, arguments); +}); +var dynCall_fifi = Module["dynCall_fifi"] = (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_fifi"].apply(null, arguments); +}); +var dynCall_fifii = Module["dynCall_fifii"] = (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_fifii"].apply(null, arguments); +}); +var dynCall_fii = Module["dynCall_fii"] = (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_fii"].apply(null, arguments); +}); +var dynCall_fiifi = Module["dynCall_fiifi"] = (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_fiifi"].apply(null, arguments); +}); +var dynCall_fiifii = Module["dynCall_fiifii"] = (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_fiifii"].apply(null, arguments); +}); +var dynCall_fiii = Module["dynCall_fiii"] = (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_fiii"].apply(null, arguments); +}); +var dynCall_fiiii = Module["dynCall_fiiii"] = (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_fiiii"].apply(null, arguments); +}); +var dynCall_fiiiif = Module["dynCall_fiiiif"] = (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_fiiiif"].apply(null, arguments); +}); +var dynCall_fiiiii = Module["dynCall_fiiiii"] = (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_fiiiii"].apply(null, arguments); +}); +var dynCall_fiiiiii = Module["dynCall_fiiiiii"] = (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_fiiiiii"].apply(null, arguments); +}); +var dynCall_fiiiiiifiifif = Module["dynCall_fiiiiiifiifif"] = (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_fiiiiiifiifif"].apply(null, arguments); +}); +var dynCall_fiiiiiifiiiif = Module["dynCall_fiiiiiifiiiif"] = (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_fiiiiiifiiiif"].apply(null, arguments); +}); +var dynCall_fji = Module["dynCall_fji"] = (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_fji"].apply(null, arguments); +}); +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); +}); +var dynCall_iddi = Module["dynCall_iddi"] = (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_iddi"].apply(null, arguments); +}); +var dynCall_idi = Module["dynCall_idi"] = (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_idi"].apply(null, arguments); +}); +var dynCall_idiii = Module["dynCall_idiii"] = (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_idiii"].apply(null, arguments); +}); +var dynCall_ifffi = Module["dynCall_ifffi"] = (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_ifffi"].apply(null, arguments); +}); +var dynCall_iffi = Module["dynCall_iffi"] = (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_iffi"].apply(null, arguments); +}); +var dynCall_ifi = Module["dynCall_ifi"] = (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_ifi"].apply(null, arguments); +}); +var dynCall_ifiii = Module["dynCall_ifiii"] = (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_ifiii"].apply(null, arguments); +}); +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); +}); +var dynCall_iiddi = Module["dynCall_iiddi"] = (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_iiddi"].apply(null, arguments); +}); +var dynCall_iiddiii = Module["dynCall_iiddiii"] = (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_iiddiii"].apply(null, arguments); +}); +var dynCall_iidi = Module["dynCall_iidi"] = (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_iidi"].apply(null, arguments); +}); +var dynCall_iidii = Module["dynCall_iidii"] = (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_iidii"].apply(null, arguments); +}); +var dynCall_iidiii = Module["dynCall_iidiii"] = (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_iidiii"].apply(null, arguments); +}); +var dynCall_iif = Module["dynCall_iif"] = (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_iif"].apply(null, arguments); +}); +var dynCall_iifff = Module["dynCall_iifff"] = (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_iifff"].apply(null, arguments); +}); +var dynCall_iifffi = Module["dynCall_iifffi"] = (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_iifffi"].apply(null, arguments); +}); +var dynCall_iiffi = Module["dynCall_iiffi"] = (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_iiffi"].apply(null, arguments); +}); +var dynCall_iiffiii = Module["dynCall_iiffiii"] = (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_iiffiii"].apply(null, arguments); +}); +var dynCall_iifi = Module["dynCall_iifi"] = (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_iifi"].apply(null, arguments); +}); +var dynCall_iifii = Module["dynCall_iifii"] = (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_iifii"].apply(null, arguments); +}); +var dynCall_iifiii = Module["dynCall_iifiii"] = (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_iifiii"].apply(null, arguments); +}); +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); +}); +var dynCall_iiidii = Module["dynCall_iiidii"] = (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_iiidii"].apply(null, arguments); +}); +var dynCall_iiidiii = Module["dynCall_iiidiii"] = (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_iiidiii"].apply(null, arguments); +}); +var dynCall_iiif = Module["dynCall_iiif"] = (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_iiif"].apply(null, arguments); +}); +var dynCall_iiifi = Module["dynCall_iiifi"] = (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_iiifi"].apply(null, arguments); +}); +var dynCall_iiifii = Module["dynCall_iiifii"] = (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_iiifii"].apply(null, arguments); +}); +var dynCall_iiifiii = Module["dynCall_iiifiii"] = (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_iiifiii"].apply(null, arguments); +}); +var dynCall_iiifiiii = Module["dynCall_iiifiiii"] = (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_iiifiiii"].apply(null, arguments); +}); +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); +}); +var dynCall_iiiidii = Module["dynCall_iiiidii"] = (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_iiiidii"].apply(null, arguments); +}); +var dynCall_iiiifffffi = Module["dynCall_iiiifffffi"] = (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_iiiifffffi"].apply(null, arguments); +}); +var dynCall_iiiifi = Module["dynCall_iiiifi"] = (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_iiiifi"].apply(null, arguments); +}); +var dynCall_iiiifii = Module["dynCall_iiiifii"] = (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_iiiifii"].apply(null, arguments); +}); +var dynCall_iiiifiii = Module["dynCall_iiiifiii"] = (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_iiiifiii"].apply(null, arguments); +}); +var dynCall_iiiifiiii = Module["dynCall_iiiifiiii"] = (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_iiiifiiii"].apply(null, arguments); +}); +var dynCall_iiiifiiiii = Module["dynCall_iiiifiiiii"] = (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_iiiifiiiii"].apply(null, arguments); +}); +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); +}); +var dynCall_iiiiifi = Module["dynCall_iiiiifi"] = (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_iiiiifi"].apply(null, arguments); +}); +var dynCall_iiiiifiii = Module["dynCall_iiiiifiii"] = (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_iiiiifiii"].apply(null, arguments); +}); +var dynCall_iiiiifiiiif = Module["dynCall_iiiiifiiiif"] = (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_iiiiifiiiif"].apply(null, arguments); +}); +var dynCall_iiiiifiiiiif = Module["dynCall_iiiiifiiiiif"] = (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_iiiiifiiiiif"].apply(null, arguments); +}); +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); +}); +var dynCall_iiiiiifffiiifiii = Module["dynCall_iiiiiifffiiifiii"] = (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_iiiiiifffiiifiii"].apply(null, arguments); +}); +var dynCall_iiiiiiffiiiiiiiiiffffiii = Module["dynCall_iiiiiiffiiiiiiiiiffffiii"] = (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_iiiiiiffiiiiiiiiiffffiii"].apply(null, arguments); +}); +var dynCall_iiiiiiffiiiiiiiiiffffiiii = Module["dynCall_iiiiiiffiiiiiiiiiffffiiii"] = (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_iiiiiiffiiiiiiiiiffffiiii"].apply(null, arguments); +}); +var dynCall_iiiiiiffiiiiiiiiiiiiiii = Module["dynCall_iiiiiiffiiiiiiiiiiiiiii"] = (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_iiiiiiffiiiiiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_iiiiiifiif = Module["dynCall_iiiiiifiif"] = (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_iiiiiifiif"].apply(null, arguments); +}); +var dynCall_iiiiiifiii = Module["dynCall_iiiiiifiii"] = (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_iiiiiifiii"].apply(null, arguments); +}); +var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = (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_iiiiiii"].apply(null, arguments); +}); +var dynCall_iiiiiiifiif = Module["dynCall_iiiiiiifiif"] = (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_iiiiiiifiif"].apply(null, arguments); +}); +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); +}); +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); +}); +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); +}); +var dynCall_iiiiiiiiiii = Module["dynCall_iiiiiiiiiii"] = (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_iiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_iiiiiiiiiiii = Module["dynCall_iiiiiiiiiiii"] = (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_iiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_iiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiii"] = (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_iiiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_iiiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiiii"] = (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_iiiiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_iiiiij = Module["dynCall_iiiiij"] = (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_iiiiij"].apply(null, arguments); +}); +var dynCall_iiiiiji = Module["dynCall_iiiiiji"] = (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_iiiiiji"].apply(null, arguments); +}); +var dynCall_iiiiijjiiiii = Module["dynCall_iiiiijjiiiii"] = (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_iiiiijjiiiii"].apply(null, arguments); +}); +var dynCall_iiiij = Module["dynCall_iiiij"] = (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_iiiij"].apply(null, arguments); +}); +var dynCall_iiiiji = Module["dynCall_iiiiji"] = (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_iiiiji"].apply(null, arguments); +}); +var dynCall_iiiijii = Module["dynCall_iiiijii"] = (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_iiiijii"].apply(null, arguments); +}); +var dynCall_iiiijiii = Module["dynCall_iiiijiii"] = (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_iiiijiii"].apply(null, arguments); +}); +var dynCall_iiiijijii = Module["dynCall_iiiijijii"] = (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_iiiijijii"].apply(null, arguments); +}); +var dynCall_iiiijjii = Module["dynCall_iiiijjii"] = (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_iiiijjii"].apply(null, arguments); +}); +var dynCall_iiiijjiiii = Module["dynCall_iiiijjiiii"] = (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_iiiijjiiii"].apply(null, arguments); +}); +var dynCall_iiij = Module["dynCall_iiij"] = (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_iiij"].apply(null, arguments); +}); +var dynCall_iiiji = Module["dynCall_iiiji"] = (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_iiiji"].apply(null, arguments); +}); +var dynCall_iiijii = Module["dynCall_iiijii"] = (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_iiijii"].apply(null, arguments); +}); +var dynCall_iiijiii = Module["dynCall_iiijiii"] = (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_iiijiii"].apply(null, arguments); +}); +var dynCall_iiijji = Module["dynCall_iiijji"] = (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_iiijji"].apply(null, arguments); +}); +var dynCall_iiijjii = Module["dynCall_iiijjii"] = (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_iiijjii"].apply(null, arguments); +}); +var dynCall_iiijjiiii = Module["dynCall_iiijjiiii"] = (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_iiijjiiii"].apply(null, arguments); +}); +var dynCall_iij = Module["dynCall_iij"] = (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_iij"].apply(null, arguments); +}); +var dynCall_iiji = Module["dynCall_iiji"] = (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_iiji"].apply(null, arguments); +}); +var dynCall_iijii = Module["dynCall_iijii"] = (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_iijii"].apply(null, arguments); +}); +var dynCall_iijiii = Module["dynCall_iijiii"] = (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_iijiii"].apply(null, arguments); +}); +var dynCall_iijji = Module["dynCall_iijji"] = (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_iijji"].apply(null, arguments); +}); +var dynCall_iijjii = Module["dynCall_iijjii"] = (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_iijjii"].apply(null, arguments); +}); +var dynCall_iijjiii = Module["dynCall_iijjiii"] = (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_iijjiii"].apply(null, arguments); +}); +var dynCall_iijjji = Module["dynCall_iijjji"] = (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_iijjji"].apply(null, arguments); +}); +var dynCall_ij = Module["dynCall_ij"] = (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_ij"].apply(null, arguments); +}); +var dynCall_iji = Module["dynCall_iji"] = (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_iji"].apply(null, arguments); +}); +var dynCall_ijiii = Module["dynCall_ijiii"] = (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_ijiii"].apply(null, arguments); +}); +var dynCall_ijiiii = Module["dynCall_ijiiii"] = (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_ijiiii"].apply(null, arguments); +}); +var dynCall_ijiiiii = Module["dynCall_ijiiiii"] = (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_ijiiiii"].apply(null, arguments); +}); +var dynCall_ijiiiiii = Module["dynCall_ijiiiiii"] = (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_ijiiiiii"].apply(null, arguments); +}); +var dynCall_ijj = Module["dynCall_ijj"] = (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_ijj"].apply(null, arguments); +}); +var dynCall_ijji = Module["dynCall_ijji"] = (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_ijji"].apply(null, arguments); +}); +var dynCall_j = Module["dynCall_j"] = (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_j"].apply(null, arguments); +}); +var dynCall_jdi = Module["dynCall_jdi"] = (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_jdi"].apply(null, arguments); +}); +var dynCall_jdii = Module["dynCall_jdii"] = (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_jdii"].apply(null, arguments); +}); +var dynCall_jfi = Module["dynCall_jfi"] = (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_jfi"].apply(null, arguments); +}); +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); +}); +var dynCall_jidi = Module["dynCall_jidi"] = (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_jidi"].apply(null, arguments); +}); +var dynCall_jidii = Module["dynCall_jidii"] = (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_jidii"].apply(null, arguments); +}); +var dynCall_jifi = Module["dynCall_jifi"] = (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_jifi"].apply(null, arguments); +}); +var dynCall_jii = Module["dynCall_jii"] = (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_jii"].apply(null, arguments); +}); +var dynCall_jiii = Module["dynCall_jiii"] = (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_jiii"].apply(null, arguments); +}); +var dynCall_jiiii = Module["dynCall_jiiii"] = (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_jiiii"].apply(null, arguments); +}); +var dynCall_jiiiii = Module["dynCall_jiiiii"] = (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_jiiiii"].apply(null, arguments); +}); +var dynCall_jiiiiii = Module["dynCall_jiiiiii"] = (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_jiiiiii"].apply(null, arguments); +}); +var dynCall_jiiiiiiiiii = Module["dynCall_jiiiiiiiiii"] = (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_jiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_jiiji = Module["dynCall_jiiji"] = (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_jiiji"].apply(null, arguments); +}); +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); +}); +var dynCall_jijii = Module["dynCall_jijii"] = (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_jijii"].apply(null, arguments); +}); +var dynCall_jijiii = Module["dynCall_jijiii"] = (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_jijiii"].apply(null, arguments); +}); +var dynCall_jijj = Module["dynCall_jijj"] = (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_jijj"].apply(null, arguments); +}); +var dynCall_jijji = Module["dynCall_jijji"] = (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_jijji"].apply(null, arguments); +}); +var dynCall_jji = Module["dynCall_jji"] = (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_jji"].apply(null, arguments); +}); +var dynCall_jjii = Module["dynCall_jjii"] = (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_jjii"].apply(null, arguments); +}); +var dynCall_jjjji = Module["dynCall_jjjji"] = (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_jjjji"].apply(null, arguments); +}); +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); +}); +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); +}); +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); +}); +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); +}); +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); +}); +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); +}); +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); +}); +var dynCall_vid = Module["dynCall_vid"] = (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_vid"].apply(null, arguments); +}); +var dynCall_vidi = Module["dynCall_vidi"] = (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_vidi"].apply(null, arguments); +}); +var dynCall_vidiii = Module["dynCall_vidiii"] = (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_vidiii"].apply(null, arguments); +}); +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); +}); +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); +}); +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); +}); +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); +}); +var dynCall_vifffffi = Module["dynCall_vifffffi"] = (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_vifffffi"].apply(null, arguments); +}); +var dynCall_viffffi = Module["dynCall_viffffi"] = (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_viffffi"].apply(null, arguments); +}); +var dynCall_viffffii = Module["dynCall_viffffii"] = (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_viffffii"].apply(null, arguments); +}); +var dynCall_vifffi = Module["dynCall_vifffi"] = (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_vifffi"].apply(null, arguments); +}); +var dynCall_vifffii = Module["dynCall_vifffii"] = (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_vifffii"].apply(null, arguments); +}); +var dynCall_viffi = Module["dynCall_viffi"] = (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_viffi"].apply(null, arguments); +}); +var dynCall_viffii = Module["dynCall_viffii"] = (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_viffii"].apply(null, arguments); +}); +var dynCall_viffiii = Module["dynCall_viffiii"] = (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_viffiii"].apply(null, arguments); +}); +var dynCall_vifi = Module["dynCall_vifi"] = (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_vifi"].apply(null, arguments); +}); +var dynCall_vifii = Module["dynCall_vifii"] = (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_vifii"].apply(null, arguments); +}); +var dynCall_vifiiii = Module["dynCall_vifiiii"] = (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_vifiiii"].apply(null, arguments); +}); +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); +}); +var dynCall_viidi = Module["dynCall_viidi"] = (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_viidi"].apply(null, arguments); +}); +var dynCall_viidii = Module["dynCall_viidii"] = (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_viidii"].apply(null, arguments); +}); +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); +}); +var dynCall_viiff = Module["dynCall_viiff"] = (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_viiff"].apply(null, arguments); +}); +var dynCall_viifff = Module["dynCall_viifff"] = (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_viifff"].apply(null, arguments); +}); +var dynCall_viifffi = Module["dynCall_viifffi"] = (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_viifffi"].apply(null, arguments); +}); +var dynCall_viiffi = Module["dynCall_viiffi"] = (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_viiffi"].apply(null, arguments); +}); +var dynCall_viiffii = Module["dynCall_viiffii"] = (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_viiffii"].apply(null, arguments); +}); +var dynCall_viifi = Module["dynCall_viifi"] = (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_viifi"].apply(null, arguments); +}); +var dynCall_viifii = Module["dynCall_viifii"] = (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_viifii"].apply(null, arguments); +}); +var dynCall_viifiii = Module["dynCall_viifiii"] = (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_viifiii"].apply(null, arguments); +}); +var dynCall_viifiiii = Module["dynCall_viifiiii"] = (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_viifiiii"].apply(null, arguments); +}); +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); +}); +var dynCall_viiiffi = Module["dynCall_viiiffi"] = (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_viiiffi"].apply(null, arguments); +}); +var dynCall_viiiffii = Module["dynCall_viiiffii"] = (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_viiiffii"].apply(null, arguments); +}); +var dynCall_viiifi = Module["dynCall_viiifi"] = (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_viiifi"].apply(null, arguments); +}); +var dynCall_viiififfi = Module["dynCall_viiififfi"] = (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_viiififfi"].apply(null, arguments); +}); +var dynCall_viiififi = Module["dynCall_viiififi"] = (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_viiififi"].apply(null, arguments); +}); +var dynCall_viiifii = Module["dynCall_viiifii"] = (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_viiifii"].apply(null, arguments); +}); +var dynCall_viiifiii = Module["dynCall_viiifiii"] = (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_viiifiii"].apply(null, arguments); +}); +var dynCall_viiifiiiii = Module["dynCall_viiifiiiii"] = (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_viiifiiiii"].apply(null, arguments); +}); +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); +}); +var dynCall_viiiif = Module["dynCall_viiiif"] = (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_viiiif"].apply(null, arguments); +}); +var dynCall_viiiiffffii = Module["dynCall_viiiiffffii"] = (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_viiiiffffii"].apply(null, arguments); +}); +var dynCall_viiiifii = Module["dynCall_viiiifii"] = (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_viiiifii"].apply(null, arguments); +}); +var dynCall_viiiifiii = Module["dynCall_viiiifiii"] = (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_viiiifiii"].apply(null, arguments); +}); +var dynCall_viiiifiiiiif = Module["dynCall_viiiifiiiiif"] = (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_viiiifiiiiif"].apply(null, arguments); +}); +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); +}); +var dynCall_viiiiif = Module["dynCall_viiiiif"] = (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_viiiiif"].apply(null, arguments); +}); +var dynCall_viiiiiffi = Module["dynCall_viiiiiffi"] = (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_viiiiiffi"].apply(null, arguments); +}); +var dynCall_viiiiiffii = Module["dynCall_viiiiiffii"] = (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_viiiiiffii"].apply(null, arguments); +}); +var dynCall_viiiiifi = Module["dynCall_viiiiifi"] = (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_viiiiifi"].apply(null, arguments); +}); +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); +}); +var dynCall_viiiiiif = Module["dynCall_viiiiiif"] = (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_viiiiiif"].apply(null, arguments); +}); +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); +}); +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); +}); +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); +}); +var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = (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_viiiiiiiiii"].apply(null, arguments); +}); +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); +}); +var dynCall_viiiiiiiiiiifii = Module["dynCall_viiiiiiiiiiifii"] = (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_viiiiiiiiiiifii"].apply(null, arguments); +}); +var dynCall_viiiiiiiiiiii = Module["dynCall_viiiiiiiiiiii"] = (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_viiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_viiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiii"] = (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_viiiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_viiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiii"] = (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_viiiiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_viiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiii"] = (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_viiiiiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_viiiiiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiiiiii"] = (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_viiiiiiiiiiiiiiiiii"].apply(null, arguments); +}); +var dynCall_viiiiiiiiiji = Module["dynCall_viiiiiiiiiji"] = (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_viiiiiiiiiji"].apply(null, arguments); +}); +var dynCall_viiiiiiiji = Module["dynCall_viiiiiiiji"] = (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_viiiiiiiji"].apply(null, arguments); +}); +var dynCall_viiiiiiijii = Module["dynCall_viiiiiiijii"] = (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_viiiiiiijii"].apply(null, arguments); +}); +var dynCall_viiiiij = Module["dynCall_viiiiij"] = (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_viiiiij"].apply(null, arguments); +}); +var dynCall_viiiiijii = Module["dynCall_viiiiijii"] = (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_viiiiijii"].apply(null, arguments); +}); +var dynCall_viiiiji = Module["dynCall_viiiiji"] = (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_viiiiji"].apply(null, arguments); +}); +var dynCall_viiiijii = Module["dynCall_viiiijii"] = (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_viiiijii"].apply(null, arguments); +}); +var dynCall_viiiijiiii = Module["dynCall_viiiijiiii"] = (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_viiiijiiii"].apply(null, arguments); +}); +var dynCall_viiiijjiii = Module["dynCall_viiiijjiii"] = (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_viiiijjiii"].apply(null, arguments); +}); +var dynCall_viiiji = Module["dynCall_viiiji"] = (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_viiiji"].apply(null, arguments); +}); +var dynCall_viiijji = Module["dynCall_viiijji"] = (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_viiijji"].apply(null, arguments); +}); +var dynCall_viiijjii = Module["dynCall_viiijjii"] = (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_viiijjii"].apply(null, arguments); +}); +var dynCall_viiijjiii = Module["dynCall_viiijjiii"] = (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_viiijjiii"].apply(null, arguments); +}); +var dynCall_viij = Module["dynCall_viij"] = (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_viij"].apply(null, arguments); +}); +var dynCall_viiji = Module["dynCall_viiji"] = (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_viiji"].apply(null, arguments); +}); +var dynCall_viijii = Module["dynCall_viijii"] = (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_viijii"].apply(null, arguments); +}); +var dynCall_viijiiii = Module["dynCall_viijiiii"] = (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_viijiiii"].apply(null, arguments); +}); +var dynCall_viijiijiii = Module["dynCall_viijiijiii"] = (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_viijiijiii"].apply(null, arguments); +}); +var dynCall_viijijii = Module["dynCall_viijijii"] = (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_viijijii"].apply(null, arguments); +}); +var dynCall_viijijiii = Module["dynCall_viijijiii"] = (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_viijijiii"].apply(null, arguments); +}); +var dynCall_viijji = Module["dynCall_viijji"] = (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_viijji"].apply(null, arguments); +}); +var dynCall_viijjii = Module["dynCall_viijjii"] = (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_viijjii"].apply(null, arguments); +}); +var dynCall_viijjiii = Module["dynCall_viijjiii"] = (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_viijjiii"].apply(null, arguments); +}); +var dynCall_viijjji = Module["dynCall_viijjji"] = (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_viijjji"].apply(null, arguments); +}); +var dynCall_vij = Module["dynCall_vij"] = (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_vij"].apply(null, arguments); +}); +var dynCall_viji = Module["dynCall_viji"] = (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_viji"].apply(null, arguments); +}); +var dynCall_vijii = Module["dynCall_vijii"] = (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_vijii"].apply(null, arguments); +}); +var dynCall_vijiii = Module["dynCall_vijiii"] = (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_vijiii"].apply(null, arguments); +}); +var dynCall_vijiji = Module["dynCall_vijiji"] = (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_vijiji"].apply(null, arguments); +}); +var dynCall_vijijji = Module["dynCall_vijijji"] = (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_vijijji"].apply(null, arguments); +}); +var dynCall_vijji = Module["dynCall_vijji"] = (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_vijji"].apply(null, arguments); +}); +var dynCall_vijjii = Module["dynCall_vijjii"] = (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_vijjii"].apply(null, arguments); +}); +var dynCall_vijjji = Module["dynCall_vijjji"] = (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_vijjji"].apply(null, arguments); +}); +var dynCall_vjiiii = Module["dynCall_vjiiii"] = (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_vjiiii"].apply(null, arguments); +}); +var dynCall_vjji = Module["dynCall_vjji"] = (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_vjji"].apply(null, arguments); +}); +Module["asm"] = asm; +if (!Module["intArrayFromString"]) Module["intArrayFromString"] = (function() { + abort("'intArrayFromString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["intArrayToString"]) Module["intArrayToString"] = (function() { + abort("'intArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +Module["ccall"] = ccall; +Module["cwrap"] = cwrap; +if (!Module["setValue"]) Module["setValue"] = (function() { + abort("'setValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["getValue"]) Module["getValue"] = (function() { + abort("'getValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["allocate"]) Module["allocate"] = (function() { + abort("'allocate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!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 (!Module["Pointer_stringify"]) Module["Pointer_stringify"] = (function() { + abort("'Pointer_stringify' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["AsciiToString"]) Module["AsciiToString"] = (function() { + abort("'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stringToAscii"]) Module["stringToAscii"] = (function() { + abort("'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["UTF8ArrayToString"]) Module["UTF8ArrayToString"] = (function() { + abort("'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["UTF8ToString"]) Module["UTF8ToString"] = (function() { + abort("'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stringToUTF8Array"]) Module["stringToUTF8Array"] = (function() { + abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stringToUTF8"]) Module["stringToUTF8"] = (function() { + abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["lengthBytesUTF8"]) Module["lengthBytesUTF8"] = (function() { + abort("'lengthBytesUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["UTF16ToString"]) Module["UTF16ToString"] = (function() { + abort("'UTF16ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stringToUTF16"]) Module["stringToUTF16"] = (function() { + abort("'stringToUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["lengthBytesUTF16"]) Module["lengthBytesUTF16"] = (function() { + abort("'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["UTF32ToString"]) Module["UTF32ToString"] = (function() { + abort("'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stringToUTF32"]) Module["stringToUTF32"] = (function() { + abort("'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["lengthBytesUTF32"]) Module["lengthBytesUTF32"] = (function() { + abort("'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["allocateUTF8"]) Module["allocateUTF8"] = (function() { + abort("'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +Module["stackTrace"] = stackTrace; +if (!Module["addOnPreRun"]) Module["addOnPreRun"] = (function() { + abort("'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["addOnInit"]) Module["addOnInit"] = (function() { + abort("'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["addOnPreMain"]) Module["addOnPreMain"] = (function() { + abort("'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["addOnExit"]) Module["addOnExit"] = (function() { + abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["addOnPostRun"]) Module["addOnPostRun"] = (function() { + abort("'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["writeStringToMemory"]) Module["writeStringToMemory"] = (function() { + abort("'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["writeArrayToMemory"]) Module["writeArrayToMemory"] = (function() { + abort("'writeArrayToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["writeAsciiToMemory"]) Module["writeAsciiToMemory"] = (function() { + abort("'writeAsciiToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +Module["addRunDependency"] = addRunDependency; +Module["removeRunDependency"] = removeRunDependency; +if (!Module["FS"]) Module["FS"] = (function() { + abort("'FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!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"); +}); +Module["FS_createPath"] = FS.createPath; +Module["FS_createDataFile"] = FS.createDataFile; +if (!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 (!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 (!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 (!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 (!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 (!Module["GL"]) Module["GL"] = (function() { + abort("'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["staticAlloc"]) Module["staticAlloc"] = (function() { + abort("'staticAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["dynamicAlloc"]) Module["dynamicAlloc"] = (function() { + abort("'dynamicAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["warnOnce"]) Module["warnOnce"] = (function() { + abort("'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["loadDynamicLibrary"]) Module["loadDynamicLibrary"] = (function() { + abort("'loadDynamicLibrary' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["loadWebAssemblyModule"]) Module["loadWebAssemblyModule"] = (function() { + abort("'loadWebAssemblyModule' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["getLEB"]) Module["getLEB"] = (function() { + abort("'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["getFunctionTables"]) Module["getFunctionTables"] = (function() { + abort("'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["alignFunctionTables"]) Module["alignFunctionTables"] = (function() { + abort("'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["registerFunctions"]) Module["registerFunctions"] = (function() { + abort("'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["addFunction"]) Module["addFunction"] = (function() { + abort("'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["removeFunction"]) Module["removeFunction"] = (function() { + abort("'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["getFuncWrapper"]) Module["getFuncWrapper"] = (function() { + abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["prettyPrint"]) Module["prettyPrint"] = (function() { + abort("'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["makeBigInt"]) Module["makeBigInt"] = (function() { + abort("'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["dynCall"]) Module["dynCall"] = (function() { + abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["getCompilerSetting"]) Module["getCompilerSetting"] = (function() { + abort("'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stackSave"]) Module["stackSave"] = (function() { + abort("'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stackRestore"]) Module["stackRestore"] = (function() { + abort("'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["stackAlloc"]) Module["stackAlloc"] = (function() { + abort("'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}); +if (!Module["ALLOC_NORMAL"]) Object.defineProperty(Module, "ALLOC_NORMAL", { + get: (function() { + abort("'ALLOC_NORMAL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); + }) +}); +if (!Module["ALLOC_STACK"]) Object.defineProperty(Module, "ALLOC_STACK", { + get: (function() { + abort("'ALLOC_STACK' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); + }) +}); +if (!Module["ALLOC_STATIC"]) Object.defineProperty(Module, "ALLOC_STATIC", { + get: (function() { + abort("'ALLOC_STATIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); + }) +}); +if (!Module["ALLOC_DYNAMIC"]) Object.defineProperty(Module, "ALLOC_DYNAMIC", { + get: (function() { + abort("'ALLOC_DYNAMIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); + }) +}); +if (!Module["ALLOC_NONE"]) Object.defineProperty(Module, "ALLOC_NONE", { + get: (function() { + abort("'ALLOC_NONE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); + }) +}); +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} +ExitStatus.prototype = new Error; +ExitStatus.prototype.constructor = ExitStatus; +var initialStackTop; +var calledMain = false; +dependenciesFulfilled = function runCaller() { + if (!Module["calledRun"]) run(); + if (!Module["calledRun"]) dependenciesFulfilled = runCaller; +}; +Module["callMain"] = function callMain(args) { + assert(runDependencies == 0, "cannot call main when async dependencies remain! (listen on __ATMAIN__)"); + assert(__ATPRERUN__.length == 0, "cannot call main when preRun functions remain to be called"); + args = args || []; + ensureInitRuntime(); + var argc = args.length + 1; + var argv = stackAlloc((argc + 1) * 4); + HEAP32[argv >> 2] = allocateUTF8OnStack(Module["thisProgram"]); + for (var i = 1; i < argc; i++) { + HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]); + } + HEAP32[(argv >> 2) + argc] = 0; + try { + var ret = Module["_main"](argc, argv, 0); + exit(ret, true); + } catch (e) { + if (e instanceof ExitStatus) { + return; + } else if (e == "SimulateInfiniteLoop") { + Module["noExitRuntime"] = true; + return; + } else { + var toLog = e; + if (e && typeof e === "object" && e.stack) { + toLog = [ e, e.stack ]; + } + Module.printErr("exception thrown: " + toLog); + Module["quit"](1, e); + } + } finally { + calledMain = true; + } +}; +function run(args) { + args = args || Module["arguments"]; + if (runDependencies > 0) { + return; + } + writeStackCookie(); + preRun(); + if (runDependencies > 0) return; + if (Module["calledRun"]) return; + function doRun() { + if (Module["calledRun"]) return; + Module["calledRun"] = true; + if (ABORT) return; + ensureInitRuntime(); + preMain(); + if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); + if (Module["_main"] && shouldRunNow) Module["callMain"](args); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout((function() { + setTimeout((function() { + Module["setStatus"](""); + }), 1); + doRun(); + }), 1); + } else { + doRun(); + } + checkStackCookie(); +} +Module["run"] = run; +function checkUnflushedContent() { + var print = Module["print"]; + var printErr = Module["printErr"]; + var has = false; + Module["print"] = Module["printErr"] = (function(x) { + has = true; + }); + try { + var flush = Module["_fflush"]; + if (flush) flush(0); + var hasFS = true; + if (hasFS) { + [ "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) {} + Module["print"] = print; + Module["printErr"] = printErr; + if (has) { + warnOnce("stdio streams had content in them that was not flushed. you should set NO_EXIT_RUNTIME to 0 (see the FAQ), or make sure to emit a newline when you printf etc."); + } +} +function exit(status, implicit) { + checkUnflushedContent(); + if (implicit && Module["noExitRuntime"] && status === 0) { + return; + } + if (Module["noExitRuntime"]) { + if (!implicit) { + Module.printErr("exit(" + status + ") called, but NO_EXIT_RUNTIME is set, so halting execution but not exiting the runtime or preventing further async execution (build with NO_EXIT_RUNTIME=0, if you want a true shutdown)"); + } + } else { + ABORT = true; + EXITSTATUS = status; + STACKTOP = initialStackTop; + exitRuntime(); + if (Module["onExit"]) Module["onExit"](status); + } + if (ENVIRONMENT_IS_NODE) { + process["exit"](status); + } + Module["quit"](status, new ExitStatus(status)); +} +Module["exit"] = exit; +var abortDecorators = []; +function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what); + } + if (what !== undefined) { + Module.print(what); + Module.printErr(what); + what = JSON.stringify(what); + } else { + what = ""; + } + ABORT = true; + EXITSTATUS = 1; + var extra = ""; + var output = "abort(" + what + ") at " + stackTrace() + extra; + if (abortDecorators) { + abortDecorators.forEach((function(decorator) { + output = decorator(output, what); + })); + } + throw output; +} +Module["abort"] = abort; +if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()(); + } +} +var shouldRunNow = true; +if (Module["noInitialRun"]) { + shouldRunNow = false; +} +Module["noExitRuntime"] = true; +run(); + + + + +}); \ No newline at end of file diff --git a/RPG/Build/Build/Build/UnityLoader.js b/RPG/Build/Build/Build/UnityLoader.js new file mode 100644 index 0000000..155d701 --- /dev/null +++ b/RPG/Build/Build/Build/UnityLoader.js @@ -0,0 +1,1374 @@ +var UnityLoader = UnityLoader || { + Compression: { + identity: { + require: function () { + return {}; + }, + decompress: function (data) { + return data; + }, + }, + gzip: { + require: function require(e){var t={"inflate.js":function(e,t,i){"use strict";function n(e){if(!(this instanceof n))return new n(e);this.options=o.assign({chunkSize:16384,windowBits:0,to:""},e||{});var t=this.options;t.raw&&t.windowBits>=0&&t.windowBits<16&&(t.windowBits=-t.windowBits,0===t.windowBits&&(t.windowBits=-15)),!(t.windowBits>=0&&t.windowBits<16)||e&&e.windowBits||(t.windowBits+=32),t.windowBits>15&&t.windowBits<48&&0===(15&t.windowBits)&&(t.windowBits|=15),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new h,this.strm.avail_out=0;var i=s.inflateInit2(this.strm,t.windowBits);if(i!==f.Z_OK)throw new Error(d[i]);this.header=new u,s.inflateGetHeader(this.strm,this.header)}function a(e,t){var i=new n(t);if(i.push(e,!0),i.err)throw i.msg||d[i.err];return i.result}function r(e,t){return t=t||{},t.raw=!0,a(e,t)}var s=e("./zlib/inflate"),o=e("./utils/common"),l=e("./utils/strings"),f=e("./zlib/constants"),d=e("./zlib/messages"),h=e("./zlib/zstream"),u=e("./zlib/gzheader"),c=Object.prototype.toString;n.prototype.push=function(e,t){var i,n,a,r,d,h,u=this.strm,b=this.options.chunkSize,w=this.options.dictionary,m=!1;if(this.ended)return!1;n=t===~~t?t:t===!0?f.Z_FINISH:f.Z_NO_FLUSH,"string"==typeof e?u.input=l.binstring2buf(e):"[object ArrayBuffer]"===c.call(e)?u.input=new Uint8Array(e):u.input=e,u.next_in=0,u.avail_in=u.input.length;do{if(0===u.avail_out&&(u.output=new o.Buf8(b),u.next_out=0,u.avail_out=b),i=s.inflate(u,f.Z_NO_FLUSH),i===f.Z_NEED_DICT&&w&&(h="string"==typeof w?l.string2buf(w):"[object ArrayBuffer]"===c.call(w)?new Uint8Array(w):w,i=s.inflateSetDictionary(this.strm,h)),i===f.Z_BUF_ERROR&&m===!0&&(i=f.Z_OK,m=!1),i!==f.Z_STREAM_END&&i!==f.Z_OK)return this.onEnd(i),this.ended=!0,!1;u.next_out&&(0!==u.avail_out&&i!==f.Z_STREAM_END&&(0!==u.avail_in||n!==f.Z_FINISH&&n!==f.Z_SYNC_FLUSH)||("string"===this.options.to?(a=l.utf8border(u.output,u.next_out),r=u.next_out-a,d=l.buf2string(u.output,a),u.next_out=r,u.avail_out=b-r,r&&o.arraySet(u.output,u.output,a,r,0),this.onData(d)):this.onData(o.shrinkBuf(u.output,u.next_out)))),0===u.avail_in&&0===u.avail_out&&(m=!0)}while((u.avail_in>0||0===u.avail_out)&&i!==f.Z_STREAM_END);return i===f.Z_STREAM_END&&(n=f.Z_FINISH),n===f.Z_FINISH?(i=s.inflateEnd(this.strm),this.onEnd(i),this.ended=!0,i===f.Z_OK):n!==f.Z_SYNC_FLUSH||(this.onEnd(f.Z_OK),u.avail_out=0,!0)},n.prototype.onData=function(e){this.chunks.push(e)},n.prototype.onEnd=function(e){e===f.Z_OK&&("string"===this.options.to?this.result=this.chunks.join(""):this.result=o.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg},i.Inflate=n,i.inflate=a,i.inflateRaw=r,i.ungzip=a},"utils/common.js":function(e,t,i){"use strict";var n="undefined"!=typeof Uint8Array&&"undefined"!=typeof Uint16Array&&"undefined"!=typeof Int32Array;i.assign=function(e){for(var t=Array.prototype.slice.call(arguments,1);t.length;){var i=t.shift();if(i){if("object"!=typeof i)throw new TypeError(i+"must be non-object");for(var n in i)i.hasOwnProperty(n)&&(e[n]=i[n])}}return e},i.shrinkBuf=function(e,t){return e.length===t?e:e.subarray?e.subarray(0,t):(e.length=t,e)};var a={arraySet:function(e,t,i,n,a){if(t.subarray&&e.subarray)return void e.set(t.subarray(i,i+n),a);for(var r=0;r=252?6:l>=248?5:l>=240?4:l>=224?3:l>=192?2:1;o[254]=o[254]=1,i.string2buf=function(e){var t,i,n,r,s,o=e.length,l=0;for(r=0;r>>6,t[s++]=128|63&i):i<65536?(t[s++]=224|i>>>12,t[s++]=128|i>>>6&63,t[s++]=128|63&i):(t[s++]=240|i>>>18,t[s++]=128|i>>>12&63,t[s++]=128|i>>>6&63,t[s++]=128|63&i);return t},i.buf2binstring=function(e){return n(e,e.length)},i.binstring2buf=function(e){for(var t=new a.Buf8(e.length),i=0,n=t.length;i4)f[a++]=65533,i+=s-1;else{for(r&=2===s?31:3===s?15:7;s>1&&i1?f[a++]=65533:r<65536?f[a++]=r:(r-=65536,f[a++]=55296|r>>10&1023,f[a++]=56320|1023&r)}return n(f,a)},i.utf8border=function(e,t){var i;for(t=t||e.length,t>e.length&&(t=e.length),i=t-1;i>=0&&128===(192&e[i]);)i--;return i<0?t:0===i?t:i+o[e[i]]>t?i:t}},"zlib/inflate.js":function(e,t,i){"use strict";function n(e){return(e>>>24&255)+(e>>>8&65280)+((65280&e)<<8)+((255&e)<<24)}function a(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new _.Buf16(320),this.work=new _.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}function r(e){var t;return e&&e.state?(t=e.state,e.total_in=e.total_out=t.total=0,e.msg="",t.wrap&&(e.adler=1&t.wrap),t.mode=U,t.last=0,t.havedict=0,t.dmax=32768,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new _.Buf32(we),t.distcode=t.distdyn=new _.Buf32(me),t.sane=1,t.back=-1,z):C}function s(e){var t;return e&&e.state?(t=e.state,t.wsize=0,t.whave=0,t.wnext=0,r(e)):C}function o(e,t){var i,n;return e&&e.state?(n=e.state,t<0?(i=0,t=-t):(i=(t>>4)+1,t<48&&(t&=15)),t&&(t<8||t>15)?C:(null!==n.window&&n.wbits!==t&&(n.window=null),n.wrap=i,n.wbits=t,s(e))):C}function l(e,t){var i,n;return e?(n=new a,e.state=n,n.window=null,i=o(e,t),i!==z&&(e.state=null),i):C}function f(e){return l(e,_e)}function d(e){if(ge){var t;for(m=new _.Buf32(512),k=new _.Buf32(32),t=0;t<144;)e.lens[t++]=8;for(;t<256;)e.lens[t++]=9;for(;t<280;)e.lens[t++]=7;for(;t<288;)e.lens[t++]=8;for(x(S,e.lens,0,288,m,0,e.work,{bits:9}),t=0;t<32;)e.lens[t++]=5;x(B,e.lens,0,32,k,0,e.work,{bits:5}),ge=!1}e.lencode=m,e.lenbits=9,e.distcode=k,e.distbits=5}function h(e,t,i,n){var a,r=e.state;return null===r.window&&(r.wsize=1<=r.wsize?(_.arraySet(r.window,t,i-r.wsize,r.wsize,0),r.wnext=0,r.whave=r.wsize):(a=r.wsize-r.wnext,a>n&&(a=n),_.arraySet(r.window,t,i-n,a,r.wnext),n-=a,n?(_.arraySet(r.window,t,i-n,n,0),r.wnext=n,r.whave=r.wsize):(r.wnext+=a,r.wnext===r.wsize&&(r.wnext=0),r.whave>>8&255,i.check=v(i.check,Ze,2,0),u=0,c=0,i.mode=j;break}if(i.flags=0,i.head&&(i.head.done=!1),!(1&i.wrap)||(((255&u)<<8)+(u>>8))%31){e.msg="incorrect header check",i.mode=ue;break}if((15&u)!==F){e.msg="unknown compression method",i.mode=ue;break}if(u>>>=4,c-=4,xe=(15&u)+8,0===i.wbits)i.wbits=xe;else if(xe>i.wbits){e.msg="invalid window size",i.mode=ue;break}i.dmax=1<>8&1),512&i.flags&&(Ze[0]=255&u,Ze[1]=u>>>8&255,i.check=v(i.check,Ze,2,0)),u=0,c=0,i.mode=D;case D:for(;c<32;){if(0===l)break e;l--,u+=a[s++]<>>8&255,Ze[2]=u>>>16&255,Ze[3]=u>>>24&255,i.check=v(i.check,Ze,4,0)),u=0,c=0,i.mode=L;case L:for(;c<16;){if(0===l)break e;l--,u+=a[s++]<>8),512&i.flags&&(Ze[0]=255&u,Ze[1]=u>>>8&255,i.check=v(i.check,Ze,2,0)),u=0,c=0,i.mode=H;case H:if(1024&i.flags){for(;c<16;){if(0===l)break e;l--,u+=a[s++]<>>8&255,i.check=v(i.check,Ze,2,0)),u=0,c=0}else i.head&&(i.head.extra=null);i.mode=K;case K:if(1024&i.flags&&(m=i.length,m>l&&(m=l),m&&(i.head&&(xe=i.head.extra_len-i.length,i.head.extra||(i.head.extra=new Array(i.head.extra_len)),_.arraySet(i.head.extra,a,s,m,xe)),512&i.flags&&(i.check=v(i.check,a,m,s)),l-=m,s+=m,i.length-=m),i.length))break e;i.length=0,i.mode=M;case M:if(2048&i.flags){if(0===l)break e;m=0;do xe=a[s+m++],i.head&&xe&&i.length<65536&&(i.head.name+=String.fromCharCode(xe));while(xe&&m>9&1,i.head.done=!0),e.adler=i.check=0,i.mode=q;break;case G:for(;c<32;){if(0===l)break e;l--,u+=a[s++]<>>=7&c,c-=7&c,i.mode=fe;break}for(;c<3;){if(0===l)break e;l--,u+=a[s++]<>>=1,c-=1,3&u){case 0:i.mode=J;break;case 1:if(d(i),i.mode=ie,t===A){u>>>=2,c-=2;break e}break;case 2:i.mode=$;break;case 3:e.msg="invalid block type",i.mode=ue}u>>>=2,c-=2;break;case J:for(u>>>=7&c,c-=7&c;c<32;){if(0===l)break e;l--,u+=a[s++]<>>16^65535)){e.msg="invalid stored block lengths",i.mode=ue;break}if(i.length=65535&u,u=0,c=0,i.mode=Q,t===A)break e;case Q:i.mode=V;case V:if(m=i.length){if(m>l&&(m=l),m>f&&(m=f),0===m)break e;_.arraySet(r,a,s,m,o),l-=m,s+=m,f-=m,o+=m,i.length-=m;break}i.mode=q;break;case $:for(;c<14;){if(0===l)break e;l--,u+=a[s++]<>>=5,c-=5,i.ndist=(31&u)+1,u>>>=5,c-=5,i.ncode=(15&u)+4,u>>>=4,c-=4,i.nlen>286||i.ndist>30){e.msg="too many length or distance symbols",i.mode=ue;break}i.have=0,i.mode=ee;case ee:for(;i.have>>=3,c-=3}for(;i.have<19;)i.lens[Ae[i.have++]]=0;if(i.lencode=i.lendyn,i.lenbits=7,Se={bits:i.lenbits},ye=x(y,i.lens,0,19,i.lencode,0,i.work,Se),i.lenbits=Se.bits,ye){e.msg="invalid code lengths set",i.mode=ue;break}i.have=0,i.mode=te;case te:for(;i.have>>24,ke=Ee>>>16&255,_e=65535&Ee,!(me<=c);){if(0===l)break e;l--,u+=a[s++]<>>=me,c-=me,i.lens[i.have++]=_e;else{if(16===_e){for(Be=me+2;c>>=me,c-=me,0===i.have){e.msg="invalid bit length repeat",i.mode=ue;break}xe=i.lens[i.have-1],m=3+(3&u),u>>>=2,c-=2}else if(17===_e){for(Be=me+3;c>>=me,c-=me,xe=0,m=3+(7&u),u>>>=3,c-=3}else{for(Be=me+7;c>>=me,c-=me,xe=0,m=11+(127&u),u>>>=7,c-=7}if(i.have+m>i.nlen+i.ndist){e.msg="invalid bit length repeat",i.mode=ue;break}for(;m--;)i.lens[i.have++]=xe}}if(i.mode===ue)break;if(0===i.lens[256]){e.msg="invalid code -- missing end-of-block",i.mode=ue;break}if(i.lenbits=9,Se={bits:i.lenbits},ye=x(S,i.lens,0,i.nlen,i.lencode,0,i.work,Se),i.lenbits=Se.bits,ye){e.msg="invalid literal/lengths set",i.mode=ue;break}if(i.distbits=6,i.distcode=i.distdyn,Se={bits:i.distbits},ye=x(B,i.lens,i.nlen,i.ndist,i.distcode,0,i.work,Se),i.distbits=Se.bits,ye){e.msg="invalid distances set",i.mode=ue;break}if(i.mode=ie,t===A)break e;case ie:i.mode=ne;case ne:if(l>=6&&f>=258){e.next_out=o,e.avail_out=f,e.next_in=s,e.avail_in=l,i.hold=u,i.bits=c,p(e,w),o=e.next_out,r=e.output,f=e.avail_out,s=e.next_in,a=e.input,l=e.avail_in,u=i.hold,c=i.bits,i.mode===q&&(i.back=-1);break}for(i.back=0;Ee=i.lencode[u&(1<>>24,ke=Ee>>>16&255,_e=65535&Ee,!(me<=c);){if(0===l)break e;l--,u+=a[s++]<>ge)],me=Ee>>>24,ke=Ee>>>16&255,_e=65535&Ee,!(ge+me<=c);){if(0===l)break e;l--,u+=a[s++]<>>=ge,c-=ge,i.back+=ge}if(u>>>=me,c-=me,i.back+=me,i.length=_e,0===ke){i.mode=le;break}if(32&ke){i.back=-1,i.mode=q;break}if(64&ke){e.msg="invalid literal/length code",i.mode=ue;break}i.extra=15&ke,i.mode=ae;case ae:if(i.extra){for(Be=i.extra;c>>=i.extra,c-=i.extra,i.back+=i.extra}i.was=i.length,i.mode=re;case re:for(;Ee=i.distcode[u&(1<>>24,ke=Ee>>>16&255,_e=65535&Ee,!(me<=c);){if(0===l)break e;l--,u+=a[s++]<>ge)],me=Ee>>>24,ke=Ee>>>16&255,_e=65535&Ee,!(ge+me<=c);){if(0===l)break e;l--,u+=a[s++]<>>=ge,c-=ge,i.back+=ge}if(u>>>=me,c-=me,i.back+=me,64&ke){e.msg="invalid distance code",i.mode=ue;break}i.offset=_e,i.extra=15&ke,i.mode=se;case se:if(i.extra){for(Be=i.extra;c>>=i.extra,c-=i.extra,i.back+=i.extra}if(i.offset>i.dmax){e.msg="invalid distance too far back",i.mode=ue;break}i.mode=oe;case oe:if(0===f)break e;if(m=w-f,i.offset>m){if(m=i.offset-m,m>i.whave&&i.sane){e.msg="invalid distance too far back",i.mode=ue;break}m>i.wnext?(m-=i.wnext,k=i.wsize-m):k=i.wnext-m,m>i.length&&(m=i.length),we=i.window}else we=r,k=o-i.offset,m=i.length;m>f&&(m=f),f-=m,i.length-=m;do r[o++]=we[k++];while(--m);0===i.length&&(i.mode=ne);break;case le:if(0===f)break e;r[o++]=i.length,f--,i.mode=ne;break;case fe:if(i.wrap){for(;c<32;){if(0===l)break e;l--,u|=a[s++]<>>16&65535|0,s=0;0!==i;){s=i>2e3?2e3:i,i-=s;do a=a+t[n++]|0,r=r+a|0;while(--s);a%=65521,r%=65521}return a|r<<16|0}t.exports=n},"zlib/crc32.js":function(e,t,i){"use strict";function n(){for(var e,t=[],i=0;i<256;i++){e=i;for(var n=0;n<8;n++)e=1&e?3988292384^e>>>1:e>>>1;t[i]=e}return t}function a(e,t,i,n){var a=r,s=n+i;e^=-1;for(var o=n;o>>8^a[255&(e^t[o])];return e^-1}var r=n();t.exports=a},"zlib/inffast.js":function(e,t,i){"use strict";var n=30,a=12;t.exports=function(e,t){var i,r,s,o,l,f,d,h,u,c,b,w,m,k,_,g,v,p,x,y,S,B,E,Z,A;i=e.state,r=e.next_in,Z=e.input,s=r+(e.avail_in-5),o=e.next_out,A=e.output,l=o-(t-e.avail_out),f=o+(e.avail_out-257),d=i.dmax,h=i.wsize,u=i.whave,c=i.wnext,b=i.window,w=i.hold,m=i.bits,k=i.lencode,_=i.distcode,g=(1<>>24,w>>>=x,m-=x,x=p>>>16&255,0===x)A[o++]=65535&p;else{if(!(16&x)){if(0===(64&x)){p=k[(65535&p)+(w&(1<>>=x,m-=x),m<15&&(w+=Z[r++]<>>24,w>>>=x,m-=x,x=p>>>16&255,!(16&x)){if(0===(64&x)){p=_[(65535&p)+(w&(1<d){e.msg="invalid distance too far back",i.mode=n;break e}if(w>>>=x,m-=x,x=o-l,S>x){if(x=S-x,x>u&&i.sane){e.msg="invalid distance too far back",i.mode=n;break e}if(B=0,E=b,0===c){if(B+=h-x,x2;)A[o++]=E[B++],A[o++]=E[B++],A[o++]=E[B++],y-=3;y&&(A[o++]=E[B++],y>1&&(A[o++]=E[B++]))}else{B=o-S;do A[o++]=A[B++],A[o++]=A[B++],A[o++]=A[B++],y-=3;while(y>2);y&&(A[o++]=A[B++],y>1&&(A[o++]=A[B++]))}break}}break}}while(r>3,r-=y,m-=y<<3,w&=(1<=1&&0===H[C];C--);if(O>C&&(O=C),0===C)return w[m++]=20971520,w[m++]=20971520,_.bits=1,0;for(N=1;N0&&(e===o||1!==C))return-1;for(K[1]=0,z=1;zr||e===f&&U>s)return 1;for(;;){B=z-T,k[R]S?(E=M[P+k[R]],Z=D[L+k[R]]):(E=96,Z=0),g=1<>T)+v]=B<<24|E<<16|Z|0;while(0!==v);for(g=1<>=1;if(0!==g?(j&=g-1,j+=g):j=0,R++,0===--H[z]){if(z===C)break;z=t[i+k[R]]}if(z>O&&(j&x)!==p){for(0===T&&(T=O),y+=N,I=z-T,F=1<r||e===f&&U>s)return 1;p=j&x,w[p]=O<<24|I<<16|y-m|0}}return 0!==j&&(w[y+j]=z-T<<24|64<<16|0),_.bits=O,0}}};for(var i in t)t[i].folder=i.substring(0,i.lastIndexOf("/")+1);var n=function(e){var i=[];return e=e.split("/").every(function(e){return".."==e?i.pop():"."==e||""==e||i.push(e)})?i.join("/"):null,e?t[e]||t[e+".js"]||t[e+"/index.js"]:null},a=function(e,t){return e?n(e.folder+"node_modules/"+t)||a(e.parent,t):null},r=function(e,t){var i=t.match(/^\//)?null:e?t.match(/^\.\.?\//)?n(e.folder+t):a(e,t):n(t);if(!i)throw"module not found: "+t;return i.exports||(i.parent=e,i(r.bind(null,i),i,i.exports={})),i.exports};return r(null,e)}, + decompress: function (data) { + if (!this.exports) + this.exports = this.require("inflate.js"); + try { return this.exports.inflate(data) } catch (e) {}; + + }, + hasUnityMarker: function (data) { + var commentOffset = 10, expectedComment = "UnityWeb Compressed Content (gzip)"; + if (commentOffset > data.length || data[0] != 0x1F || data[1] != 0x8B) + return false; + var flags = data[3]; + if (flags & 0x04) { + if (commentOffset + 2 > data.length) + return false; + commentOffset += 2 + data[commentOffset] + (data[commentOffset + 1] << 8); + if (commentOffset > data.length) + return false; + } + if (flags & 0x08) { + while (commentOffset < data.length && data[commentOffset]) + commentOffset++; + if (commentOffset + 1 > data.length) + return false; + commentOffset++; + } + return (flags & 0x10) && String.fromCharCode.apply(null, data.subarray(commentOffset, commentOffset + expectedComment.length + 1)) == expectedComment + "\0"; + + }, + }, + brotli: { + require: function require(e){var n={"decompress.js":function(e,n,t){n.exports=e("./dec/decode").BrotliDecompressBuffer},"dec/bit_reader.js":function(e,n,t){function r(e){this.buf_=new Uint8Array(o),this.input_=e,this.reset()}const i=4096,o=8224,s=8191,a=new Uint32Array([0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535,131071,262143,524287,1048575,2097151,4194303,8388607,16777215]);r.READ_SIZE=i,r.IBUF_MASK=s,r.prototype.reset=function(){this.buf_ptr_=0,this.val_=0,this.pos_=0,this.bit_pos_=0,this.bit_end_pos_=0,this.eos_=0,this.readMoreInput();for(var e=0;e<4;e++)this.val_|=this.buf_[this.pos_]<<8*e,++this.pos_;return this.bit_end_pos_>0},r.prototype.readMoreInput=function(){if(!(this.bit_end_pos_>256))if(this.eos_){if(this.bit_pos_>this.bit_end_pos_)throw new Error("Unexpected end of input "+this.bit_pos_+" "+this.bit_end_pos_)}else{var e=this.buf_ptr_,n=this.input_.read(this.buf_,e,i);if(n<0)throw new Error("Unexpected end of input");if(n=8;)this.val_>>>=8,this.val_|=this.buf_[this.pos_&s]<<24,++this.pos_,this.bit_pos_=this.bit_pos_-8>>>0,this.bit_end_pos_=this.bit_end_pos_-8>>>0},r.prototype.readBits=function(e){32-this.bit_pos_>>this.bit_pos_&a[e];return this.bit_pos_+=e,n},n.exports=r},"dec/context.js":function(e,n,t){t.lookup=new Uint8Array([0,0,0,0,0,0,0,0,0,4,4,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,12,16,12,12,20,12,16,24,28,12,12,32,12,36,12,44,44,44,44,44,44,44,44,44,44,32,32,24,40,28,12,12,48,52,52,52,48,52,52,52,48,52,52,52,52,52,48,52,52,52,52,52,48,52,52,52,52,52,24,12,28,12,12,12,56,60,60,60,56,60,60,60,56,60,60,60,60,60,56,60,60,60,60,60,56,60,60,60,60,60,24,12,28,12,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,0,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,56,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13,14,14,14,14,15,15,15,15,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,22,22,22,22,23,23,23,23,24,24,24,24,25,25,25,25,26,26,26,26,27,27,27,27,28,28,28,28,29,29,29,29,30,30,30,30,31,31,31,31,32,32,32,32,33,33,33,33,34,34,34,34,35,35,35,35,36,36,36,36,37,37,37,37,38,38,38,38,39,39,39,39,40,40,40,40,41,41,41,41,42,42,42,42,43,43,43,43,44,44,44,44,45,45,45,45,46,46,46,46,47,47,47,47,48,48,48,48,49,49,49,49,50,50,50,50,51,51,51,51,52,52,52,52,53,53,53,53,54,54,54,54,55,55,55,55,56,56,56,56,57,57,57,57,58,58,58,58,59,59,59,59,60,60,60,60,61,61,61,61,62,62,62,62,63,63,63,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),t.lookupOffsets=new Uint16Array([1024,1536,1280,1536,0,256,768,512])},"dec/decode.js":function(e,n,t){function r(e){var n;return 0===e.readBits(1)?16:(n=e.readBits(3),n>0?17+n:(n=e.readBits(3),n>0?8+n:17))}function i(e){if(e.readBits(1)){var n=e.readBits(3);return 0===n?1:e.readBits(n)+(1<1&&0===s)throw new Error("Invalid size byte");i.meta_block_length|=s<<8*r}}else for(r=0;r4&&0===a)throw new Error("Invalid size nibble");i.meta_block_length|=a<<4*r}return++i.meta_block_length,i.input_end||i.is_metadata||(i.is_uncompressed=e.readBits(1)),i}function a(e,n,t){var r;return t.fillBitWindow(),n+=t.val_>>>t.bit_pos_&K,r=e[n].bits-k,r>0&&(t.bit_pos_+=k,n+=e[n].value,n+=t.val_>>>t.bit_pos_&(1<0;){var u,p=0;if(r.readMoreInput(),r.fillBitWindow(),p+=r.val_>>>r.bit_pos_&31,r.bit_pos_+=w[p].bits,u=255&w[p].value,u>u);else{var c,h,l=u-14,b=0;if(u===M&&(b=o),a!==b&&(s=0,a=b),c=s,s>0&&(s-=2,s<<=l),s+=r.readBits(l)+3,h=s-c,i+h>n)throw new Error("[ReadHuffmanCodeLengths] symbol + repeat_delta > num_symbols");for(var v=0;v0;++a){var v,m=L[a],y=0;r.fillBitWindow(),y+=r.val_>>>r.bit_pos_&15,r.bit_pos_+=b[y].bits,v=b[y].value,c[m]=v,0!==v&&(h-=32>>v,++l)}if(1!==l&&0!==h)throw new Error("[ReadHuffmanCode] invalid num_codes or space");f(c,e,s,r)}if(o=q(n,t,k,s,e),0===o)throw new Error("[ReadHuffmanCode] BuildHuffmanTable failed: ");return o}function d(e,n,t){var r,i;return r=a(e,n,t),i=B.kBlockLengthPrefixCode[r].nbits,B.kBlockLengthPrefixCode[r].offset+t.readBits(i)}function u(e,n,t){var r;return e>>5]),this.htrees=new Uint32Array(n)}function l(e,n){var t,r,o,s={num_htrees:null,context_map:null},f=0;n.readMoreInput();var d=s.num_htrees=i(n)+1,u=s.context_map=new Uint8Array(e);if(d<=1)return s;for(t=n.readBits(1),t&&(f=n.readBits(4)+1),r=[],o=0;o=e)throw new Error("[DecodeContextMap] i >= context_map_size");u[o]=0,++o}else u[o]=p-f,++o}return n.readBits(1)&&c(u,e),s}function b(e,n,t,r,i,o,s){var f,w=2*t,d=t,u=a(n,t*X,s);f=0===u?i[w+(1&o[d])]:1===u?i[w+(o[d]-1&1)]+1:u-2,f>=e&&(f-=e),r[t]=f,i[w+(1&o[d])]=f,++o[d]}function v(e,n,t,r,i,o){var s,a=i+1,f=t&i,w=o.pos_&V.IBUF_MASK;if(n<8||o.bit_pos_+(n<<3)0;)o.readMoreInput(),r[f++]=o.readBits(8),f===a&&(e.write(r,a),f=0);else{if(o.bit_end_pos_<32)throw new Error("[CopyUncompressedBlockToOutput] br.bit_end_pos_ < 32");for(;o.bit_pos_<32;)r[f]=o.val_>>>o.bit_pos_,o.bit_pos_+=8,++f,--n;if(s=o.bit_end_pos_-o.bit_pos_>>3,w+s>V.IBUF_MASK){for(var d=V.IBUF_MASK+1-w,u=0;u=a){e.write(r,a),f-=a;for(var u=0;u=a;){if(s=a-f,o.input_.read(r,f,s)n.buffer.length){var We=new Uint8Array(E+te);We.set(n.buffer),n.buffer=We}if(q=ye.input_end,D=ye.is_uncompressed,ye.is_metadata)for(m(U);te>0;--te)U.readMoreInput(),U.readBits(8);else if(0!==te)if(D)U.bit_pos_=U.bit_pos_+7&-8,v(n,te,E,c,p,U),E+=te;else{for(t=0;t<3;++t)oe[t]=i(U)+1,oe[t]>=2&&(w(oe[t]+2,W,t*X,U),w(F,x,t*X,U),re[t]=d(x,t*X,U),ae[t]=1);for(U.readMoreInput(),j=U.readBits(2),Q=J+(U.readBits(4)<0;){var Ee,Ve,Oe,Ne,qe,Ye,Be,Re,He,Me,Ae;for(U.readMoreInput(),0===re[1]&&(b(oe[1],W,1,ie,se,ae,U),re[1]=d(x,X,U),ne=T[1].htrees[ie[1]]),--re[1],Ee=a(T[1].codes,ne,U),Ve=Ee>>6,Ve>=2?(Ve-=2,Be=-1):Be=0,Oe=B.kInsertRangeLut[Ve]+(Ee>>3&7),Ne=B.kCopyRangeLut[Ve]+(7&Ee),qe=B.kInsertLengthPrefixCode[Oe].offset+U.readBits(B.kInsertLengthPrefixCode[Oe].nbits),Ye=B.kCopyLengthPrefixCode[Ne].offset+U.readBits(B.kCopyLengthPrefixCode[Ne].nbits),G=c[E-1&p],L=c[E-2&p],Me=0;Me4?3:Ye-2),be=de[le+He],Be=a(T[2].codes,T[2].htrees[be],U),Be>=Q){var ge,Fe,Ze;Be-=Q,Fe=Be&C,Be>>=j,ge=(Be>>1)+1,Ze=(2+(1&Be)<M){if(!(Ye>=O.minDictionaryWordLength&&Ye<=O.maxDictionaryWordLength))throw new Error("Invalid backward reference. pos: "+E+" distance: "+Re+" len: "+Ye+" bytes left: "+te);var Ze=O.offsetsByLength[Ye],Pe=Re-M-1,ke=O.sizeBitsByLength[Ye],Ke=(1<>ke;if(Ze+=Xe*Ye,!(Ge=y){n.write(c,f);for(var Je=0;Je0&&(k[3&K]=Re,++K),Ye>te)throw new Error("Invalid backward reference. pos: "+E+" distance: "+Re+" len: "+Ye+" bytes left: "+te);for(Me=0;Me>=1;return(e&t-1)+t}function o(e,n,t,i,o){do i-=t,e[n+i]=new r(o.bits,o.value);while(i>0)}function s(e,n,t){for(var r=1<0;--U[u])d=new r(255&u,65535&W[p++]),o(e,n+c,h,m,d),c=i(c,u);for(b=y-1,l=-1,u=t+1,h=2;u<=a;++u,h<<=1)for(;U[u]>0;--U[u])(c&b)!==l&&(n+=m,v=s(U,u,t),m=1<>t),h,m,d),c=i(c,u);return y}},"dec/prefix.js":function(e,n,t){function r(e,n){this.offset=e,this.nbits=n}t.kBlockLengthPrefixCode=[new r(1,2),new r(5,2),new r(9,2),new r(13,2),new r(17,3),new r(25,3),new r(33,3),new r(41,3),new r(49,4),new r(65,4),new r(81,4),new r(97,4),new r(113,5),new r(145,5),new r(177,5),new r(209,5),new r(241,6),new r(305,6),new r(369,7),new r(497,8),new r(753,9),new r(1265,10),new r(2289,11),new r(4337,12),new r(8433,13),new r(16625,24)],t.kInsertLengthPrefixCode=[new r(0,0),new r(1,0),new r(2,0),new r(3,0),new r(4,0),new r(5,0),new r(6,1),new r(8,1),new r(10,2),new r(14,2),new r(18,3),new r(26,3),new r(34,4),new r(50,4),new r(66,5),new r(98,5),new r(130,6),new r(194,7),new r(322,8),new r(578,9),new r(1090,10),new r(2114,12),new r(6210,14),new r(22594,24)],t.kCopyLengthPrefixCode=[new r(2,0),new r(3,0),new r(4,0),new r(5,0),new r(6,0),new r(7,0),new r(8,0),new r(9,0),new r(10,1),new r(12,1),new r(14,2),new r(18,2),new r(22,3),new r(30,3),new r(38,4),new r(54,4),new r(70,5),new r(102,5),new r(134,6),new r(198,7),new r(326,8),new r(582,9),new r(1094,10),new r(2118,24)],t.kInsertRangeLut=[0,0,8,8,0,16,8,16,16],t.kCopyRangeLut=[0,8,0,8,16,0,16,8,16]},"dec/streams.js":function(e,n,t){function r(e){this.buffer=e,this.pos=0}function i(e){this.buffer=e,this.pos=0}r.prototype.read=function(e,n,t){this.pos+t>this.buffer.length&&(t=this.buffer.length-this.pos);for(var r=0;rthis.buffer.length)throw new Error("Output buffer is not large enough");return this.buffer.set(e.subarray(0,n),this.pos),this.pos+=n,n},t.BrotliOutput=i},"dec/transform.js":function(e,n,t){function r(e,n,t){this.prefix=new Uint8Array(e.length),this.transform=n,this.suffix=new Uint8Array(t.length);for(var r=0;r=97&&e[n]<=122&&(e[n]^=32),1):e[n]<224?(e[n+1]^=32,2):(e[n+2]^=5,3)}var o=e("./dictionary");const s=0,a=1,f=2,w=3,d=4,u=5,p=6,c=7,h=8,l=9,b=10,v=11,m=12,y=13,W=14,x=15,U=16,E=17,V=18,O=20;var N=[new r("",s,""),new r("",s," "),new r(" ",s," "),new r("",m,""),new r("",b," "),new r("",s," the "),new r(" ",s,""),new r("s ",s," "),new r("",s," of "),new r("",b,""),new r("",s," and "),new r("",y,""),new r("",a,""),new r(", ",s," "),new r("",s,", "),new r(" ",b," "),new r("",s," in "),new r("",s," to "),new r("e ",s," "),new r("",s,'"'),new r("",s,"."),new r("",s,'">'),new r("",s,"\n"),new r("",w,""),new r("",s,"]"),new r("",s," for "),new r("",W,""),new r("",f,""),new r("",s," a "),new r("",s," that "),new r(" ",b,""),new r("",s,". "),new r(".",s,""),new r(" ",s,", "),new r("",x,""),new r("",s," with "),new r("",s,"'"),new r("",s," from "),new r("",s," by "),new r("",U,""),new r("",E,""),new r(" the ",s,""),new r("",d,""),new r("",s,". The "),new r("",v,""),new r("",s," on "),new r("",s," as "),new r("",s," is "),new r("",c,""),new r("",a,"ing "),new r("",s,"\n\t"),new r("",s,":"),new r(" ",s,". "),new r("",s,"ed "),new r("",O,""),new r("",V,""),new r("",p,""),new r("",s,"("),new r("",b,", "),new r("",h,""),new r("",s," at "),new r("",s,"ly "),new r(" the ",s," of "),new r("",u,""),new r("",l,""),new r(" ",b,", "),new r("",b,'"'),new r(".",s,"("),new r("",v," "),new r("",b,'">'),new r("",s,'="'),new r(" ",s,"."),new r(".com/",s,""),new r(" the ",s," of the "),new r("",b,"'"),new r("",s,". This "),new r("",s,","),new r(".",s," "),new r("",b,"("),new r("",b,"."),new r("",s," not "),new r(" ",s,'="'),new r("",s,"er "),new r(" ",v," "),new r("",s,"al "),new r(" ",v,""),new r("",s,"='"),new r("",v,'"'),new r("",b,". "),new r(" ",s,"("),new r("",s,"ful "),new r(" ",b,". "),new r("",s,"ive "),new r("",s,"less "),new r("",v,"'"),new r("",s,"est "),new r(" ",b,"."),new r("",v,'">'),new r(" ",s,"='"),new r("",b,","),new r("",s,"ize "),new r("",v,"."),new r("\xc2\xa0",s,""),new r(" ",s,","),new r("",b,'="'),new r("",v,'="'),new r("",s,"ous "),new r("",v,", "),new r("",b,"='"),new r(" ",b,","),new r(" ",v,'="'),new r(" ",v,", "),new r("",v,","),new r("",v,"("),new r("",v,". "),new r(" ",v,"."),new r("",v,"='"),new r(" ",v,". "),new r(" ",b,'="'),new r(" ",v,"='"),new r(" ",b,"='")];t.kTransforms=N,t.kNumTransforms=N.length,t.transformDictionaryWord=function(e,n,t,r,s){var a,f=N[s].prefix,w=N[s].suffix,d=N[s].transform,u=dr&&(u=r);for(var h=0;h0;){var y=i(e,a);a+=y,r-=y}for(var W=0;W0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===e[n-2]?2:"="===e[n-1]?1:0}function i(e){return 3*e.length/4-r(e)}function o(e){var n,t,i,o,s,a,f=e.length;s=r(e),a=new u(3*f/4-s),i=s>0?f-4:f;var w=0;for(n=0,t=0;n>16&255,a[w++]=o>>8&255,a[w++]=255&o;return 2===s?(o=d[e.charCodeAt(n)]<<2|d[e.charCodeAt(n+1)]>>4,a[w++]=255&o):1===s&&(o=d[e.charCodeAt(n)]<<10|d[e.charCodeAt(n+1)]<<4|d[e.charCodeAt(n+2)]>>2,a[w++]=o>>8&255,a[w++]=255&o),a}function s(e){return w[e>>18&63]+w[e>>12&63]+w[e>>6&63]+w[63&e]}function a(e,n,t){for(var r,i=[],o=n;od?d:f+s));return 1===r?(n=e[t-1],i+=w[n>>2],i+=w[n<<4&63],i+="=="):2===r&&(n=(e[t-2]<<8)+e[t-1],i+=w[n>>10],i+=w[n>>4&63],i+=w[n<<2&63],i+="="),o.push(i),o.join("")}t.byteLength=i,t.toByteArray=o,t.fromByteArray=f;for(var w=[],d=[],u="undefined"!=typeof Uint8Array?Uint8Array:Array,p="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",c=0,h=p.length;c> 3); + commentOffset = (WBITS_length + 1 + 2 + 1 + 2 + (MSKIPBYTES << 3) + 7) >> 3; + if (WBITS == 0x11 || commentOffset > data.length) + return false; + var expectedCommentPrefix = WBITS + (((3 << 1) + (MSKIPBYTES << 4) + ((expectedComment.length - 1) << 6)) << WBITS_length); + for (var i = 0; i < commentOffset; i++, expectedCommentPrefix >>>= 8) { + if (data[i] != (expectedCommentPrefix & 0xFF)) + return false; + } + return String.fromCharCode.apply(null, data.subarray(commentOffset, commentOffset + expectedComment.length)) == expectedComment; + + }, + }, + decompress: function (compressed, callback) { + var decompressor = this.gzip.hasUnityMarker(compressed) ? this.gzip : this.brotli.hasUnityMarker(compressed) ? this.brotli : this.identity; + if (this.serverSetupWarningEnabled && decompressor != this.identity) { + console.log("You can reduce your startup time if you configure your web server to host .unityweb files using " + (decompressor == this.gzip ? "gzip" : "brotli") + " compression."); + this.serverSetupWarningEnabled = false; + } + if (typeof callback != "function") + return decompressor.decompress(compressed); + if (!decompressor.worker) { + var workerUrl = URL.createObjectURL(new Blob(["this.require = ", decompressor.require.toString(), "; this.decompress = ", decompressor.decompress.toString(), "; this.onmessage = ", function (e) { + var data = { id: e.data.id, decompressed: this.decompress(e.data.compressed) }; + postMessage(data, data.decompressed ? [data.decompressed.buffer] : []); + }.toString(), "; postMessage({ ready: true });"], { type: "text/javascript" })); + decompressor.worker = new Worker(workerUrl); + decompressor.worker.onmessage = function (e) { + if (e.data.ready) { + URL.revokeObjectURL(workerUrl); + return; + } + this.callbacks[e.data.id](e.data.decompressed); + delete this.callbacks[e.data.id]; + }; + decompressor.worker.callbacks = {}; + decompressor.worker.nextCallbackId = 0; + } + var id = decompressor.worker.nextCallbackId++; + decompressor.worker.callbacks[id] = callback; + decompressor.worker.postMessage({id: id, compressed: compressed}, [compressed.buffer]); + }, + serverSetupWarningEnabled: true, + }, + Cryptography: { + crc32: function (code) { + var module = UnityLoader.Cryptography.crc32.module; + if (!module) { + var buffer = new ArrayBuffer(0x1000000); + var asm = (function (global, env, buffer) { + "use asm" + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + function process(data, length) { + data = data | 0; + length = length | 0; + var crc = 0; + for (crc = HEAPU32[0x400 >> 2] | 0; length; data = (data + 1) | 0, length = (length - 1) | 0) + crc = HEAPU32[(((crc & 0xFF) ^ HEAPU8[data]) << 2) >> 2] ^ (crc >>> 8) ^ 0xFF000000; + HEAPU32[0x400 >> 2] = crc; + } + return {process: process}; + })({Uint8Array: Uint8Array, Uint32Array: Uint32Array}, null, buffer); + + module = UnityLoader.Cryptography.crc32.module = { + buffer: buffer, + HEAPU8: new Uint8Array(buffer), + HEAPU32: new Uint32Array(buffer), + process: asm.process, + crc32: 0x400, + data: 0x404, + }; + for (var i = 0; i < 0x100; i++) { + var a = i ^ 0xFF; + for (var j = 0; j < 8; j++) + a = (a >>> 1) ^ ((a & 1) ? 0xEDB88320 : 0); + module.HEAPU32[i] = a; + } + } + + module.HEAPU32[module.crc32 >> 2] = 0; + for (var offset = 0; offset < code.length;) { + var length = Math.min(module.HEAPU8.length - module.data, code.length - offset); + module.HEAPU8.set(code.subarray(offset, offset + length), module.data); + crc = module.process(module.data, length); + offset += length; + } + var crc32 = module.HEAPU32[module.crc32 >> 2]; + return new Uint8Array([crc32 >> 24, crc32 >> 16, crc32 >> 8, crc32]); + + }, + md5: function (code) { + var module = UnityLoader.Cryptography.md5.module; + if (!module) { + var buffer = new ArrayBuffer(0x1000000); + var asm = (function (global, env, buffer) { + "use asm" + var HEAPU32 = new global.Uint32Array(buffer); + function process(data, blockCount) { + data = data | 0; + blockCount = blockCount | 0; + var h0 = 0, h1 = 0, h2 = 0, h3 = 0, d0 = 0, d1 = 0, d2 = 0, d3 = 0, d4 = 0, i = 0, t = 0, s = 0; + h0 = HEAPU32[0x80] | 0, h1 = HEAPU32[0x81] | 0, h2 = HEAPU32[0x82] | 0, h3 = HEAPU32[0x83] | 0; + for (; blockCount; data = (data + 64) | 0, blockCount = (blockCount - 1) | 0) { + d0 = h0; d1 = h1; d2 = h2; d3 = h3; + for (i = 0; (i | 0) < 512; i = (i + 8) | 0) { + s = (HEAPU32[i >> 2] | 0); + h0 = (h0 + (HEAPU32[(i + 4) >> 2] | 0) + (HEAPU32[(data + (s >>> 14)) >> 2] | 0) + ( + (i | 0) < 128 ? h3 ^ (h1 & (h2 ^ h3)) : + (i | 0) < 256 ? h2 ^ (h3 & (h1 ^ h2)) : + (i | 0) < 384 ? h1 ^ h2 ^ h3: + (h2 ^ (h1 | ~h3)) + )) | 0; + t = (((h0 << (s & 31)) | (h0 >>> (32 - (s & 31)))) + h1) | 0; h0 = h3; h3 = h2; h2 = h1; h1 = t; + } + h0 = (h0 + d0) | 0; h1 = (h1 + d1) | 0; h2 = (h2 + d2) | 0; h3 = (h3 + d3) | 0; + } + HEAPU32[0x80] = h0; HEAPU32[0x81] = h1; HEAPU32[0x82] = h2; HEAPU32[0x83] = h3; + } + return {process: process}; + })({Uint32Array:Uint32Array}, null, buffer); + + module = UnityLoader.Cryptography.md5.module = { + buffer: buffer, + HEAPU8: new Uint8Array(buffer), + HEAPU32: new Uint32Array(buffer), + process: asm.process, + md5: 0x200, + data: 0x240, + }; + + module.HEAPU32.set(new Uint32Array([ + 0x00000007, 0xD76AA478, 0x0001000C, 0xE8C7B756, 0x00020011, 0x242070DB, 0x00030016, 0xC1BDCEEE, + 0x00040007, 0xF57C0FAF, 0x0005000C, 0x4787C62A, 0x00060011, 0xA8304613, 0x00070016, 0xFD469501, + 0x00080007, 0x698098D8, 0x0009000C, 0x8B44F7AF, 0x000A0011, 0xFFFF5BB1, 0x000B0016, 0x895CD7BE, + 0x000C0007, 0x6B901122, 0x000D000C, 0xFD987193, 0x000E0011, 0xA679438E, 0x000F0016, 0x49B40821, + 0x00010005, 0xF61E2562, 0x00060009, 0xC040B340, 0x000B000E, 0x265E5A51, 0x00000014, 0xE9B6C7AA, + 0x00050005, 0xD62F105D, 0x000A0009, 0x02441453, 0x000F000E, 0xD8A1E681, 0x00040014, 0xE7D3FBC8, + 0x00090005, 0x21E1CDE6, 0x000E0009, 0xC33707D6, 0x0003000E, 0xF4D50D87, 0x00080014, 0x455A14ED, + 0x000D0005, 0xA9E3E905, 0x00020009, 0xFCEFA3F8, 0x0007000E, 0x676F02D9, 0x000C0014, 0x8D2A4C8A, + 0x00050004, 0xFFFA3942, 0x0008000B, 0x8771F681, 0x000B0010, 0x6D9D6122, 0x000E0017, 0xFDE5380C, + 0x00010004, 0xA4BEEA44, 0x0004000B, 0x4BDECFA9, 0x00070010, 0xF6BB4B60, 0x000A0017, 0xBEBFBC70, + 0x000D0004, 0x289B7EC6, 0x0000000B, 0xEAA127FA, 0x00030010, 0xD4EF3085, 0x00060017, 0x04881D05, + 0x00090004, 0xD9D4D039, 0x000C000B, 0xE6DB99E5, 0x000F0010, 0x1FA27CF8, 0x00020017, 0xC4AC5665, + 0x00000006, 0xF4292244, 0x0007000A, 0x432AFF97, 0x000E000F, 0xAB9423A7, 0x00050015, 0xFC93A039, + 0x000C0006, 0x655B59C3, 0x0003000A, 0x8F0CCC92, 0x000A000F, 0xFFEFF47D, 0x00010015, 0x85845DD1, + 0x00080006, 0x6FA87E4F, 0x000F000A, 0xFE2CE6E0, 0x0006000F, 0xA3014314, 0x000D0015, 0x4E0811A1, + 0x00040006, 0xF7537E82, 0x000B000A, 0xBD3AF235, 0x0002000F, 0x2AD7D2BB, 0x00090015, 0xEB86D391, + ])); + } + + module.HEAPU32.set(new Uint32Array([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476]), module.md5 >> 2); + for (var offset = 0; offset < code.length;) { + var length = Math.min(module.HEAPU8.length - module.data, code.length - offset) & ~63; + module.HEAPU8.set(code.subarray(offset, offset + length), module.data); + offset += length; + module.process(module.data, length >> 6); + if (code.length - offset < 64) { + length = code.length - offset; + module.HEAPU8.set(code.subarray(code.length - length, code.length), module.data); + offset += length; + module.HEAPU8[module.data + length++] = 0x80; + if (length > 56) { + for (var i = length; i < 64; i++) + module.HEAPU8[module.data + i] = 0; + module.process(module.data, 1); + length = 0; + } + for (var i = length; i < 64; i++) + module.HEAPU8[module.data + i] = 0; + for (var value = code.length, add = 0, i = 56; i < 64; i++, add = (value & 0xE0) >> 5, value /= 0x100) + module.HEAPU8[module.data + i] = ((value & 0x1F) << 3) + add; + module.process(module.data, 1); + } + } + return new Uint8Array(module.HEAPU8.subarray(module.md5, module.md5 + 16)); + + }, + sha1: function (code) { + var module = UnityLoader.Cryptography.sha1.module; + if (!module) { + var buffer = new ArrayBuffer(0x1000000); + var asm = (function (global, env, buffer) { + "use asm" + var HEAPU32 = new global.Uint32Array(buffer); + function process(data, blockCount) { + data = data | 0; + blockCount = blockCount | 0; + var h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0, d0 = 0, d1 = 0, d2 = 0, d3 = 0, d4 = 0, t = 0, i = 0; + h0 = HEAPU32[80] | 0, h1 = HEAPU32[81] | 0, h2 = HEAPU32[82] | 0, h3 = HEAPU32[83] | 0, h4 = HEAPU32[84] | 0; + for (; blockCount; data = (data + 64) | 0, blockCount = (blockCount - 1) | 0) { + d0 = h0; d1 = h1; d2 = h2; d3 = h3; d4 = h4; + for (i = 0; (i | 0) < 320; i = (i + 4) | 0, h4 = h3, h3 = h2, h2 = (h1 << 30) | (h1 >>> 2), h1 = h0, h0 = t) { + if ((i | 0) < 64) { + t = (HEAPU32[(data + i) >> 2] | 0); + t = ((t << 24) & 0xFF000000) | ((t << 8) & 0xFF0000) | ((t >>> 8) & 0xFF00) | ((t >>> 24) & 0xFF); + } else { + t = HEAPU32[(i - 12) >> 2] ^ HEAPU32[(i - 32) >> 2] ^ HEAPU32[(i - 56) >> 2] ^ HEAPU32[(i - 64) >> 2]; + t = (t << 1) | (t >>> 31); + } + HEAPU32[i >> 2] = t; + t = (t + (((h0 << 5) | (h0 >>> 27)) + h4) + ( + (i | 0) < 80 ? ((((h1 & h2) | (~h1 & h3)) | 0) + 0x5A827999) | 0 : + (i | 0) < 160 ? ((h1 ^ h2 ^ h3) + 0x6ED9EBA1) | 0 : + (i | 0) < 240 ? (((h1 & h2) | (h1 & h3) | (h2 & h3)) + 0x8F1BBCDC) | 0 : + ((h1 ^ h2 ^ h3) + 0xCA62C1D6) | 0 + )) | 0; + } + h0 = (h0 + d0) | 0; h1 = (h1 + d1) | 0; h2 = (h2 + d2) | 0; h3 = (h3 + d3) | 0; h4 = (h4 + d4) | 0; + } + HEAPU32[80] = h0; HEAPU32[81] = h1; HEAPU32[82] = h2; HEAPU32[83] = h3; HEAPU32[84] = h4; + } + return {process: process}; + })({Uint32Array:Uint32Array}, null, buffer); + + module = UnityLoader.Cryptography.sha1.module = { + buffer: buffer, + HEAPU8: new Uint8Array(buffer), + HEAPU32: new Uint32Array(buffer), + process: asm.process, + sha1: 0x140, + data: 0x180, + }; + } + + module.HEAPU32.set(new Uint32Array([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]), module.sha1 >> 2); + for (var offset = 0; offset < code.length;) { + var length = Math.min(module.HEAPU8.length - module.data, code.length - offset) & ~63; + module.HEAPU8.set(code.subarray(offset, offset + length), module.data); + offset += length; + module.process(module.data, length >> 6); + if (code.length - offset < 64) { + length = code.length - offset; + module.HEAPU8.set(code.subarray(code.length - length, code.length), module.data); + offset += length; + module.HEAPU8[module.data + length++] = 0x80; + if (length > 56) { + for (var i = length; i < 64; i++) + module.HEAPU8[module.data + i] = 0; + module.process(module.data, 1); + length = 0; + } + for (var i = length; i < 64; i++) + module.HEAPU8[module.data + i] = 0; + for (var value = code.length, add = 0, i = 63; i >=56; i--, add = (value & 0xE0) >> 5, value /= 0x100) + module.HEAPU8[module.data + i] = ((value & 0x1F) << 3) + add; + module.process(module.data, 1); + } + } + var sha1 = new Uint8Array(20); + for (var i = 0; i < sha1.length; i++) + sha1[i] = module.HEAPU8[module.sha1 + (i & ~3) + 3 - (i & 3)]; + return sha1; + + }, + + }, + Error: { + // stacktrace example: + // + // [Chrome] + // Error + // at Array.eWg (blob:http%3A//localhost%3A8080/7dd54af3-48c5-47e1-893f-5f1ef09ab62b:10:238896) + // at Object.P7h [as dynCall_iiii] (blob:http%3A//localhost%3A8080/7dd54af3-48c5-47e1-893f-5f1ef09ab62b:28:33689) + // at invoke_iiii (blob:http%3A//localhost%3A8080/972f149f-a28e-4ee9-a1c7-45e8c4b0998b:1:334638) + // at DJd (blob:http%3A//localhost%3A8080/7dd54af3-48c5-47e1-893f-5f1ef09ab62b:15:260807) + // at Object.dynCall (blob:http%3A//localhost%3A8080/972f149f-a28e-4ee9-a1c7-45e8c4b0998b:1:7492) + // at browserIterationFunc (blob:http%3A//localhost%3A8080/972f149f-a28e-4ee9-a1c7-45e8c4b0998b:1:207518) + // at Object.runIter (blob:http%3A//localhost%3A8080/972f149f-a28e-4ee9-a1c7-45e8c4b0998b:1:189915) + // + // [Chrome WebAssembly] + // at ([24622]+70) + // at ([24000]+73) + // + // [Firefox] + // eWg@blob:http://localhost:8080/0e677969-e11c-e24b-bb23-4f3afdbd5a3a:10:1 + // P7h@blob:http://localhost:8080/0e677969-e11c-e24b-bb23-4f3afdbd5a3a:28:1 + // invoke_iiii@blob:http://localhost:8080/67513e21-4cf2-de4e-a571-c6ee67cc2a72:1:334616 + // DJd@blob:http://localhost:8080/0e677969-e11c-e24b-bb23-4f3afdbd5a3a:15:1 + // Runtime.dynCall@blob:http://localhost:8080/67513e21-4cf2-de4e-a571-c6ee67cc2a72:1:7469 + // _emscripten_set_main_loop/browserIterationFunc@blob:http://localhost:8080/67513e21-4cf2-de4e-a571-c6ee67cc2a72:1:207510 + // Browser.mainLoop.runIter@blob:http://localhost:8080/67513e21-4cf2-de4e-a571-c6ee67cc2a72:1:189915 + // + // [Firefox WebAssembly] + // wasm-function[24622]@blob:null/2e0a79af-37a7-ac43-9534-4ac66e23fea4:8059611:1 + // wasm-function[24000]@blob:null/2e0a79af-37a7-ac43-9534-4ac66e23fea4:7932153:1 + // + // [Safari] + // eWg@blob:http://localhost:8080/6efe7f5a-b930-45c3-9175-296366f9d9f4:10:238896 + // P7h@blob:http://localhost:8080/6efe7f5a-b930-45c3-9175-296366f9d9f4:28:33689 + // invoke_iiii@blob:http://localhost:8080/597cffca-fc52-4586-9da7-f9c8e591738b:1:334638 + // DJd@blob:http://localhost:8080/6efe7f5a-b930-45c3-9175-296366f9d9f4:15:260809 + // dynCall@blob:http://localhost:8080/597cffca-fc52-4586-9da7-f9c8e591738b:1:7496 + // browserIterationFunc@blob:http://localhost:8080/597cffca-fc52-4586-9da7-f9c8e591738b:1:207525 + // runIter@blob:http://localhost:8080/597cffca-fc52-4586-9da7-f9c8e591738b:1:189919 + + init: (function () { + Error.stackTraceLimit = 50; + window.addEventListener("error", function (e) { + var Module = UnityLoader.Error.getModule(e); + if (!Module) + return UnityLoader.Error.handler(e); + var debugSymbolsUrl = Module.useWasm ? Module.wasmSymbolsUrl : Module.asmSymbolsUrl; + if (!debugSymbolsUrl) + return UnityLoader.Error.handler(e, Module); + var xhr = new XMLHttpRequest(); + xhr.open("GET", Module.resolveBuildUrl(debugSymbolsUrl)); + xhr.responseType = "arraybuffer"; + xhr.onload = function () { + UnityLoader.loadCode(UnityLoader.Compression.decompress(new Uint8Array(xhr.response)), function (id) { + Module.demangleSymbol = UnityLoader[id](); + UnityLoader.Error.handler(e, Module); + }); + }; + xhr.send(); + }); + return true; + })(), + stackTraceFormat: navigator.userAgent.indexOf("Chrome") != -1 ? "(\\s+at\\s+)(([\\w\\d_\\.]*?)([\\w\\d_$]+)(/[\\w\\d_\\./]+|))(\\s+\\[.*\\]|)\\s*\\((blob:.*)\\)" : + "(\\s*)(([\\w\\d_\\.]*?)([\\w\\d_$]+)(/[\\w\\d_\\./]+|))(\\s+\\[.*\\]|)\\s*@(blob:.*)", + stackTraceFormatWasm: navigator.userAgent.indexOf("Chrome") != -1 ? "((\\s+at\\s*)\\s\\(\\[(\\d+)\\]\\+\\d+\\))()" : + "((\\s*)wasm-function\\[(\\d+)\\])@(blob:.*)", + blobParseRegExp: new RegExp("^(blob:.*)(:\\d+:\\d+)$"), + getModule: function (e) { + var traceMatch = e.message.match(new RegExp(this.stackTraceFormat, "g")); + for (var trace in traceMatch) { + var traceParse = traceMatch[trace].match(new RegExp("^" + this.stackTraceFormat + "$")); + var blobParse = traceParse[7].match(this.blobParseRegExp); + if (blobParse && UnityLoader.Blobs[blobParse[1]] && UnityLoader.Blobs[blobParse[1]].Module) + return UnityLoader.Blobs[blobParse[1]].Module; + } + }, + demangle: function (e, Module) { + var message = e.message; + if (!Module) + return message; + message = message.replace(new RegExp(this.stackTraceFormat, "g"), function (trace) { + var errParse = trace.match(new RegExp("^" + this.stackTraceFormat + "$")); + var blobParse = errParse[7].match(this.blobParseRegExp); + var functionName = Module.demangleSymbol ? Module.demangleSymbol(errParse[4]) : errParse[4]; + var url = blobParse && UnityLoader.Blobs[blobParse[1]] && UnityLoader.Blobs[blobParse[1]].url ? UnityLoader.Blobs[blobParse[1]].url : "blob"; + return errParse[1] + functionName + (errParse[2] != functionName ? " ["+ errParse[2] + "]" : "") + + " (" + (blobParse ? url.substr(url.lastIndexOf("/") + 1) + blobParse[2] : errParse[7]) + ")"; + }.bind(this)); + if (Module.useWasm) { + message = message.replace(new RegExp(this.stackTraceFormatWasm, "g"), function (trace) { + var errParse = trace.match(new RegExp("^" + this.stackTraceFormatWasm + "$")); + var functionName = Module.demangleSymbol ? Module.demangleSymbol(errParse[3]) : errParse[3]; + var blobParse = errParse[4].match(this.blobParseRegExp); + var url = blobParse && UnityLoader.Blobs[blobParse[1]] && UnityLoader.Blobs[blobParse[1]].url ? UnityLoader.Blobs[blobParse[1]].url : "blob"; + return (functionName == errParse[3] ? errParse[1] : errParse[2] + functionName + " [wasm:"+ errParse[3] + "]") + + (errParse[4] ? " (" + (blobParse ? url.substr(url.lastIndexOf("/") + 1) + blobParse[2] : errParse[4]) + ")" : ""); + }.bind(this)); + } + return message; + }, + handler: function (e, Module) { + var message = Module ? this.demangle(e, Module) : e.message; + if (Module && Module.errorhandler && Module.errorhandler(message, e.filename, e.lineno)) + return; + console.log("Invoking error handler due to\n" + message); + if (typeof dump == "function") + dump("Invoking error handler due to\n" + message); + // Firefox has a bug where it's IndexedDB implementation will throw UnknownErrors, which are harmless, and should not be shown. + if (message.indexOf("UnknownError") != -1) + return; + // Ignore error when application terminated with return code 0 + if (message.indexOf("Program terminated with exit(0)") != -1) + return; + if (this.didShowErrorMessage) + return; + var message = "An error occurred running the Unity content on this page. See your browser JavaScript console for more info. The error was:\n" + message; + if (message.indexOf("DISABLE_EXCEPTION_CATCHING") != -1) { + message = "An exception has occurred, but exception handling has been disabled in this build. If you are the developer of this content, enable exceptions in your project WebGL player settings to be able to catch the exception or see the stack trace."; + } else if (message.indexOf("Cannot enlarge memory arrays") != -1) { + message = "Out of memory. If you are the developer of this content, try allocating more memory to your WebGL build in the WebGL player settings."; + } else if (message.indexOf("Invalid array buffer length") != -1 || message.indexOf("Invalid typed array length") != -1 || message.indexOf("out of memory") != -1 || message.indexOf("could not allocate memory") != -1) { + message = "The browser could not allocate enough memory for the WebGL content. If you are the developer of this content, try allocating less memory to your WebGL build in the WebGL player settings."; + } + alert(message); + this.didShowErrorMessage = true; + + }, + popup: function (gameInstance, message, callbacks) { + callbacks = callbacks || [{text: "OK"}]; + var popup = document.createElement("div"); + popup.style.cssText = "position: absolute; top: 50%; left: 50%; -webkit-transform: translate(-50%, -50%); transform: translate(-50%, -50%); text-align: center; border: 1px solid black; padding: 5px; background: #E8E8E8"; + var messageElement = document.createElement("span"); + messageElement.textContent = message; + popup.appendChild(messageElement); + popup.appendChild(document.createElement("br")); + for (var i = 0; i < callbacks.length; i++) { + var button = document.createElement("button"); + if (callbacks[i].text) + button.textContent = callbacks[i].text; + if (callbacks[i].callback) + button.onclick = callbacks[i].callback; + button.style.margin = "5px"; + button.addEventListener("click", function () { gameInstance.container.removeChild(popup); }) + popup.appendChild(button); + } + gameInstance.container.appendChild(popup); + + }, + + }, + Job: { + schedule: function (Module, id, dependencies, callback, parameters) { + parameters = parameters || {}; + var job = Module.Jobs[id]; + if (!job) + job = Module.Jobs[id] = {dependencies: {}, dependants: {}}; + if (job.callback) + throw "[UnityLoader.Job.schedule] job '" + id + "' has been already scheduled"; + if (typeof callback != "function") + throw "[UnityLoader.Job.schedule] job '" + id + "' has invalid callback"; + if (typeof parameters != "object") + throw "[UnityLoader.Job.schedule] job '" + id + "' has invalid parameters"; + job.callback = function (x,y) { job.starttime = performance.now(); callback(x,y) }; + job.parameters = parameters; + job.complete = function (result) { + job.endtime = performance.now(); + job.result = {value: result}; + for (var dependant in job.dependants) { + var dependantJob = Module.Jobs[dependant]; + dependantJob.dependencies[id] = job.dependants[dependant] = false; + var pending = typeof dependantJob.callback != "function"; + for (var dependency in dependantJob.dependencies) + pending = pending || dependantJob.dependencies[dependency]; + if (!pending) { + if (dependantJob.executed) + throw "[UnityLoader.Job.schedule] job '" + id + "' has already been executed"; + dependantJob.executed = true; + setTimeout(dependantJob.callback.bind(null, Module, dependantJob), 0); + } + } + } + var pending = false; + dependencies.forEach(function (dependency) { + var dependencyJob = Module.Jobs[dependency]; + if (!dependencyJob) + dependencyJob = Module.Jobs[dependency] = {dependencies: {}, dependants: {}}; + if (job.dependencies[dependency] = dependencyJob.dependants[id] = !dependencyJob.result) + pending = true; + }); + if (!pending) { + job.executed = true; + setTimeout(job.callback.bind(null, Module, job), 0); + } + + }, + result: function (Module, id) { + var job = Module.Jobs[id]; + if (!job) + throw "[UnityLoader.Job.result] job '" + id + "' does not exist"; + if (typeof job.result != "object") + throw "[UnityLoader.Job.result] job '" + id + "' has invalid result"; + return job.result.value; + + }, + + }, + Progress: { + Styles: { + Dark: { + progressLogoUrl: "data:image/png;base64,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", + progressEmptyUrl: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAI0AAAASCAYAAABmbl0zAAAACXBIWXMAAAsSAAALEgHS3X78AAAATUlEQVRo3u3aIQ4AIAwEQUr4/5cPiyMVBDOj0M2mCKgkGdAwjYCudZzLOLiITYPrCdEgGkSDaEA0iAbRIBpEA6JBNHx1vnL7V4NNwxsbCNMGI3YImu0AAAAASUVORK5CYII=", + progressFullUrl: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAI0AAAASCAYAAABmbl0zAAAACXBIWXMAAAsSAAALEgHS3X78AAAAO0lEQVRo3u3SQREAAAjDMMC/56EB3omEXjtJCg5GAkyDaTANpsE0YBpMg2kwDaYB02AaTINpMA2Yhr8FO18EIBpZMeQAAAAASUVORK5CYII=", + }, + Light: { + progressLogoUrl: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJoAAACCCAYAAAC+etHhAAAACXBIWXMAAAsSAAALEgHS3X78AAAIhUlEQVR42u2dzW3bSBTH/yFcgNIBg5wDMKccPa5ATAVxKkhUga0KbFdgdmCpglDHnFZAzsGyBHWgPYjcMIQlkm++3sy8P7AInI3tGfKnN+9rZt4cj0eIRLaVySMQudBV/4v3Hz7JE+GvAoACcA2gBLAC8Dj3h/z+9dMfaCKWyntgqfbrvpYU0LxaNBELLQZgFSP/XgW3dIq8LodlD665UgBqAU302nLYB2uh+fOWApqoWw7LC36WrtgvnwKaPanW0kzxs0wsvQsABwEtnbTD0pOFKQFUAlq8aYelIT9LV9cCWnxph9KCnxW1nyagjb+8zmoVzMeat/81Alo4flZntUJTCaZVgtRBy3G5vBOargU0fnoJ1GoF6ael2iZURghZF7AUAhqfl/EQ+YdIQGOg7xH4YmN+moDGwPn/FvkcFfwnj5MH7Y7JSzg4gE1A8/hJv/UI1gantuuP7Z9JLZ8ppTfuHINVA9i1f+4HwciP1CxaKqDdOnj4HVibAVivBSO2l+8CzMpRKYC2sGTN+harnhGMuLKsCoy6OVIAzVQ6gwLWUC7zd9cCmjvloKcz9i1QW5jpx1dwm0wtAXwV0NzoYYY/tB9YrYOFsVC06flcc12GYsRfFNB6TvwXwsPlANZwHtQa5Kr1626JVlRAm/Byng3+vKa1Di7AGsJPtWbrdtxbImhs2oauIofs0FqE2mOoT61GND1IqD4imwJ7FjFkAHDTRl6+IMvbqJdqzQ69Dwx1CVQCml3IvjLwT6hzqV9JTWwFNJ6QVZ7nozRe8voMfBQtBbR4IdOxZtUZqKgBTAEGHSuZQGZF1GpEF7xcWlKDXD4zgcxKOoNaz3wasVpUP22ZMmgxQgbopTPuJwQJYtEEMq10xmoijA1xXHlqoMUKmU4AUONUtZiiDfF3qJRAixkypfEy53RZ7EL00zKBzLs1e5y5HIpFcwRZxRAynXTGmrjUUqLhImbQTEP2lRlkOumMfj1zjqhpjjJW0GKHDJjXXNnXHvQWnpr4fdcxgpYCZAXoe0V19nbuQUtzqNhASwGyzppRtIH+PgTq95exgJYKZCXRQozVM6eKmua4jgG0VCDTsWZPMNOIGVSaIxPISLoHLZ3RwFwPP7Xr1kvbUCaQzdYC9L2i1HRG8H5aJpCRlswFEYrK8Fio+bQ8NNBMQrYPADJf6YxL8B6IH+hgQDMN2Q34ixoAVLC3UWbu8rmGh11hGSPIDswh853OOKc5aQ6TwYh10FKETGe3+ZPl+c1Jc6x9PetMIJskandGg/H2bF01E5dCG8GIFdBShSzXSGe4Cm6mWLWVz4d45QGyTi8IQ7lGOqN2NMYdLu9VeITnXftXniArEL9cpmrqkWBk7fthZB4gS0Fz27N1dbgAm7cAYCpoAhn9pfuwILszvjCL89Eygcy4Vp4syIZbADAGmkCmF01XHn93H/DKYTAyG7RcINPSk+ff3wdry+nBDEFrwL+wzVm+b87LGY1ldOmsBDaydLo7TEDWTxspj2OZHAwIbHRR+9V0pRiNZTJoAhtdC9BPFNLR8sxY7riDJrDRdQf3XazqzN9/B4NKzJQSVBeum4xGh6E4Z+VEaJ7hrplzbMPJAzw3lk4tqtuA7TPC6d74l2hhFNzkssoJY7lFIG1CJpfRAqdbeBcBgNaAXsZxlZOcsinYa2Awt/HRNGyhJIephencQWCwwLQWc19BCgk007CVgcCm0/dPPTxZNwjgEqSQQTMN220gsFWgNQ/aTjHMPTL0OSTQUoWNatVsphgU4d8Ht1M9Ndhq0A9XsXGfek5cCovQQEsRNqpVs2FJSo0PTHCgpQZbA3oHrWmrRjnr7BAyaKnBRt0TkMPsPk+KRat9PDDTB/GlApvOvoBvMJPuUMTv28UAWkqwVaCf929iCaXehLKJBbSUYFtrzEk38qNYtAae7pfPLH/iTcJ2zxC0GvRCtY5Vy4mg1r4elO0LLUzCdgdGrck9UbfXKY35UP2zbaygmYbtmSFsB9B3P1HroNQj3OuYQUsBtnvQ0x2UjgpKWsNrs6nLaxRjh41aMfiGeWUk6vHtXvd5ur4YNmbYqNfuzO3uCKbs5BO02GGjWrXbGQ5+MGUn36DFDJvO6T1TrNoCtIiz9v1gMo+/O1bYqG3fasIcFHFMu5RBixU2nTro2AYSalpjkzposcJG7e4Y20BCCQQaeCo7cQPNBmyKwZyo8zm3gSQHrZu25vCCuYBmGrYX+D8GoNZ4yQ+GrBnA5Jw0TqCZhG2B0wZl37BR5/LadUDBlZ04g2YDttLjXBqYa/umuANszjjhCJpp2F4AHFvo7j34b4/El90/1E8hwLJTX1fgq6r984sGZMMTEBX+JEZrnPJLOr7U1HTHCrTmzYc2NUHtpq25vMw3x+Px/y/ef/iEyPRjhgWzDd4/RJ/xsZ1DQQD87bn/+fvXTwHNoFQLG9UamARPZywUbXA6GowFaBniVg16q3W3zP4w5OPpjIWiHacXEbtFA+gH6dmweHm7hLo4p+wdLlQExKLxSjGYtngN3Fx60YBB2Sk10HRSDDbAc3HzXc3tBaQCms5BeqbBK2D/9rsttxeQgo9mIsUQmt6OWXDx0exqlcAcWR6tnxpocyLEULXlOKjUQAPivwmmFtB4qAGT658tBT0CGiOxuNA+FWuWMmhdwfljC10sftuO68CukLb2+PvugBKnTlaFMNMgGwEtnBfVvazFALw8AN+zEdDCXF4r/Om4yAfgcbswjfXynwlPs6PVz61/d8PMv9tyfnhi0fQsSN1bZpVn/64W0NJYZvv+XT4Az7Z/x/5GZwHN3jLb9++KAXim/bst9wcioLlRl0bpKhJqAF7Uy6aAFod/dxDQRC78uzqESQpo4ft3OwFNZNO/W7YQbkKYxF+t3CKRLUllQCSgieLRf80sS5fCDVbiAAAAAElFTkSuQmCC", + progressEmptyUrl: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAI0AAAASCAYAAABmbl0zAAAACXBIWXMAAAsSAAALEgHS3X78AAAAUUlEQVRo3u3aMQ4AEAxAUcRJzGb3v1mt3cQglvcmc/NTA3XMFQUuNCPgVk/nahwchE2D6wnRIBpEg2hANIgG0SAaRAOiQTR8lV+5/avBpuGNDcz6A6oq1CgNAAAAAElFTkSuQmCC", + progressFullUrl: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAI0AAAASCAYAAABmbl0zAAAACXBIWXMAAAsSAAALEgHS3X78AAAAQElEQVRo3u3SMREAMAgAsVIpnTvj3xlogDmR8PfxftaBgSsBpsE0mAbTYBowDabBNJgG04BpMA2mwTSYBkzDXgP/hgGnr4PpeAAAAABJRU5ErkJggg==", + }, + }, + handler: function (gameInstance, progress) { + if (!gameInstance.Module) + return; + var style = UnityLoader.Progress.Styles[gameInstance.Module.splashScreenStyle]; + var progressLogoUrl = gameInstance.Module.progressLogoUrl ? gameInstance.Module.resolveBuildUrl(gameInstance.Module.progressLogoUrl) : style.progressLogoUrl; + var progressEmptyUrl = gameInstance.Module.progressEmptyUrl ? gameInstance.Module.resolveBuildUrl(gameInstance.Module.progressEmptyUrl) : style.progressEmptyUrl; + var progressFullUrl = gameInstance.Module.progressFullUrl ? gameInstance.Module.resolveBuildUrl(gameInstance.Module.progressFullUrl) : style.progressFullUrl; + var commonStyle = "position: absolute; left: 50%; top: 50%; -webkit-transform: translate(-50%, -50%); transform: translate(-50%, -50%);"; + if (!gameInstance.logo) { + gameInstance.logo = document.createElement("div"); + gameInstance.logo.style.cssText = commonStyle + "background: url('" + progressLogoUrl + "') no-repeat center / contain; width: 154px; height: 130px;"; + gameInstance.container.appendChild(gameInstance.logo); + } + if (!gameInstance.progress) { + gameInstance.progress = document.createElement("div"); + gameInstance.progress.style.cssText = commonStyle + " height: 18px; width: 141px; margin-top: 90px;"; + gameInstance.progress.empty = document.createElement("div"); + gameInstance.progress.empty.style.cssText = "background: url('" + progressEmptyUrl + "') no-repeat right / cover; float: right; width: 100%; height: 100%; display: inline-block;"; + gameInstance.progress.appendChild(gameInstance.progress.empty); + gameInstance.progress.full = document.createElement("div"); + gameInstance.progress.full.style.cssText = "background: url('" + progressFullUrl + "') no-repeat left / cover; float: left; width: 0%; height: 100%; display: inline-block;"; + gameInstance.progress.appendChild(gameInstance.progress.full); + gameInstance.container.appendChild(gameInstance.progress); + } + gameInstance.progress.full.style.width = (100 * progress) + "%"; + gameInstance.progress.empty.style.width = (100 * (1 - progress)) + "%"; + if (progress == 1) + gameInstance.logo.style.display = gameInstance.progress.style.display = "none"; + + }, + update: function (Module, id, e) { + var progress = Module.buildDownloadProgress[id]; + if (!progress) + progress = Module.buildDownloadProgress[id] = { + started: false, + finished: false, + lengthComputable: false, + total: 0, + loaded: 0, + }; + if (typeof e == "object" && (e.type == "progress" || e.type == "load")) { + if (!progress.started) { + progress.started = true; + progress.lengthComputable = e.lengthComputable; + progress.total = e.total; + } + progress.loaded = e.loaded; + if (e.type == "load") + progress.finished = true; + } + var loaded = 0, total = 0, started = 0, computable = 0, unfinishedNonComputable = 0; + for (var id in Module.buildDownloadProgress) { + var progress = Module.buildDownloadProgress[id]; + if (!progress.started) + return 0; + started++; + if (progress.lengthComputable) { + loaded += progress.loaded; + total += progress.total; + computable++; + } else if (!progress.finished) { + unfinishedNonComputable++; + } + } + var totalProgress = started ? (started - unfinishedNonComputable - (total ? computable * (total - loaded) / total : 0)) / started : 0; + Module.gameInstance.onProgress(Module.gameInstance, 0.9 * totalProgress); + + }, + + }, + // The Unity WebGL generated content depends on SystemInfo, therefore it should not be changed. If any modification is necessary, do it at your own risk. + SystemInfo: (function() { + var unknown = "-"; + var nVer = navigator.appVersion; + var nAgt = navigator.userAgent; + var browser = navigator.appName; + var version = navigator.appVersion; + var majorVersion = parseInt(navigator.appVersion, 10); + var nameOffset, verOffset, ix; + if ((verOffset = nAgt.indexOf("Opera")) != -1) { + browser = "Opera"; + version = nAgt.substring(verOffset + 6); + if ((verOffset = nAgt.indexOf("Version")) != -1) { + version = nAgt.substring(verOffset + 8); + } + } else if ((verOffset = nAgt.indexOf("MSIE")) != -1) { + browser = "Microsoft Internet Explorer"; + version = nAgt.substring(verOffset + 5); + } else if ((verOffset = nAgt.indexOf("Edge")) != -1) { + browser = "Edge"; + version = nAgt.substring(verOffset + 5); + } else if ((verOffset = nAgt.indexOf("Chrome")) != -1) { + browser = "Chrome"; + version = nAgt.substring(verOffset + 7); + } else if ((verOffset = nAgt.indexOf("Safari")) != -1) { + browser = "Safari"; + version = nAgt.substring(verOffset + 7); + if ((verOffset = nAgt.indexOf("Version")) != -1) { + version = nAgt.substring(verOffset + 8); + } + } else if ((verOffset = nAgt.indexOf("Firefox")) != -1) { + browser = "Firefox"; + version = nAgt.substring(verOffset + 8); + } else if (nAgt.indexOf("Trident/") != -1) { + browser = "Microsoft Internet Explorer"; + version = nAgt.substring(nAgt.indexOf("rv:") + 3); + } else if ((nameOffset = nAgt.lastIndexOf(" ") + 1) < (verOffset = nAgt.lastIndexOf("/"))) { + browser = nAgt.substring(nameOffset, verOffset); + version = nAgt.substring(verOffset + 1); + if (browser.toLowerCase() == browser.toUpperCase()) { + browser = navigator.appName; + } + } + if ((ix = version.indexOf(";")) != -1) + version = version.substring(0, ix); + if ((ix = version.indexOf(" ")) != -1) + version = version.substring(0, ix); + if ((ix = version.indexOf(")")) != -1) + version = version.substring(0, ix); + majorVersion = parseInt("" + version, 10); + if (isNaN(majorVersion)) { + version = "" + parseFloat(navigator.appVersion); + majorVersion = parseInt(navigator.appVersion, 10); + } + else version = "" + parseFloat(version); + var mobile = /Mobile|mini|Fennec|Android|iP(ad|od|hone)/.test(nVer); + var os = unknown; + var clientStrings = [ + {s: "Windows 3.11", r: /Win16/}, + {s: "Windows 95", r: /(Windows 95|Win95|Windows_95)/}, + {s: "Windows ME", r: /(Win 9x 4.90|Windows ME)/}, + {s: "Windows 98", r: /(Windows 98|Win98)/}, + {s: "Windows CE", r: /Windows CE/}, + {s: "Windows 2000", r: /(Windows NT 5.0|Windows 2000)/}, + {s: "Windows XP", r: /(Windows NT 5.1|Windows XP)/}, + {s: "Windows Server 2003", r: /Windows NT 5.2/}, + {s: "Windows Vista", r: /Windows NT 6.0/}, + {s: "Windows 7", r: /(Windows 7|Windows NT 6.1)/}, + {s: "Windows 8.1", r: /(Windows 8.1|Windows NT 6.3)/}, + {s: "Windows 8", r: /(Windows 8|Windows NT 6.2)/}, + {s: "Windows 10", r: /(Windows 10|Windows NT 10.0)/}, + {s: "Windows NT 4.0", r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/}, + {s: "Windows ME", r: /Windows ME/}, + {s: "Android", r: /Android/}, + {s: "Open BSD", r: /OpenBSD/}, + {s: "Sun OS", r: /SunOS/}, + {s: "Linux", r: /(Linux|X11)/}, + {s: "iOS", r: /(iPhone|iPad|iPod)/}, + {s: "Mac OS X", r: /Mac OS X/}, + {s: "Mac OS", r: /(MacPPC|MacIntel|Mac_PowerPC|Macintosh)/}, + {s: "QNX", r: /QNX/}, + {s: "UNIX", r: /UNIX/}, + {s: "BeOS", r: /BeOS/}, + {s: "OS/2", r: /OS\/2/}, + {s: "Search Bot", r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/} + ]; + for (var id in clientStrings) { + var cs = clientStrings[id]; + if (cs.r.test(nAgt)) { + os = cs.s; + break; + } + } + + var osVersion = unknown; + if (/Windows/.test(os)) { + osVersion = /Windows (.*)/.exec(os)[1]; + os = "Windows"; + } + switch (os) { + case "Mac OS X": + osVersion = /Mac OS X (10[\.\_\d]+)/.exec(nAgt)[1]; + break; + case "Android": + osVersion = /Android ([\.\_\d]+)/.exec(nAgt)[1]; + break; + case "iOS": + osVersion = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer); + osVersion = osVersion[1] + "." + osVersion[2] + "." + (osVersion[3] | 0); + break; + } + return { + width: screen.width ? screen.width : 0, + height: screen.height ? screen.height : 0, + browser: browser, + browserVersion: version, + mobile: mobile, + os: os, + osVersion: osVersion, + gpu: (function() { + var canvas = document.createElement("canvas"); + var gl = canvas.getContext("experimental-webgl"); + if(gl) { + var renderedInfo = gl.getExtension("WEBGL_debug_renderer_info"); + if(renderedInfo) { + return gl.getParameter(renderedInfo.UNMASKED_RENDERER_WEBGL); + } + } + return unknown; + })(), + language: window.navigator.userLanguage || window.navigator.language, + hasWebGL: (function() { + if (!window.WebGLRenderingContext) { + return 0; + } + var canvas = document.createElement("canvas"); + var gl = canvas.getContext("webgl2"); + if (!gl) { + gl = canvas.getContext("experimental-webgl2"); + if (!gl) { + gl = canvas.getContext("webgl"); + if (!gl) { + gl = canvas.getContext("experimental-webgl"); + if (!gl) { + return 0; + } + } + return 1; + } + return 2; + } + return 2; + })(), + hasCursorLock: (function() { + var e = document.createElement("canvas"); + if (e["requestPointerLock"] || e["mozRequestPointerLock"] || e["webkitRequestPointerLock"] || e["msRequestPointerLock"]) return 1; else return 0; + })(), + hasFullscreen: (function() { + var e = document.createElement("canvas"); + if (e["requestFullScreen"] || e["mozRequestFullScreen"] || e["msRequestFullscreen"] || e["webkitRequestFullScreen"]) { + if (browser.indexOf("Safari") == -1 || version >= 10.1) return 1; + } + return 0; + })(), + hasThreads: typeof SharedArrayBuffer !== 'undefined', + hasWasm: typeof WebAssembly == "object" && typeof WebAssembly.validate == "function" && typeof WebAssembly.compile == "function", + }; + + })(), + compatibilityCheck: function (gameInstance, onsuccess, onerror) { + if (!UnityLoader.SystemInfo.hasWebGL) { + gameInstance.popup("Your browser does not support WebGL", + [{text: "OK", callback: onerror}]); + } else if (UnityLoader.SystemInfo.mobile) { + gameInstance.popup("Please note that Unity WebGL is not currently supported on mobiles. Press OK if you wish to continue anyway.", + [{text: "OK", callback: onsuccess}]); + } else if (["Edge", "Firefox", "Chrome", "Safari"].indexOf(UnityLoader.SystemInfo.browser) == -1) { + gameInstance.popup("Please note that your browser is not currently supported for this Unity WebGL content. Press OK if you wish to continue anyway.", + [{text: "OK", callback: onsuccess}]); + } else { + onsuccess(); + } + + }, + Blobs: {}, + loadCode: function (code, onload, info) { + var functionId = [].slice.call(UnityLoader.Cryptography.md5(code)).map(function(x) { return ("0" + x.toString(16)).substr(-2); }).join(""); + var script = document.createElement("script"); + var blobUrl = URL.createObjectURL(new Blob(["UnityLoader[\"" + functionId + "\"]=", code], { type: "text/javascript" })); + UnityLoader.Blobs[blobUrl] = info; + script.src = blobUrl; + script.onload = function () { + URL.revokeObjectURL(blobUrl); + onload(functionId); + delete script.onload; + } + document.body.appendChild(script); + + }, + setupIndexedDBJob: function (Module, job) { + function setupIndexedDB(idb) { + if (setupIndexedDB.called) + return; + setupIndexedDB.called = true; + Module.indexedDB = idb; + job.complete(); + } + try { + var idb = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + var testRequest = idb.open("/idbfs-test"); + testRequest.onerror = function(e) { e.preventDefault(); setupIndexedDB(); } + testRequest.onsuccess = function() { testRequest.result.close(); setupIndexedDB(idb); } + } catch (e) { + setupIndexedDB(); + } + + }, + processWasmCodeJob: function (Module, job) { + Module.wasmBinary = UnityLoader.Job.result(Module, "downloadWasmCode"); + job.complete(); + + }, + processWasmFrameworkJob: function (Module, job) { + var code = UnityLoader.Job.result(Module, "downloadWasmFramework"); + UnityLoader.loadCode(code, function (id) { + var blob = new Blob([code], { type: "application/javascript" }); + Module["mainScriptUrlOrBlob"] = blob; + UnityLoader[id](Module); + job.complete(); + }, {Module: Module, url: Module["wasmFrameworkUrl"]}); + + }, + processAsmCodeJob: function (Module, job) { + var asm = UnityLoader.Job.result(Module, "downloadAsmCode"); + UnityLoader.loadCode(!Math.fround ? UnityLoader.Utils.optimizeMathFround(asm) : asm, function (id) { + Module.asm = UnityLoader[id]; + job.complete(); + }, {Module: Module, url: Module["asmCodeUrl"]}); + + }, + processAsmFrameworkJob: function (Module, job) { + var code = UnityLoader.Job.result(Module, "downloadAsmFramework"); + UnityLoader.loadCode(code, function (id) { + var blob = new Blob([code], { type: "application/javascript" }); + Module["mainScriptUrlOrBlob"] = blob; + UnityLoader[id](Module); + job.complete(); + }, {Module: Module, url: Module["asmFrameworkUrl"]}); + + }, + processMemoryInitializerJob: function (Module, job) { + Module["memoryInitializerRequest"].status = 200; + Module["memoryInitializerRequest"].response = UnityLoader.Job.result(Module, "downloadMemoryInitializer"); + if (Module["memoryInitializerRequest"].callback) + Module["memoryInitializerRequest"].callback(); + job.complete(); + + }, + processDataJob: function (Module, job) { + var data = UnityLoader.Job.result(Module, "downloadData"); + var view = new DataView(data.buffer, data.byteOffset, data.byteLength); + var pos = 0; + var prefix = "UnityWebData1.0\0"; + if (!String.fromCharCode.apply(null, data.subarray(pos, pos + prefix.length)) == prefix) + throw "unknown data format"; + pos += prefix.length; + var headerSize = view.getUint32(pos, true); pos += 4; + while (pos < headerSize) { + var offset = view.getUint32(pos, true); pos += 4; + var size = view.getUint32(pos, true); pos += 4; + var pathLength = view.getUint32(pos, true); pos += 4; + var path = String.fromCharCode.apply(null, data.subarray(pos, pos + pathLength)); pos += pathLength; + for (var folder = 0, folderNext = path.indexOf("/", folder) + 1 ; folderNext > 0; folder = folderNext, folderNext = path.indexOf("/", folder) + 1) + Module["FS_createPath"](path.substring(0, folder), path.substring(folder, folderNext - 1), true, true); + Module["FS_createDataFile"](path, null, data.subarray(offset, offset + size), true, true, true); + } + Module["removeRunDependency"]("processDataJob"); + job.complete(); + + }, + downloadJob: function (Module, job) { + var xhr = job.parameters.objParameters ? new UnityLoader.UnityCache.XMLHttpRequest(job.parameters.objParameters) : new XMLHttpRequest(); + xhr.open("GET", job.parameters.url); + xhr.responseType = "arraybuffer"; + xhr.onload = function () { UnityLoader.Compression.decompress(new Uint8Array(xhr.response), function (decompressed) { job.complete(decompressed) }) }; + if (job.parameters.onprogress) + xhr.addEventListener("progress", job.parameters.onprogress); + if (job.parameters.onload) + xhr.addEventListener("load", job.parameters.onload); + xhr.send(); + + }, + scheduleBuildDownloadJob: function (Module, jobId, urlId) { + UnityLoader.Progress.update(Module, jobId); + UnityLoader.Job.schedule(Module, jobId, [], UnityLoader.downloadJob, { + url: Module.resolveBuildUrl(Module[urlId]), + onprogress: function(e) { UnityLoader.Progress.update(Module, jobId, e); }, + onload: function(e) { UnityLoader.Progress.update(Module, jobId, e); }, + objParameters: Module.companyName && Module.productName && Module.cacheControl && (Module.cacheControl[urlId] || Module.cacheControl["default"]) ? { + companyName: Module.companyName, + productName: Module.productName, + cacheControl: Module.cacheControl[urlId] || Module.cacheControl["default"], + } : null, + }); + + }, + loadModule: function (Module) { + Module.useWasm = Module["wasmCodeUrl"] && UnityLoader.SystemInfo.hasWasm; + + if (Module.useWasm) { + UnityLoader.scheduleBuildDownloadJob(Module, "downloadWasmCode", "wasmCodeUrl"); + UnityLoader.Job.schedule(Module, "processWasmCode", ["downloadWasmCode"], UnityLoader.processWasmCodeJob); + if (Module["wasmMemoryUrl"]) + { + UnityLoader.scheduleBuildDownloadJob(Module, "downloadMemoryInitializer", "wasmMemoryUrl"); + UnityLoader.Job.schedule(Module, "processMemoryInitializer", ["downloadMemoryInitializer"], UnityLoader.processMemoryInitializerJob); + Module["memoryInitializerRequest"] = { addEventListener: function (type, callback) { Module["memoryInitializerRequest"].callback = callback; } } + } + UnityLoader.scheduleBuildDownloadJob(Module, "downloadWasmFramework", "wasmFrameworkUrl"); + UnityLoader.Job.schedule(Module, "processWasmFramework", ["downloadWasmFramework", "processWasmCode", "setupIndexedDB"], UnityLoader.processWasmFrameworkJob); + + } else if (Module["asmCodeUrl"]) { + UnityLoader.scheduleBuildDownloadJob(Module, "downloadAsmCode", "asmCodeUrl"); + UnityLoader.Job.schedule(Module, "processAsmCode", ["downloadAsmCode"], UnityLoader.processAsmCodeJob); + UnityLoader.scheduleBuildDownloadJob(Module, "downloadMemoryInitializer", "asmMemoryUrl"); + UnityLoader.Job.schedule(Module, "processMemoryInitializer", ["downloadMemoryInitializer"], UnityLoader.processMemoryInitializerJob); + Module["memoryInitializerRequest"] = { addEventListener: function (type, callback) { Module["memoryInitializerRequest"].callback = callback; } } + if (Module.asmLibraryUrl) + Module.dynamicLibraries = [Module.asmLibraryUrl].map(Module.resolveBuildUrl); + UnityLoader.scheduleBuildDownloadJob(Module, "downloadAsmFramework", "asmFrameworkUrl"); + UnityLoader.Job.schedule(Module, "processAsmFramework", ["downloadAsmFramework", "processAsmCode", "setupIndexedDB"], UnityLoader.processAsmFrameworkJob); + + } else { + throw "WebAssembly support is not detected in this browser."; + } + + UnityLoader.scheduleBuildDownloadJob(Module, "downloadData", "dataUrl"); + UnityLoader.Job.schedule(Module, "setupIndexedDB", [], UnityLoader.setupIndexedDBJob); + + Module["preRun"].push(function () { + Module["addRunDependency"]("processDataJob"); + UnityLoader.Job.schedule(Module, "processData", ["downloadData"], UnityLoader.processDataJob); + }); + + }, + instantiate: function (container, url, parameters) { + function instantiate(container, gameInstance) { + if (typeof container == "string" && !(container = document.getElementById(container))) + return false; + + container.innerHTML = ""; + container.style.border = container.style.margin = container.style.padding = 0; + if (getComputedStyle(container).getPropertyValue("position") == "static") + container.style.position = "relative"; + container.style.width = gameInstance.width || container.style.width; + container.style.height = gameInstance.height || container.style.height; + gameInstance.container = container; + + var Module = gameInstance.Module; + Module.canvas = document.createElement("canvas"); + Module.canvas.style.width = "100%"; + Module.canvas.style.height = "100%"; + Module.canvas.addEventListener("contextmenu", function (e) { e.preventDefault() }), + Module.canvas.addEventListener("dragstart", function (e) { e.preventDefault() }), + Module.canvas.id = "#canvas"; + container.appendChild(Module.canvas); + + gameInstance.compatibilityCheck(gameInstance, function () { + var xhr = new XMLHttpRequest(); + xhr.open("GET", gameInstance.url, true); + xhr.responseType = "text"; + xhr.onerror = function() { + Module.print("Could not download " + gameInstance.url); + if (document.URL.indexOf("file:") == 0) { + alert ("It seems your browser does not support running Unity WebGL content from file:// urls. Please upload it to an http server, or try a different browser."); + } + } + xhr.onload = function () { + var parameters = JSON.parse(xhr.responseText); + for (var parameter in parameters) { + if (typeof Module[parameter] == "undefined") + Module[parameter] = parameters[parameter]; + } + + var graphicsApiMatch = false; + for(var i = 0; i < Module.graphicsAPI.length; i++) { + var api = Module.graphicsAPI[i]; + if (api == "WebGL 2.0" && UnityLoader.SystemInfo.hasWebGL == 2) { + graphicsApiMatch = true; + } + else if (api == "WebGL 1.0" && UnityLoader.SystemInfo.hasWebGL >= 1) { + graphicsApiMatch = true; + } + else + Module.print("Warning: Unsupported graphics API " + api); + } + if (!graphicsApiMatch) { + gameInstance.popup("Your browser does not support any of the required graphics API for this content: " + Module.graphicsAPI, [{text: "OK"}]); + return; + } + + container.style.background = Module.backgroundUrl ? "center/cover url('" + Module.resolveBuildUrl(Module.backgroundUrl) + "')" : + Module.backgroundColor ? " " + Module.backgroundColor : ""; + + // show loading screen as soon as possible + gameInstance.onProgress(gameInstance, 0.0); + + UnityLoader.loadModule(Module); + } + xhr.send(); + }, function () { + Module.printErr("Instantiation of the '" + url + "' terminated due to the failed compatibility check."); + }); + + return true; + } + + function resolveURL(url) { + resolveURL.link = resolveURL.link || document.createElement("a"); + resolveURL.link.href = url; + return resolveURL.link.href; + } + + var gameInstance = { + url: url, + onProgress: UnityLoader.Progress.handler, + compatibilityCheck: UnityLoader.compatibilityCheck, + Module: { + graphicsAPI: ["WebGL 2.0", "WebGL 1.0"], + onAbort: function(what){ + if (what !== undefined) { + this.print(what); + this.printErr(what); + what = JSON.stringify(what); + } else { + what = ''; + } + throw 'abort(' + what + ') at ' + this.stackTrace(); + }, + preRun: [], + postRun: [], + print: function (message) { console.log(message); }, + printErr: function (message) { console.error(message); }, + Jobs: {}, + buildDownloadProgress: {}, + resolveBuildUrl: function (buildUrl) { return buildUrl.match(/(http|https|ftp|file):\/\//) ? buildUrl : url.substring(0, url.lastIndexOf("/") + 1) + buildUrl; }, + streamingAssetsUrl: function () { return resolveURL(this.resolveBuildUrl("../StreamingAssets")) }, + pthreadMainPrefixURL: "Build/", + }, + SetFullscreen: function() { + if (gameInstance.Module.SetFullscreen) + return gameInstance.Module.SetFullscreen.apply(gameInstance.Module, arguments); + }, + SendMessage: function() { + if (gameInstance.Module.SendMessage) + return gameInstance.Module.SendMessage.apply(gameInstance.Module, arguments); + }, + }; + + gameInstance.Module.gameInstance = gameInstance; + gameInstance.popup = function (message, callbacks) { return UnityLoader.Error.popup(gameInstance, message, callbacks); }; + gameInstance.Module.postRun.push(function() { + gameInstance.onProgress(gameInstance, 1); + }); + + for (var parameter in parameters) { + if (parameter == "Module") { + for (var moduleParameter in parameters[parameter]) + gameInstance.Module[moduleParameter] = parameters[parameter][moduleParameter]; + } else { + gameInstance[parameter] = parameters[parameter]; + } + } + + if (!instantiate(container, gameInstance)) + document.addEventListener("DOMContentLoaded", function () { instantiate(container, gameInstance) }); + + return gameInstance; + + }, + Utils: { + assert: function (condition, text) { + if (!condition) + abort("Assertion failed: " + text); + + }, + optimizeMathFround: function (code, embeddedAsm) { + console.log("optimizing out Math.fround calls"); + + var State = { + LOOKING_FOR_MODULE: 0, + SCANNING_MODULE_VARIABLES: 1, + SCANNING_MODULE_FUNCTIONS: 2, + }; + var stateSwitchMarker = [ + "EMSCRIPTEN_START_ASM", + "EMSCRIPTEN_START_FUNCS", + "EMSCRIPTEN_END_FUNCS", + ]; + var froundPrefix = "var"; + var froundMarker = "global.Math.fround;"; + + var position = 0; + var state = embeddedAsm ? State.LOOKING_FOR_MODULE : State.SCANNING_MODULE_VARIABLES; + var froundLast = 0; + var froundLength = 0; + + for(; state <= State.SCANNING_MODULE_FUNCTIONS && position < code.length; position++) { + if (code[position] == 0x2F && code[position + 1] == 0x2F && code[position + 2] == 0x20 && + String.fromCharCode.apply(null, code.subarray(position + 3, position + 3 + stateSwitchMarker[state].length)) === stateSwitchMarker[state]) { + // if code at position starts with "// " + stateSwitchMarker[state] + state++; + } else if (state == State.SCANNING_MODULE_VARIABLES && !froundLength && code[position] == 0x3D && + String.fromCharCode.apply(null, code.subarray(position + 1, position + 1 + froundMarker.length)) === froundMarker) { + // if we are at the module variable section and Math_fround name has not yet been found and code at position starts with "=" + froundMarker + froundLast = position - 1; + while(code[froundLast - froundLength] != 0x20) + froundLength++; // scan back until the first space character (it is always present as at least it is a part of the previously found "// ") + if (!froundLength || String.fromCharCode.apply(null, code.subarray(froundLast - froundLength - froundPrefix.length, froundLast - froundLength)) !== froundPrefix) + froundLast = froundLength = 0; + } else if (froundLength && code[position] == 0x28) { + // if Math_fround name has been found and code at position starts with "(" + var nameLength = 0; + while (nameLength < froundLength && code[position - 1 - nameLength] == code[froundLast - nameLength]) + nameLength++; + if (nameLength == froundLength) { + var c = code[position - 1 - nameLength]; + if (c < 0x24 || (0x24 < c && c < 0x30) || (0x39 < c && c < 0x41) || (0x5A < c && c < 0x5F) || (0x5F < c && c < 0x61) || 0x7A < c) { + // if the matched Math_fround name is not a suffix of another identifier, i.e. it's preceding character does not match [$0-9A-Z_a-z] + for(;nameLength; nameLength--) + code[position - nameLength] = 0x20; // fill the Math_fround name with spaces (replacement works faster than shifting back the rest of the code) + } + } + } + } + return code; + + }, + + }, + UnityCache: function () { + var UnityCacheDatabase = { name: "UnityCache", version: 2 }; + var XMLHttpRequestStore = { name: "XMLHttpRequest", version: 1 }; + var WebAssemblyStore = { name: "WebAssembly", version: 1 }; + + function log(message) { + console.log("[UnityCache] " + message); + } + + function resolveURL(url) { + resolveURL.link = resolveURL.link || document.createElement("a"); + resolveURL.link.href = url; + return resolveURL.link.href; + } + + function isCrossOriginURL(url) { + var originMatch = window.location.href.match(/^[a-z]+:\/\/[^\/]+/); + return !originMatch || url.lastIndexOf(originMatch[0], 0); + } + + function UnityCache() { + var cache = this; + cache.queue = []; + + function initDatabase(database) { + if (typeof cache.database != "undefined") + return; + cache.database = database; + if (!cache.database) + log("indexedDB database could not be opened"); + while (cache.queue.length) { + var queued = cache.queue.shift(); + if (cache.database) { + cache.execute.apply(cache, queued); + } else if (typeof queued.onerror == "function") { + queued.onerror(new Error("operation cancelled")); + } + } + } + + try { + var indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + function upgradeDatabase() { + var openRequest = indexedDB.open(UnityCacheDatabase.name, UnityCacheDatabase.version); + openRequest.onupgradeneeded = function (e) { + var database = e.target.result; + if (!database.objectStoreNames.contains(WebAssemblyStore.name)) + database.createObjectStore(WebAssemblyStore.name); + }; + openRequest.onsuccess = function (e) { initDatabase(e.target.result); }; + openRequest.onerror = function () { initDatabase(null); }; + } + var openRequest = indexedDB.open(UnityCacheDatabase.name); + openRequest.onupgradeneeded = function (e) { + var objectStore = e.target.result.createObjectStore(XMLHttpRequestStore.name, { keyPath: "url" }); + ["version", "company", "product", "updated", "revalidated", "accessed"].forEach(function (index) { objectStore.createIndex(index, index); }); + }; + openRequest.onsuccess = function (e) { + var database = e.target.result; + if (database.version < UnityCacheDatabase.version) { + database.close(); + upgradeDatabase(); + } else { + initDatabase(database); + } + }; + openRequest.onerror = function () { initDatabase(null); }; + } catch (e) { + initDatabase(null); + } + }; + + UnityCache.prototype.execute = function (store, operation, parameters, onsuccess, onerror) { + if (this.database) { + try { + var target = this.database.transaction([store], ["put", "delete", "clear"].indexOf(operation) != -1 ? "readwrite" : "readonly").objectStore(store); + if (operation == "openKeyCursor") { + target = target.index(parameters[0]); + parameters = parameters.slice(1); + } + var request = target[operation].apply(target, parameters); + if (typeof onsuccess == "function") + request.onsuccess = function (e) { onsuccess(e.target.result); }; + request.onerror = onerror; + } catch (e) { + if (typeof onerror == "function") + onerror(e); + } + } else if (typeof this.database == "undefined") { + this.queue.push(arguments); + } else if (typeof onerror == "function") { + onerror(new Error("indexedDB access denied")); + } + }; + + var unityCache = new UnityCache(); + + function createXMLHttpRequestResult(url, company, product, timestamp, xhr) { + var result = { url: url, version: XMLHttpRequestStore.version, company: company, product: product, updated: timestamp, revalidated: timestamp, accessed: timestamp, responseHeaders: {}, xhr: {} }; + if (xhr) { + ["Last-Modified", "ETag"].forEach(function (header) { result.responseHeaders[header] = xhr.getResponseHeader(header); }); + ["responseURL", "status", "statusText", "response"].forEach(function (property) { result.xhr[property] = xhr[property]; }); + } + return result; + } + + function CachedXMLHttpRequest(objParameters) { + this.cache = { enabled: false }; + if (objParameters) { + this.cache.control = objParameters.cacheControl; + this.cache.company = objParameters.companyName; + this.cache.product = objParameters.productName; + } + this.xhr = new XMLHttpRequest(objParameters); + this.xhr.addEventListener("load", function () { + var xhr = this.xhr, cache = this.cache; + if (!cache.enabled || cache.revalidated) + return; + if (xhr.status == 304) { + cache.result.revalidated = cache.result.accessed; + cache.revalidated = true; + unityCache.execute(XMLHttpRequestStore.name, "put", [cache.result]); + log("'" + cache.result.url + "' successfully revalidated and served from the indexedDB cache"); + } else if (xhr.status == 200) { + cache.result = createXMLHttpRequestResult(cache.result.url, cache.company, cache.product, cache.result.accessed, xhr); + cache.revalidated = true; + unityCache.execute(XMLHttpRequestStore.name, "put", [cache.result], function (result) { + log("'" + cache.result.url + "' successfully downloaded and stored in the indexedDB cache"); + }, function (error) { + log("'" + cache.result.url + "' successfully downloaded but not stored in the indexedDB cache due to the error: " + error); + }); + } else { + log("'" + cache.result.url + "' request failed with status: " + xhr.status + " " + xhr.statusText); + } + }.bind(this)); + }; + + CachedXMLHttpRequest.prototype.send = function (data) { + var xhr = this.xhr, cache = this.cache; + var sendArguments = arguments; + cache.enabled = cache.enabled && xhr.responseType == "arraybuffer" && !data; + if (!cache.enabled) + return xhr.send.apply(xhr, sendArguments); + unityCache.execute(XMLHttpRequestStore.name, "get", [cache.result.url], function (result) { + if (!result || result.version != XMLHttpRequestStore.version) { + xhr.send.apply(xhr, sendArguments); + return; + } + cache.result = result; + cache.result.accessed = Date.now(); + if (cache.control == "immutable") { + cache.revalidated = true; + unityCache.execute(XMLHttpRequestStore.name, "put", [cache.result]); + xhr.dispatchEvent(new Event('load')); + log("'" + cache.result.url + "' served from the indexedDB cache without revalidation"); + } else if (isCrossOriginURL(cache.result.url) && (cache.result.responseHeaders["Last-Modified"] || cache.result.responseHeaders["ETag"])) { + var headXHR = new XMLHttpRequest(); + headXHR.open("HEAD", cache.result.url); + headXHR.onload = function () { + cache.revalidated = ["Last-Modified", "ETag"].every(function (header) { + return !cache.result.responseHeaders[header] || cache.result.responseHeaders[header] == headXHR.getResponseHeader(header); + }); + if (cache.revalidated) { + cache.result.revalidated = cache.result.accessed; + unityCache.execute(XMLHttpRequestStore.name, "put", [cache.result]); + xhr.dispatchEvent(new Event('load')); + log("'" + cache.result.url + "' successfully revalidated and served from the indexedDB cache"); + } else { + xhr.send.apply(xhr, sendArguments); + } + } + headXHR.send(); + } else { + if (cache.result.responseHeaders["Last-Modified"]) { + xhr.setRequestHeader("If-Modified-Since", cache.result.responseHeaders["Last-Modified"]); + xhr.setRequestHeader("Cache-Control", "no-cache"); + } else if (cache.result.responseHeaders["ETag"]) { + xhr.setRequestHeader("If-None-Match", cache.result.responseHeaders["ETag"]); + xhr.setRequestHeader("Cache-Control", "no-cache"); + } + xhr.send.apply(xhr, sendArguments); + } + }, function (error) { + xhr.send.apply(xhr, sendArguments); + }); + }; + + CachedXMLHttpRequest.prototype.open = function (method, url, async, user, password) { + this.cache.result = createXMLHttpRequestResult(resolveURL(url), this.cache.company, this.cache.product, Date.now()); + this.cache.enabled = ["must-revalidate", "immutable"].indexOf(this.cache.control) != -1 && method == "GET" && this.cache.result.url.match("^https?:\/\/") + && (typeof async == "undefined" || async) && typeof user == "undefined" && typeof password == "undefined"; + this.cache.revalidated = false; + return this.xhr.open.apply(this.xhr, arguments); + }; + + CachedXMLHttpRequest.prototype.setRequestHeader = function (header, value) { + this.cache.enabled = false; + return this.xhr.setRequestHeader.apply(this.xhr, arguments); + }; + + var xhr = new XMLHttpRequest(); + for (var property in xhr) { + if (!CachedXMLHttpRequest.prototype.hasOwnProperty(property)) { + (function (property) { + Object.defineProperty(CachedXMLHttpRequest.prototype, property, typeof xhr[property] == "function" ? { + value: function () { return this.xhr[property].apply(this.xhr, arguments); }, + } : { + get: function () { return this.cache.revalidated && this.cache.result.xhr.hasOwnProperty(property) ? this.cache.result.xhr[property] : this.xhr[property]; }, + set: function (value) { this.xhr[property] = value; }, + }); + })(property); + } + } + + return { + XMLHttpRequest: CachedXMLHttpRequest, + WebAssembly: { + get: function (url, callback) { + var base = { url: resolveURL(url), version: WebAssemblyStore.version, module: null, md5: null }; + unityCache.execute(WebAssemblyStore.name, "get", [base.url], function (result) { + callback(result && result.version == WebAssemblyStore.version ? result : base); + }, function () { + callback(base); + }); + }, + put: function (result, onsuccess, onerror) { + unityCache.execute(WebAssemblyStore.name, "put", [result, result.url], onsuccess, onerror); + }, + }, + }; + } (), + +}; diff --git a/RPG/Build/Build/TemplateData/UnityProgress.js b/RPG/Build/Build/TemplateData/UnityProgress.js new file mode 100644 index 0000000..1ed4372 --- /dev/null +++ b/RPG/Build/Build/TemplateData/UnityProgress.js @@ -0,0 +1,24 @@ +function UnityProgress(gameInstance, progress) { + if (!gameInstance.Module) + return; + if (!gameInstance.logo) { + gameInstance.logo = document.createElement("div"); + gameInstance.logo.className = "logo " + gameInstance.Module.splashScreenStyle; + gameInstance.container.appendChild(gameInstance.logo); + } + if (!gameInstance.progress) { + gameInstance.progress = document.createElement("div"); + gameInstance.progress.className = "progress " + gameInstance.Module.splashScreenStyle; + gameInstance.progress.empty = document.createElement("div"); + gameInstance.progress.empty.className = "empty"; + gameInstance.progress.appendChild(gameInstance.progress.empty); + gameInstance.progress.full = document.createElement("div"); + gameInstance.progress.full.className = "full"; + gameInstance.progress.appendChild(gameInstance.progress.full); + gameInstance.container.appendChild(gameInstance.progress); + } + gameInstance.progress.full.style.width = (100 * progress) + "%"; + gameInstance.progress.empty.style.width = (100 * (1 - progress)) + "%"; + if (progress == 1) + gameInstance.logo.style.display = gameInstance.progress.style.display = "none"; +} \ No newline at end of file diff --git a/RPG/Build/Build/TemplateData/favicon.ico b/RPG/Build/Build/TemplateData/favicon.ico new file mode 100644 index 0000000..dd6bf7e Binary files /dev/null and b/RPG/Build/Build/TemplateData/favicon.ico differ diff --git a/RPG/Build/Build/TemplateData/fullscreen.png b/RPG/Build/Build/TemplateData/fullscreen.png new file mode 100644 index 0000000..22cfc35 Binary files /dev/null and b/RPG/Build/Build/TemplateData/fullscreen.png differ diff --git a/RPG/Build/Build/TemplateData/progressEmpty.Dark.png b/RPG/Build/Build/TemplateData/progressEmpty.Dark.png new file mode 100644 index 0000000..eff4730 Binary files /dev/null and b/RPG/Build/Build/TemplateData/progressEmpty.Dark.png differ diff --git a/RPG/Build/Build/TemplateData/progressEmpty.Light.png b/RPG/Build/Build/TemplateData/progressEmpty.Light.png new file mode 100644 index 0000000..b428ec4 Binary files /dev/null and b/RPG/Build/Build/TemplateData/progressEmpty.Light.png differ diff --git a/RPG/Build/Build/TemplateData/progressFull.Dark.png b/RPG/Build/Build/TemplateData/progressFull.Dark.png new file mode 100644 index 0000000..3e5c8a0 Binary files /dev/null and b/RPG/Build/Build/TemplateData/progressFull.Dark.png differ diff --git a/RPG/Build/Build/TemplateData/progressFull.Light.png b/RPG/Build/Build/TemplateData/progressFull.Light.png new file mode 100644 index 0000000..0064427 Binary files /dev/null and b/RPG/Build/Build/TemplateData/progressFull.Light.png differ diff --git a/RPG/Build/Build/TemplateData/progressLogo.Dark.png b/RPG/Build/Build/TemplateData/progressLogo.Dark.png new file mode 100644 index 0000000..c15fb23 Binary files /dev/null and b/RPG/Build/Build/TemplateData/progressLogo.Dark.png differ diff --git a/RPG/Build/Build/TemplateData/progressLogo.Light.png b/RPG/Build/Build/TemplateData/progressLogo.Light.png new file mode 100644 index 0000000..cdd4f74 Binary files /dev/null and b/RPG/Build/Build/TemplateData/progressLogo.Light.png differ diff --git a/RPG/Build/Build/TemplateData/style.css b/RPG/Build/Build/TemplateData/style.css new file mode 100644 index 0000000..1283de4 --- /dev/null +++ b/RPG/Build/Build/TemplateData/style.css @@ -0,0 +1,18 @@ +.webgl-content * {border: 0; margin: 0; padding: 0} +.webgl-content {position: absolute; top: 50%; left: 50%; -webkit-transform: translate(-50%, -50%); transform: translate(-50%, -50%);} + +.webgl-content .logo, .progress {position: absolute; left: 50%; top: 50%; -webkit-transform: translate(-50%, -50%); transform: translate(-50%, -50%);} +.webgl-content .logo {background: url('progressLogo.Light.png') no-repeat center / contain; width: 154px; height: 130px;} +.webgl-content .progress {height: 18px; width: 141px; margin-top: 90px;} +.webgl-content .progress .empty {background: url('progressEmpty.Light.png') no-repeat right / cover; float: right; width: 100%; height: 100%; display: inline-block;} +.webgl-content .progress .full {background: url('progressFull.Light.png') no-repeat left / cover; float: left; width: 0%; height: 100%; display: inline-block;} + +.webgl-content .logo.Dark {background-image: url('progressLogo.Dark.png');} +.webgl-content .progress.Dark .empty {background-image: url('progressEmpty.Dark.png');} +.webgl-content .progress.Dark .full {background-image: url('progressFull.Dark.png');} + +.webgl-content .footer {margin-top: 5px; height: 38px; line-height: 38px; font-family: Helvetica, Verdana, Arial, sans-serif; font-size: 18px;} +.webgl-content .footer .webgl-logo, .title, .fullscreen {height: 100%; display: inline-block; background: transparent center no-repeat;} +.webgl-content .footer .webgl-logo {background-image: url('webgl-logo.png'); width: 204px; float: left;} +.webgl-content .footer .title {margin-right: 10px; float: right;} +.webgl-content .footer .fullscreen {background-image: url('fullscreen.png'); width: 38px; float: right;} diff --git a/RPG/Build/Build/TemplateData/webgl-logo.png b/RPG/Build/Build/TemplateData/webgl-logo.png new file mode 100644 index 0000000..8af9ba6 Binary files /dev/null and b/RPG/Build/Build/TemplateData/webgl-logo.png differ diff --git a/RPG/Build/Build/index.html b/RPG/Build/Build/index.html new file mode 100644 index 0000000..85c9e6c --- /dev/null +++ b/RPG/Build/Build/index.html @@ -0,0 +1,25 @@ + + + + + + Unity WebGL Player | RPG + + + + + + + +
+
+
+ +
+
RPG
+
+
+ + diff --git a/RPG/ProjectSettings/EditorBuildSettings.asset b/RPG/ProjectSettings/EditorBuildSettings.asset index 319ac9a..6ced9ca 100644 --- a/RPG/ProjectSettings/EditorBuildSettings.asset +++ b/RPG/ProjectSettings/EditorBuildSettings.asset @@ -39,11 +39,14 @@ EditorBuildSettings: path: Assets/Scenes/2D_3B.unity guid: 15bbe7047c00f1f4ca994b7fdf9b25d5 - enabled: 1 - path: Assets/Scenes/2D_4.unity + path: Assets/Scenes/Blank.unity guid: 2e837f765ac414a489153bdbf94cdc00 - enabled: 1 path: Assets/Scenes/2D_4Battle.unity guid: 00647b6d9c0291f4aae30472917a59b1 + - enabled: 1 + path: Assets/Scenes/Winner.unity + guid: eef6707da05321e478b84a5b8460b255 - enabled: 1 path: Assets/Scenes/GameOver.unity guid: b08fde3ce47079c4bbf412c75a623d7d diff --git a/RPG/ProjectSettings/TagManager.asset b/RPG/ProjectSettings/TagManager.asset index 45097b4..af860a3 100644 --- a/RPG/ProjectSettings/TagManager.asset +++ b/RPG/ProjectSettings/TagManager.asset @@ -15,6 +15,7 @@ TagManager: - Yourself - Cube3 - CubeBattle + - Blank layers: - Default - TransparentFX