| var Module = typeof Module != "undefined" ? Module : {};
|
| var ENVIRONMENT_IS_WEB = !!globalThis.window;
|
| var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
|
| var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
|
| if (!Module["expectedDataFileDownloads"]) Module["expectedDataFileDownloads"] = 0;
|
| Module["expectedDataFileDownloads"]++;
|
| var arguments_ = [];
|
| var thisProgram = "./this.program";
|
| var quit_ = (status, toThrow) => {
|
| throw toThrow
|
| };
|
| var _scriptName = globalThis.document?.currentScript?.src;
|
| if (typeof __filename != "undefined") {
|
| _scriptName = __filename
|
| } else if (ENVIRONMENT_IS_WORKER) {
|
| _scriptName = self.location.href
|
| }
|
| var scriptDirectory = "";
|
|
|
| function locateFile(path) {
|
| if (Module["locateFile"]) {
|
| return Module["locateFile"](path, scriptDirectory)
|
| }
|
| return scriptDirectory + path
|
| }
|
| var readAsync, readBinary;
|
| if (ENVIRONMENT_IS_NODE) {
|
| var fs = require("fs");
|
| scriptDirectory = __dirname + "/";
|
| readBinary = filename => {
|
| filename = isFileURI(filename) ? new URL(filename) : filename;
|
| var ret = fs.readFileSync(filename);
|
| return ret
|
| };
|
| readAsync = async (filename, binary = true) => {
|
| filename = isFileURI(filename) ? new URL(filename) : filename;
|
| var ret = fs.readFileSync(filename, binary ? undefined : "utf8");
|
| return ret
|
| };
|
| if (process.argv.length > 1) {
|
| thisProgram = process.argv[1].replace(/\\/g, "/")
|
| }
|
| arguments_ = process.argv.slice(2);
|
| if (typeof module != "undefined") {
|
| module["exports"] = Module
|
| }
|
| quit_ = (status, toThrow) => {
|
| process.exitCode = status;
|
| throw toThrow
|
| }
|
| } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
|
| try {
|
| scriptDirectory = new URL(".", _scriptName).href
|
| } catch {} {
|
| if (ENVIRONMENT_IS_WORKER) {
|
| readBinary = url => {
|
| var xhr = new XMLHttpRequest;
|
| xhr.open("GET", url, false);
|
| xhr.responseType = "arraybuffer";
|
| xhr.send(null);
|
| return new Uint8Array(xhr.response)
|
| }
|
| }
|
| readAsync = async url => {
|
| if (isFileURI(url)) {
|
| return new Promise((resolve, reject) => {
|
| var xhr = new XMLHttpRequest;
|
| xhr.open("GET", url, true);
|
| xhr.responseType = "arraybuffer";
|
| xhr.onload = () => {
|
| if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
|
| resolve(xhr.response);
|
| return
|
| }
|
| reject(xhr.status)
|
| };
|
| xhr.onerror = reject;
|
| xhr.send(null)
|
| })
|
| }
|
| var response = await fetch(url, {
|
| credentials: "same-origin"
|
| });
|
| if (response.ok) {
|
| return response.arrayBuffer()
|
| }
|
| throw new Error(response.status + " : " + response.url)
|
| }
|
| }
|
| } else {}
|
| var out = console.log.bind(console);
|
| var err = console.error.bind(console);
|
| var wasmBinary;
|
| var ABORT = false;
|
| var EXITSTATUS;
|
| var isFileURI = filename => filename.startsWith("file://");
|
| var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
|
| var HEAP64, HEAPU64;
|
| var runtimeInitialized = false;
|
|
|
| function updateMemoryViews() {
|
| var b = wasmMemory.buffer;
|
| HEAP8 = new Int8Array(b);
|
| HEAP16 = new Int16Array(b);
|
| HEAPU8 = new Uint8Array(b);
|
| HEAPU16 = new Uint16Array(b);
|
| HEAP32 = new Int32Array(b);
|
| HEAPU32 = new Uint32Array(b);
|
| HEAPF32 = new Float32Array(b);
|
| HEAPF64 = new Float64Array(b);
|
| HEAP64 = new BigInt64Array(b);
|
| HEAPU64 = new BigUint64Array(b)
|
| }
|
|
|
| function preRun() {
|
| if (Module["preRun"]) {
|
| if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
|
| while (Module["preRun"].length) {
|
| addOnPreRun(Module["preRun"].shift())
|
| }
|
| }
|
| callRuntimeCallbacks(onPreRuns)
|
| }
|
|
|
| function initRuntime() {
|
| FS.createPreloadedFile = FS_createPreloadedFile;
|
| FS.preloadFile = FS_preloadFile;
|
| if (window.initGLFrame) window.initGLFrame();
|
| Fetch.init();
|
| runtimeInitialized = true;
|
| TTY.init();
|
| wasmExports["xk"]();
|
| FS.ignorePermissions = false
|
| }
|
|
|
| function preMain() {}
|
|
|
| function postRun() {
|
| if (Module["postRun"]) {
|
| if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
|
| while (Module["postRun"].length) {
|
| addOnPostRun(Module["postRun"].shift())
|
| }
|
| }
|
| callRuntimeCallbacks(onPostRuns)
|
| }
|
| abort = function(what) {
|
| Module["onAbort"]?.(what);
|
| what = "Aborted(" + what + ")";
|
| err(what);
|
| ABORT = true;
|
| what += ". Build with -sASSERTIONS for more info.";
|
| var e = new WebAssembly.RuntimeError(what);
|
| throw e
|
| };
|
| var wasmBinaryFile;
|
|
|
| function findWasmBinary() {
|
| return locateFile("index.wasm")
|
| }
|
|
|
| function getBinarySync(file) {
|
| if (file == wasmBinaryFile && wasmBinary) {
|
| return new Uint8Array(wasmBinary)
|
| }
|
| if (readBinary) {
|
| return readBinary(file)
|
| }
|
| throw "both async and sync fetching of the wasm failed"
|
| }
|
| async function getWasmBinary(binaryFile) {
|
| if (!wasmBinary) {
|
| try {
|
| var response = await readAsync(binaryFile);
|
| return new Uint8Array(response)
|
| } catch {}
|
| }
|
| return getBinarySync(binaryFile)
|
| }
|
| async function instantiateArrayBuffer(binaryFile, imports) {
|
| try {
|
| var binary = await getWasmBinary(binaryFile);
|
| var instance = await WebAssembly.instantiate(binary, imports);
|
| return instance
|
| } catch (reason) {
|
| err(`failed to asynchronously prepare wasm: ${reason}`);
|
| abort(reason)
|
| }
|
| }
|
| async function instantiateAsync(binary, binaryFile, imports) {
|
| if (!binary && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
|
| try {
|
| var response = fetch(binaryFile, {
|
| credentials: "same-origin"
|
| });
|
| var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
|
| return instantiationResult
|
| } catch (reason) {
|
| err(`wasm streaming compile failed: ${reason}`);
|
| err("falling back to ArrayBuffer instantiation")
|
| }
|
| }
|
| return instantiateArrayBuffer(binaryFile, imports)
|
| }
|
|
|
| function getWasmImports() {
|
| initDependencies();
|
| var imports = {
|
| a: wasmImports
|
| };
|
| return imports
|
| }
|
| async function createWasm() {
|
| function receiveInstance(instance, module) {
|
| wasmExports = instance.exports;
|
| assignWasmExports(wasmExports);
|
| updateMemoryViews();
|
| removeRunDependency("wasm-instantiate");
|
| return wasmExports
|
| }
|
| addRunDependency("wasm-instantiate");
|
|
|
| function receiveInstantiationResult(result) {
|
| return receiveInstance(result["instance"])
|
| }
|
| var info = getWasmImports();
|
| if (Module["instantiateWasm"]) {
|
| return new Promise((resolve, reject) => {
|
| Module["instantiateWasm"](info, (inst, mod) => {
|
| resolve(receiveInstance(inst, mod))
|
| })
|
| })
|
| }
|
| wasmBinaryFile ??= findWasmBinary();
|
| var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
|
| var exports = receiveInstantiationResult(result);
|
| return exports
|
| }
|
| class ExitStatus {
|
| name = "ExitStatus";
|
| constructor(status) {
|
| this.message = `Program terminated with exit(${status})`;
|
| this.status = status
|
| }
|
| }
|
| var callRuntimeCallbacks = callbacks => {
|
| while (callbacks.length > 0) {
|
| callbacks.shift()(Module)
|
| }
|
| };
|
| var onPostRuns = [];
|
| var addOnPostRun = cb => onPostRuns.push(cb);
|
| var onPreRuns = [];
|
| var addOnPreRun = cb => onPreRuns.push(cb);
|
| var runDependencies = 0;
|
| var dependenciesFulfilled = null;
|
| var removeRunDependency = id => {
|
| runDependencies--;
|
| Module["monitorRunDependencies"]?.(runDependencies);
|
| if (runDependencies == 0) {
|
| if (dependenciesFulfilled) {
|
| var callback = dependenciesFulfilled;
|
| dependenciesFulfilled = null;
|
| callback()
|
| }
|
| }
|
| };
|
| var addRunDependency = id => {
|
| runDependencies++;
|
| Module["monitorRunDependencies"]?.(runDependencies)
|
| };
|
| var noExitRuntime = true;
|
|
|
| function setValue(ptr, value, type = "i8") {
|
| if (type.endsWith("*")) type = "*";
|
| switch (type) {
|
| case "i1":
|
| HEAP8[ptr] = value;
|
| break;
|
| case "i8":
|
| HEAP8[ptr] = value;
|
| break;
|
| case "i16":
|
| HEAP16[ptr >> 1] = value;
|
| break;
|
| case "i32":
|
| HEAP32[ptr >> 2] = value;
|
| break;
|
| case "i64":
|
| HEAP64[ptr >> 3] = BigInt(value);
|
| break;
|
| case "float":
|
| HEAPF32[ptr >> 2] = value;
|
| break;
|
| case "double":
|
| HEAPF64[ptr >> 3] = value;
|
| break;
|
| case "*":
|
| HEAPU32[ptr >> 2] = value;
|
| break;
|
| default:
|
| abort(`invalid type for setValue: ${type}`)
|
| }
|
| }
|
| var stackRestore = val => __emscripten_stack_restore(val);
|
| var stackSave = () => _emscripten_stack_get_current();
|
| var exceptionCaught = [];
|
| var uncaughtExceptionCount = 0;
|
| var ___cxa_begin_catch = ptr => {
|
| var info = new ExceptionInfo(ptr);
|
| if (!info.get_caught()) {
|
| info.set_caught(true);
|
| uncaughtExceptionCount--
|
| }
|
| info.set_rethrown(false);
|
| exceptionCaught.push(info);
|
| ___cxa_increment_exception_refcount(ptr);
|
| return ___cxa_get_exception_ptr(ptr)
|
| };
|
| var exceptionLast = 0;
|
| var ___cxa_end_catch = () => {
|
| _setThrew(0, 0);
|
| var info = exceptionCaught.pop();
|
| ___cxa_decrement_exception_refcount(info.excPtr);
|
| exceptionLast = 0
|
| };
|
| class ExceptionInfo {
|
| constructor(excPtr) {
|
| this.excPtr = excPtr;
|
| this.ptr = excPtr - 24
|
| }
|
| set_type(type) {
|
| HEAPU32[this.ptr + 4 >> 2] = type
|
| }
|
| get_type() {
|
| return HEAPU32[this.ptr + 4 >> 2]
|
| }
|
| set_destructor(destructor) {
|
| HEAPU32[this.ptr + 8 >> 2] = destructor
|
| }
|
| get_destructor() {
|
| return HEAPU32[this.ptr + 8 >> 2]
|
| }
|
| set_caught(caught) {
|
| caught = caught ? 1 : 0;
|
| HEAP8[this.ptr + 12] = caught
|
| }
|
| get_caught() {
|
| return HEAP8[this.ptr + 12] != 0
|
| }
|
| set_rethrown(rethrown) {
|
| rethrown = rethrown ? 1 : 0;
|
| HEAP8[this.ptr + 13] = rethrown
|
| }
|
| get_rethrown() {
|
| return HEAP8[this.ptr + 13] != 0
|
| }
|
| init(type, destructor) {
|
| this.set_adjusted_ptr(0);
|
| this.set_type(type);
|
| this.set_destructor(destructor)
|
| }
|
| set_adjusted_ptr(adjustedPtr) {
|
| HEAPU32[this.ptr + 16 >> 2] = adjustedPtr
|
| }
|
| get_adjusted_ptr() {
|
| return HEAPU32[this.ptr + 16 >> 2]
|
| }
|
| }
|
| var setTempRet0 = val => __emscripten_tempret_set(val);
|
| var findMatchingCatch = args => {
|
| var thrown = exceptionLast;
|
| if (!thrown) {
|
| setTempRet0(0);
|
| return 0
|
| }
|
| var info = new ExceptionInfo(thrown);
|
| info.set_adjusted_ptr(thrown);
|
| var thrownType = info.get_type();
|
| if (!thrownType) {
|
| setTempRet0(0);
|
| return thrown
|
| }
|
| for (var caughtType of args) {
|
| if (caughtType === 0 || caughtType === thrownType) {
|
| break
|
| }
|
| var adjusted_ptr_addr = info.ptr + 16;
|
| if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
|
| setTempRet0(caughtType);
|
| return thrown
|
| }
|
| }
|
| setTempRet0(thrownType);
|
| return thrown
|
| };
|
| var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
|
| var ___cxa_find_matching_catch_3 = arg0 => findMatchingCatch([arg0]);
|
| var ___cxa_rethrow = () => {
|
| var info = exceptionCaught.pop();
|
| if (!info) {
|
| abort("no exception to throw")
|
| }
|
| var ptr = info.excPtr;
|
| if (!info.get_rethrown()) {
|
| exceptionCaught.push(info);
|
| info.set_rethrown(true);
|
| info.set_caught(false);
|
| uncaughtExceptionCount++
|
| }
|
| exceptionLast = ptr;
|
| throw exceptionLast
|
| };
|
| var ___cxa_throw = (ptr, type, destructor) => {
|
| var info = new ExceptionInfo(ptr);
|
| info.init(type, destructor);
|
| exceptionLast = ptr;
|
| uncaughtExceptionCount++;
|
| throw exceptionLast
|
| };
|
| var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
|
| var ___resumeException = ptr => {
|
| if (!exceptionLast) {
|
| exceptionLast = ptr
|
| }
|
| throw exceptionLast
|
| };
|
| var __abort_js = () => abort("");
|
| var INT53_MAX = 9007199254740992;
|
| var INT53_MIN = -9007199254740992;
|
| var bigintToI53Checked = num => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
|
|
|
| function __gmtime_js(time, tmPtr) {
|
| time = bigintToI53Checked(time);
|
| var date = new Date(time * 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();
|
| 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
|
| }
|
| var isLeapYear = year => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
|
| var MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
|
| var MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
|
| var ydayFromDate = date => {
|
| var leap = isLeapYear(date.getFullYear());
|
| var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
|
| var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
|
| return yday
|
| };
|
|
|
| function __localtime_js(time, tmPtr) {
|
| time = bigintToI53Checked(time);
|
| var date = new Date(time * 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 yday = ydayFromDate(date) | 0;
|
| HEAP32[tmPtr + 28 >> 2] = yday;
|
| HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60);
|
| var start = new Date(date.getFullYear(), 0, 1);
|
| var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
|
| var winterOffset = start.getTimezoneOffset();
|
| var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
|
| HEAP32[tmPtr + 32 >> 2] = dst
|
| }
|
| var __mktime_js = function(tmPtr) {
|
| var ret = (() => {
|
| 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(date.getFullYear(), 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 = ydayFromDate(date) | 0;
|
| HEAP32[tmPtr + 28 >> 2] = yday;
|
| 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.getYear();
|
| var timeMs = date.getTime();
|
| if (isNaN(timeMs)) {
|
| return -1
|
| }
|
| return timeMs / 1e3
|
| })();
|
| return BigInt(ret)
|
| };
|
| var __tzset_js = (timezone, daylight, std_name, dst_name) => {
|
| var currentYear = (new Date).getFullYear();
|
| var winter = new Date(currentYear, 0, 1);
|
| var summer = new Date(currentYear, 6, 1);
|
| var winterOffset = winter.getTimezoneOffset();
|
| var summerOffset = summer.getTimezoneOffset();
|
| var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
|
| HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
|
| HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
|
| var extractZone = timezoneOffset => {
|
| var sign = timezoneOffset >= 0 ? "-" : "+";
|
| var absOffset = Math.abs(timezoneOffset);
|
| var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
|
| var minutes = String(absOffset % 60).padStart(2, "0");
|
| return `UTC${sign}${hours}${minutes}`
|
| };
|
| var winterName = extractZone(winterOffset);
|
| var summerName = extractZone(summerOffset);
|
| if (summerOffset < winterOffset) {
|
| stringToUTF8(winterName, std_name, 17);
|
| stringToUTF8(summerName, dst_name, 17)
|
| } else {
|
| stringToUTF8(winterName, dst_name, 17);
|
| stringToUTF8(summerName, std_name, 17)
|
| }
|
| };
|
| var _emscripten_set_main_loop_timing = (mode, value) => {
|
| MainLoop.timingMode = mode;
|
| MainLoop.timingValue = value;
|
| if (!MainLoop.func) {
|
| return 1
|
| }
|
| if (!MainLoop.running) {
|
| MainLoop.running = true
|
| }
|
| if (mode == 0) {
|
| MainLoop.scheduler = function MainLoop_scheduler_setTimeout() {
|
| var timeUntilNextTick = Math.max(0, MainLoop.tickStartTime + value - _emscripten_get_now()) | 0;
|
| setTimeout(MainLoop.runner, timeUntilNextTick)
|
| };
|
| MainLoop.method = "timeout"
|
| } else if (mode == 1) {
|
| MainLoop.scheduler = function MainLoop_scheduler_rAF() {
|
| MainLoop.requestAnimationFrame(MainLoop.runner)
|
| };
|
| MainLoop.method = "rAF"
|
| } else if (mode == 2) {
|
| if (!MainLoop.setImmediate) {
|
| if (globalThis.setImmediate) {
|
| MainLoop.setImmediate = setImmediate
|
| } else {
|
| var setImmediates = [];
|
| var emscriptenMainLoopMessageId = "setimmediate";
|
| var MainLoop_setImmediate_messageHandler = event => {
|
| if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) {
|
| event.stopPropagation();
|
| setImmediates.shift()()
|
| }
|
| };
|
| addEventListener("message", MainLoop_setImmediate_messageHandler, true);
|
| MainLoop.setImmediate = func => {
|
| setImmediates.push(func);
|
| if (ENVIRONMENT_IS_WORKER) {
|
| Module["setImmediates"] ??= [];
|
| Module["setImmediates"].push(func);
|
| postMessage({
|
| target: emscriptenMainLoopMessageId
|
| })
|
| } else postMessage(emscriptenMainLoopMessageId, "*")
|
| }
|
| }
|
| }
|
| MainLoop.scheduler = function MainLoop_scheduler_setImmediate() {
|
| MainLoop.setImmediate(MainLoop.runner)
|
| };
|
| MainLoop.method = "immediate"
|
| }
|
| return 0
|
| };
|
| var _emscripten_get_now = () => performance.now();
|
| var runtimeKeepaliveCounter = 0;
|
| var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
|
| var _proc_exit = code => {
|
| EXITSTATUS = code;
|
| if (!keepRuntimeAlive()) {
|
| Module["onExit"]?.(code);
|
| ABORT = true
|
| }
|
| quit_(code, new ExitStatus(code))
|
| };
|
| var exitJS = (status, implicit) => {
|
| EXITSTATUS = status;
|
| _proc_exit(status)
|
| };
|
| var _exit = exitJS;
|
| var handleException = e => {
|
| if (e instanceof ExitStatus || e == "unwind") {
|
| return EXITSTATUS
|
| }
|
| quit_(1, e)
|
| };
|
| var maybeExit = () => {
|
| if (!keepRuntimeAlive()) {
|
| try {
|
| _exit(EXITSTATUS)
|
| } catch (e) {
|
| handleException(e)
|
| }
|
| }
|
| };
|
| var setMainLoop = (iterFunc, fps, simulateInfiniteLoop, arg, noSetTiming) => {
|
| MainLoop.func = iterFunc;
|
| MainLoop.arg = arg;
|
| var thisMainLoopId = MainLoop.currentlyRunningMainloop;
|
|
|
| function checkIsRunning() {
|
| if (thisMainLoopId < MainLoop.currentlyRunningMainloop) {
|
| maybeExit();
|
| return false
|
| }
|
| return true
|
| }
|
| MainLoop.running = false;
|
| MainLoop.runner = function MainLoop_runner() {
|
| if (ABORT) return;
|
| if (MainLoop.queue.length > 0) {
|
| var start = Date.now();
|
| var blocker = MainLoop.queue.shift();
|
| blocker.func(blocker.arg);
|
| if (MainLoop.remainingBlockers) {
|
| var remaining = MainLoop.remainingBlockers;
|
| var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
|
| if (blocker.counted) {
|
| MainLoop.remainingBlockers = next
|
| } else {
|
| next = next + .5;
|
| MainLoop.remainingBlockers = (8 * remaining + next) / 9
|
| }
|
| }
|
| MainLoop.updateStatus();
|
| if (!checkIsRunning()) return;
|
| setTimeout(MainLoop.runner, 0);
|
| return
|
| }
|
| if (!checkIsRunning()) return;
|
| MainLoop.currentFrameNumber = MainLoop.currentFrameNumber + 1 | 0;
|
| if (MainLoop.timingMode == 1 && MainLoop.timingValue > 1 && MainLoop.currentFrameNumber % MainLoop.timingValue != 0) {
|
| MainLoop.scheduler();
|
| return
|
| } else if (MainLoop.timingMode == 0) {
|
| MainLoop.tickStartTime = _emscripten_get_now()
|
| }
|
| MainLoop.runIter(iterFunc);
|
| if (!checkIsRunning()) return;
|
| MainLoop.scheduler()
|
| };
|
| if (!noSetTiming) {
|
| if (fps > 0) {
|
| _emscripten_set_main_loop_timing(0, 1e3 / fps)
|
| } else {
|
| _emscripten_set_main_loop_timing(1, 1)
|
| }
|
| MainLoop.scheduler()
|
| }
|
| if (simulateInfiniteLoop) {
|
| throw "unwind"
|
| }
|
| };
|
| var callUserCallback = func => {
|
| if (ABORT) {
|
| return
|
| }
|
| try {
|
| func();
|
| maybeExit()
|
| } catch (e) {
|
| handleException(e)
|
| }
|
| };
|
| var MainLoop = {
|
| running: false,
|
| scheduler: null,
|
| method: "",
|
| currentlyRunningMainloop: 0,
|
| func: null,
|
| arg: 0,
|
| timingMode: 0,
|
| timingValue: 0,
|
| currentFrameNumber: 0,
|
| queue: [],
|
| preMainLoop: [],
|
| postMainLoop: [],
|
| pause() {
|
| MainLoop.scheduler = null;
|
| MainLoop.currentlyRunningMainloop++
|
| },
|
| resume() {
|
| MainLoop.currentlyRunningMainloop++;
|
| var timingMode = MainLoop.timingMode;
|
| var timingValue = MainLoop.timingValue;
|
| var func = MainLoop.func;
|
| MainLoop.func = null;
|
| setMainLoop(func, 0, false, MainLoop.arg, true);
|
| _emscripten_set_main_loop_timing(timingMode, timingValue);
|
| MainLoop.scheduler()
|
| },
|
| updateStatus() {
|
| if (Module["setStatus"]) {
|
| var message = Module["statusMessage"] || "Please wait...";
|
| var remaining = MainLoop.remainingBlockers ?? 0;
|
| var expected = MainLoop.expectedBlockers ?? 0;
|
| if (remaining) {
|
| if (remaining < expected) {
|
| Module["setStatus"](`{message} ({expected - remaining}/{expected})`)
|
| } else {
|
| Module["setStatus"](message)
|
| }
|
| } else {
|
| Module["setStatus"]("")
|
| }
|
| }
|
| },
|
| init() {
|
| Module["preMainLoop"] && MainLoop.preMainLoop.push(Module["preMainLoop"]);
|
| Module["postMainLoop"] && MainLoop.postMainLoop.push(Module["postMainLoop"])
|
| },
|
| runIter(func) {
|
| if (ABORT) return;
|
| for (var pre of MainLoop.preMainLoop) {
|
| if (pre() === false) {
|
| return
|
| }
|
| }
|
| callUserCallback(func);
|
| for (var post of MainLoop.postMainLoop) {
|
| post()
|
| }
|
| },
|
| nextRAF: 0,
|
| fakeRequestAnimationFrame(func) {
|
| var now = Date.now();
|
| if (MainLoop.nextRAF === 0) {
|
| MainLoop.nextRAF = now + 1e3 / 60
|
| } else {
|
| while (now + 2 >= MainLoop.nextRAF) {
|
| MainLoop.nextRAF += 1e3 / 60
|
| }
|
| }
|
| var delay = Math.max(MainLoop.nextRAF - now, 0);
|
| setTimeout(func, delay)
|
| },
|
| requestAnimationFrame(func) {
|
| if (globalThis.requestAnimationFrame) {
|
| requestAnimationFrame(func)
|
| } else {
|
| MainLoop.fakeRequestAnimationFrame(func)
|
| }
|
| }
|
| };
|
| var _emscripten_date_now = () => Date.now();
|
| var nowIsMonotonic = 1;
|
| var checkWasiClock = clock_id => clock_id >= 0 && clock_id <= 3;
|
|
|
| function _clock_time_get(clk_id, ignored_precision, ptime) {
|
| ignored_precision = bigintToI53Checked(ignored_precision);
|
| if (!checkWasiClock(clk_id)) {
|
| return 28
|
| }
|
| var now;
|
| if (clk_id === 0) {
|
| now = _emscripten_date_now()
|
| } else if (nowIsMonotonic) {
|
| now = _emscripten_get_now()
|
| } else {
|
| return 52
|
| }
|
| var nsec = Math.round(now * 1e3 * 1e3);
|
| HEAP64[ptime >> 3] = BigInt(nsec);
|
| return 0
|
| }
|
|
|
| function getFullscreenElement() {
|
| return document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.webkitCurrentFullScreenElement || document.msFullscreenElement
|
| }
|
| var safeSetTimeout = (func, timeout) => setTimeout(() => {
|
| callUserCallback(func)
|
| }, timeout);
|
| var warnOnce = text => {
|
| warnOnce.shown ||= {};
|
| if (!warnOnce.shown[text]) {
|
| warnOnce.shown[text] = 1;
|
| if (ENVIRONMENT_IS_NODE) text = "warning: " + text;
|
| err(text)
|
| }
|
| };
|
| var readEmAsmArgsArray = [];
|
| var readEmAsmArgs = (sigPtr, buf) => {
|
| readEmAsmArgsArray.length = 0;
|
| var ch;
|
| while (ch = HEAPU8[sigPtr++]) {
|
| var wide = ch != 105;
|
| wide &= ch != 112;
|
| buf += wide && buf % 8 ? 4 : 0;
|
| readEmAsmArgsArray.push(ch == 112 ? HEAPU32[buf >> 2] : ch == 106 ? HEAP64[buf >> 3] : ch == 105 ? HEAP32[buf >> 2] : HEAPF64[buf >> 3]);
|
| buf += wide ? 8 : 4
|
| }
|
| return readEmAsmArgsArray
|
| };
|
| var runEmAsmFunction = (code, sigPtr, argbuf) => {
|
| var args = readEmAsmArgs(sigPtr, argbuf);
|
| return ASM_CONSTS[code](...args)
|
| };
|
| var _emscripten_asm_const_int = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf);
|
| var runMainThreadEmAsm = (emAsmAddr, sigPtr, argbuf, sync) => {
|
| var args = readEmAsmArgs(sigPtr, argbuf);
|
| return ASM_CONSTS[emAsmAddr](...args)
|
| };
|
| var _emscripten_asm_const_int_sync_on_main_thread = (emAsmAddr, sigPtr, argbuf) => runMainThreadEmAsm(emAsmAddr, sigPtr, argbuf, 1);
|
| var _emscripten_asm_const_ptr_sync_on_main_thread = (emAsmAddr, sigPtr, argbuf) => runMainThreadEmAsm(emAsmAddr, sigPtr, argbuf, 1);
|
| var _emscripten_err = str => err(UTF8ToString(str));
|
| var _emscripten_set_window_title = title => document.title = UTF8ToString(title);
|
| var _emscripten_sleep = () => {
|
| abort("Please compile your program with async support in order to use asynchronous operations like emscripten_sleep")
|
| };
|
| class HandleAllocator {
|
| allocated = [undefined];
|
| freelist = [];
|
| get(id) {
|
| return this.allocated[id]
|
| }
|
| has(id) {
|
| return this.allocated[id] !== undefined
|
| }
|
| allocate(handle) {
|
| var id = this.freelist.pop() || this.allocated.length;
|
| this.allocated[id] = handle;
|
| return id
|
| }
|
| free(id) {
|
| this.allocated[id] = undefined;
|
| this.freelist.push(id)
|
| }
|
| }
|
| var ENV = {};
|
| var getExecutableName = () => thisProgram || "./this.program";
|
| var getEnvStrings = () => {
|
| if (!getEnvStrings.strings) {
|
| var lang = (globalThis.navigator?.language ?? "C").replace("-", "_") + ".UTF-8";
|
| var env = {
|
| USER: "web_user",
|
| LOGNAME: "web_user",
|
| PATH: "/",
|
| PWD: "/",
|
| HOME: "/home/web_user",
|
| LANG: lang,
|
| _: getExecutableName()
|
| };
|
| for (var x in ENV) {
|
| if (ENV[x] === undefined) delete env[x];
|
| else env[x] = ENV[x]
|
| }
|
| var strings = [];
|
| for (var x in env) {
|
| strings.push(`${x}=${env[x]}`)
|
| }
|
| getEnvStrings.strings = strings
|
| }
|
| return getEnvStrings.strings
|
| };
|
| var _environ_get = (__environ, environ_buf) => {
|
| var bufSize = 0;
|
| var envp = 0;
|
| for (var string of getEnvStrings()) {
|
| var ptr = environ_buf + bufSize;
|
| HEAPU32[__environ + envp >> 2] = ptr;
|
| bufSize += stringToUTF8(string, ptr, Infinity) + 1;
|
| envp += 4
|
| }
|
| return 0
|
| };
|
| var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
|
| var strings = getEnvStrings();
|
| HEAPU32[penviron_count >> 2] = strings.length;
|
| var bufSize = 0;
|
| for (var string of strings) {
|
| bufSize += lengthBytesUTF8(string) + 1
|
| }
|
| HEAPU32[penviron_buf_size >> 2] = bufSize;
|
| return 0
|
| };
|
|
|
| function _fd_close(fd) {
|
| try {
|
| var stream = SYSCALLS.getStreamFromFD(fd);
|
| FS.close(stream);
|
| return 0
|
| } catch (e) {
|
| if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
|
| return e.errno
|
| }
|
| }
|
| var doReadv = (stream, iov, iovcnt, offset) => {
|
| var ret = 0;
|
| for (var i = 0; i < iovcnt; i++) {
|
| var ptr = HEAPU32[iov >> 2];
|
| var len = HEAPU32[iov + 4 >> 2];
|
| iov += 8;
|
| var curr = FS.read(stream, HEAP8, ptr, len, offset);
|
| if (curr < 0) return -1;
|
| ret += curr;
|
| if (curr < len) break;
|
| if (typeof offset != "undefined") {
|
| offset += curr
|
| }
|
| }
|
| return ret
|
| };
|
|
|
| function _fd_read(fd, iov, iovcnt, pnum) {
|
| try {
|
| var stream = SYSCALLS.getStreamFromFD(fd);
|
| var num = doReadv(stream, iov, iovcnt);
|
| HEAPU32[pnum >> 2] = num;
|
| return 0
|
| } catch (e) {
|
| if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
|
| return e.errno
|
| }
|
| }
|
|
|
| function _fd_seek(fd, offset, whence, newOffset) {
|
| offset = bigintToI53Checked(offset);
|
| try {
|
| if (isNaN(offset)) return 61;
|
| var stream = SYSCALLS.getStreamFromFD(fd);
|
| FS.llseek(stream, offset, whence);
|
| HEAP64[newOffset >> 3] = BigInt(stream.position);
|
| if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
|
| return 0
|
| } catch (e) {
|
| if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
|
| return e.errno
|
| }
|
| }
|
| var doWritev = (stream, iov, iovcnt, offset) => {
|
| var ret = 0;
|
| for (var i = 0; i < iovcnt; i++) {
|
| var ptr = HEAPU32[iov >> 2];
|
| var len = HEAPU32[iov + 4 >> 2];
|
| iov += 8;
|
| var curr = FS.write(stream, HEAP8, ptr, len, offset);
|
| if (curr < 0) return -1;
|
| ret += curr;
|
| if (curr < len) {
|
| break
|
| }
|
| if (typeof offset != "undefined") {
|
| offset += curr
|
| }
|
| }
|
| return ret
|
| };
|
|
|
| function _fd_write(fd, iov, iovcnt, pnum) {
|
| try {
|
| var stream = SYSCALLS.getStreamFromFD(fd);
|
| var num = doWritev(stream, iov, iovcnt);
|
| HEAPU32[pnum >> 2] = num;
|
| return 0
|
| } catch (e) {
|
| if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
|
| return e.errno
|
| }
|
| }
|
| var _glActiveTexture = (...args) => _emscripten_glActiveTexture(...args);
|
| var _glAttachShader = (...args) => _emscripten_glAttachShader(...args);
|
| var _glBindBuffer = (...args) => _emscripten_glBindBuffer(...args);
|
| var _glBindBufferBase = (...args) => _emscripten_glBindBufferBase(...args);
|
| var _glBindFramebuffer = (...args) => _emscripten_glBindFramebuffer(...args);
|
| var _glBindRenderbuffer = (...args) => _emscripten_glBindRenderbuffer(...args);
|
| var _glBindSampler = (...args) => _emscripten_glBindSampler(...args);
|
| var _glBindTexture = (...args) => _emscripten_glBindTexture(...args);
|
| var _glBindVertexArray = (...args) => _emscripten_glBindVertexArray(...args);
|
| var _glBlendEquationSeparate = (...args) => _emscripten_glBlendEquationSeparate(...args);
|
| var _glBlendFuncSeparate = (...args) => _emscripten_glBlendFuncSeparate(...args);
|
| var _glBufferData = (...args) => _emscripten_glBufferData(...args);
|
| var _glClear = (...args) => _emscripten_glClear(...args);
|
| var _glClearColor = (...args) => _emscripten_glClearColor(...args);
|
| var _glClearDepthf = (...args) => _emscripten_glClearDepthf(...args);
|
| var _glClearStencil = (...args) => _emscripten_glClearStencil(...args);
|
| var _glColorMask = (...args) => _emscripten_glColorMask(...args);
|
| var _glCompileShader = (...args) => _emscripten_glCompileShader(...args);
|
| var _glCopyTexSubImage2D = (...args) => _emscripten_glCopyTexSubImage2D(...args);
|
| var _glCreateProgram = (...args) => _emscripten_glCreateProgram(...args);
|
| var _glCreateShader = (...args) => _emscripten_glCreateShader(...args);
|
| var _glCullFace = (...args) => _emscripten_glCullFace(...args);
|
| var _glDeleteBuffers = (...args) => _emscripten_glDeleteBuffers(...args);
|
| var _glDeleteFramebuffers = (...args) => _emscripten_glDeleteFramebuffers(...args);
|
| var _glDeleteProgram = (...args) => _emscripten_glDeleteProgram(...args);
|
| var _glDeleteRenderbuffers = (...args) => _emscripten_glDeleteRenderbuffers(...args);
|
| var _glDeleteSamplers = (...args) => _emscripten_glDeleteSamplers(...args);
|
| var _glDeleteShader = (...args) => _emscripten_glDeleteShader(...args);
|
| var _glDeleteTextures = (...args) => _emscripten_glDeleteTextures(...args);
|
| var _glDeleteVertexArrays = (...args) => _emscripten_glDeleteVertexArrays(...args);
|
| var _glDepthFunc = (...args) => _emscripten_glDepthFunc(...args);
|
| var _glDepthMask = (...args) => _emscripten_glDepthMask(...args);
|
| var _glDepthRangef = (...args) => _emscripten_glDepthRangef(...args);
|
| var _glDisable = (...args) => _emscripten_glDisable(...args);
|
| var _glDisableVertexAttribArray = (...args) => _emscripten_glDisableVertexAttribArray(...args);
|
| var _glDrawArraysInstanced = (...args) => _emscripten_glDrawArraysInstanced(...args);
|
| var _glDrawBuffers = (...args) => _emscripten_glDrawBuffers(...args);
|
| var _glDrawElementsInstanced = (...args) => _emscripten_glDrawElementsInstanced(...args);
|
| var _glEnable = (...args) => _emscripten_glEnable(...args);
|
| var _glEnableVertexAttribArray = (...args) => _emscripten_glEnableVertexAttribArray(...args);
|
| var _glFramebufferRenderbuffer = (...args) => _emscripten_glFramebufferRenderbuffer(...args);
|
| var _glFramebufferTexture2D = (...args) => _emscripten_glFramebufferTexture2D(...args);
|
| var _glFrontFace = (...args) => _emscripten_glFrontFace(...args);
|
| var _glGenBuffers = (...args) => _emscripten_glGenBuffers(...args);
|
| var _glGenFramebuffers = (...args) => _emscripten_glGenFramebuffers(...args);
|
| var _glGenRenderbuffers = (...args) => _emscripten_glGenRenderbuffers(...args);
|
| var _glGenSamplers = (...args) => _emscripten_glGenSamplers(...args);
|
| var _glGenTextures = (...args) => _emscripten_glGenTextures(...args);
|
| var _glGenVertexArrays = (...args) => _emscripten_glGenVertexArrays(...args);
|
| var _glGenerateMipmap = (...args) => _emscripten_glGenerateMipmap(...args);
|
| var _glGetIntegerv = (...args) => _emscripten_glGetIntegerv(...args);
|
| var _glGetProgramInfoLog = (...args) => _emscripten_glGetProgramInfoLog(...args);
|
| var _glGetProgramiv = (...args) => _emscripten_glGetProgramiv(...args);
|
| var _glGetShaderInfoLog = (...args) => _emscripten_glGetShaderInfoLog(...args);
|
| var _glGetShaderiv = (...args) => _emscripten_glGetShaderiv(...args);
|
| var _glGetStringi = (...args) => _emscripten_glGetStringi(...args);
|
| var _glGetUniformBlockIndex = (...args) => _emscripten_glGetUniformBlockIndex(...args);
|
| var _glGetUniformLocation = (...args) => _emscripten_glGetUniformLocation(...args);
|
| var _glLinkProgram = (...args) => _emscripten_glLinkProgram(...args);
|
| var _glPixelStorei = (...args) => _emscripten_glPixelStorei(...args);
|
| var _glPolygonOffset = (...args) => _emscripten_glPolygonOffset(...args);
|
| var _glReadPixels = (...args) => _emscripten_glReadPixels(...args);
|
| var _glRenderbufferStorage = (...args) => _emscripten_glRenderbufferStorage(...args);
|
| var _glSamplerParameterf = (...args) => _emscripten_glSamplerParameterf(...args);
|
| var _glSamplerParameteri = (...args) => _emscripten_glSamplerParameteri(...args);
|
| var _glScissor = (...args) => _emscripten_glScissor(...args);
|
| var _glShaderSource = (...args) => _emscripten_glShaderSource(...args);
|
| var _glStencilFunc = (...args) => _emscripten_glStencilFunc(...args);
|
| var _glStencilMask = (...args) => _emscripten_glStencilMask(...args);
|
| var _glStencilOp = (...args) => _emscripten_glStencilOp(...args);
|
| var _glTexImage2D = (...args) => _emscripten_glTexImage2D(...args);
|
| var _glTexParameteri = (...args) => _emscripten_glTexParameteri(...args);
|
| var _glTexSubImage2D = (...args) => _emscripten_glTexSubImage2D(...args);
|
| var _glUniform1i = (...args) => _emscripten_glUniform1i(...args);
|
| var _glUniformBlockBinding = (...args) => _emscripten_glUniformBlockBinding(...args);
|
| var _glUseProgram = (...args) => _emscripten_glUseProgram(...args);
|
| var _glVertexAttribDivisor = (...args) => _emscripten_glVertexAttribDivisor(...args);
|
| var _glVertexAttribPointer = (...args) => _emscripten_glVertexAttribPointer(...args);
|
| var _glViewport = (...args) => _emscripten_glViewport(...args);
|
| var _llvm_eh_typeid_for = type => type;
|
| var dynCall = (sig, ptr, args = [], promising = false) => {
|
| var func = getWasmTableEntry(ptr);
|
| var rtn = func(...args);
|
|
|
| function convert(rtn) {
|
| return rtn
|
| }
|
| return convert(rtn)
|
| };
|
| var FS_createPath = (...args) => FS.createPath(...args);
|
| var FS_unlink = (...args) => FS.unlink(...args);
|
| var FS_createLazyFile = (...args) => FS.createLazyFile(...args);
|
| var FS_createDevice = (...args) => FS.createDevice(...args);
|
| var createContext;
|
| var dependenciesInitted = false;
|
| function initDependencies() {
|
| if (dependenciesInitted) return;
|
| dependenciesInitted = true;
|
| console.log("Initializing dependencies...");
|
| var fs_obj = typeof FS !== "undefined" ? FS : window.FS;
|
| if (fs_obj) {
|
| console.log("Initializing FS...");
|
| if (!fs_obj.nameTable) fs_obj.staticInit();
|
| if (!fs_obj.initialized) fs_obj.init();
|
| } else { console.error("FS NOT FOUND!"); }
|
| if (typeof FS !== "undefined") {
|
| }
|
| createContext = (...args) => Browser.createContext(...args);
|
|
|
|
|
| Module["requestAnimationFrame"] = MainLoop.requestAnimationFrame;
|
| Module["pauseMainLoop"] = MainLoop.pause;
|
| Module["resumeMainLoop"] = MainLoop.resume;
|
| MainLoop.init();
|
| window.initGLFrame = () => registerPreMainLoop(() => GL.newRenderingFrameStarted());
|
| for (let i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));
|
| var miniTempWebGLFloatBuffersStorage = new Float32Array(288);
|
| for (var i = 0; i <= 288; ++i) {
|
| miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i)
|
| }
|
| var miniTempWebGLIntBuffersStorage = new Int32Array(288);
|
| for (var i = 0; i <= 288; ++i) {
|
| miniTempWebGLIntBuffers[i] = miniTempWebGLIntBuffersStorage.subarray(0, i)
|
| }
|
|
|
| }
|
| {
|
| if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
|
| if (Module["preloadPlugins"]) preloadPlugins = Module["preloadPlugins"];
|
| if (Module["print"]) out = Module["print"];
|
| if (Module["printErr"]) err = Module["printErr"];
|
| if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
|
| if (Module["arguments"]) arguments_ = Module["arguments"];
|
| if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
|
| if (Module["preInit"]) {
|
| if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
|
| while (Module["preInit"].length > 0) {
|
| Module["preInit"].shift()()
|
| }
|
| }
|
| }
|
| Module["addRunDependency"] = addRunDependency;
|
| Module["removeRunDependency"] = removeRunDependency;
|
| Module["createContext"] = (...args) => createContext(...args);
|
| Module["FS_preloadFile"] = (...args) => window.FS_preloadFile(...args);
|
| Module["FS_unlink"] = FS_unlink;
|
| Module["FS_createPath"] = FS_createPath;
|
| Module["FS_createDevice"] = FS_createDevice;
|
| Object.defineProperty(Module, "FS", { get: () => typeof FS !== "undefined" ? FS : window.FS });
|
| Module["FS_createDataFile"] = (...args) => FS_createDataFile(...args);
|
| Module["FS_createLazyFile"] = (...args) => FS_createLazyFile(...args);
|
|
|
| var stackAlloc = (...args) => __emscripten_stack_alloc(...args);
|
| var stringToUTF8OnStack = str => {
|
| var len = lengthBytesUTF8(str) + 1;
|
| var ret = stackAlloc(len);
|
| stringToUTF8(str, ret, len);
|
| return ret;
|
| };
|
|
|
| var getWasmTableEntry = funcPtr => wasmTable.get(funcPtr);
|
| var _malloc, _free, _realloc, _main, _setThrew, __emscripten_tempret_set, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, ___cxa_decrement_exception_refcount, ___cxa_increment_exception_refcount, ___cxa_can_catch, ___cxa_get_exception_ptr, memory, __indirect_function_table, wasmMemory, wasmTable;
|
|
|
| function assignWasmExports(wasmExports) {
|
| _malloc = wasmExports["zk"];
|
| _free = wasmExports["Ak"];
|
| _realloc = wasmExports["Bk"];
|
| _main = Module["_main"] = wasmExports["Ck"];
|
| _setThrew = wasmExports["Dk"];
|
| __emscripten_tempret_set = wasmExports["Ek"];
|
| __emscripten_stack_restore = wasmExports["Fk"];
|
| __emscripten_stack_alloc = wasmExports["Gk"];
|
| _emscripten_stack_get_current = wasmExports["Hk"];
|
| ___cxa_decrement_exception_refcount = wasmExports["Ik"];
|
| ___cxa_increment_exception_refcount = wasmExports["Jk"];
|
| ___cxa_can_catch = wasmExports["Kk"];
|
| ___cxa_get_exception_ptr = wasmExports["Lk"];
|
| memory = wasmMemory = wasmExports["wk"];
|
| __indirect_function_table = wasmTable = wasmExports["yk"]
|
| }
|
| var wasmImports = {
|
| n: (...args) => ___cxa_begin_catch(...args),
|
| z: (...args) => ___cxa_end_catch(...args),
|
| a: (...args) => ___cxa_find_matching_catch_2(...args),
|
| f: (...args) => ___cxa_find_matching_catch_3(...args),
|
| gc: (...args) => ___cxa_rethrow(...args),
|
| h: (...args) => ___cxa_throw(...args),
|
| fc: (...args) => ___cxa_uncaught_exceptions(...args),
|
| c: (...args) => ___resumeException(...args),
|
| vk: (...args) => ___syscall__newselect(...args),
|
| uk: (...args) => ___syscall_chdir(...args),
|
| tk: (...args) => ___syscall_faccessat(...args),
|
| H: (...args) => ___syscall_fcntl64(...args),
|
| sk: (...args) => ___syscall_getcwd(...args),
|
| rk: (...args) => ___syscall_getdents64(...args),
|
| qk: (...args) => ___syscall_ioctl(...args),
|
| pk: (...args) => ___syscall_lstat64(...args),
|
| ok: (...args) => ___syscall_mkdirat(...args),
|
| nk: (...args) => ___syscall_newfstatat(...args),
|
| ec: (...args) => ___syscall_openat(...args),
|
| mk: (...args) => ___syscall_readlinkat(...args),
|
| lk: (...args) => ___syscall_stat64(...args),
|
| kk: (...args) => ___syscall_unlinkat(...args),
|
| fk: (...args) => __abort_js(...args),
|
| ek: (...args) => __gmtime_js(...args),
|
| dk: (...args) => __localtime_js(...args),
|
| ck: (...args) => __mktime_js(...args),
|
| bk: (...args) => __tzset_js(...args),
|
| ak: (...args) => _alBuffer3f(...args),
|
| $j: (...args) => _alBuffer3i(...args),
|
| ia: (...args) => _alBufferData(...args),
|
| _j: (...args) => _alBufferf(...args),
|
| Zj: (...args) => _alBufferfv(...args),
|
| Yj: (...args) => _alBufferi(...args),
|
| bc: (...args) => _alBufferiv(...args),
|
| ha: (...args) => _alDeleteBuffers(...args),
|
| Ia: (...args) => _alDeleteSources(...args),
|
| Xj: (...args) => _alDisable(...args),
|
| ac: (...args) => _alDistanceModel(...args),
|
| Wj: (...args) => _alDopplerFactor(...args),
|
| Vj: (...args) => _alDopplerVelocity(...args),
|
| Uj: (...args) => _alEnable(...args),
|
| ga: (...args) => _alGenBuffers(...args),
|
| Ha: (...args) => _alGenSources(...args),
|
| Tj: (...args) => _alGetBoolean(...args),
|
| Sj: (...args) => _alGetBooleanv(...args),
|
| Rj: (...args) => _alGetBuffer3f(...args),
|
| Qj: (...args) => _alGetBuffer3i(...args),
|
| Pj: (...args) => _alGetBufferf(...args),
|
| Oj: (...args) => _alGetBufferfv(...args),
|
| Nj: (...args) => _alGetBufferi(...args),
|
| Mj: (...args) => _alGetBufferiv(...args),
|
| Lj: (...args) => _alGetDouble(...args),
|
| Kj: (...args) => _alGetDoublev(...args),
|
| $b: (...args) => _alGetEnumValue(...args),
|
| Jj: (...args) => _alGetError(...args),
|
| Ij: (...args) => _alGetFloat(...args),
|
| Hj: (...args) => _alGetFloatv(...args),
|
| Gj: (...args) => _alGetInteger(...args),
|
| Fj: (...args) => _alGetIntegerv(...args),
|
| Ej: (...args) => _alGetListener3f(...args),
|
| Dj: (...args) => _alGetListener3i(...args),
|
| Cj: (...args) => _alGetListenerf(...args),
|
| Bj: (...args) => _alGetListenerfv(...args),
|
| Aj: (...args) => _alGetListeneri(...args),
|
| zj: (...args) => _alGetListeneriv(...args),
|
| yj: (...args) => _alGetSource3f(...args),
|
| xj: (...args) => _alGetSource3i(...args),
|
| _b: (...args) => _alGetSourcef(...args),
|
| wj: (...args) => _alGetSourcefv(...args),
|
| u: (...args) => _alGetSourcei(...args),
|
| vj: (...args) => _alGetSourceiv(...args),
|
| Zb: (...args) => _alGetString(...args),
|
| Ga: (...args) => _alIsBuffer(...args),
|
| uj: (...args) => _alIsEnabled(...args),
|
| tj: (...args) => _alIsExtensionPresent(...args),
|
| sj: (...args) => _alIsSource(...args),
|
| Fa: (...args) => _alListener3f(...args),
|
| rj: (...args) => _alListener3i(...args),
|
| Yb: (...args) => _alListenerf(...args),
|
| Xb: (...args) => _alListenerfv(...args),
|
| qj: (...args) => _alListeneri(...args),
|
| pj: (...args) => _alListeneriv(...args),
|
| D: (...args) => _alSource3f(...args),
|
| ra: (...args) => _alSource3i(...args),
|
| Ea: (...args) => _alSourcePause(...args),
|
| oj: (...args) => _alSourcePausev(...args),
|
| R: (...args) => _alSourcePlay(...args),
|
| nj: (...args) => _alSourcePlayv(...args),
|
| G: (...args) => _alSourceQueueBuffers(...args),
|
| mj: (...args) => _alSourceRewind(...args),
|
| lj: (...args) => _alSourceRewindv(...args),
|
| $: (...args) => _alSourceStop(...args),
|
| kj: (...args) => _alSourceStopv(...args),
|
| fa: (...args) => _alSourceUnqueueBuffers(...args),
|
| v: (...args) => _alSourcef(...args),
|
| jj: (...args) => _alSourcefv(...args),
|
| y: (...args) => _alSourcei(...args),
|
| ij: (...args) => _alSourceiv(...args),
|
| hj: (...args) => _alSpeedOfSound(...args),
|
| Wb: (...args) => _alcCloseDevice(...args),
|
| Vb: (...args) => _alcCreateContext(...args),
|
| Ub: (...args) => _alcDestroyContext(...args),
|
| gj: (...args) => _alcGetIntegerv(...args),
|
| qa: (...args) => _alcIsExtensionPresent(...args),
|
| Da: (...args) => _alcMakeContextCurrent(...args),
|
| Tb: (...args) => _alcOpenDevice(...args),
|
| fj: (...args) => _alcSuspendContext(...args),
|
| jk: (...args) => _clock_time_get(...args),
|
| ej: (...args) => _eglBindAPI(...args),
|
| Sb: (...args) => _eglChooseConfig(...args),
|
| Rb: (...args) => _eglCreateContext(...args),
|
| Qb: (...args) => _eglCreateWindowSurface(...args),
|
| dj: (...args) => _eglDestroyContext(...args),
|
| cj: (...args) => _eglDestroySurface(...args),
|
| bj: (...args) => _eglGetConfigAttrib(...args),
|
| Ca: (...args) => _eglGetDisplay(...args),
|
| aj: (...args) => _eglGetError(...args),
|
| Pb: (...args) => _eglInitialize(...args),
|
| Ob: (...args) => _eglMakeCurrent(...args),
|
| $i: (...args) => _eglQueryString(...args),
|
| Nb: (...args) => _eglSwapBuffers(...args),
|
| _i: (...args) => _eglSwapInterval(...args),
|
| Zi: (...args) => _eglTerminate(...args),
|
| Yi: (...args) => _eglWaitGL(...args),
|
| Xi: (...args) => _eglWaitNative(...args),
|
| q: (...args) => _emscripten_asm_const_int(...args),
|
| B: (...args) => _emscripten_asm_const_int_sync_on_main_thread(...args),
|
| Wi: (...args) => _emscripten_asm_const_ptr_sync_on_main_thread(...args),
|
| Mb: (...args) => _emscripten_date_now(...args),
|
| Lb: (...args) => _emscripten_err(...args),
|
| Vi: (...args) => _emscripten_exit_fullscreen(...args),
|
| Ui: (...args) => _emscripten_exit_pointerlock(...args),
|
| Ti: (...args) => _emscripten_fetch_free(...args),
|
| ea: (...args) => _emscripten_get_device_pixel_ratio(...args),
|
| U: (...args) => _emscripten_get_element_css_size(...args),
|
| Kb: (...args) => _emscripten_get_gamepad_status(...args),
|
| Jb: (...args) => _emscripten_get_now(...args),
|
| Si: (...args) => _emscripten_get_num_gamepads(...args),
|
| Ri: (...args) => _emscripten_get_screen_size(...args),
|
| Qi: (...args) => _emscripten_glActiveTexture(...args),
|
| Pi: (...args) => _emscripten_glAttachShader(...args),
|
| Oi: (...args) => _emscripten_glBeginQuery(...args),
|
| Ni: (...args) => _emscripten_glBeginQueryEXT(...args),
|
| Mi: (...args) => _emscripten_glBeginTransformFeedback(...args),
|
| Li: (...args) => _emscripten_glBindAttribLocation(...args),
|
| Ki: (...args) => _emscripten_glBindBuffer(...args),
|
| Ji: (...args) => _emscripten_glBindBufferBase(...args),
|
| Ii: (...args) => _emscripten_glBindBufferRange(...args),
|
| Hi: (...args) => _emscripten_glBindFramebuffer(...args),
|
| Gi: (...args) => _emscripten_glBindRenderbuffer(...args),
|
| Fi: (...args) => _emscripten_glBindSampler(...args),
|
| Ei: (...args) => _emscripten_glBindTexture(...args),
|
| Di: (...args) => _emscripten_glBindTransformFeedback(...args),
|
| Ci: (...args) => _emscripten_glBindVertexArray(...args),
|
| Bi: (...args) => _emscripten_glBindVertexArrayOES(...args),
|
| Ai: (...args) => _emscripten_glBlendColor(...args),
|
| zi: (...args) => _emscripten_glBlendEquation(...args),
|
| yi: (...args) => _emscripten_glBlendEquationSeparate(...args),
|
| xi: (...args) => _emscripten_glBlendFunc(...args),
|
| wi: (...args) => _emscripten_glBlendFuncSeparate(...args),
|
| vi: (...args) => _emscripten_glBlitFramebuffer(...args),
|
| ui: (...args) => _emscripten_glBufferData(...args),
|
| ti: (...args) => _emscripten_glBufferSubData(...args),
|
| si: (...args) => _emscripten_glCheckFramebufferStatus(...args),
|
| ri: (...args) => _emscripten_glClear(...args),
|
| qi: (...args) => _emscripten_glClearBufferfi(...args),
|
| pi: (...args) => _emscripten_glClearBufferfv(...args),
|
| oi: (...args) => _emscripten_glClearBufferiv(...args),
|
| ni: (...args) => _emscripten_glClearBufferuiv(...args),
|
| mi: (...args) => _emscripten_glClearColor(...args),
|
| li: (...args) => _emscripten_glClearDepthf(...args),
|
| ki: (...args) => _emscripten_glClearStencil(...args),
|
| ji: (...args) => _emscripten_glClientWaitSync(...args),
|
| ii: (...args) => _emscripten_glClipControlEXT(...args),
|
| hi: (...args) => _emscripten_glColorMask(...args),
|
| gi: (...args) => _emscripten_glCompileShader(...args),
|
| fi: (...args) => _emscripten_glCompressedTexImage2D(...args),
|
| ei: (...args) => _emscripten_glCompressedTexImage3D(...args),
|
| di: (...args) => _emscripten_glCompressedTexSubImage2D(...args),
|
| ci: (...args) => _emscripten_glCompressedTexSubImage3D(...args),
|
| bi: (...args) => _emscripten_glCopyBufferSubData(...args),
|
| ai: (...args) => _emscripten_glCopyTexImage2D(...args),
|
| $h: (...args) => _emscripten_glCopyTexSubImage2D(...args),
|
| _h: (...args) => _emscripten_glCopyTexSubImage3D(...args),
|
| Zh: (...args) => _emscripten_glCreateProgram(...args),
|
| Yh: (...args) => _emscripten_glCreateShader(...args),
|
| Xh: (...args) => _emscripten_glCullFace(...args),
|
| Wh: (...args) => _emscripten_glDeleteBuffers(...args),
|
| Vh: (...args) => _emscripten_glDeleteFramebuffers(...args),
|
| Uh: (...args) => _emscripten_glDeleteProgram(...args),
|
| Th: (...args) => _emscripten_glDeleteQueries(...args),
|
| Sh: (...args) => _emscripten_glDeleteQueriesEXT(...args),
|
| Rh: (...args) => _emscripten_glDeleteRenderbuffers(...args),
|
| Qh: (...args) => _emscripten_glDeleteSamplers(...args),
|
| Ph: (...args) => _emscripten_glDeleteShader(...args),
|
| Oh: (...args) => _emscripten_glDeleteSync(...args),
|
| Nh: (...args) => _emscripten_glDeleteTextures(...args),
|
| Mh: (...args) => _emscripten_glDeleteTransformFeedbacks(...args),
|
| Lh: (...args) => _emscripten_glDeleteVertexArrays(...args),
|
| Kh: (...args) => _emscripten_glDeleteVertexArraysOES(...args),
|
| Jh: (...args) => _emscripten_glDepthFunc(...args),
|
| Ih: (...args) => _emscripten_glDepthMask(...args),
|
| Hh: (...args) => _emscripten_glDepthRangef(...args),
|
| Gh: (...args) => _emscripten_glDetachShader(...args),
|
| Fh: (...args) => _emscripten_glDisable(...args),
|
| Eh: (...args) => _emscripten_glDisableVertexAttribArray(...args),
|
| Dh: (...args) => _emscripten_glDrawArrays(...args),
|
| Ch: (...args) => _emscripten_glDrawArraysInstanced(...args),
|
| Bh: (...args) => _emscripten_glDrawArraysInstancedANGLE(...args),
|
| Ah: (...args) => _emscripten_glDrawArraysInstancedARB(...args),
|
| zh: (...args) => _emscripten_glDrawArraysInstancedEXT(...args),
|
| yh: (...args) => _emscripten_glDrawArraysInstancedNV(...args),
|
| xh: (...args) => _emscripten_glDrawBuffers(...args),
|
| wh: (...args) => _emscripten_glDrawBuffersEXT(...args),
|
| vh: (...args) => _emscripten_glDrawBuffersWEBGL(...args),
|
| uh: (...args) => _emscripten_glDrawElements(...args),
|
| th: (...args) => _emscripten_glDrawElementsInstanced(...args),
|
| sh: (...args) => _emscripten_glDrawElementsInstancedANGLE(...args),
|
| rh: (...args) => _emscripten_glDrawElementsInstancedARB(...args),
|
| qh: (...args) => _emscripten_glDrawElementsInstancedEXT(...args),
|
| ph: (...args) => _emscripten_glDrawElementsInstancedNV(...args),
|
| oh: (...args) => _emscripten_glDrawRangeElements(...args),
|
| nh: (...args) => _emscripten_glEnable(...args),
|
| mh: (...args) => _emscripten_glEnableVertexAttribArray(...args),
|
| lh: (...args) => _emscripten_glEndQuery(...args),
|
| kh: (...args) => _emscripten_glEndQueryEXT(...args),
|
| jh: (...args) => _emscripten_glEndTransformFeedback(...args),
|
| ih: (...args) => _emscripten_glFenceSync(...args),
|
| hh: (...args) => _emscripten_glFinish(...args),
|
| gh: (...args) => _emscripten_glFlush(...args),
|
| fh: (...args) => _emscripten_glFlushMappedBufferRange(...args),
|
| eh: (...args) => _emscripten_glFramebufferRenderbuffer(...args),
|
| dh: (...args) => _emscripten_glFramebufferTexture2D(...args),
|
| ch: (...args) => _emscripten_glFramebufferTextureLayer(...args),
|
| bh: (...args) => _emscripten_glFrontFace(...args),
|
| ah: (...args) => _emscripten_glGenBuffers(...args),
|
| $g: (...args) => _emscripten_glGenFramebuffers(...args),
|
| _g: (...args) => _emscripten_glGenQueries(...args),
|
| Zg: (...args) => _emscripten_glGenQueriesEXT(...args),
|
| Yg: (...args) => _emscripten_glGenRenderbuffers(...args),
|
| Xg: (...args) => _emscripten_glGenSamplers(...args),
|
| Wg: (...args) => _emscripten_glGenTextures(...args),
|
| Vg: (...args) => _emscripten_glGenTransformFeedbacks(...args),
|
| Ug: (...args) => _emscripten_glGenVertexArrays(...args),
|
| Tg: (...args) => _emscripten_glGenVertexArraysOES(...args),
|
| Sg: (...args) => _emscripten_glGenerateMipmap(...args),
|
| Rg: (...args) => _emscripten_glGetActiveAttrib(...args),
|
| Qg: (...args) => _emscripten_glGetActiveUniform(...args),
|
| Pg: (...args) => _emscripten_glGetActiveUniformBlockName(...args),
|
| Og: (...args) => _emscripten_glGetActiveUniformBlockiv(...args),
|
| Ng: (...args) => _emscripten_glGetActiveUniformsiv(...args),
|
| Mg: (...args) => _emscripten_glGetAttachedShaders(...args),
|
| Lg: (...args) => _emscripten_glGetAttribLocation(...args),
|
| Kg: (...args) => _emscripten_glGetBooleanv(...args),
|
| Jg: (...args) => _emscripten_glGetBufferParameteri64v(...args),
|
| Ig: (...args) => _emscripten_glGetBufferParameteriv(...args),
|
| Hg: (...args) => _emscripten_glGetBufferPointerv(...args),
|
| Gg: (...args) => _emscripten_glGetError(...args),
|
| Fg: (...args) => _emscripten_glGetFloatv(...args),
|
| Eg: (...args) => _emscripten_glGetFragDataLocation(...args),
|
| Dg: (...args) => _emscripten_glGetFramebufferAttachmentParameteriv(...args),
|
| Cg: (...args) => _emscripten_glGetInteger64i_v(...args),
|
| Bg: (...args) => _emscripten_glGetInteger64v(...args),
|
| Ag: (...args) => _emscripten_glGetIntegeri_v(...args),
|
| zg: (...args) => _emscripten_glGetIntegerv(...args),
|
| yg: (...args) => _emscripten_glGetInternalformativ(...args),
|
| xg: (...args) => _emscripten_glGetProgramBinary(...args),
|
| wg: (...args) => _emscripten_glGetProgramInfoLog(...args),
|
| vg: (...args) => _emscripten_glGetProgramiv(...args),
|
| ug: (...args) => _emscripten_glGetQueryObjecti64vEXT(...args),
|
| tg: (...args) => _emscripten_glGetQueryObjectivEXT(...args),
|
| sg: (...args) => _emscripten_glGetQueryObjectui64vEXT(...args),
|
| rg: (...args) => _emscripten_glGetQueryObjectuiv(...args),
|
| qg: (...args) => _emscripten_glGetQueryObjectuivEXT(...args),
|
| pg: (...args) => _emscripten_glGetQueryiv(...args),
|
| og: (...args) => _emscripten_glGetQueryivEXT(...args),
|
| ng: (...args) => _emscripten_glGetRenderbufferParameteriv(...args),
|
| mg: (...args) => _emscripten_glGetSamplerParameterfv(...args),
|
| lg: (...args) => _emscripten_glGetSamplerParameteriv(...args),
|
| kg: (...args) => _emscripten_glGetShaderInfoLog(...args),
|
| jg: (...args) => _emscripten_glGetShaderPrecisionFormat(...args),
|
| ig: (...args) => _emscripten_glGetShaderSource(...args),
|
| hg: (...args) => _emscripten_glGetShaderiv(...args),
|
| gg: (...args) => _emscripten_glGetString(...args),
|
| fg: (...args) => _emscripten_glGetStringi(...args),
|
| eg: (...args) => _emscripten_glGetSynciv(...args),
|
| dg: (...args) => _emscripten_glGetTexParameterfv(...args),
|
| cg: (...args) => _emscripten_glGetTexParameteriv(...args),
|
| bg: (...args) => _emscripten_glGetTransformFeedbackVarying(...args),
|
| ag: (...args) => _emscripten_glGetUniformBlockIndex(...args),
|
| $f: (...args) => _emscripten_glGetUniformIndices(...args),
|
| _f: (...args) => _emscripten_glGetUniformLocation(...args),
|
| Zf: (...args) => _emscripten_glGetUniformfv(...args),
|
| Yf: (...args) => _emscripten_glGetUniformiv(...args),
|
| Xf: (...args) => _emscripten_glGetUniformuiv(...args),
|
| Wf: (...args) => _emscripten_glGetVertexAttribIiv(...args),
|
| Vf: (...args) => _emscripten_glGetVertexAttribIuiv(...args),
|
| Uf: (...args) => _emscripten_glGetVertexAttribPointerv(...args),
|
| Tf: (...args) => _emscripten_glGetVertexAttribfv(...args),
|
| Sf: (...args) => _emscripten_glGetVertexAttribiv(...args),
|
| Rf: (...args) => _emscripten_glHint(...args),
|
| Qf: (...args) => _emscripten_glInvalidateFramebuffer(...args),
|
| Pf: (...args) => _emscripten_glInvalidateSubFramebuffer(...args),
|
| Of: (...args) => _emscripten_glIsBuffer(...args),
|
| Nf: (...args) => _emscripten_glIsEnabled(...args),
|
| Mf: (...args) => _emscripten_glIsFramebuffer(...args),
|
| Lf: (...args) => _emscripten_glIsProgram(...args),
|
| Kf: (...args) => _emscripten_glIsQuery(...args),
|
| Jf: (...args) => _emscripten_glIsQueryEXT(...args),
|
| If: (...args) => _emscripten_glIsRenderbuffer(...args),
|
| Hf: (...args) => _emscripten_glIsSampler(...args),
|
| Gf: (...args) => _emscripten_glIsShader(...args),
|
| Ff: (...args) => _emscripten_glIsSync(...args),
|
| Ef: (...args) => _emscripten_glIsTexture(...args),
|
| Df: (...args) => _emscripten_glIsTransformFeedback(...args),
|
| Cf: (...args) => _emscripten_glIsVertexArray(...args),
|
| Bf: (...args) => _emscripten_glIsVertexArrayOES(...args),
|
| Af: (...args) => _emscripten_glLineWidth(...args),
|
| zf: (...args) => _emscripten_glLinkProgram(...args),
|
| yf: (...args) => _emscripten_glMapBufferRange(...args),
|
| xf: (...args) => _emscripten_glPauseTransformFeedback(...args),
|
| wf: (...args) => _emscripten_glPixelStorei(...args),
|
| vf: (...args) => _emscripten_glPolygonModeWEBGL(...args),
|
| uf: (...args) => _emscripten_glPolygonOffset(...args),
|
| tf: (...args) => _emscripten_glPolygonOffsetClampEXT(...args),
|
| sf: (...args) => _emscripten_glProgramBinary(...args),
|
| rf: (...args) => _emscripten_glProgramParameteri(...args),
|
| qf: (...args) => _emscripten_glQueryCounterEXT(...args),
|
| pf: (...args) => _emscripten_glReadBuffer(...args),
|
| of: (...args) => _emscripten_glReadPixels(...args),
|
| nf: (...args) => _emscripten_glReleaseShaderCompiler(...args),
|
| mf: (...args) => _emscripten_glRenderbufferStorage(...args),
|
| lf: (...args) => _emscripten_glRenderbufferStorageMultisample(...args),
|
| kf: (...args) => _emscripten_glResumeTransformFeedback(...args),
|
| jf: (...args) => _emscripten_glSampleCoverage(...args),
|
| hf: (...args) => _emscripten_glSamplerParameterf(...args),
|
| gf: (...args) => _emscripten_glSamplerParameterfv(...args),
|
| ff: (...args) => _emscripten_glSamplerParameteri(...args),
|
| ef: (...args) => _emscripten_glSamplerParameteriv(...args),
|
| df: (...args) => _emscripten_glScissor(...args),
|
| cf: (...args) => _emscripten_glShaderBinary(...args),
|
| bf: (...args) => _emscripten_glShaderSource(...args),
|
| af: (...args) => _emscripten_glStencilFunc(...args),
|
| $e: (...args) => _emscripten_glStencilFuncSeparate(...args),
|
| _e: (...args) => _emscripten_glStencilMask(...args),
|
| Ze: (...args) => _emscripten_glStencilMaskSeparate(...args),
|
| Ye: (...args) => _emscripten_glStencilOp(...args),
|
| Xe: (...args) => _emscripten_glStencilOpSeparate(...args),
|
| We: (...args) => _emscripten_glTexImage2D(...args),
|
| Ve: (...args) => _emscripten_glTexImage3D(...args),
|
| Ue: (...args) => _emscripten_glTexParameterf(...args),
|
| Te: (...args) => _emscripten_glTexParameterfv(...args),
|
| Se: (...args) => _emscripten_glTexParameteri(...args),
|
| Re: (...args) => _emscripten_glTexParameteriv(...args),
|
| Qe: (...args) => _emscripten_glTexStorage2D(...args),
|
| Pe: (...args) => _emscripten_glTexStorage3D(...args),
|
| Oe: (...args) => _emscripten_glTexSubImage2D(...args),
|
| Ne: (...args) => _emscripten_glTexSubImage3D(...args),
|
| Me: (...args) => _emscripten_glTransformFeedbackVaryings(...args),
|
| Le: (...args) => _emscripten_glUniform1f(...args),
|
| Ke: (...args) => _emscripten_glUniform1fv(...args),
|
| Je: (...args) => _emscripten_glUniform1i(...args),
|
| Ie: (...args) => _emscripten_glUniform1iv(...args),
|
| He: (...args) => _emscripten_glUniform1ui(...args),
|
| Ge: (...args) => _emscripten_glUniform1uiv(...args),
|
| Fe: (...args) => _emscripten_glUniform2f(...args),
|
| Ee: (...args) => _emscripten_glUniform2fv(...args),
|
| De: (...args) => _emscripten_glUniform2i(...args),
|
| Ce: (...args) => _emscripten_glUniform2iv(...args),
|
| Be: (...args) => _emscripten_glUniform2ui(...args),
|
| Ae: (...args) => _emscripten_glUniform2uiv(...args),
|
| ze: (...args) => _emscripten_glUniform3f(...args),
|
| ye: (...args) => _emscripten_glUniform3fv(...args),
|
| xe: (...args) => _emscripten_glUniform3i(...args),
|
| we: (...args) => _emscripten_glUniform3iv(...args),
|
| ve: (...args) => _emscripten_glUniform3ui(...args),
|
| ue: (...args) => _emscripten_glUniform3uiv(...args),
|
| te: (...args) => _emscripten_glUniform4f(...args),
|
| se: (...args) => _emscripten_glUniform4fv(...args),
|
| re: (...args) => _emscripten_glUniform4i(...args),
|
| qe: (...args) => _emscripten_glUniform4iv(...args),
|
| pe: (...args) => _emscripten_glUniform4ui(...args),
|
| oe: (...args) => _emscripten_glUniform4uiv(...args),
|
| ne: (...args) => _emscripten_glUniformBlockBinding(...args),
|
| me: (...args) => _emscripten_glUniformMatrix2fv(...args),
|
| le: (...args) => _emscripten_glUniformMatrix2x3fv(...args),
|
| ke: (...args) => _emscripten_glUniformMatrix2x4fv(...args),
|
| je: (...args) => _emscripten_glUniformMatrix3fv(...args),
|
| ie: (...args) => _emscripten_glUniformMatrix3x2fv(...args),
|
| he: (...args) => _emscripten_glUniformMatrix3x4fv(...args),
|
| ge: (...args) => _emscripten_glUniformMatrix4fv(...args),
|
| fe: (...args) => _emscripten_glUniformMatrix4x2fv(...args),
|
| ee: (...args) => _emscripten_glUniformMatrix4x3fv(...args),
|
| de: (...args) => _emscripten_glUnmapBuffer(...args),
|
| ce: (...args) => _emscripten_glUseProgram(...args),
|
| be: (...args) => _emscripten_glValidateProgram(...args),
|
| ae: (...args) => _emscripten_glVertexAttrib1f(...args),
|
| $d: (...args) => _emscripten_glVertexAttrib1fv(...args),
|
| _d: (...args) => _emscripten_glVertexAttrib2f(...args),
|
| Zd: (...args) => _emscripten_glVertexAttrib2fv(...args),
|
| Yd: (...args) => _emscripten_glVertexAttrib3f(...args),
|
| Xd: (...args) => _emscripten_glVertexAttrib3fv(...args),
|
| Wd: (...args) => _emscripten_glVertexAttrib4f(...args),
|
| Vd: (...args) => _emscripten_glVertexAttrib4fv(...args),
|
| Ud: (...args) => _emscripten_glVertexAttribDivisor(...args),
|
| Td: (...args) => _emscripten_glVertexAttribDivisorANGLE(...args),
|
| Sd: (...args) => _emscripten_glVertexAttribDivisorARB(...args),
|
| Rd: (...args) => _emscripten_glVertexAttribDivisorEXT(...args),
|
| Qd: (...args) => _emscripten_glVertexAttribDivisorNV(...args),
|
| Pd: (...args) => _emscripten_glVertexAttribI4i(...args),
|
| Od: (...args) => _emscripten_glVertexAttribI4iv(...args),
|
| Nd: (...args) => _emscripten_glVertexAttribI4ui(...args),
|
| Md: (...args) => _emscripten_glVertexAttribI4uiv(...args),
|
| Ld: (...args) => _emscripten_glVertexAttribIPointer(...args),
|
| Kd: (...args) => _emscripten_glVertexAttribPointer(...args),
|
| Jd: (...args) => _emscripten_glViewport(...args),
|
| Id: (...args) => _emscripten_glWaitSync(...args),
|
| Ba: (...args) => _emscripten_has_asyncify(...args),
|
| Hd: (...args) => _emscripten_is_main_browser_thread(...args),
|
| Gd: (...args) => _emscripten_request_fullscreen_strategy(...args),
|
| Ib: (...args) => _emscripten_request_pointerlock(...args),
|
| Fd: (...args) => _emscripten_resize_heap(...args),
|
| Ed: (...args) => _emscripten_run_script_int(...args),
|
| Hb: (...args) => _emscripten_sample_gamepad_data(...args),
|
| Gb: (...args) => _emscripten_set_beforeunload_callback_on_thread(...args),
|
| Fb: (...args) => _emscripten_set_blur_callback_on_thread(...args),
|
| da: (...args) => _emscripten_set_canvas_element_size(...args),
|
| Aa: (...args) => _emscripten_set_element_css_size(...args),
|
| Eb: (...args) => _emscripten_set_focus_callback_on_thread(...args),
|
| Db: (...args) => _emscripten_set_fullscreenchange_callback_on_thread(...args),
|
| Cb: (...args) => _emscripten_set_gamepadconnected_callback_on_thread(...args),
|
| Bb: (...args) => _emscripten_set_gamepaddisconnected_callback_on_thread(...args),
|
| Ab: (...args) => _emscripten_set_keydown_callback_on_thread(...args),
|
| zb: (...args) => _emscripten_set_keypress_callback_on_thread(...args),
|
| yb: (...args) => _emscripten_set_keyup_callback_on_thread(...args),
|
| Dd: (...args) => _emscripten_set_main_loop(...args),
|
| xb: (...args) => _emscripten_set_mousedown_callback_on_thread(...args),
|
| wb: (...args) => _emscripten_set_mouseenter_callback_on_thread(...args),
|
| vb: (...args) => _emscripten_set_mouseleave_callback_on_thread(...args),
|
| ub: (...args) => _emscripten_set_mousemove_callback_on_thread(...args),
|
| tb: (...args) => _emscripten_set_mouseup_callback_on_thread(...args),
|
| sb: (...args) => _emscripten_set_pointerlockchange_callback_on_thread(...args),
|
| rb: (...args) => _emscripten_set_resize_callback_on_thread(...args),
|
| qb: (...args) => _emscripten_set_touchcancel_callback_on_thread(...args),
|
| pb: (...args) => _emscripten_set_touchend_callback_on_thread(...args),
|
| ob: (...args) => _emscripten_set_touchmove_callback_on_thread(...args),
|
| nb: (...args) => _emscripten_set_touchstart_callback_on_thread(...args),
|
| mb: (...args) => _emscripten_set_visibilitychange_callback_on_thread(...args),
|
| lb: (...args) => _emscripten_set_wheel_callback_on_thread(...args),
|
| Cd: (...args) => _emscripten_set_window_title(...args),
|
| za: (...args) => _emscripten_sleep(...args),
|
| Bd: (...args) => _emscripten_start_fetch(...args),
|
| ik: (...args) => _environ_get(...args),
|
| hk: (...args) => _environ_sizes_get(...args),
|
| Ad: (...args) => _exit(...args),
|
| ja: (...args) => _fd_close(...args),
|
| dc: (...args) => _fd_read(...args),
|
| gk: (...args) => _fd_seek(...args),
|
| cc: (...args) => _fd_write(...args),
|
| zd: (...args) => _glActiveTexture(...args),
|
| kb: (...args) => _glAttachShader(...args),
|
| _: (...args) => _glBindBuffer(...args),
|
| yd: (...args) => _glBindBufferBase(...args),
|
| Z: (...args) => _glBindFramebuffer(...args),
|
| jb: (...args) => _glBindRenderbuffer(...args),
|
| xd: (...args) => _glBindSampler(...args),
|
| M: (...args) => _glBindTexture(...args),
|
| wd: (...args) => _glBindVertexArray(...args),
|
| vd: (...args) => _glBlendEquationSeparate(...args),
|
| ud: (...args) => _glBlendFuncSeparate(...args),
|
| Y: (...args) => _glBufferData(...args),
|
| td: (...args) => _glClear(...args),
|
| sd: (...args) => _glClearColor(...args),
|
| rd: (...args) => _glClearDepthf(...args),
|
| qd: (...args) => _glClearStencil(...args),
|
| pd: (...args) => _glColorMask(...args),
|
| od: (...args) => _glCompileShader(...args),
|
| nd: (...args) => _glCopyTexSubImage2D(...args),
|
| md: (...args) => _glCreateProgram(...args),
|
| ld: (...args) => _glCreateShader(...args),
|
| kd: (...args) => _glCullFace(...args),
|
| ya: (...args) => _glDeleteBuffers(...args),
|
| ib: (...args) => _glDeleteFramebuffers(...args),
|
| jd: (...args) => _glDeleteProgram(...args),
|
| id: (...args) => _glDeleteRenderbuffers(...args),
|
| hd: (...args) => _glDeleteSamplers(...args),
|
| hb: (...args) => _glDeleteShader(...args),
|
| gd: (...args) => _glDeleteTextures(...args),
|
| fd: (...args) => _glDeleteVertexArrays(...args),
|
| ed: (...args) => _glDepthFunc(...args),
|
| xa: (...args) => _glDepthMask(...args),
|
| dd: (...args) => _glDepthRangef(...args),
|
| Q: (...args) => _glDisable(...args),
|
| cd: (...args) => _glDisableVertexAttribArray(...args),
|
| bd: (...args) => _glDrawArraysInstanced(...args),
|
| ad: (...args) => _glDrawBuffers(...args),
|
| $c: (...args) => _glDrawElementsInstanced(...args),
|
| P: (...args) => _glEnable(...args),
|
| _c: (...args) => _glEnableVertexAttribArray(...args),
|
| Zc: (...args) => _glFramebufferRenderbuffer(...args),
|
| gb: (...args) => _glFramebufferTexture2D(...args),
|
| Yc: (...args) => _glFrontFace(...args),
|
| wa: (...args) => _glGenBuffers(...args),
|
| fb: (...args) => _glGenFramebuffers(...args),
|
| Xc: (...args) => _glGenRenderbuffers(...args),
|
| Wc: (...args) => _glGenSamplers(...args),
|
| Vc: (...args) => _glGenTextures(...args),
|
| Uc: (...args) => _glGenVertexArrays(...args),
|
| Tc: (...args) => _glGenerateMipmap(...args),
|
| C: (...args) => _glGetIntegerv(...args),
|
| Sc: (...args) => _glGetProgramInfoLog(...args),
|
| eb: (...args) => _glGetProgramiv(...args),
|
| Rc: (...args) => _glGetShaderInfoLog(...args),
|
| db: (...args) => _glGetShaderiv(...args),
|
| Qc: (...args) => _glGetStringi(...args),
|
| Pc: (...args) => _glGetUniformBlockIndex(...args),
|
| Oc: (...args) => _glGetUniformLocation(...args),
|
| Nc: (...args) => _glLinkProgram(...args),
|
| cb: (...args) => _glPixelStorei(...args),
|
| Mc: (...args) => _glPolygonOffset(...args),
|
| Lc: (...args) => _glReadPixels(...args),
|
| Kc: (...args) => _glRenderbufferStorage(...args),
|
| Jc: (...args) => _glSamplerParameterf(...args),
|
| pa: (...args) => _glSamplerParameteri(...args),
|
| bb: (...args) => _glScissor(...args),
|
| Ic: (...args) => _glShaderSource(...args),
|
| Hc: (...args) => _glStencilFunc(...args),
|
| Gc: (...args) => _glStencilMask(...args),
|
| Fc: (...args) => _glStencilOp(...args),
|
| Ec: (...args) => _glTexImage2D(...args),
|
| Dc: (...args) => _glTexParameteri(...args),
|
| Cc: (...args) => _glTexSubImage2D(...args),
|
| Bc: (...args) => _glUniform1i(...args),
|
| Ac: (...args) => _glUniformBlockBinding(...args),
|
| va: (...args) => _glUseProgram(...args),
|
| zc: (...args) => _glVertexAttribDivisor(...args),
|
| yc: (...args) => _glVertexAttribPointer(...args),
|
| xc: (...args) => _glViewport(...args),
|
| ab: invoke_diii,
|
| wc: invoke_f,
|
| ca: invoke_fff,
|
| $a: invoke_ffffi,
|
| ba: invoke_fi,
|
| F: invoke_fii,
|
| oa: invoke_fiif,
|
| na: invoke_fiii,
|
| _a: invoke_fiiif,
|
| t: invoke_i,
|
| Za: invoke_idiiii,
|
| d: invoke_ii,
|
| Ya: invoke_iif,
|
| aa: invoke_iifiiiiiii,
|
| k: invoke_iii,
|
| w: invoke_iiifffii,
|
| A: invoke_iiiffii,
|
| ua: invoke_iiifi,
|
| j: invoke_iiii,
|
| ta: invoke_iiiid,
|
| Xa: invoke_iiiif,
|
| Wa: invoke_iiiifi,
|
| Va: invoke_iiiifii,
|
| m: invoke_iiiii,
|
| vc: invoke_iiiiiff,
|
| X: invoke_iiiiifffffff,
|
| T: invoke_iiiiifiiii,
|
| L: invoke_iiiiifiiiii,
|
| o: invoke_iiiiii,
|
| r: invoke_iiiiiii,
|
| K: invoke_iiiiiiii,
|
| Ua: invoke_iiiiiiiii,
|
| ma: invoke_iiiiiiiiiiii,
|
| Ta: invoke_iiiiiiiiiiiii,
|
| W: invoke_iiji,
|
| la: invoke_iijiii,
|
| uc: invoke_iijji,
|
| Sa: invoke_iijjiii,
|
| tc: invoke_ijjiiii,
|
| O: invoke_j,
|
| Ra: invoke_ji,
|
| Qa: invoke_jiiii,
|
| g: invoke_v,
|
| Pa: invoke_vdii,
|
| sc: invoke_vf,
|
| e: invoke_vi,
|
| N: invoke_vif,
|
| Oa: invoke_viff,
|
| rc: invoke_vifffii,
|
| J: invoke_vifi,
|
| b: invoke_vii,
|
| I: invoke_viif,
|
| qc: invoke_viiff,
|
| Na: invoke_viifi,
|
| i: invoke_viii,
|
| Ma: invoke_viiif,
|
| pc: invoke_viiiffi,
|
| sa: invoke_viiifi,
|
| x: invoke_viiifiiiiifi,
|
| l: invoke_viiii,
|
| La: invoke_viiiiffffiiif,
|
| Ka: invoke_viiiifi,
|
| oc: invoke_viiiifif,
|
| p: invoke_viiiii,
|
| s: invoke_viiiiii,
|
| E: invoke_viiiiiii,
|
| S: invoke_viiiiiiii,
|
| nc: invoke_viiiiiiiii,
|
| V: invoke_viiiiiiiiii,
|
| mc: invoke_viiiiiiiiiii,
|
| ka: invoke_viiiiiiiiiiiiiii,
|
| lc: invoke_viij,
|
| Ja: invoke_viijii,
|
| kc: invoke_vij,
|
| jc: invoke_viji,
|
| ic: invoke_vjjii,
|
| hc: _llvm_eh_typeid_for
|
| };
|
|
|
| function invoke_viiii(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vii(index, a1, a2) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_ii(index, a1) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iii(index, a1, a2) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_v(index) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)()
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viii(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vi(index, a1) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiii(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiii(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_i(index) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)()
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiid(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vif(index, a1, a2) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vifi(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viif(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiifiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vf(index, a1) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_ffffi(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiii(index, a1, a2, a3, a4, a5) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiifii(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiifi(index, a1, a2, a3, a4, a5) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_fff(index, a1, a2) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiif(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiif(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_fi(index, a1) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiifiiiiifi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iif(index, a1, a2) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_j(index) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)()
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0);
|
| return 0n
|
| }
|
| }
|
|
|
| function invoke_ji(index, a1) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0);
|
| return 0n
|
| }
|
| }
|
|
|
| function invoke_viifi(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_f(index) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)()
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiff(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiji(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiifiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iifiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiifffffff(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiiff(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiffffiiif(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiifi(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiifi(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiifi(index, a1, a2, a3, a4, a5) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vifffii(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_fiii(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_fiiif(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_fiif(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiffi(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_fii(index, a1, a2) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vij(index, a1, a2) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viij(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viff(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iijiii(index, a1, a2, a3, a4, a5) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iijjiii(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iijji(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vjjii(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_ijjiiii(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_vdii(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_idiiii(index, a1, a2, a3, a4, a5) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiffii(index, a1, a2, a3, a4, a5, a6) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiifffii(index, a1, a2, a3, a4, a5, a6, a7) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiifif(index, a1, a2, a3, a4, a5, a6, a7) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viji(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viijii(index, a1, a2, a3, a4, a5) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_jiiii(index, a1, a2, a3, a4) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0);
|
| return 0n
|
| }
|
| }
|
|
|
| function invoke_diii(index, a1, a2, a3) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_iiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
|
| var sp = stackSave();
|
| try {
|
| return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function invoke_viiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {
|
| var sp = stackSave();
|
| try {
|
| getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
|
| } catch (e) {
|
| stackRestore(sp);
|
| if (e !== e + 0) throw e;
|
| _setThrew(1, 0)
|
| }
|
| }
|
|
|
| function callMain(args = []) {
|
| var entryFunction = _main;
|
| args.unshift(thisProgram);
|
| var argc = args.length;
|
| var argv = stackAlloc((argc + 1) * 4);
|
| var argv_ptr = argv;
|
| for (var arg of args) {
|
| HEAPU32[argv_ptr >> 2] = stringToUTF8OnStack(arg);
|
| argv_ptr += 4
|
| }
|
| HEAPU32[argv_ptr >> 2] = 0;
|
| try {
|
| var ret = entryFunction(argc, argv);
|
| exitJS(ret, true);
|
| return ret
|
| } catch (e) {
|
| return handleException(e)
|
| }
|
| }
|
|
|
| function run(args = arguments_) {
|
| if (runDependencies > 0) {
|
| dependenciesFulfilled = run;
|
| return
|
| }
|
| preRun();
|
| if (runDependencies > 0) {
|
| dependenciesFulfilled = run;
|
| return
|
| }
|
|
|
| function doRun() {
|
| Module["calledRun"] = true;
|
| if (ABORT) return;
|
| initRuntime();
|
| preMain();
|
| Module["onRuntimeInitialized"]?.();
|
| var noInitialRun = Module["noInitialRun"] || false;
|
| if (!noInitialRun) callMain(args);
|
| postRun()
|
| }
|
| if (Module["setStatus"]) {
|
| Module["setStatus"]("Running...");
|
| setTimeout(() => {
|
| setTimeout(() => Module["setStatus"](""), 1);
|
| doRun()
|
| }, 1)
|
| } else {
|
| doRun()
|
| }
|
| }
|
|
|
