From d74b495736f0c04522ec54274b70fed0ded2878d Mon Sep 17 00:00:00 2001
From: zhongrj <646384940@qq.com>
Date: Tue, 27 Jun 2023 11:30:06 +0800
Subject: [PATCH] 任务新增导出
---
public/map/lib/videoPlay/js/playctrl/Decoder.min.js | 3305 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 3,305 insertions(+), 0 deletions(-)
diff --git a/public/map/lib/videoPlay/js/playctrl/Decoder.min.js b/public/map/lib/videoPlay/js/playctrl/Decoder.min.js
new file mode 100644
index 0000000..e6c3e52
--- /dev/null
+++ b/public/map/lib/videoPlay/js/playctrl/Decoder.min.js
@@ -0,0 +1,3305 @@
+var Module;
+if (!Module) Module = (typeof Module !== "undefined" ? Module : null) || {};
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key]
+ }
+}
+var ENVIRONMENT_IS_WEB = false;
+var ENVIRONMENT_IS_WORKER = false;
+var ENVIRONMENT_IS_NODE = false;
+var ENVIRONMENT_IS_SHELL = false;
+if (Module["ENVIRONMENT"]) {
+ if (Module["ENVIRONMENT"] === "WEB") {
+ ENVIRONMENT_IS_WEB = true
+ } else if (Module["ENVIRONMENT"] === "WORKER") {
+ ENVIRONMENT_IS_WORKER = true
+ } else if (Module["ENVIRONMENT"] === "NODE") {
+ ENVIRONMENT_IS_NODE = true
+ } else if (Module["ENVIRONMENT"] === "SHELL") {
+ ENVIRONMENT_IS_SHELL = true
+ } else {
+ throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.")
+ }
+} else {
+ ENVIRONMENT_IS_WEB = typeof window === "object";
+ ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
+ ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
+ ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER
+}
+if (ENVIRONMENT_IS_NODE) {
+ if (!Module["print"]) Module["print"] = console.log;
+ if (!Module["printErr"]) Module["printErr"] = console.warn;
+ var nodeFS;
+ var nodePath;
+ Module["read"] = function shell_read(filename, binary) {
+ if (!nodeFS) nodeFS = require("fs");
+ if (!nodePath) nodePath = require("path");
+ filename = nodePath["normalize"](filename);
+ var ret = nodeFS["readFileSync"](filename);
+ return binary ? ret : ret.toString()
+ };
+ Module["readBinary"] = function readBinary(filename) {
+ var ret = Module["read"](filename, true);
+ if (!ret.buffer) {
+ ret = new Uint8Array(ret)
+ }
+ assert(ret.buffer);
+ return ret
+ };
+ Module["load"] = function load(f) {
+ globalEval(read(f))
+ };
+ if (!Module["thisProgram"]) {
+ if (process["argv"].length > 1) {
+ Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/")
+ } else {
+ Module["thisProgram"] = "unknown-program"
+ }
+ }
+ Module["arguments"] = process["argv"].slice(2);
+ if (typeof module !== "undefined") {
+ module["exports"] = Module
+ }
+ process["on"]("uncaughtException", (function(ex) {
+ if (!(ex instanceof ExitStatus)) {
+ throw ex
+ }
+ }));
+ Module["inspect"] = (function() {
+ return "[Emscripten Module object]"
+ })
+} else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module["print"]) Module["print"] = print;
+ if (typeof printErr != "undefined") Module["printErr"] = printErr;
+ if (typeof read != "undefined") {
+ Module["read"] = read
+ } else {
+ Module["read"] = function shell_read() {
+ throw "no read() available"
+ }
+ }
+ Module["readBinary"] = function readBinary(f) {
+ if (typeof readbuffer === "function") {
+ return new Uint8Array(readbuffer(f))
+ }
+ var data = read(f, "binary");
+ assert(typeof data === "object");
+ return data
+ };
+ if (typeof scriptArgs != "undefined") {
+ Module["arguments"] = scriptArgs
+ } else if (typeof arguments != "undefined") {
+ Module["arguments"] = arguments
+ }
+ if (typeof quit === "function") {
+ Module["quit"] = (function(status, toThrow) {
+ quit(status)
+ })
+ }
+} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module["read"] = function shell_read(url) {
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, false);
+ xhr.send(null);
+ return xhr.responseText
+ };
+ if (ENVIRONMENT_IS_WORKER) {
+ Module["readBinary"] = function readBinary(url) {
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, false);
+ xhr.responseType = "arraybuffer";
+ xhr.send(null);
+ return new Uint8Array(xhr.response)
+ }
+ }
+ Module["readAsync"] = function readAsync(url, onload, onerror) {
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, true);
+ xhr.responseType = "arraybuffer";
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+ onload(xhr.response)
+ } else {
+ onerror()
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null)
+ };
+ if (typeof arguments != "undefined") {
+ Module["arguments"] = arguments
+ }
+ if (typeof console !== "undefined") {
+ if (!Module["print"]) Module["print"] = function shell_print(x) {
+ console.log(x)
+ };
+ if (!Module["printErr"]) Module["printErr"] = function shell_printErr(x) {
+ console.warn(x)
+ }
+ } else {
+ var TRY_USE_DUMP = false;
+ if (!Module["print"]) Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? (function(x) {
+ dump(x)
+ }) : (function(x) {})
+ }
+ if (ENVIRONMENT_IS_WORKER) {
+ Module["load"] = importScripts
+ }
+ if (typeof Module["setWindowTitle"] === "undefined") {
+ Module["setWindowTitle"] = (function(title) {
+ document.title = title
+ })
+ }
+} else {
+ throw "Unknown runtime environment. Where are we?"
+}
+function globalEval(x) {
+ eval.call(null, x)
+}
+if (!Module["load"] && Module["read"]) {
+ Module["load"] = function load(f) {
+ globalEval(Module["read"](f))
+ }
+}
+if (!Module["print"]) {
+ Module["print"] = (function() {})
+}
+if (!Module["printErr"]) {
+ Module["printErr"] = Module["print"]
+}
+if (!Module["arguments"]) {
+ Module["arguments"] = []
+}
+if (!Module["thisProgram"]) {
+ Module["thisProgram"] = "./this.program"
+}
+if (!Module["quit"]) {
+ Module["quit"] = (function(status, toThrow) {
+ throw toThrow
+ })
+}
+Module.print = Module["print"];
+Module.printErr = Module["printErr"];
+Module["preRun"] = [];
+Module["postRun"] = [];
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key]
+ }
+}
+moduleOverrides = undefined;
+var Runtime = {
+ setTempRet0: (function(value) {
+ tempRet0 = value;
+ return value
+ }),
+ getTempRet0: (function() {
+ return tempRet0
+ }),
+ stackSave: (function() {
+ return STACKTOP
+ }),
+ stackRestore: (function(stackTop) {
+ STACKTOP = stackTop
+ }),
+ getNativeTypeSize: (function(type) {
+ switch (type) {
+ case "i1":
+ case "i8":
+ return 1;
+ case "i16":
+ return 2;
+ case "i32":
+ return 4;
+ case "i64":
+ return 8;
+ case "float":
+ return 4;
+ case "double":
+ return 8;
+ default:
+ {
+ if (type[type.length - 1] === "*") {
+ return Runtime.QUANTUM_SIZE
+ } else if (type[0] === "i") {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits / 8
+ } else {
+ return 0
+ }
+ }
+ }
+ }),
+ getNativeFieldSize: (function(type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE)
+ }),
+ STACK_ALIGN: 16,
+ prepVararg: (function(ptr, type) {
+ if (type === "double" || type === "i64") {
+ if (ptr & 7) {
+ assert((ptr & 7) === 4);
+ ptr += 4
+ }
+ } else {
+ assert((ptr & 3) === 0)
+ }
+ return ptr
+ }),
+ getAlignSize: (function(type, size, vararg) {
+ if (!vararg && (type == "i64" || type == "double")) return 8;
+ if (!type) return Math.min(size, 8);
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE)
+ }),
+ dynCall: (function(sig, ptr, args) {
+ if (args && args.length) {
+ return Module["dynCall_" + sig].apply(null, [ptr].concat(args))
+ } else {
+ return Module["dynCall_" + sig].call(null, ptr)
+ }
+ }),
+ functionPointers: [],
+ addFunction: (function(func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2 * (1 + i)
+ }
+ }
+ throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."
+ }),
+ removeFunction: (function(index) {
+ Runtime.functionPointers[(index - 2) / 2] = null
+ }),
+ warnOnce: (function(text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text)
+ }
+ }),
+ funcWrappers: {},
+ getFuncWrapper: (function(func, sig) {
+ if (!func) return;
+ assert(sig);
+ if (!Runtime.funcWrappers[sig]) {
+ Runtime.funcWrappers[sig] = {}
+ }
+ var sigCache = Runtime.funcWrappers[sig];
+ if (!sigCache[func]) {
+ if (sig.length === 1) {
+ sigCache[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func)
+ }
+ } else if (sig.length === 2) {
+ sigCache[func] = function dynCall_wrapper(arg) {
+ return Runtime.dynCall(sig, func, [arg])
+ }
+ } else {
+ sigCache[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, Array.prototype.slice.call(arguments))
+ }
+ }
+ }
+ return sigCache[func]
+ }),
+ getCompilerSetting: (function(name) {
+ throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work"
+ }),
+ stackAlloc: (function(size) {
+ var ret = STACKTOP;
+ STACKTOP = STACKTOP + size | 0;
+ STACKTOP = STACKTOP + 15 & -16;
+ return ret
+ }),
+ staticAlloc: (function(size) {
+ var ret = STATICTOP;
+ STATICTOP = STATICTOP + size | 0;
+ STATICTOP = STATICTOP + 15 & -16;
+ return ret
+ }),
+ dynamicAlloc: (function(size) {
+ var ret = HEAP32[DYNAMICTOP_PTR >> 2];
+ var end = (ret + size + 15 | 0) & -16;
+ HEAP32[DYNAMICTOP_PTR >> 2] = end;
+ if (end >= TOTAL_MEMORY) {
+ var success = enlargeMemory();
+ if (!success) {
+ HEAP32[DYNAMICTOP_PTR >> 2] = ret;
+ return 0
+ }
+ }
+ return ret
+ }),
+ alignMemory: (function(size, quantum) {
+ var ret = size = Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16);
+ return ret
+ }),
+ makeBigInt: (function(low, high, unsigned) {
+ var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296;
+ return ret
+ }),
+ GLOBAL_BASE: 1024,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+};
+Module["Runtime"] = Runtime;
+var ABORT = 0;
+var EXITSTATUS = 0;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort("Assertion failed: " + text)
+ }
+}
+function getCFunc(ident) {
+ var func = Module["_" + ident];
+ if (!func) {
+ try {
+ func = eval("_" + ident)
+ } catch (e) {}
+ }
+ assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
+ return func
+}
+var cwrap, ccall;
+((function() {
+ var JSfuncs = {
+ "stackSave": (function() {
+ Runtime.stackSave()
+ }),
+ "stackRestore": (function() {
+ Runtime.stackRestore()
+ }),
+ "arrayToC": (function(arr) {
+ var ret = Runtime.stackAlloc(arr.length);
+ writeArrayToMemory(arr, ret);
+ return ret
+ }),
+ "stringToC": (function(str) {
+ var ret = 0;
+ if (str !== null && str !== undefined && str !== 0) {
+ var len = (str.length << 2) + 1;
+ ret = Runtime.stackAlloc(len);
+ stringToUTF8(str, ret, len)
+ }
+ return ret
+ })
+ };
+ var toC = {
+ "string": JSfuncs["stringToC"],
+ "array": JSfuncs["arrayToC"]
+ };
+ ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
+ var func = getCFunc(ident);
+ var cArgs = [];
+ var stack = 0;
+ if (args) {
+ for (var i = 0; i < args.length; i++) {
+ var converter = toC[argTypes[i]];
+ if (converter) {
+ if (stack === 0) stack = Runtime.stackSave();
+ cArgs[i] = converter(args[i])
+ } else {
+ cArgs[i] = args[i]
+ }
+ }
+ }
+ var ret = func.apply(null, cArgs);
+ if (returnType === "string") ret = Pointer_stringify(ret);
+ if (stack !== 0) {
+ if (opts && opts.async) {
+ EmterpreterAsync.asyncFinalizers.push((function() {
+ Runtime.stackRestore(stack)
+ }));
+ return
+ }
+ Runtime.stackRestore(stack)
+ }
+ return ret
+ };
+ var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
+
+ function parseJSFunc(jsfunc) {
+ var parsed = jsfunc.toString().match(sourceRegex).slice(1);
+ return {
+ arguments: parsed[0],
+ body: parsed[1],
+ returnValue: parsed[2]
+ }
+ }
+ var JSsource = null;
+
+ function ensureJSsource() {
+ if (!JSsource) {
+ JSsource = {};
+ for (var fun in JSfuncs) {
+ if (JSfuncs.hasOwnProperty(fun)) {
+ JSsource[fun] = parseJSFunc(JSfuncs[fun])
+ }
+ }
+ }
+ }
+ cwrap = function cwrap(ident, returnType, argTypes) {
+ argTypes = argTypes || [];
+ var cfunc = getCFunc(ident);
+ var numericArgs = argTypes.every((function(type) {
+ return type === "number"
+ }));
+ var numericRet = returnType !== "string";
+ if (numericRet && numericArgs) {
+ return cfunc
+ }
+ var argNames = argTypes.map((function(x, i) {
+ return "$" + i
+ }));
+ var funcstr = "(function(" + argNames.join(",") + ") {";
+ var nargs = argTypes.length;
+ if (!numericArgs) {
+ ensureJSsource();
+ funcstr += "var stack = " + JSsource["stackSave"].body + ";";
+ for (var i = 0; i < nargs; i++) {
+ var arg = argNames[i],
+ type = argTypes[i];
+ if (type === "number") continue;
+ var convertCode = JSsource[type + "ToC"];
+ funcstr += "var " + convertCode.arguments + " = " + arg + ";";
+ funcstr += convertCode.body + ";";
+ funcstr += arg + "=(" + convertCode.returnValue + ");"
+ }
+ }
+ var cfuncname = parseJSFunc((function() {
+ return cfunc
+ })).returnValue;
+ funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
+ if (!numericRet) {
+ var strgfy = parseJSFunc((function() {
+ return Pointer_stringify
+ })).returnValue;
+ funcstr += "ret = " + strgfy + "(ret);"
+ }
+ if (!numericArgs) {
+ ensureJSsource();
+ funcstr += JSsource["stackRestore"].body.replace("()", "(stack)") + ";"
+ }
+ funcstr += "return ret})";
+ return eval(funcstr)
+ }
+}))();
+Module["ccall"] = ccall;
+Module["cwrap"] = cwrap;
+
+function setValue(ptr, value, type, noSafe) {
+ type = type || "i8";
+ if (type.charAt(type.length - 1) === "*") type = "i32";
+ switch (type) {
+ case "i1":
+ HEAP8[ptr >> 0] = value;
+ break;
+ case "i8":
+ HEAP8[ptr >> 0] = value;
+ break;
+ case "i16":
+ HEAP16[ptr >> 1] = value;
+ break;
+ case "i32":
+ HEAP32[ptr >> 2] = value;
+ break;
+ case "i64":
+ tempI64 = [value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~ + Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
+ break;
+ case "float":
+ HEAPF32[ptr >> 2] = value;
+ break;
+ case "double":
+ HEAPF64[ptr >> 3] = value;
+ break;
+ default:
+ abort("invalid type for setValue: " + type)
+ }
+}
+Module["setValue"] = setValue;
+
+function getValue(ptr, type, noSafe) {
+ type = type || "i8";
+ if (type.charAt(type.length - 1) === "*") type = "i32";
+ switch (type) {
+ case "i1":
+ return HEAP8[ptr >> 0];
+ case "i8":
+ return HEAP8[ptr >> 0];
+ case "i16":
+ return HEAP16[ptr >> 1];
+ case "i32":
+ return HEAP32[ptr >> 2];
+ case "i64":
+ return HEAP32[ptr >> 2];
+ case "float":
+ return HEAPF32[ptr >> 2];
+ case "double":
+ return HEAPF64[ptr >> 3];
+ default:
+ abort("invalid type for setValue: " + type)
+ }
+ return null
+}
+Module["getValue"] = getValue;
+var ALLOC_NORMAL = 0;
+var ALLOC_STACK = 1;
+var ALLOC_STATIC = 2;
+var ALLOC_DYNAMIC = 3;
+var ALLOC_NONE = 4;
+Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
+Module["ALLOC_STACK"] = ALLOC_STACK;
+Module["ALLOC_STATIC"] = ALLOC_STATIC;
+Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
+Module["ALLOC_NONE"] = ALLOC_NONE;
+
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === "number") {
+ zeroinit = true;
+ size = slab
+ } else {
+ zeroinit = false;
+ size = slab.length
+ }
+ var singleType = typeof types === "string" ? types : null;
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr
+ } else {
+ ret = [typeof _malloc === "function" ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length))
+ }
+ if (zeroinit) {
+ var ptr = ret,
+ stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[ptr >> 2] = 0
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[ptr++ >> 0] = 0
+ }
+ return ret
+ }
+ if (singleType === "i8") {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret)
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret)
+ }
+ return ret
+ }
+ var i = 0,
+ type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+ if (typeof curr === "function") {
+ curr = Runtime.getFunctionIndex(curr)
+ }
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue
+ }
+ if (type == "i64") type = "i32";
+ setValue(ret + i, curr, type);
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type
+ }
+ i += typeSize
+ }
+ return ret
+}
+Module["allocate"] = allocate;
+
+function getMemory(size) {
+ if (!staticSealed) return Runtime.staticAlloc(size);
+ if (!runtimeInitialized) return Runtime.dynamicAlloc(size);
+ return _malloc(size)
+}
+Module["getMemory"] = getMemory;
+
+function Pointer_stringify(ptr, length) {
+ if (length === 0 || !ptr) return "";
+ var hasUtf = 0;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[ptr + i >> 0];
+ hasUtf |= t;
+ if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break
+ }
+ if (!length) length = i;
+ var ret = "";
+ if (hasUtf < 128) {
+ var MAX_CHUNK = 1024;
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK
+ }
+ return ret
+ }
+ return Module["UTF8ToString"](ptr)
+}
+Module["Pointer_stringify"] = Pointer_stringify;
+
+function AsciiToString(ptr) {
+ var str = "";
+ while (1) {
+ var ch = HEAP8[ptr++ >> 0];
+ if (!ch) return str;
+ str += String.fromCharCode(ch)
+ }
+}
+Module["AsciiToString"] = AsciiToString;
+
+function stringToAscii(str, outPtr) {
+ return writeAsciiToMemory(str, outPtr, false)
+}
+Module["stringToAscii"] = stringToAscii;
+var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
+
+function UTF8ArrayToString(u8Array, idx) {
+ var endPtr = idx;
+ while (u8Array[endPtr])++endPtr;
+ if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
+ return UTF8Decoder.decode(u8Array.subarray(idx, endPtr))
+ } else {
+ var u0, u1, u2, u3, u4, u5;
+ var str = "";
+ while (1) {
+ u0 = u8Array[idx++];
+ if (!u0) return str;
+ if (!(u0 & 128)) {
+ str += String.fromCharCode(u0);
+ continue
+ }
+ u1 = u8Array[idx++] & 63;
+ if ((u0 & 224) == 192) {
+ str += String.fromCharCode((u0 & 31) << 6 | u1);
+ continue
+ }
+ u2 = u8Array[idx++] & 63;
+ if ((u0 & 240) == 224) {
+ u0 = (u0 & 15) << 12 | u1 << 6 | u2
+ } else {
+ u3 = u8Array[idx++] & 63;
+ if ((u0 & 248) == 240) {
+ u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3
+ } else {
+ u4 = u8Array[idx++] & 63;
+ if ((u0 & 252) == 248) {
+ u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4
+ } else {
+ u5 = u8Array[idx++] & 63;
+ u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5
+ }
+ }
+ }
+ if (u0 < 65536) {
+ str += String.fromCharCode(u0)
+ } else {
+ var ch = u0 - 65536;
+ str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
+ }
+ }
+ }
+}
+Module["UTF8ArrayToString"] = UTF8ArrayToString;
+
+function UTF8ToString(ptr) {
+ return UTF8ArrayToString(HEAPU8, ptr)
+}
+Module["UTF8ToString"] = UTF8ToString;
+
+function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
+ if (!(maxBytesToWrite > 0)) return 0;
+ var startIdx = outIdx;
+ var endIdx = outIdx + maxBytesToWrite - 1;
+ for (var i = 0; i < str.length; ++i) {
+ var u = str.charCodeAt(i);
+ if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
+ if (u <= 127) {
+ if (outIdx >= endIdx) break;
+ outU8Array[outIdx++] = u
+ } else if (u <= 2047) {
+ if (outIdx + 1 >= endIdx) break;
+ outU8Array[outIdx++] = 192 | u >> 6;
+ outU8Array[outIdx++] = 128 | u & 63
+ } else if (u <= 65535) {
+ if (outIdx + 2 >= endIdx) break;
+ outU8Array[outIdx++] = 224 | u >> 12;
+ outU8Array[outIdx++] = 128 | u >> 6 & 63;
+ outU8Array[outIdx++] = 128 | u & 63
+ } else if (u <= 2097151) {
+ if (outIdx + 3 >= endIdx) break;
+ outU8Array[outIdx++] = 240 | u >> 18;
+ outU8Array[outIdx++] = 128 | u >> 12 & 63;
+ outU8Array[outIdx++] = 128 | u >> 6 & 63;
+ outU8Array[outIdx++] = 128 | u & 63
+ } else if (u <= 67108863) {
+ if (outIdx + 4 >= endIdx) break;
+ outU8Array[outIdx++] = 248 | u >> 24;
+ outU8Array[outIdx++] = 128 | u >> 18 & 63;
+ outU8Array[outIdx++] = 128 | u >> 12 & 63;
+ outU8Array[outIdx++] = 128 | u >> 6 & 63;
+ outU8Array[outIdx++] = 128 | u & 63
+ } else {
+ if (outIdx + 5 >= endIdx) break;
+ outU8Array[outIdx++] = 252 | u >> 30;
+ outU8Array[outIdx++] = 128 | u >> 24 & 63;
+ outU8Array[outIdx++] = 128 | u >> 18 & 63;
+ outU8Array[outIdx++] = 128 | u >> 12 & 63;
+ outU8Array[outIdx++] = 128 | u >> 6 & 63;
+ outU8Array[outIdx++] = 128 | u & 63
+ }
+ }
+ outU8Array[outIdx] = 0;
+ return outIdx - startIdx
+}
+Module["stringToUTF8Array"] = stringToUTF8Array;
+
+function stringToUTF8(str, outPtr, maxBytesToWrite) {
+ return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
+}
+Module["stringToUTF8"] = stringToUTF8;
+
+function lengthBytesUTF8(str) {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+ var u = str.charCodeAt(i);
+ if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
+ if (u <= 127) {
+ ++len
+ } else if (u <= 2047) {
+ len += 2
+ } else if (u <= 65535) {
+ len += 3
+ } else if (u <= 2097151) {
+ len += 4
+ } else if (u <= 67108863) {
+ len += 5
+ } else {
+ len += 6
+ }
+ }
+ return len
+}
+Module["lengthBytesUTF8"] = lengthBytesUTF8;
+var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
+
+function demangle(func) {
+ var __cxa_demangle_func = Module["___cxa_demangle"] || Module["__cxa_demangle"];
+ if (__cxa_demangle_func) {
+ try {
+ var s = func.substr(1);
+ var len = lengthBytesUTF8(s) + 1;
+ var buf = _malloc(len);
+ stringToUTF8(s, buf, len);
+ var status = _malloc(4);
+ var ret = __cxa_demangle_func(buf, 0, 0, status);
+ if (getValue(status, "i32") === 0 && ret) {
+ return Pointer_stringify(ret)
+ }
+ } catch (e) {} finally {
+ if (buf) _free(buf);
+ if (status) _free(status);
+ if (ret) _free(ret)
+ }
+ return func
+ }
+ Runtime.warnOnce("warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling");
+ return func
+}
+function demangleAll(text) {
+ var regex = /__Z[\w\d_]+/g;
+ return text.replace(regex, (function(x) {
+ var y = demangle(x);
+ return x === y ? x : x + " [" + y + "]"
+ }))
+}
+function jsStackTrace() {
+ var err = new Error;
+ if (!err.stack) {
+ try {
+ throw new Error(0)
+ } catch (e) {
+ err = e
+ }
+ if (!err.stack) {
+ return "(no stack trace available)"
+ }
+ }
+ return err.stack.toString()
+}
+function stackTrace() {
+ var js = jsStackTrace();
+ if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
+ return demangleAll(js)
+}
+Module["stackTrace"] = stackTrace;
+var WASM_PAGE_SIZE = 65536;
+var ASMJS_PAGE_SIZE = 16777216;
+
+function alignUp(x, multiple) {
+ if (x % multiple > 0) {
+ x += multiple - x % multiple
+ }
+ return x
+}
+var HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+function updateGlobalBuffer(buf) {
+ Module["buffer"] = buffer = buf
+}
+function updateGlobalBufferViews() {
+ Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
+ Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
+ Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
+ Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
+ Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
+ Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
+ Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
+ Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer)
+}
+var STATIC_BASE, STATICTOP, staticSealed;
+var STACK_BASE, STACKTOP, STACK_MAX;
+var DYNAMIC_BASE, DYNAMICTOP_PTR;
+STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
+staticSealed = false;
+
+function abortOnCannotGrowMemory() {
+ abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value " + TOTAL_MEMORY + ", (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ")
+}
+function enlargeMemory() {
+ abortOnCannotGrowMemory()
+}
+var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
+var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 134217728;
+if (TOTAL_MEMORY < TOTAL_STACK) Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
+if (Module["buffer"]) {
+ buffer = Module["buffer"]
+} else {
+ if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") {
+ Module["wasmMemory"] = new WebAssembly.Memory({
+ "initial": TOTAL_MEMORY / WASM_PAGE_SIZE,
+ "maximum": TOTAL_MEMORY / WASM_PAGE_SIZE
+ });
+ buffer = Module["wasmMemory"].buffer
+ } else {
+ buffer = new ArrayBuffer(TOTAL_MEMORY)
+ }
+}
+updateGlobalBufferViews();
+
+function getTotalMemory() {
+ return TOTAL_MEMORY
+}
+HEAP32[0] = 1668509029;
+HEAP16[1] = 25459;
+if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99) throw "Runtime error: expected the system to be little-endian!";
+Module["HEAP"] = HEAP;
+Module["buffer"] = buffer;
+Module["HEAP8"] = HEAP8;
+Module["HEAP16"] = HEAP16;
+Module["HEAP32"] = HEAP32;
+Module["HEAPU8"] = HEAPU8;
+Module["HEAPU16"] = HEAPU16;
+Module["HEAPU32"] = HEAPU32;
+Module["HEAPF32"] = HEAPF32;
+Module["HEAPF64"] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while (callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == "function") {
+ callback();
+ continue
+ }
+ var func = callback.func;
+ if (typeof func === "number") {
+ if (callback.arg === undefined) {
+ Module["dynCall_v"](func)
+ } else {
+ Module["dynCall_vi"](func, callback.arg)
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg)
+ }
+ }
+}
+var __ATPRERUN__ = [];
+var __ATINIT__ = [];
+var __ATMAIN__ = [];
+var __ATEXIT__ = [];
+var __ATPOSTRUN__ = [];
+var runtimeInitialized = false;
+var runtimeExited = false;
+
+function preRun() {
+ if (Module["preRun"]) {
+ if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+ while (Module["preRun"].length) {
+ addOnPreRun(Module["preRun"].shift())
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__)
+}
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__)
+}
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__)
+}
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+ runtimeExited = true
+}
+function postRun() {
+ if (Module["postRun"]) {
+ if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+ while (Module["postRun"].length) {
+ addOnPostRun(Module["postRun"].shift())
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__)
+}
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb)
+}
+Module["addOnPreRun"] = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb)
+}
+Module["addOnInit"] = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb)
+}
+Module["addOnPreMain"] = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb)
+}
+Module["addOnExit"] = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb)
+}
+Module["addOnPostRun"] = addOnPostRun;
+
+function intArrayFromString(stringy, dontAddNull, length) {
+ var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+ var u8array = new Array(len);
+ var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+ if (dontAddNull) u8array.length = numBytesWritten;
+ return u8array
+}
+Module["intArrayFromString"] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 255) {
+ chr &= 255
+ }
+ ret.push(String.fromCharCode(chr))
+ }
+ return ret.join("")
+}
+Module["intArrayToString"] = intArrayToString;
+
+function writeStringToMemory(string, buffer, dontAddNull) {
+ Runtime.warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");
+ var lastChar, end;
+ if (dontAddNull) {
+ end = buffer + lengthBytesUTF8(string);
+ lastChar = HEAP8[end]
+ }
+ stringToUTF8(string, buffer, Infinity);
+ if (dontAddNull) HEAP8[end] = lastChar
+}
+Module["writeStringToMemory"] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ HEAP8.set(array, buffer)
+}
+Module["writeArrayToMemory"] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; ++i) {
+ HEAP8[buffer++ >> 0] = str.charCodeAt(i)
+ }
+ if (!dontAddNull) HEAP8[buffer >> 0] = 0
+}
+Module["writeAsciiToMemory"] = writeAsciiToMemory;
+if (!Math["imul"] || Math["imul"](4294967295, 5) !== -5) Math["imul"] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 65535;
+ var bh = b >>> 16;
+ var bl = b & 65535;
+ return al * bl + (ah * bl + al * bh << 16) | 0
+};
+Math.imul = Math["imul"];
+if (!Math["fround"]) {
+ var froundBuffer = new Float32Array(1);
+ Math["fround"] = (function(x) {
+ froundBuffer[0] = x;
+ return froundBuffer[0]
+ })
+}
+Math.fround = Math["fround"];
+if (!Math["clz32"]) Math["clz32"] = (function(x) {
+ x = x >>> 0;
+ for (var i = 0; i < 32; i++) {
+ if (x & 1 << 31 - i) return i
+ }
+ return 32
+});
+Math.clz32 = Math["clz32"];
+if (!Math["trunc"]) Math["trunc"] = (function(x) {
+ return x < 0 ? Math.ceil(x) : Math.floor(x)
+});
+Math.trunc = Math["trunc"];
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_round = Math.round;
+var Math_min = Math.min;
+var Math_clz32 = Math.clz32;
+var Math_trunc = Math.trunc;
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null;
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module["monitorRunDependencies"]) {
+ Module["monitorRunDependencies"](runDependencies)
+ }
+}
+Module["addRunDependency"] = addRunDependency;
+
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module["monitorRunDependencies"]) {
+ Module["monitorRunDependencies"](runDependencies)
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback()
+ }
+ }
+}
+Module["removeRunDependency"] = removeRunDependency;
+Module["preloadedImages"] = {};
+Module["preloadedAudios"] = {};
+var memoryInitializer = null;
+
+function integrateWasmJS() {
+ var method = Module["wasmJSMethod"] || "native-wasm";
+ Module["wasmJSMethod"] = method;
+ var wasmTextFile = Module["wasmTextFile"] || "Decoder.wast";
+ var wasmBinaryFile = Module["wasmBinaryFile"] || "Decoder.wasm";
+ var asmjsCodeFile = Module["asmjsCodeFile"] || "Decoder.temp.asm.js";
+ if (typeof Module["locateFile"] === "function") {
+ wasmTextFile = Module["locateFile"](wasmTextFile);
+ wasmBinaryFile = Module["locateFile"](wasmBinaryFile);
+ asmjsCodeFile = Module["locateFile"](asmjsCodeFile)
+ }
+ var wasmPageSize = 64 * 1024;
+ var asm2wasmImports = {
+ "f64-rem": (function(x, y) {
+ return x % y
+ }),
+ "f64-to-int": (function(x) {
+ return x | 0
+ }),
+ "i32s-div": (function(x, y) {
+ return (x | 0) / (y | 0) | 0
+ }),
+ "i32u-div": (function(x, y) {
+ return (x >>> 0) / (y >>> 0) >>> 0
+ }),
+ "i32s-rem": (function(x, y) {
+ return (x | 0) % (y | 0) | 0
+ }),
+ "i32u-rem": (function(x, y) {
+ return (x >>> 0) % (y >>> 0) >>> 0
+ }),
+ "debugger": (function() {
+ debugger
+ })
+ };
+ var info = {
+ "global": null,
+ "env": null,
+ "asm2wasm": asm2wasmImports,
+ "parent": Module
+ };
+ var exports = null;
+
+ function lookupImport(mod, base) {
+ var lookup = info;
+ if (mod.indexOf(".") < 0) {
+ lookup = (lookup || {})[mod]
+ } else {
+ var parts = mod.split(".");
+ lookup = (lookup || {})[parts[0]];
+ lookup = (lookup || {})[parts[1]]
+ }
+ if (base) {
+ lookup = (lookup || {})[base]
+ }
+ if (lookup === undefined) {
+ abort("bad lookupImport to (" + mod + ")." + base)
+ }
+ return lookup
+ }
+ function mergeMemory(newBuffer) {
+ var oldBuffer = Module["buffer"];
+ if (newBuffer.byteLength < oldBuffer.byteLength) {
+ Module["printErr"]("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here")
+ }
+ var oldView = new Int8Array(oldBuffer);
+ var newView = new Int8Array(newBuffer);
+ if (!memoryInitializer) {
+ oldView.set(newView.subarray(Module["STATIC_BASE"], Module["STATIC_BASE"] + Module["STATIC_BUMP"]), Module["STATIC_BASE"])
+ }
+ newView.set(oldView);
+ updateGlobalBuffer(newBuffer);
+ updateGlobalBufferViews()
+ }
+ var WasmTypes = {
+ none: 0,
+ i32: 1,
+ i64: 2,
+ f32: 3,
+ f64: 4
+ };
+
+ function fixImports(imports) {
+ if (!0) return imports;
+ var ret = {};
+ for (var i in imports) {
+ var fixed = i;
+ if (fixed[0] == "_") fixed = fixed.substr(1);
+ ret[fixed] = imports[i]
+ }
+ return ret
+ }
+ function getBinary() {
+ try {
+ var binary;
+ if (Module["wasmBinary"]) {
+ binary = Module["wasmBinary"];
+ binary = new Uint8Array(binary)
+ } else if (Module["readBinary"]) {
+ binary = Module["readBinary"](wasmBinaryFile)
+ } else {
+ throw "on the web, we need the wasm binary to be preloaded and set on Module['wasmBinary']. emcc.py will do that for you when generating HTML (but not JS)"
+ }
+ return binary
+ } catch (err) {
+ abort(err)
+ }
+ }
+ function getBinaryPromise() {
+ if (!Module["wasmBinary"] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function") {
+ return fetch(wasmBinaryFile, {
+ credentials: "same-origin"
+ }).then((function(response) {
+ if (!response["ok"]) {
+ throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
+ }
+ return response["arrayBuffer"]()
+ }))
+ }
+ return new Promise((function(resolve, reject) {
+ resolve(getBinary())
+ }))
+ }
+ function doNativeWasm(global, env, providedBuffer) {
+ if (typeof WebAssembly !== "object") {
+ Module["printErr"]("no native wasm support detected");
+ return false
+ }
+ if (!(Module["wasmMemory"] instanceof WebAssembly.Memory)) {
+ Module["printErr"]("no native wasm Memory in use");
+ return false
+ }
+ env["memory"] = Module["wasmMemory"];
+ info["global"] = {
+ "NaN": NaN,
+ "Infinity": Infinity
+ };
+ info["global.Math"] = global.Math;
+ info["env"] = env;
+
+ function receiveInstance(instance) {
+ exports = instance.exports;
+ if (exports.memory) mergeMemory(exports.memory);
+ Module["asm"] = exports;
+ Module["usingWasm"] = true;
+ removeRunDependency("wasm-instantiate")
+ }
+ addRunDependency("wasm-instantiate");
+ if (Module["instantiateWasm"]) {
+ try {
+ return Module["instantiateWasm"](info, receiveInstance)
+ } catch (e) {
+ Module["printErr"]("Module.instantiateWasm callback failed with error: " + e);
+ return false
+ }
+ }
+ function receiveInstantiatedSource(output) {
+ receiveInstance(output["instance"])
+ }
+ function instantiateArrayBuffer(receiver) {
+ getBinaryPromise().then((function(binary) {
+ return WebAssembly.instantiate(binary, info)
+ })).then(receiver).
+ catch ((function(reason) {
+ Module["printErr"]("failed to asynchronously prepare wasm: " + reason);
+ abort(reason)
+ }))
+ }
+ if (!Module["wasmBinary"] && typeof WebAssembly.instantiateStreaming === "function") {
+ WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, {
+ credentials: "same-origin"
+ }), info).then(receiveInstantiatedSource).
+ catch ((function(reason) {
+ Module["printErr"]("wasm streaming compile failed: " + reason);
+ Module["printErr"]("falling back to ArrayBuffer instantiation");
+ instantiateArrayBuffer(receiveInstantiatedSource)
+ }))
+ } else {
+ instantiateArrayBuffer(receiveInstantiatedSource)
+ }
+ return {}
+ }
+ Module["asmPreload"] = Module["asm"];
+ var asmjsReallocBuffer = Module["reallocBuffer"];
+ var wasmReallocBuffer = (function(size) {
+ var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE;
+ size = alignUp(size, PAGE_MULTIPLE);
+ var old = Module["buffer"];
+ var oldSize = old.byteLength;
+ if (Module["usingWasm"]) {
+ try {
+ var result = Module["wasmMemory"].grow((size - oldSize) / wasmPageSize);
+ if (result !== (-1 | 0)) {
+ return Module["buffer"] = Module["wasmMemory"].buffer
+ } else {
+ return null
+ }
+ } catch (e) {
+ return null
+ }
+ } else {
+ exports["__growWasmMemory"]((size - oldSize) / wasmPageSize);
+ return Module["buffer"] !== old ? Module["buffer"] : null
+ }
+ });
+ Module["reallocBuffer"] = (function(size) {
+ if (finalMethod === "asmjs") {
+ return asmjsReallocBuffer(size)
+ } else {
+ return wasmReallocBuffer(size)
+ }
+ });
+ var finalMethod = "";
+ Module["asm"] = (function(global, env, providedBuffer) {
+ global = fixImports(global);
+ env = fixImports(env);
+ if (!env["table"]) {
+ var TABLE_SIZE = Module["wasmTableSize"];
+ if (TABLE_SIZE === undefined) TABLE_SIZE = 1024;
+ var MAX_TABLE_SIZE = Module["wasmMaxTableSize"];
+ if (typeof WebAssembly === "object" && typeof WebAssembly.Table === "function") {
+ if (MAX_TABLE_SIZE !== undefined) {
+ env["table"] = new WebAssembly.Table({
+ "initial": TABLE_SIZE,
+ "maximum": MAX_TABLE_SIZE,
+ "element": "anyfunc"
+ })
+ } else {
+ env["table"] = new WebAssembly.Table({
+ "initial": TABLE_SIZE,
+ element: "anyfunc"
+ })
+ }
+ } else {
+ env["table"] = new Array(TABLE_SIZE)
+ }
+ Module["wasmTable"] = env["table"]
+ }
+ if (!env["memoryBase"]) {
+ env["memoryBase"] = Module["STATIC_BASE"]
+ }
+ if (!env["tableBase"]) {
+ env["tableBase"] = 0
+ }
+ var exports;
+ exports = doNativeWasm(global, env, providedBuffer);
+ if (!exports) abort("no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: https://github.com/kripken/emscripten/wiki/WebAssembly#binaryen-methods");
+ return exports
+ });
+ var methodHandler = Module["asm"]
+}
+integrateWasmJS();
+var ASM_CONSTS = [];
+STATIC_BASE = Runtime.GLOBAL_BASE;
+STATICTOP = STATIC_BASE + 163120;
+__ATINIT__.push({
+ func: (function() {
+ __GLOBAL__sub_I_Decoder_cpp()
+ })
+}, {
+ func: (function() {
+ __GLOBAL__sub_I_bind_cpp()
+ })
+});
+memoryInitializer = Module["wasmJSMethod"].indexOf("asmjs") >= 0 || Module["wasmJSMethod"].indexOf("interpret-asm2wasm") >= 0 ? "Decoder.js.mem" : null;
+var STATIC_BUMP = 163120;
+Module["STATIC_BASE"] = STATIC_BASE;
+Module["STATIC_BUMP"] = STATIC_BUMP;
+var tempDoublePtr = STATICTOP;
+STATICTOP += 16;
+var structRegistrations = {};
+
+function embind_init_charCodes() {
+ var codes = new Array(256);
+ for (var i = 0; i < 256; ++i) {
+ codes[i] = String.fromCharCode(i)
+ }
+ embind_charCodes = codes
+}
+var embind_charCodes = undefined;
+
+function readLatin1String(ptr) {
+ var ret = "";
+ var c = ptr;
+ while (HEAPU8[c]) {
+ ret += embind_charCodes[HEAPU8[c++]]
+ }
+ return ret
+}
+var char_0 = 48;
+var char_9 = 57;
+
+function makeLegalFunctionName(name) {
+ if (undefined === name) {
+ return "_unknown"
+ }
+ name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+ var f = name.charCodeAt(0);
+ if (f >= char_0 && f <= char_9) {
+ return "_" + name
+ } else {
+ return name
+ }
+}
+function createNamedFunction(name, body) {
+ name = makeLegalFunctionName(name);
+ return (new Function("body", "return function " + name + "() {\n" + ' "use strict";' + " return body.apply(this, arguments);\n" + "};\n"))(body)
+}
+function extendError(baseErrorType, errorName) {
+ var errorClass = createNamedFunction(errorName, (function(message) {
+ this.name = errorName;
+ this.message = message;
+ var stack = (new Error(message)).stack;
+ if (stack !== undefined) {
+ this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "")
+ }
+ }));
+ errorClass.prototype = Object.create(baseErrorType.prototype);
+ errorClass.prototype.constructor = errorClass;
+ errorClass.prototype.toString = (function() {
+ if (this.message === undefined) {
+ return this.name
+ } else {
+ return this.name + ": " + this.message
+ }
+ });
+ return errorClass
+}
+var BindingError = undefined;
+
+function throwBindingError(message) {
+ throw new BindingError(message)
+}
+function requireFunction(signature, rawFunction) {
+ signature = readLatin1String(signature);
+
+ function makeDynCaller(dynCall) {
+ var args = [];
+ for (var i = 1; i < signature.length; ++i) {
+ args.push("a" + i)
+ }
+ var name = "dynCall_" + signature + "_" + rawFunction;
+ var body = "return function " + name + "(" + args.join(", ") + ") {\n";
+ body += " return dynCall(rawFunction" + (args.length ? ", " : "") + args.join(", ") + ");\n";
+ body += "};\n";
+ return (new Function("dynCall", "rawFunction", body))(dynCall, rawFunction)
+ }
+ var fp;
+ if (Module["FUNCTION_TABLE_" + signature] !== undefined) {
+ fp = Module["FUNCTION_TABLE_" + signature][rawFunction]
+ } else if (typeof FUNCTION_TABLE !== "undefined") {
+ fp = FUNCTION_TABLE[rawFunction]
+ } else {
+ var dc = Module["asm"]["dynCall_" + signature];
+ if (dc === undefined) {
+ dc = Module["asm"]["dynCall_" + signature.replace(/f/g, "d")];
+ if (dc === undefined) {
+ throwBindingError("No dynCall invoker for signature: " + signature)
+ }
+ }
+ fp = makeDynCaller(dc)
+ }
+ if (typeof fp !== "function") {
+ throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction)
+ }
+ return fp
+}
+function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
+ structRegistrations[rawType] = {
+ name: readLatin1String(name),
+ rawConstructor: requireFunction(constructorSignature, rawConstructor),
+ rawDestructor: requireFunction(destructorSignature, rawDestructor),
+ fields: []
+ }
+}
+function ___assert_fail(condition, filename, line, func) {
+ ABORT = true;
+ throw "Assertion failed: " + Pointer_stringify(condition) + ", at: " + [filename ? Pointer_stringify(filename) : "unknown filename", line, func ? Pointer_stringify(func) : "unknown function"] + " at " + stackTrace()
+}
+var awaitingDependencies = {};
+var registeredTypes = {};
+var typeDependencies = {};
+var InternalError = undefined;
+
+function throwInternalError(message) {
+ throw new InternalError(message)
+}
+function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
+ myTypes.forEach((function(type) {
+ typeDependencies[type] = dependentTypes
+ }));
+
+ function onComplete(typeConverters) {
+ var myTypeConverters = getTypeConverters(typeConverters);
+ if (myTypeConverters.length !== myTypes.length) {
+ throwInternalError("Mismatched type converter count")
+ }
+ for (var i = 0; i < myTypes.length; ++i) {
+ registerType(myTypes[i], myTypeConverters[i])
+ }
+ }
+ var typeConverters = new Array(dependentTypes.length);
+ var unregisteredTypes = [];
+ var registered = 0;
+ dependentTypes.forEach((function(dt, i) {
+ if (registeredTypes.hasOwnProperty(dt)) {
+ typeConverters[i] = registeredTypes[dt]
+ } else {
+ unregisteredTypes.push(dt);
+ if (!awaitingDependencies.hasOwnProperty(dt)) {
+ awaitingDependencies[dt] = []
+ }
+ awaitingDependencies[dt].push((function() {
+ typeConverters[i] = registeredTypes[dt];
+ ++registered;
+ if (registered === unregisteredTypes.length) {
+ onComplete(typeConverters)
+ }
+ }))
+ }
+ }));
+ if (0 === unregisteredTypes.length) {
+ onComplete(typeConverters)
+ }
+}
+function registerType(rawType, registeredInstance, options) {
+ options = options || {};
+ if (!("argPackAdvance" in registeredInstance)) {
+ throw new TypeError("registerType registeredInstance requires argPackAdvance")
+ }
+ var name = registeredInstance.name;
+ if (!rawType) {
+ throwBindingError('type "' + name + '" must have a positive integer typeid pointer')
+ }
+ if (registeredTypes.hasOwnProperty(rawType)) {
+ if (options.ignoreDuplicateRegistrations) {
+ return
+ } else {
+ throwBindingError("Cannot register type '" + name + "' twice")
+ }
+ }
+ registeredTypes[rawType] = registeredInstance;
+ delete typeDependencies[rawType];
+ if (awaitingDependencies.hasOwnProperty(rawType)) {
+ var callbacks = awaitingDependencies[rawType];
+ delete awaitingDependencies[rawType];
+ callbacks.forEach((function(cb) {
+ cb()
+ }))
+ }
+}
+function __embind_register_void(rawType, name) {
+ name = readLatin1String(name);
+ registerType(rawType, {
+ isVoid: true,
+ name: name,
+ "argPackAdvance": 0,
+ "fromWireType": (function() {
+ return undefined
+ }),
+ "toWireType": (function(destructors, o) {
+ return undefined
+ })
+ })
+}
+function _pthread_mutex_destroy() {}
+function __ZSt18uncaught_exceptionv() {
+ return !!__ZSt18uncaught_exceptionv.uncaught_exception
+}
+var EXCEPTIONS = {
+ last: 0,
+ caught: [],
+ infos: {},
+ deAdjust: (function(adjusted) {
+ if (!adjusted || EXCEPTIONS.infos[adjusted]) return adjusted;
+ for (var ptr in EXCEPTIONS.infos) {
+ var info = EXCEPTIONS.infos[ptr];
+ if (info.adjusted === adjusted) {
+ return ptr
+ }
+ }
+ return adjusted
+ }),
+ addRef: (function(ptr) {
+ if (!ptr) return;
+ var info = EXCEPTIONS.infos[ptr];
+ info.refcount++
+ }),
+ decRef: (function(ptr) {
+ if (!ptr) return;
+ var info = EXCEPTIONS.infos[ptr];
+ assert(info.refcount > 0);
+ info.refcount--;
+ if (info.refcount === 0 && !info.rethrown) {
+ if (info.destructor) {
+ Module["dynCall_vi"](info.destructor, ptr)
+ }
+ delete EXCEPTIONS.infos[ptr];
+ ___cxa_free_exception(ptr)
+ }
+ }),
+ clearRef: (function(ptr) {
+ if (!ptr) return;
+ var info = EXCEPTIONS.infos[ptr];
+ info.refcount = 0
+ })
+};
+
+function ___resumeException(ptr) {
+ if (!EXCEPTIONS.last) {
+ EXCEPTIONS.last = ptr
+ }
+ throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch."
+}
+function ___cxa_find_matching_catch() {
+ var thrown = EXCEPTIONS.last;
+ if (!thrown) {
+ return (Runtime.setTempRet0(0), 0) | 0
+ }
+ var info = EXCEPTIONS.infos[thrown];
+ var throwntype = info.type;
+ if (!throwntype) {
+ return (Runtime.setTempRet0(0), thrown) | 0
+ }
+ var typeArray = Array.prototype.slice.call(arguments);
+ var pointer = Module["___cxa_is_pointer_type"](throwntype);
+ if (!___cxa_find_matching_catch.buffer) ___cxa_find_matching_catch.buffer = _malloc(4);
+ HEAP32[___cxa_find_matching_catch.buffer >> 2] = thrown;
+ thrown = ___cxa_find_matching_catch.buffer;
+ for (var i = 0; i < typeArray.length; i++) {
+ if (typeArray[i] && Module["___cxa_can_catch"](typeArray[i], throwntype, thrown)) {
+ thrown = HEAP32[thrown >> 2];
+ info.adjusted = thrown;
+ return (Runtime.setTempRet0(typeArray[i]), thrown) | 0
+ }
+ }
+ thrown = HEAP32[thrown >> 2];
+ return (Runtime.setTempRet0(throwntype), thrown) | 0
+}
+function ___cxa_throw(ptr, type, destructor) {
+ EXCEPTIONS.infos[ptr] = {
+ ptr: ptr,
+ adjusted: ptr,
+ type: type,
+ destructor: destructor,
+ refcount: 0,
+ caught: false,
+ rethrown: false
+ };
+ EXCEPTIONS.last = ptr;
+ if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
+ __ZSt18uncaught_exceptionv.uncaught_exception = 1
+ } else {
+ __ZSt18uncaught_exceptionv.uncaught_exception++
+ }
+ throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch."
+}
+function getShiftFromSize(size) {
+ switch (size) {
+ case 1:
+ return 0;
+ case 2:
+ return 1;
+ case 4:
+ return 2;
+ case 8:
+ return 3;
+ default:
+ throw new TypeError("Unknown type size: " + size)
+ }
+}
+function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
+ var shift = getShiftFromSize(size);
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ "fromWireType": (function(wt) {
+ return !!wt
+ }),
+ "toWireType": (function(destructors, o) {
+ return o ? trueValue : falseValue
+ }),
+ "argPackAdvance": 8,
+ "readValueFromPointer": (function(pointer) {
+ var heap;
+ if (size === 1) {
+ heap = HEAP8
+ } else if (size === 2) {
+ heap = HEAP16
+ } else if (size === 4) {
+ heap = HEAP32
+ } else {
+ throw new TypeError("Unknown boolean type size: " + name)
+ }
+ return this["fromWireType"](heap[pointer >> shift])
+ }),
+ destructorFunction: null
+ })
+}
+function ___gxx_personality_v0() {}
+function _pthread_cond_signal() {
+ return 0
+}
+function _abort() {
+ Module["abort"]()
+}
+function _pthread_cond_destroy() {
+ return 0
+}
+function simpleReadValueFromPointer(pointer) {
+ return this["fromWireType"](HEAPU32[pointer >> 2])
+}
+function __embind_register_std_string(rawType, name) {
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ "fromWireType": (function(value) {
+ var length = HEAPU32[value >> 2];
+ var a = new Array(length);
+ for (var i = 0; i < length; ++i) {
+ a[i] = String.fromCharCode(HEAPU8[value + 4 + i])
+ }
+ _free(value);
+ return a.join("")
+ }),
+ "toWireType": (function(destructors, value) {
+ if (value instanceof ArrayBuffer) {
+ value = new Uint8Array(value)
+ }
+ function getTAElement(ta, index) {
+ return ta[index]
+ }
+ function getStringElement(string, index) {
+ return string.charCodeAt(index)
+ }
+ var getElement;
+ if (value instanceof Uint8Array) {
+ getElement = getTAElement
+ } else if (value instanceof Uint8ClampedArray) {
+ getElement = getTAElement
+ } else if (value instanceof Int8Array) {
+ getElement = getTAElement
+ } else if (typeof value === "string") {
+ getElement = getStringElement
+ } else {
+ throwBindingError("Cannot pass non-string to std::string")
+ }
+ var length = value.length;
+ var ptr = _malloc(4 + length);
+ HEAPU32[ptr >> 2] = length;
+ for (var i = 0; i < length; ++i) {
+ var charCode = getElement(value, i);
+ if (charCode > 255) {
+ _free(ptr);
+ throwBindingError("String has UTF-16 code units that do not fit in 8 bits")
+ }
+ HEAPU8[ptr + 4 + i] = charCode
+ }
+ if (destructors !== null) {
+ destructors.push(_free, ptr)
+ }
+ return ptr
+ }),
+ "argPackAdvance": 8,
+ "readValueFromPointer": simpleReadValueFromPointer,
+ destructorFunction: (function(ptr) {
+ _free(ptr)
+ })
+ })
+}
+function _embind_repr(v) {
+ if (v === null) {
+ return "null"
+ }
+ var t = typeof v;
+ if (t === "object" || t === "array" || t === "function") {
+ return v.toString()
+ } else {
+ return "" + v
+ }
+}
+function integerReadValueFromPointer(name, shift, signed) {
+ switch (shift) {
+ case 0:
+ return signed ?
+ function readS8FromPointer(pointer) {
+ return HEAP8[pointer]
+ } : function readU8FromPointer(pointer) {
+ return HEAPU8[pointer]
+ };
+ case 1:
+ return signed ?
+ function readS16FromPointer(pointer) {
+ return HEAP16[pointer >> 1]
+ } : function readU16FromPointer(pointer) {
+ return HEAPU16[pointer >> 1]
+ };
+ case 2:
+ return signed ?
+ function readS32FromPointer(pointer) {
+ return HEAP32[pointer >> 2]
+ } : function readU32FromPointer(pointer) {
+ return HEAPU32[pointer >> 2]
+ };
+ default:
+ throw new TypeError("Unknown integer type: " + name)
+ }
+}
+function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
+ name = readLatin1String(name);
+ if (maxRange === -1) {
+ maxRange = 4294967295
+ }
+ var shift = getShiftFromSize(size);
+ var fromWireType = (function(value) {
+ return value
+ });
+ if (minRange === 0) {
+ var bitshift = 32 - 8 * size;
+ fromWireType = (function(value) {
+ return value << bitshift >>> bitshift
+ })
+ }
+ var isUnsignedType = name.indexOf("unsigned") != -1;
+ registerType(primitiveType, {
+ name: name,
+ "fromWireType": fromWireType,
+ "toWireType": (function(destructors, value) {
+ if (typeof value !== "number" && typeof value !== "boolean") {
+ throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name)
+ }
+ if (value < minRange || value > maxRange) {
+ throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ", " + maxRange + "]!")
+ }
+ return isUnsignedType ? value >>> 0 : value | 0
+ }),
+ "argPackAdvance": 8,
+ "readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0),
+ destructorFunction: null
+ })
+}
+function _pthread_once(ptr, func) {
+ if (!_pthread_once.seen) _pthread_once.seen = {};
+ if (ptr in _pthread_once.seen) return;
+ Module["dynCall_v"](func);
+ _pthread_once.seen[ptr] = 1
+}
+function _pthread_create() {
+ return 11
+}
+function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+ structRegistrations[structType].fields.push({
+ fieldName: readLatin1String(fieldName),
+ getterReturnType: getterReturnType,
+ getter: requireFunction(getterSignature, getter),
+ getterContext: getterContext,
+ setterArgumentType: setterArgumentType,
+ setter: requireFunction(setterSignature, setter),
+ setterContext: setterContext
+ })
+}
+function ___lock() {}
+function ___unlock() {}
+var PTHREAD_SPECIFIC = {};
+
+function _pthread_getspecific(key) {
+ return PTHREAD_SPECIFIC[key] || 0
+}
+function runDestructors(destructors) {
+ while (destructors.length) {
+ var ptr = destructors.pop();
+ var del = destructors.pop();
+ del(ptr)
+ }
+}
+function __embind_finalize_value_object(structType) {
+ var reg = structRegistrations[structType];
+ delete structRegistrations[structType];
+ var rawConstructor = reg.rawConstructor;
+ var rawDestructor = reg.rawDestructor;
+ var fieldRecords = reg.fields;
+ var fieldTypes = fieldRecords.map((function(field) {
+ return field.getterReturnType
+ })).concat(fieldRecords.map((function(field) {
+ return field.setterArgumentType
+ })));
+ whenDependentTypesAreResolved([structType], fieldTypes, (function(fieldTypes) {
+ var fields = {};
+ fieldRecords.forEach((function(field, i) {
+ var fieldName = field.fieldName;
+ var getterReturnType = fieldTypes[i];
+ var getter = field.getter;
+ var getterContext = field.getterContext;
+ var setterArgumentType = fieldTypes[i + fieldRecords.length];
+ var setter = field.setter;
+ var setterContext = field.setterContext;
+ fields[fieldName] = {
+ read: (function(ptr) {
+ return getterReturnType["fromWireType"](getter(getterContext, ptr))
+ }),
+ write: (function(ptr, o) {
+ var destructors = [];
+ setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o));
+ runDestructors(destructors)
+ })
+ }
+ }));
+ return [{
+ name: reg.name,
+ "fromWireType": (function(ptr) {
+ var rv = {};
+ for (var i in fields) {
+ rv[i] = fields[i].read(ptr)
+ }
+ rawDestructor(ptr);
+ return rv
+ }),
+ "toWireType": (function(destructors, o) {
+ for (var fieldName in fields) {
+ if (!(fieldName in o)) {
+ throw new TypeError("Missing field")
+ }
+ }
+ var ptr = rawConstructor();
+ for (fieldName in fields) {
+ fields[fieldName].write(ptr, o[fieldName])
+ }
+ if (destructors !== null) {
+ destructors.push(rawDestructor, ptr)
+ }
+ return ptr
+ }),
+ "argPackAdvance": 8,
+ "readValueFromPointer": simpleReadValueFromPointer,
+ destructorFunction: rawDestructor
+ }]
+ }))
+}
+function _clock() {
+ if (_clock.start === undefined) _clock.start = Date.now();
+ return (Date.now() - _clock.start) * (1e6 / 1e3) | 0
+}
+var PTHREAD_SPECIFIC_NEXT_KEY = 1;
+var ERRNO_CODES = {
+ EPERM: 1,
+ ENOENT: 2,
+ ESRCH: 3,
+ EINTR: 4,
+ EIO: 5,
+ ENXIO: 6,
+ E2BIG: 7,
+ ENOEXEC: 8,
+ EBADF: 9,
+ ECHILD: 10,
+ EAGAIN: 11,
+ EWOULDBLOCK: 11,
+ ENOMEM: 12,
+ EACCES: 13,
+ EFAULT: 14,
+ ENOTBLK: 15,
+ EBUSY: 16,
+ EEXIST: 17,
+ EXDEV: 18,
+ ENODEV: 19,
+ ENOTDIR: 20,
+ EISDIR: 21,
+ EINVAL: 22,
+ ENFILE: 23,
+ EMFILE: 24,
+ ENOTTY: 25,
+ ETXTBSY: 26,
+ EFBIG: 27,
+ ENOSPC: 28,
+ ESPIPE: 29,
+ EROFS: 30,
+ EMLINK: 31,
+ EPIPE: 32,
+ EDOM: 33,
+ ERANGE: 34,
+ ENOMSG: 42,
+ EIDRM: 43,
+ ECHRNG: 44,
+ EL2NSYNC: 45,
+ EL3HLT: 46,
+ EL3RST: 47,
+ ELNRNG: 48,
+ EUNATCH: 49,
+ ENOCSI: 50,
+ EL2HLT: 51,
+ EDEADLK: 35,
+ ENOLCK: 37,
+ EBADE: 52,
+ EBADR: 53,
+ EXFULL: 54,
+ ENOANO: 55,
+ EBADRQC: 56,
+ EBADSLT: 57,
+ EDEADLOCK: 35,
+ EBFONT: 59,
+ ENOSTR: 60,
+ ENODATA: 61,
+ ETIME: 62,
+ ENOSR: 63,
+ ENONET: 64,
+ ENOPKG: 65,
+ EREMOTE: 66,
+ ENOLINK: 67,
+ EADV: 68,
+ ESRMNT: 69,
+ ECOMM: 70,
+ EPROTO: 71,
+ EMULTIHOP: 72,
+ EDOTDOT: 73,
+ EBADMSG: 74,
+ ENOTUNIQ: 76,
+ EBADFD: 77,
+ EREMCHG: 78,
+ ELIBACC: 79,
+ ELIBBAD: 80,
+ ELIBSCN: 81,
+ ELIBMAX: 82,
+ ELIBEXEC: 83,
+ ENOSYS: 38,
+ ENOTEMPTY: 39,
+ ENAMETOOLONG: 36,
+ ELOOP: 40,
+ EOPNOTSUPP: 95,
+ EPFNOSUPPORT: 96,
+ ECONNRESET: 104,
+ ENOBUFS: 105,
+ EAFNOSUPPORT: 97,
+ EPROTOTYPE: 91,
+ ENOTSOCK: 88,
+ ENOPROTOOPT: 92,
+ ESHUTDOWN: 108,
+ ECONNREFUSED: 111,
+ EADDRINUSE: 98,
+ ECONNABORTED: 103,
+ ENETUNREACH: 101,
+ ENETDOWN: 100,
+ ETIMEDOUT: 110,
+ EHOSTDOWN: 112,
+ EHOSTUNREACH: 113,
+ EINPROGRESS: 115,
+ EALREADY: 114,
+ EDESTADDRREQ: 89,
+ EMSGSIZE: 90,
+ EPROTONOSUPPORT: 93,
+ ESOCKTNOSUPPORT: 94,
+ EADDRNOTAVAIL: 99,
+ ENETRESET: 102,
+ EISCONN: 106,
+ ENOTCONN: 107,
+ ETOOMANYREFS: 109,
+ EUSERS: 87,
+ EDQUOT: 122,
+ ESTALE: 116,
+ ENOTSUP: 95,
+ ENOMEDIUM: 123,
+ EILSEQ: 84,
+ EOVERFLOW: 75,
+ ECANCELED: 125,
+ ENOTRECOVERABLE: 131,
+ EOWNERDEAD: 130,
+ ESTRPIPE: 86
+};
+
+function _pthread_key_create(key, destructor) {
+ if (key == 0) {
+ return ERRNO_CODES.EINVAL
+ }
+ HEAP32[key >> 2] = PTHREAD_SPECIFIC_NEXT_KEY;
+ PTHREAD_SPECIFIC[PTHREAD_SPECIFIC_NEXT_KEY] = 0;
+ PTHREAD_SPECIFIC_NEXT_KEY++;
+ return 0
+}
+function _pthread_mutex_init() {}
+var emval_free_list = [];
+var emval_handle_array = [{}, {
+ value: undefined
+}, {
+ value: null
+}, {
+ value: true
+}, {
+ value: false
+}];
+
+function __emval_decref(handle) {
+ if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
+ emval_handle_array[handle] = undefined;
+ emval_free_list.push(handle)
+ }
+}
+function count_emval_handles() {
+ var count = 0;
+ for (var i = 5; i < emval_handle_array.length; ++i) {
+ if (emval_handle_array[i] !== undefined) {
+ ++count
+ }
+ }
+ return count
+}
+function get_first_emval() {
+ for (var i = 5; i < emval_handle_array.length; ++i) {
+ if (emval_handle_array[i] !== undefined) {
+ return emval_handle_array[i]
+ }
+ }
+ return null
+}
+function init_emval() {
+ Module["count_emval_handles"] = count_emval_handles;
+ Module["get_first_emval"] = get_first_emval
+}
+function __emval_register(value) {
+ switch (value) {
+ case undefined:
+ {
+ return 1
+ };
+ case null:
+ {
+ return 2
+ };
+ case true:
+ {
+ return 3
+ };
+ case false:
+ {
+ return 4
+ };
+ default:
+ {
+ var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
+ emval_handle_array[handle] = {
+ refcount: 1,
+ value: value
+ };
+ return handle
+ }
+ }
+}
+function __embind_register_emval(rawType, name) {
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ "fromWireType": (function(handle) {
+ var rv = emval_handle_array[handle].value;
+ __emval_decref(handle);
+ return rv
+ }),
+ "toWireType": (function(destructors, value) {
+ return __emval_register(value)
+ }),
+ "argPackAdvance": 8,
+ "readValueFromPointer": simpleReadValueFromPointer,
+ destructorFunction: null
+ })
+}
+function _pthread_setspecific(key, value) {
+ if (!(key in PTHREAD_SPECIFIC)) {
+ return ERRNO_CODES.EINVAL
+ }
+ PTHREAD_SPECIFIC[key] = value;
+ return 0
+}
+function ___cxa_allocate_exception(size) {
+ return _malloc(size)
+}
+var SYSCALLS = {
+ varargs: 0,
+ get: (function(varargs) {
+ SYSCALLS.varargs += 4;
+ var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
+ return ret
+ }),
+ getStr: (function() {
+ var ret = Pointer_stringify(SYSCALLS.get());
+ return ret
+ }),
+ get64: (function() {
+ var low = SYSCALLS.get(),
+ high = SYSCALLS.get();
+ if (low >= 0) assert(high === 0);
+ else assert(high === -1);
+ return low
+ }),
+ getZero: (function() {
+ assert(SYSCALLS.get() === 0)
+ })
+};
+
+function ___syscall54(which, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+ return 0
+ } catch (e) {
+ if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+ return -e.errno
+ }
+}
+function ___cxa_pure_virtual() {
+ ABORT = true;
+ throw "Pure virtual function called!"
+}
+function floatReadValueFromPointer(name, shift) {
+ switch (shift) {
+ case 2:
+ return (function(pointer) {
+ return this["fromWireType"](HEAPF32[pointer >> 2])
+ });
+ case 3:
+ return (function(pointer) {
+ return this["fromWireType"](HEAPF64[pointer >> 3])
+ });
+ default:
+ throw new TypeError("Unknown float type: " + name)
+ }
+}
+function __embind_register_float(rawType, name, size) {
+ var shift = getShiftFromSize(size);
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ "fromWireType": (function(value) {
+ return value
+ }),
+ "toWireType": (function(destructors, value) {
+ if (typeof value !== "number" && typeof value !== "boolean") {
+ throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name)
+ }
+ return value
+ }),
+ "argPackAdvance": 8,
+ "readValueFromPointer": floatReadValueFromPointer(name, shift),
+ destructorFunction: null
+ })
+}
+function new_(constructor, argumentList) {
+ if (!(constructor instanceof Function)) {
+ throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function")
+ }
+ var dummy = createNamedFunction(constructor.name || "unknownFunctionName", (function() {}));
+ dummy.prototype = constructor.prototype;
+ var obj = new dummy;
+ var r = constructor.apply(obj, argumentList);
+ return r instanceof Object ? r : obj
+}
+function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
+ var argCount = argTypes.length;
+ if (argCount < 2) {
+ throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")
+ }
+ var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+ var needsDestructorStack = false;
+ for (var i = 1; i < argTypes.length; ++i) {
+ if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
+ needsDestructorStack = true;
+ break
+ }
+ }
+ var returns = argTypes[0].name !== "void";
+ var argsList = "";
+ var argsListWired = "";
+ for (var i = 0; i < argCount - 2; ++i) {
+ argsList += (i !== 0 ? ", " : "") + "arg" + i;
+ argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired"
+ }
+ var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n";
+ if (needsDestructorStack) {
+ invokerFnBody += "var destructors = [];\n"
+ }
+ var dtorStack = needsDestructorStack ? "destructors" : "null";
+ var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
+ var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
+ if (isClassMethodFunc) {
+ invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n"
+ }
+ for (var i = 0; i < argCount - 2; ++i) {
+ invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
+ args1.push("argType" + i);
+ args2.push(argTypes[i + 2])
+ }
+ if (isClassMethodFunc) {
+ argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired
+ }
+ invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
+ if (needsDestructorStack) {
+ invokerFnBody += "runDestructors(destructors);\n"
+ } else {
+ for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+ var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
+ if (argTypes[i].destructorFunction !== null) {
+ invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
+ args1.push(paramName + "_dtor");
+ args2.push(argTypes[i].destructorFunction)
+ }
+ }
+ }
+ if (returns) {
+ invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n"
+ } else {}
+ invokerFnBody += "}\n";
+ args1.push(invokerFnBody);
+ var invokerFunction = new_(Function, args1).apply(null, args2);
+ return invokerFunction
+}
+function ensureOverloadTable(proto, methodName, humanName) {
+ if (undefined === proto[methodName].overloadTable) {
+ var prevFunc = proto[methodName];
+ proto[methodName] = (function() {
+ if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
+ throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!")
+ }
+ return proto[methodName].overloadTable[arguments.length].apply(this, arguments)
+ });
+ proto[methodName].overloadTable = [];
+ proto[methodName].overloadTable[prevFunc.argCount] = prevFunc
+ }
+}
+function exposePublicSymbol(name, value, numArguments) {
+ if (Module.hasOwnProperty(name)) {
+ if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
+ throwBindingError("Cannot register public name '" + name + "' twice")
+ }
+ ensureOverloadTable(Module, name, name);
+ if (Module.hasOwnProperty(numArguments)) {
+ throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!")
+ }
+ Module[name].overloadTable[numArguments] = value
+ } else {
+ Module[name] = value;
+ if (undefined !== numArguments) {
+ Module[name].numArguments = numArguments
+ }
+ }
+}
+function heap32VectorToArray(count, firstElement) {
+ var array = [];
+ for (var i = 0; i < count; i++) {
+ array.push(HEAP32[(firstElement >> 2) + i])
+ }
+ return array
+}
+function replacePublicSymbol(name, value, numArguments) {
+ if (!Module.hasOwnProperty(name)) {
+ throwInternalError("Replacing nonexistant public symbol")
+ }
+ if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
+ Module[name].overloadTable[numArguments] = value
+ } else {
+ Module[name] = value;
+ Module[name].argCount = numArguments
+ }
+}
+var UnboundTypeError = undefined;
+
+function getTypeName(type) {
+ var ptr = ___getTypeName(type);
+ var rv = readLatin1String(ptr);
+ _free(ptr);
+ return rv
+}
+function throwUnboundTypeError(message, types) {
+ var unboundTypes = [];
+ var seen = {};
+
+ function visit(type) {
+ if (seen[type]) {
+ return
+ }
+ if (registeredTypes[type]) {
+ return
+ }
+ if (typeDependencies[type]) {
+ typeDependencies[type].forEach(visit);
+ return
+ }
+ unboundTypes.push(type);
+ seen[type] = true
+ }
+ types.forEach(visit);
+ throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "]))
+}
+function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {
+ var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+ name = readLatin1String(name);
+ rawInvoker = requireFunction(signature, rawInvoker);
+ exposePublicSymbol(name, (function() {
+ throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes)
+ }), argCount - 1);
+ whenDependentTypesAreResolved([], argTypes, (function(argTypes) {
+ var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
+ replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1);
+ return []
+ }))
+}
+function _pthread_join() {}
+function _pthread_cond_init() {
+ return 0
+}
+function ___syscall6(which, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD();
+ FS.close(stream);
+ return 0
+ } catch (e) {
+ if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+ return -e.errno
+ }
+}
+function ___setErrNo(value) {
+ if (Module["___errno_location"]) HEAP32[Module["___errno_location"]() >> 2] = value;
+ return value
+}
+function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
+ return dest
+}
+function __embind_register_std_wstring(rawType, charSize, name) {
+ name = readLatin1String(name);
+ var getHeap, shift;
+ if (charSize === 2) {
+ getHeap = (function() {
+ return HEAPU16
+ });
+ shift = 1
+ } else if (charSize === 4) {
+ getHeap = (function() {
+ return HEAPU32
+ });
+ shift = 2
+ }
+ registerType(rawType, {
+ name: name,
+ "fromWireType": (function(value) {
+ var HEAP = getHeap();
+ var length = HEAPU32[value >> 2];
+ var a = new Array(length);
+ var start = value + 4 >> shift;
+ for (var i = 0; i < length; ++i) {
+ a[i] = String.fromCharCode(HEAP[start + i])
+ }
+ _free(value);
+ return a.join("")
+ }),
+ "toWireType": (function(destructors, value) {
+ var HEAP = getHeap();
+ var length = value.length;
+ var ptr = _malloc(4 + length * charSize);
+ HEAPU32[ptr >> 2] = length;
+ var start = ptr + 4 >> shift;
+ for (var i = 0; i < length; ++i) {
+ HEAP[start + i] = value.charCodeAt(i)
+ }
+ if (destructors !== null) {
+ destructors.push(_free, ptr)
+ }
+ return ptr
+ }),
+ "argPackAdvance": 8,
+ "readValueFromPointer": simpleReadValueFromPointer,
+ destructorFunction: (function(ptr) {
+ _free(ptr)
+ })
+ })
+}
+function ___cxa_begin_catch(ptr) {
+ var info = EXCEPTIONS.infos[ptr];
+ if (info && !info.caught) {
+ info.caught = true;
+ __ZSt18uncaught_exceptionv.uncaught_exception--
+ }
+ if (info) info.rethrown = false;
+ EXCEPTIONS.caught.push(ptr);
+ EXCEPTIONS.addRef(EXCEPTIONS.deAdjust(ptr));
+ return ptr
+}
+function _gettimeofday(ptr) {
+ var now = Date.now();
+ HEAP32[ptr >> 2] = now / 1e3 | 0;
+ HEAP32[ptr + 4 >> 2] = now % 1e3 * 1e3 | 0;
+ return 0
+}
+function _pthread_cond_wait() {
+ return 0
+}
+function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+ var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+ var TA = typeMapping[dataTypeIndex];
+
+ function decodeMemoryView(handle) {
+ handle = handle >> 2;
+ var heap = HEAPU32;
+ var size = heap[handle];
+ var data = heap[handle + 1];
+ return new TA(heap["buffer"], data, size)
+ }
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ "fromWireType": decodeMemoryView,
+ "argPackAdvance": 8,
+ "readValueFromPointer": decodeMemoryView
+ }, {
+ ignoreDuplicateRegistrations: true
+ })
+}
+function ___syscall140(which, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(),
+ offset_high = SYSCALLS.get(),
+ offset_low = SYSCALLS.get(),
+ result = SYSCALLS.get(),
+ whence = SYSCALLS.get();
+ var offset = offset_low;
+ FS.llseek(stream, offset, whence);
+ HEAP32[result >> 2] = stream.position;
+ if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
+ return 0
+ } catch (e) {
+ if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+ return -e.errno
+ }
+}
+function ___syscall146(which, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.get(),
+ iov = SYSCALLS.get(),
+ iovcnt = SYSCALLS.get();
+ var ret = 0;
+ if (!___syscall146.buffer) {
+ ___syscall146.buffers = [null, [],
+ []
+ ];
+ ___syscall146.printChar = (function(stream, curr) {
+ var buffer = ___syscall146.buffers[stream];
+ assert(buffer);
+ if (curr === 0 || curr === 10) {
+ (stream === 1 ? Module["print"] : Module["printErr"])(UTF8ArrayToString(buffer, 0));
+ buffer.length = 0
+ } else {
+ buffer.push(curr)
+ }
+ })
+ }
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAP32[iov + i * 8 >> 2];
+ var len = HEAP32[iov + (i * 8 + 4) >> 2];
+ for (var j = 0; j < len; j++) {
+ ___syscall146.printChar(stream, HEAPU8[ptr + j])
+ }
+ ret += len
+ }
+ return ret
+ } catch (e) {
+ if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+ return -e.errno
+ }
+}
+embind_init_charCodes();
+BindingError = Module["BindingError"] = extendError(Error, "BindingError");
+InternalError = Module["InternalError"] = extendError(Error, "InternalError");
+init_emval();
+UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
+__ATEXIT__.push((function() {
+ var fflush = Module["_fflush"];
+ if (fflush) fflush(0);
+ var printChar = ___syscall146.printChar;
+ if (!printChar) return;
+ var buffers = ___syscall146.buffers;
+ if (buffers[1].length) printChar(1, 10);
+ if (buffers[2].length) printChar(2, 10)
+}));
+DYNAMICTOP_PTR = allocate(1, "i32", ALLOC_STATIC);
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+STACK_MAX = STACK_BASE + TOTAL_STACK;
+DYNAMIC_BASE = Runtime.alignMemory(STACK_MAX);
+HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
+staticSealed = true;
+Module["wasmTableSize"] = 494;
+Module["wasmMaxTableSize"] = 494;
+
+function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
+ try {
+ return Module["dynCall_iiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiii(index, a1, a2, a3, a4, a5) {
+ try {
+ Module["dynCall_viiiii"](index, a1, a2, a3, a4, a5)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_vi(index, a1) {
+ try {
+ Module["dynCall_vi"](index, a1)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_vii(index, a1, a2) {
+ try {
+ Module["dynCall_vii"](index, a1, a2)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
+ try {
+ return Module["dynCall_iiiiiii"](index, a1, a2, a3, a4, a5, a6)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_ii(index, a1) {
+ try {
+ return Module["dynCall_ii"](index, a1)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
+ try {
+ Module["dynCall_viiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
+ try {
+ return Module["dynCall_iiiiii"](index, a1, a2, a3, a4, a5)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_iiii(index, a1, a2, a3) {
+ try {
+ return Module["dynCall_iiii"](index, a1, a2, a3)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ try {
+ Module["dynCall_viiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
+ try {
+ Module["dynCall_viiiiii"](index, a1, a2, a3, a4, a5, a6)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) {
+ try {
+ Module["dynCall_viiiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
+ try {
+ Module["dynCall_viiiiiii"](index, a1, a2, a3, a4, a5, a6, a7)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ try {
+ Module["dynCall_viiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+ try {
+ Module["dynCall_viiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_iii(index, a1, a2) {
+ try {
+ return Module["dynCall_iii"](index, a1, a2)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_i(index) {
+ try {
+ return Module["dynCall_i"](index)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
+ try {
+ Module["dynCall_viiiiiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_iiiii(index, a1, a2, a3, a4) {
+ try {
+ return Module["dynCall_iiiii"](index, a1, a2, a3, a4)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viii(index, a1, a2, a3) {
+ try {
+ Module["dynCall_viii"](index, a1, a2, a3)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_v(index) {
+ try {
+ Module["dynCall_v"](index)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ try {
+ return Module["dynCall_iiiiiiiii"](index, a1, a2, a3, a4, a5, a6, a7, a8)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+function invoke_viiii(index, a1, a2, a3, a4) {
+ try {
+ Module["dynCall_viiii"](index, a1, a2, a3, a4)
+ } catch (e) {
+ if (typeof e !== "number" && e !== "longjmp") throw e;
+ Module["setThrew"](1, 0)
+ }
+}
+Module.asmGlobalArg = {
+ "Math": Math,
+ "Int8Array": Int8Array,
+ "Int16Array": Int16Array,
+ "Int32Array": Int32Array,
+ "Uint8Array": Uint8Array,
+ "Uint16Array": Uint16Array,
+ "Uint32Array": Uint32Array,
+ "Float32Array": Float32Array,
+ "Float64Array": Float64Array,
+ "NaN": NaN,
+ "Infinity": Infinity
+};
+Module.asmLibraryArg = {
+ "abort": abort,
+ "assert": assert,
+ "enlargeMemory": enlargeMemory,
+ "getTotalMemory": getTotalMemory,
+ "abortOnCannotGrowMemory": abortOnCannotGrowMemory,
+ "invoke_iiiiiiii": invoke_iiiiiiii,
+ "invoke_viiiii": invoke_viiiii,
+ "invoke_vi": invoke_vi,
+ "invoke_vii": invoke_vii,
+ "invoke_iiiiiii": invoke_iiiiiii,
+ "invoke_ii": invoke_ii,
+ "invoke_viiiiiiiiiii": invoke_viiiiiiiiiii,
+ "invoke_iiiiii": invoke_iiiiii,
+ "invoke_iiii": invoke_iiii,
+ "invoke_viiiiiiii": invoke_viiiiiiii,
+ "invoke_viiiiii": invoke_viiiiii,
+ "invoke_viiiiiiiiiiiii": invoke_viiiiiiiiiiiii,
+ "invoke_viiiiiii": invoke_viiiiiii,
+ "invoke_viiiiiiiii": invoke_viiiiiiiii,
+ "invoke_viiiiiiiiii": invoke_viiiiiiiiii,
+ "invoke_iii": invoke_iii,
+ "invoke_i": invoke_i,
+ "invoke_viiiiiiiiiiii": invoke_viiiiiiiiiiii,
+ "invoke_iiiii": invoke_iiiii,
+ "invoke_viii": invoke_viii,
+ "invoke_v": invoke_v,
+ "invoke_iiiiiiiii": invoke_iiiiiiiii,
+ "invoke_viiii": invoke_viiii,
+ "requireFunction": requireFunction,
+ "_pthread_cond_wait": _pthread_cond_wait,
+ "_pthread_join": _pthread_join,
+ "simpleReadValueFromPointer": simpleReadValueFromPointer,
+ "new_": new_,
+ "___syscall54": ___syscall54,
+ "__embind_register_integer": __embind_register_integer,
+ "throwInternalError": throwInternalError,
+ "get_first_emval": get_first_emval,
+ "_abort": _abort,
+ "whenDependentTypesAreResolved": whenDependentTypesAreResolved,
+ "___gxx_personality_v0": ___gxx_personality_v0,
+ "extendError": extendError,
+ "___assert_fail": ___assert_fail,
+ "__embind_register_void": __embind_register_void,
+ "___cxa_find_matching_catch": ___cxa_find_matching_catch,
+ "__embind_register_value_object_field": __embind_register_value_object_field,
+ "exposePublicSymbol": exposePublicSymbol,
+ "_pthread_cond_init": _pthread_cond_init,
+ "__embind_register_function": __embind_register_function,
+ "embind_init_charCodes": embind_init_charCodes,
+ "___cxa_begin_catch": ___cxa_begin_catch,
+ "___setErrNo": ___setErrNo,
+ "__emval_register": __emval_register,
+ "readLatin1String": readLatin1String,
+ "___cxa_allocate_exception": ___cxa_allocate_exception,
+ "_emscripten_memcpy_big": _emscripten_memcpy_big,
+ "__embind_register_bool": __embind_register_bool,
+ "___resumeException": ___resumeException,
+ "__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv,
+ "_embind_repr": _embind_repr,
+ "__embind_register_std_wstring": __embind_register_std_wstring,
+ "_pthread_getspecific": _pthread_getspecific,
+ "_clock": _clock,
+ "createNamedFunction": createNamedFunction,
+ "__embind_register_emval": __embind_register_emval,
+ "_pthread_cond_signal": _pthread_cond_signal,
+ "__embind_finalize_value_object": __embind_finalize_value_object,
+ "_pthread_mutex_destroy": _pthread_mutex_destroy,
+ "throwUnboundTypeError": throwUnboundTypeError,
+ "craftInvokerFunction": craftInvokerFunction,
+ "__emval_decref": __emval_decref,
+ "_pthread_once": _pthread_once,
+ "getShiftFromSize": getShiftFromSize,
+ "makeLegalFunctionName": makeLegalFunctionName,
+ "_pthread_key_create": _pthread_key_create,
+ "___unlock": ___unlock,
+ "heap32VectorToArray": heap32VectorToArray,
+ "init_emval": init_emval,
+ "_pthread_create": _pthread_create,
+ "floatReadValueFromPointer": floatReadValueFromPointer,
+ "__embind_register_value_object": __embind_register_value_object,
+ "_pthread_setspecific": _pthread_setspecific,
+ "integerReadValueFromPointer": integerReadValueFromPointer,
+ "registerType": registerType,
+ "___cxa_throw": ___cxa_throw,
+ "___lock": ___lock,
+ "___syscall6": ___syscall6,
+ "throwBindingError": throwBindingError,
+ "ensureOverloadTable": ensureOverloadTable,
+ "count_emval_handles": count_emval_handles,
+ "_pthread_cond_destroy": _pthread_cond_destroy,
+ "__embind_register_float": __embind_register_float,
+ "_gettimeofday": _gettimeofday,
+ "getTypeName": getTypeName,
+ "___syscall140": ___syscall140,
+ "_pthread_mutex_init": _pthread_mutex_init,
+ "__embind_register_memory_view": __embind_register_memory_view,
+ "__embind_register_std_string": __embind_register_std_string,
+ "replacePublicSymbol": replacePublicSymbol,
+ "___cxa_pure_virtual": ___cxa_pure_virtual,
+ "___syscall146": ___syscall146,
+ "runDestructors": runDestructors,
+ "DYNAMICTOP_PTR": DYNAMICTOP_PTR,
+ "tempDoublePtr": tempDoublePtr,
+ "ABORT": ABORT,
+ "STACKTOP": STACKTOP,
+ "STACK_MAX": STACK_MAX
+};
+var asm = Module["asm"](Module.asmGlobalArg, Module.asmLibraryArg, buffer);
+Module["asm"] = asm;
+var stackSave = Module["stackSave"] = (function() {
+ return Module["asm"]["stackSave"].apply(null, arguments)
+});
+var _SetIFrameDecInterval = Module["_SetIFrameDecInterval"] = (function() {
+ return Module["asm"]["_SetIFrameDecInterval"].apply(null, arguments)
+});
+var _CloseStream = Module["_CloseStream"] = (function() {
+ return Module["asm"]["_CloseStream"].apply(null, arguments)
+});
+var setThrew = Module["setThrew"] = (function() {
+ return Module["asm"]["setThrew"].apply(null, arguments)
+});
+var _GetFrameData = Module["_GetFrameData"] = (function() {
+ return Module["asm"]["_GetFrameData"].apply(null, arguments)
+});
+var _sbrk = Module["_sbrk"] = (function() {
+ return Module["asm"]["_sbrk"].apply(null, arguments)
+});
+var _fflush = Module["_fflush"] = (function() {
+ return Module["asm"]["_fflush"].apply(null, arguments)
+});
+var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = (function() {
+ return Module["asm"]["___cxa_is_pointer_type"].apply(null, arguments)
+});
+var _memset = Module["_memset"] = (function() {
+ return Module["asm"]["_memset"].apply(null, arguments)
+});
+var _SetDisplayRegion = Module["_SetDisplayRegion"] = (function() {
+ return Module["asm"]["_SetDisplayRegion"].apply(null, arguments)
+});
+var _memcpy = Module["_memcpy"] = (function() {
+ return Module["asm"]["_memcpy"].apply(null, arguments)
+});
+var _llvm_bswap_i32 = Module["_llvm_bswap_i32"] = (function() {
+ return Module["asm"]["_llvm_bswap_i32"].apply(null, arguments)
+});
+var stackAlloc = Module["stackAlloc"] = (function() {
+ return Module["asm"]["stackAlloc"].apply(null, arguments)
+});
+var getTempRet0 = Module["getTempRet0"] = (function() {
+ return Module["asm"]["getTempRet0"].apply(null, arguments)
+});
+var __GLOBAL__sub_I_bind_cpp = Module["__GLOBAL__sub_I_bind_cpp"] = (function() {
+ return Module["asm"]["__GLOBAL__sub_I_bind_cpp"].apply(null, arguments)
+});
+var setTempRet0 = Module["setTempRet0"] = (function() {
+ return Module["asm"]["setTempRet0"].apply(null, arguments)
+});
+var _SetSecretKey = Module["_SetSecretKey"] = (function() {
+ return Module["asm"]["_SetSecretKey"].apply(null, arguments)
+});
+var _pthread_mutex_unlock = Module["_pthread_mutex_unlock"] = (function() {
+ return Module["asm"]["_pthread_mutex_unlock"].apply(null, arguments)
+});
+var __GLOBAL__sub_I_Decoder_cpp = Module["__GLOBAL__sub_I_Decoder_cpp"] = (function() {
+ return Module["asm"]["__GLOBAL__sub_I_Decoder_cpp"].apply(null, arguments)
+});
+var _emscripten_get_global_libc = Module["_emscripten_get_global_libc"] = (function() {
+ return Module["asm"]["_emscripten_get_global_libc"].apply(null, arguments)
+});
+var _InputData = Module["_InputData"] = (function() {
+ return Module["asm"]["_InputData"].apply(null, arguments)
+});
+var ___getTypeName = Module["___getTypeName"] = (function() {
+ return Module["asm"]["___getTypeName"].apply(null, arguments)
+});
+var _GetJPEG = Module["_GetJPEG"] = (function() {
+ return Module["asm"]["_GetJPEG"].apply(null, arguments)
+});
+var _OpenStream = Module["_OpenStream"] = (function() {
+ return Module["asm"]["_OpenStream"].apply(null, arguments)
+});
+var _GetBMP = Module["_GetBMP"] = (function() {
+ return Module["asm"]["_GetBMP"].apply(null, arguments)
+});
+var _pthread_cond_broadcast = Module["_pthread_cond_broadcast"] = (function() {
+ return Module["asm"]["_pthread_cond_broadcast"].apply(null, arguments)
+});
+var ___errno_location = Module["___errno_location"] = (function() {
+ return Module["asm"]["___errno_location"].apply(null, arguments)
+});
+var runPostSets = Module["runPostSets"] = (function() {
+ return Module["asm"]["runPostSets"].apply(null, arguments)
+});
+var ___cxa_can_catch = Module["___cxa_can_catch"] = (function() {
+ return Module["asm"]["___cxa_can_catch"].apply(null, arguments)
+});
+var _free = Module["_free"] = (function() {
+ return Module["asm"]["_free"].apply(null, arguments)
+});
+var _GetFrameBuffer = Module["_GetFrameBuffer"] = (function() {
+ return Module["asm"]["_GetFrameBuffer"].apply(null, arguments)
+});
+var establishStackSpace = Module["establishStackSpace"] = (function() {
+ return Module["asm"]["establishStackSpace"].apply(null, arguments)
+});
+var _memmove = Module["_memmove"] = (function() {
+ return Module["asm"]["_memmove"].apply(null, arguments)
+});
+var _SetStreamOpenMode = Module["_SetStreamOpenMode"] = (function() {
+ return Module["asm"]["_SetStreamOpenMode"].apply(null, arguments)
+});
+var stackRestore = Module["stackRestore"] = (function() {
+ return Module["asm"]["stackRestore"].apply(null, arguments)
+});
+var _malloc = Module["_malloc"] = (function() {
+ return Module["asm"]["_malloc"].apply(null, arguments)
+});
+var _pthread_mutex_lock = Module["_pthread_mutex_lock"] = (function() {
+ return Module["asm"]["_pthread_mutex_lock"].apply(null, arguments)
+});
+var _SetDecodeFrameType = Module["_SetDecodeFrameType"] = (function() {
+ return Module["asm"]["_SetDecodeFrameType"].apply(null, arguments)
+});
+var _Stop = Module["_Stop"] = (function() {
+ return Module["asm"]["_Stop"].apply(null, arguments)
+});
+var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_iiiiiiii"].apply(null, arguments)
+});
+var dynCall_viiiii = Module["dynCall_viiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiii"].apply(null, arguments)
+});
+var dynCall_vi = Module["dynCall_vi"] = (function() {
+ return Module["asm"]["dynCall_vi"].apply(null, arguments)
+});
+var dynCall_vii = Module["dynCall_vii"] = (function() {
+ return Module["asm"]["dynCall_vii"].apply(null, arguments)
+});
+var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = (function() {
+ return Module["asm"]["dynCall_iiiiiii"].apply(null, arguments)
+});
+var dynCall_ii = Module["dynCall_ii"] = (function() {
+ return Module["asm"]["dynCall_ii"].apply(null, arguments)
+});
+var dynCall_viiiiiiiiiii = Module["dynCall_viiiiiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiiiiiiii"].apply(null, arguments)
+});
+var dynCall_iiiiii = Module["dynCall_iiiiii"] = (function() {
+ return Module["asm"]["dynCall_iiiiii"].apply(null, arguments)
+});
+var dynCall_iiii = Module["dynCall_iiii"] = (function() {
+ return Module["asm"]["dynCall_iiii"].apply(null, arguments)
+});
+var dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiiiii"].apply(null, arguments)
+});
+var dynCall_viiiiii = Module["dynCall_viiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiii"].apply(null, arguments)
+});
+var dynCall_viiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiiiiiiiiii"].apply(null, arguments)
+});
+var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiiii"].apply(null, arguments)
+});
+var dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiiiiii"].apply(null, arguments)
+});
+var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiiiiiii"].apply(null, arguments)
+});
+var dynCall_iii = Module["dynCall_iii"] = (function() {
+ return Module["asm"]["dynCall_iii"].apply(null, arguments)
+});
+var dynCall_i = Module["dynCall_i"] = (function() {
+ return Module["asm"]["dynCall_i"].apply(null, arguments)
+});
+var dynCall_viiiiiiiiiiii = Module["dynCall_viiiiiiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_viiiiiiiiiiii"].apply(null, arguments)
+});
+var dynCall_iiiii = Module["dynCall_iiiii"] = (function() {
+ return Module["asm"]["dynCall_iiiii"].apply(null, arguments)
+});
+var dynCall_viii = Module["dynCall_viii"] = (function() {
+ return Module["asm"]["dynCall_viii"].apply(null, arguments)
+});
+var dynCall_v = Module["dynCall_v"] = (function() {
+ return Module["asm"]["dynCall_v"].apply(null, arguments)
+});
+var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = (function() {
+ return Module["asm"]["dynCall_iiiiiiiii"].apply(null, arguments)
+});
+var dynCall_viiii = Module["dynCall_viiii"] = (function() {
+ return Module["asm"]["dynCall_viiii"].apply(null, arguments)
+});
+Runtime.stackAlloc = Module["stackAlloc"];
+Runtime.stackSave = Module["stackSave"];
+Runtime.stackRestore = Module["stackRestore"];
+Runtime.establishStackSpace = Module["establishStackSpace"];
+Runtime.setTempRet0 = Module["setTempRet0"];
+Runtime.getTempRet0 = Module["getTempRet0"];
+Module["asm"] = asm;
+if (memoryInitializer) {
+ if (typeof Module["locateFile"] === "function") {
+ memoryInitializer = Module["locateFile"](memoryInitializer)
+ } else if (Module["memoryInitializerPrefixURL"]) {
+ memoryInitializer = Module["memoryInitializerPrefixURL"] + memoryInitializer
+ }
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module["readBinary"](memoryInitializer);
+ HEAPU8.set(data, Runtime.GLOBAL_BASE)
+ } else {
+ addRunDependency("memory initializer");
+ var applyMemoryInitializer = (function(data) {
+ if (data.byteLength) data = new Uint8Array(data);
+ HEAPU8.set(data, Runtime.GLOBAL_BASE);
+ if (Module["memoryInitializerRequest"]) delete Module["memoryInitializerRequest"].response;
+ removeRunDependency("memory initializer")
+ });
+
+ function doBrowserLoad() {
+ Module["readAsync"](memoryInitializer, applyMemoryInitializer, (function() {
+ throw "could not load memory initializer " + memoryInitializer
+ }))
+ }
+ if (Module["memoryInitializerRequest"]) {
+ function useRequest() {
+ var request = Module["memoryInitializerRequest"];
+ if (request.status !== 200 && request.status !== 0) {
+ console.warn("a problem seems to have happened with Module.memoryInitializerRequest, status: " + request.status + ", retrying " + memoryInitializer);
+ doBrowserLoad();
+ return
+ }
+ applyMemoryInitializer(request.response)
+ }
+ if (Module["memoryInitializerRequest"].response) {
+ setTimeout(useRequest, 0)
+ } else {
+ Module["memoryInitializerRequest"].addEventListener("load", useRequest)
+ }
+ } else {
+ doBrowserLoad()
+ }
+ }
+}
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status
+}
+ExitStatus.prototype = new Error;
+ExitStatus.prototype.constructor = ExitStatus;
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+dependenciesFulfilled = function runCaller() {
+ if (!Module["calledRun"]) run();
+ if (!Module["calledRun"]) dependenciesFulfilled = runCaller
+};
+Module["callMain"] = Module.callMain = function callMain(args) {
+ args = args || [];
+ ensureInitRuntime();
+ var argc = args.length + 1;
+
+ function pad() {
+ for (var i = 0; i < 4 - 1; i++) {
+ argv.push(0)
+ }
+ }
+ var argv = [allocate(intArrayFromString(Module["thisProgram"]), "i8", ALLOC_NORMAL)];
+ pad();
+ for (var i = 0; i < argc - 1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), "i8", ALLOC_NORMAL));
+ pad()
+ }
+ argv.push(0);
+ argv = allocate(argv, "i32", ALLOC_NORMAL);
+ try {
+ var ret = Module["_main"](argc, argv, 0);
+ exit(ret, true)
+ } catch (e) {
+ if (e instanceof ExitStatus) {
+ return
+ } else if (e == "SimulateInfiniteLoop") {
+ Module["noExitRuntime"] = true;
+ return
+ } else {
+ var toLog = e;
+ if (e && typeof e === "object" && e.stack) {
+ toLog = [e, e.stack]
+ }
+ Module.printErr("exception thrown: " + toLog);
+ Module["quit"](1, e)
+ }
+ } finally {
+ calledMain = true
+ }
+};
+
+function run(args) {
+ args = args || Module["arguments"];
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+ if (runDependencies > 0) {
+ return
+ }
+ preRun();
+ if (runDependencies > 0) return;
+ if (Module["calledRun"]) return;
+
+ function doRun() {
+ if (Module["calledRun"]) return;
+ Module["calledRun"] = true;
+ if (ABORT) return;
+ ensureInitRuntime();
+ preMain();
+ if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
+ if (Module["_main"] && shouldRunNow) Module["callMain"](args);
+ postRun()
+ }
+ if (Module["setStatus"]) {
+ Module["setStatus"]("Running...");
+ setTimeout((function() {
+ setTimeout((function() {
+ Module["setStatus"]("")
+ }), 1);
+ doRun()
+ }), 1)
+ } else {
+ doRun()
+ }
+}
+Module["run"] = Module.run = run;
+
+function exit(status, implicit) {
+ if (implicit && Module["noExitRuntime"]) {
+ return
+ }
+ if (Module["noExitRuntime"]) {} else {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+ exitRuntime();
+ if (Module["onExit"]) Module["onExit"](status)
+ }
+ if (ENVIRONMENT_IS_NODE) {
+ process["exit"](status)
+ }
+ Module["quit"](status, new ExitStatus(status))
+}
+Module["exit"] = Module.exit = exit;
+var abortDecorators = [];
+
+function abort(what) {
+ if (Module["onAbort"]) {
+ Module["onAbort"](what)
+ }
+ if (what !== undefined) {
+ Module.print(what);
+ Module.printErr(what);
+ what = JSON.stringify(what)
+ } else {
+ what = ""
+ }
+ ABORT = true;
+ EXITSTATUS = 1;
+ var extra = "\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.";
+ var output = "abort(" + what + ") at " + stackTrace() + extra;
+ if (abortDecorators) {
+ abortDecorators.forEach((function(decorator) {
+ output = decorator(output, what)
+ }))
+ }
+ throw output
+}
+Module["abort"] = Module.abort = abort;
+if (Module["preInit"]) {
+ if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+ while (Module["preInit"].length > 0) {
+ Module["preInit"].pop()()
+ }
+}
+var shouldRunNow = true;
+if (Module["noInitialRun"]) {
+ shouldRunNow = false
+}
+run()
\ No newline at end of file
--
Gitblit v1.9.3