var Module = (function() {
    var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
    return (
        function(Module) {
            Module = Module || {};
            var Module = typeof Module !== "undefined" ? Module : {};
            var readyPromiseResolve, readyPromiseReject;
            Module["ready"] = new Promise(function(resolve, reject) {
                readyPromiseResolve = resolve;
                readyPromiseReject = reject
            });
            if (!Module.expectedDataFileDownloads) {
                Module.expectedDataFileDownloads = 0;
                Module.finishedDataFileDownloads = 0
            }
            Module.expectedDataFileDownloads++;
            (function() {
                var loadPackage = function(metadata) {
                    var PACKAGE_PATH;
                    if (typeof window === "object") {
                        PACKAGE_PATH = window["encodeURIComponent"](window.location.pathname.toString().substring(0, window.location.pathname.toString().lastIndexOf("/")) + "/")
                    } else if (typeof location !== "undefined") {
                        PACKAGE_PATH = encodeURIComponent(location.pathname.toString().substring(0, location.pathname.toString().lastIndexOf("/")) + "/")
                    } else {
                        throw "using preloaded data can only be done on a web page or in a web worker"
                    }
                    var PACKAGE_NAME = "waflash.data";
                    var REMOTE_PACKAGE_BASE = "waflash.data";
                    if (typeof Module["locateFilePackage"] === "function" && !Module["locateFile"]) {
                        Module["locateFile"] = Module["locateFilePackage"];
                        err("warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)")
                    }
                    var REMOTE_PACKAGE_NAME = Module["locateFile"] ? Module["locateFile"](REMOTE_PACKAGE_BASE, "") : REMOTE_PACKAGE_BASE;
                    var REMOTE_PACKAGE_SIZE = metadata["remote_package_size"];
                    var PACKAGE_UUID = metadata["package_uuid"];

                    function fetchRemotePackage(packageName, packageSize, callback, errback) {
                        var xhr = new XMLHttpRequest;
                        xhr.open("GET", packageName, true);
                        xhr.responseType = "arraybuffer";
                        xhr.onprogress = function(event) {
                            var url = packageName;
                            var size = packageSize;
                            if (event.total) size = event.total;
                            if (event.loaded) {
                                if (!xhr.addedTotal) {
                                    xhr.addedTotal = true;
                                    if (!Module.dataFileDownloads) Module.dataFileDownloads = {};
                                    Module.dataFileDownloads[url] = {
                                        loaded: event.loaded,
                                        total: size
                                    }
                                } else {
                                    Module.dataFileDownloads[url].loaded = event.loaded
                                }
                                var total = 0;
                                var loaded = 0;
                                var num = 0;
                                for (var download in Module.dataFileDownloads) {
                                    var data = Module.dataFileDownloads[download];
                                    total += data.total;
                                    loaded += data.loaded;
                                    num++
                                }
                                total = Math.ceil(total * Module.expectedDataFileDownloads / num);
                                if (Module["setStatus"]) Module["setStatus"]("Downloading data... (" + loaded + "/" + total + ")")
                            } else if (!Module.dataFileDownloads) {
                                if (Module["setStatus"]) Module["setStatus"]("Downloading data...")
                            }
                        };
                        xhr.onerror = function(event) {
                            throw new Error("NetworkError for: " + packageName)
                        };
                        xhr.onload = function(event) {
                            if (xhr.status == 200 || xhr.status == 304 || xhr.status == 206 || xhr.status == 0 && xhr.response) {
                                var packageData = xhr.response;
                                callback(packageData)
                            } else {
                                throw new Error(xhr.statusText + " : " + xhr.responseURL)
                            }
                        };
                        xhr.send(null)
                    }

                    function handleError(error) {
                        console.error("package error:", error)
                    }
                    var fetchedCallback = null;
                    var fetched = Module["getPreloadedPackage"] ? Module["getPreloadedPackage"](REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE) : null;
                    if (!fetched) fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE, function(data) {
                        if (fetchedCallback) {
                            fetchedCallback(data);
                            fetchedCallback = null
                        } else {
                            fetched = data
                        }
                    }, handleError);

                    function runWithFS() {
                        function assert(check, msg) {
                            if (!check) throw msg + (new Error).stack
                        }

                        function DataRequest(start, end, audio) {
                            this.start = start;
                            this.end = end;
                            this.audio = audio
                        }
                        DataRequest.prototype = {
                            requests: {},
                            open: function(mode, name) {
                                this.name = name;
                                this.requests[name] = this;
                                Module["addRunDependency"]("fp " + this.name)
                            },
                            send: function() {},
                            onload: function() {
                                var byteArray = this.byteArray.subarray(this.start, this.end);
                                this.finish(byteArray)
                            },
                            finish: function(byteArray) {
                                var that = this;
                                Module["FS_createDataFile"](this.name, null, byteArray, true, true, true);
                                Module["removeRunDependency"]("fp " + that.name);
                                this.requests[this.name] = null
                            }
                        };
                        var files = metadata["files"];
                        for (var i = 0; i < files.length; ++i) {
                            new DataRequest(files[i]["start"], files[i]["end"], files[i]["audio"]).open("GET", files[i]["filename"])
                        }

                        function processPackageData(arrayBuffer) {
                            Module.finishedDataFileDownloads++;
                            assert(arrayBuffer, "Loading data file failed.");
                            assert(arrayBuffer instanceof ArrayBuffer, "bad input to processPackageData");
                            var byteArray = new Uint8Array(arrayBuffer);
                            DataRequest.prototype.byteArray = byteArray;
                            var files = metadata["files"];
                            for (var i = 0; i < files.length; ++i) {
                                DataRequest.prototype.requests[files[i].filename].onload()
                            }
                            Module["removeRunDependency"]("datafile_waflash.data")
                        }
                        Module["addRunDependency"]("datafile_waflash.data");
                        if (!Module.preloadResults) Module.preloadResults = {};
                        Module.preloadResults[PACKAGE_NAME] = {
                            fromCache: false
                        };
                        if (fetched) {
                            processPackageData(fetched);
                            fetched = null
                        } else {
                            fetchedCallback = processPackageData
                        }
                    }
                    if (Module["calledRun"]) {
                        runWithFS()
                    } else {
                        if (!Module["preRun"]) Module["preRun"] = [];
                        Module["preRun"].push(runWithFS)
                    }
                };
                loadPackage({
                    "files": [{
                        "filename": "/desktop.ini",
                        "start": 0,
                        "end": 46,
                        "audio": 0
                    }, {
                        "filename": "/NanumSquareRoundOTFR.otf",
                        "start": 46,
                        "end": 465950,
                        "audio": 0
                    }],
                    "remote_package_size": 465950,
                    "package_uuid": "1302f8fa-6355-4df6-ae92-6f55ca742376"
                })
            })();
            var moduleOverrides = {};
            var key;
            for (key in Module) {
                if (Module.hasOwnProperty(key)) {
                    moduleOverrides[key] = Module[key]
                }
            }
            var arguments_ = [];
            var thisProgram = "./this.program";
            var quit_ = function(status, toThrow) {
                throw toThrow
            };
            var ENVIRONMENT_IS_WEB = true;
            var ENVIRONMENT_IS_WORKER = false;
            var scriptDirectory = "";

            function locateFile(path) {
                if (Module["locateFile"]) {
                    return Module["locateFile"](path, scriptDirectory)
                }
                return scriptDirectory + path
            }
            var read_, readAsync, readBinary, setWindowTitle;
            if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
                if (ENVIRONMENT_IS_WORKER) {
                    scriptDirectory = self.location.href
                } else if (document.currentScript) {
                    scriptDirectory = document.currentScript.src
                }
                if (_scriptDir) {
                    scriptDirectory = _scriptDir
                }
                if (scriptDirectory.indexOf("blob:") !== 0) {
                    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1)
                } else {
                    scriptDirectory = ""
                } {
                    read_ = function shell_read(url) {
                        var xhr = new XMLHttpRequest;
                        xhr.open("GET", url, false);
                        xhr.send(null);
                        return xhr.responseText
                    };
                    if (ENVIRONMENT_IS_WORKER) {
                        readBinary = function readBinary(url) {
                            var xhr = new XMLHttpRequest;
                            xhr.open("GET", url, false);
                            xhr.responseType = "arraybuffer";
                            xhr.send(null);
                            return new Uint8Array(xhr.response)
                        }
                    }
                    readAsync = function readAsync(url, onload, onerror) {
                        var xhr = new XMLHttpRequest;
                        xhr.open("GET", url, true);
                        xhr.responseType = "arraybuffer";
                        xhr.onload = function xhr_onload() {
                            if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
                                onload(xhr.response);
                                return
                            }
                            onerror()
                        };
                        xhr.onerror = onerror;
                        xhr.send(null)
                    }
                }
                setWindowTitle = function(title) {
                    document.title = title
                }
            } else {}
            var out = Module["print"] || console.log.bind(console);
            var err = Module["printErr"] || console.warn.bind(console);
            for (key in moduleOverrides) {
                if (moduleOverrides.hasOwnProperty(key)) {
                    Module[key] = moduleOverrides[key]
                }
            }
            moduleOverrides = null;
            if (Module["arguments"]) arguments_ = Module["arguments"];
            if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
            if (Module["quit"]) quit_ = Module["quit"];
            var STACK_ALIGN = 16;

            function dynamicAlloc(size) {
                var ret = HEAP32[DYNAMICTOP_PTR >> 2];
                var end = ret + size + 15 & -16;
                HEAP32[DYNAMICTOP_PTR >> 2] = end;
                return ret
            }

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

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

            function convertJsFunctionToWasm(func, sig) {
                if (typeof WebAssembly.Function === "function") {
                    var typeNames = {
                        "i": "i32",
                        "j": "i64",
                        "f": "f32",
                        "d": "f64"
                    };
                    var type = {
                        parameters: [],
                        results: sig[0] == "v" ? [] : [typeNames[sig[0]]]
                    };
                    for (var i = 1; i < sig.length; ++i) {
                        type.parameters.push(typeNames[sig[i]])
                    }
                    return new WebAssembly.Function(type, func)
                }
                var typeSection = [1, 0, 1, 96];
                var sigRet = sig.slice(0, 1);
                var sigParam = sig.slice(1);
                var typeCodes = {
                    "i": 127,
                    "j": 126,
                    "f": 125,
                    "d": 124
                };
                typeSection.push(sigParam.length);
                for (var i = 0; i < sigParam.length; ++i) {
                    typeSection.push(typeCodes[sigParam[i]])
                }
                if (sigRet == "v") {
                    typeSection.push(0)
                } else {
                    typeSection = typeSection.concat([1, typeCodes[sigRet]])
                }
                typeSection[1] = typeSection.length - 2;
                var bytes = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0].concat(typeSection, [2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0]));
                var module = new WebAssembly.Module(bytes);
                var instance = new WebAssembly.Instance(module, {
                    "e": {
                        "f": func
                    }
                });
                var wrappedFunc = instance.exports["f"];
                return wrappedFunc
            }
            var freeTableIndexes = [];
            var functionsInTableMap;

            function addFunctionWasm(func, sig) {
                var table = wasmTable;
                if (!functionsInTableMap) {
                    functionsInTableMap = new WeakMap;
                    for (var i = 0; i < table.length; i++) {
                        var item = table.get(i);
                        if (item) {
                            functionsInTableMap.set(item, i)
                        }
                    }
                }
                if (functionsInTableMap.has(func)) {
                    return functionsInTableMap.get(func)
                }
                var ret;
                if (freeTableIndexes.length) {
                    ret = freeTableIndexes.pop()
                } else {
                    ret = table.length;
                    try {
                        table.grow(1)
                    } catch (err) {
                        if (!(err instanceof RangeError)) {
                            throw err
                        }
                        throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."
                    }
                }
                try {
                    table.set(ret, func)
                } catch (err) {
                    if (!(err instanceof TypeError)) {
                        throw err
                    }
                    var wrapped = convertJsFunctionToWasm(func, sig);
                    table.set(ret, wrapped)
                }
                functionsInTableMap.set(func, ret);
                return ret
            }

            function removeFunctionWasm(index) {
                functionsInTableMap.delete(wasmTable.get(index));
                freeTableIndexes.push(index)
            }
            var funcWrappers = {};

            function dynCall(sig, ptr, args) {
                if (args && args.length) {
                    return Module["dynCall_" + sig].apply(null, [ptr].concat(args))
                } else {
                    return Module["dynCall_" + sig].call(null, ptr)
                }
            }
            var tempRet0 = 0;
            var setTempRet0 = function(value) {
                tempRet0 = value
            };
            var getTempRet0 = function() {
                return tempRet0
            };
            var wasmBinary;
            if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
            var noExitRuntime;
            if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
            if (typeof WebAssembly !== "object") {
                err("no native wasm support detected")
            }

            function setValue(ptr, value, type, noSafe) {
                type = type || "i8";
                if (type.charAt(type.length - 1) === "*") type = "i32";
                switch (type) {
                    case "i1":
                        HEAP8[ptr >> 0] = value;
                        break;
                    case "i8":
                        HEAP8[ptr >> 0] = value;
                        break;
                    case "i16":
                        HEAP16[ptr >> 1] = value;
                        break;
                    case "i32":
                        HEAP32[ptr >> 2] = value;
                        break;
                    case "i64":
                        tempI64 = [value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
                        break;
                    case "float":
                        HEAPF32[ptr >> 2] = value;
                        break;
                    case "double":
                        HEAPF64[ptr >> 3] = value;
                        break;
                    default:
                        abort("invalid type for setValue: " + type)
                }
            }
            var wasmMemory;
            var wasmTable = new WebAssembly.Table({
                "initial": 12014,
                "maximum": 12014 + 0,
                "element": "anyfunc"
            });
            var ABORT = false;
            var EXITSTATUS = 0;

            function assert(condition, text) {
                if (!condition) {
                    abort("Assertion failed: " + text)
                }
            }

            function getCFunc(ident) {
                var func = Module["_" + ident];
                assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
                return func
            }

            function ccall(ident, returnType, argTypes, args, opts) {
                var toC = {
                    "string": function(str) {
                        var ret = 0;
                        if (str !== null && str !== undefined && str !== 0) {
                            var len = (str.length << 2) + 1;
                            ret = stackAlloc(len);
                            stringToUTF8(str, ret, len)
                        }
                        return ret
                    },
                    "array": function(arr) {
                        var ret = stackAlloc(arr.length);
                        writeArrayToMemory(arr, ret);
                        return ret
                    }
                };

                function convertReturnValue(ret) {
                    if (returnType === "string") return UTF8ToString(ret);
                    if (returnType === "boolean") return Boolean(ret);
                    return ret
                }
                var func = getCFunc(ident);
                var cArgs = [];
                var stack = 0;
                if (args) {
                    for (var i = 0; i < args.length; i++) {
                        var converter = toC[argTypes[i]];
                        if (converter) {
                            if (stack === 0) stack = stackSave();
                            cArgs[i] = converter(args[i])
                        } else {
                            cArgs[i] = args[i]
                        }
                    }
                }
                var ret = func.apply(null, cArgs);
                ret = convertReturnValue(ret);
                if (stack !== 0) stackRestore(stack);
                return ret
            }

            function cwrap(ident, returnType, argTypes, opts) {
                argTypes = argTypes || [];
                var numericArgs = argTypes.every(function(type) {
                    return type === "number"
                });
                var numericRet = returnType !== "string";
                if (numericRet && numericArgs && !opts) {
                    return getCFunc(ident)
                }
                return function() {
                    return ccall(ident, returnType, argTypes, arguments, opts)
                }
            }
            var ALLOC_NORMAL = 0;
            var ALLOC_NONE = 3;

            function allocate(slab, types, allocator, ptr) {
                var zeroinit, size;
                if (typeof slab === "number") {
                    zeroinit = true;
                    size = slab
                } else {
                    zeroinit = false;
                    size = slab.length
                }
                var singleType = typeof types === "string" ? types : null;
                var ret;
                if (allocator == ALLOC_NONE) {
                    ret = ptr
                } else {
                    ret = [_malloc, stackAlloc, dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length))
                }
                if (zeroinit) {
                    var stop;
                    ptr = ret;
                    assert((ret & 3) == 0);
                    stop = ret + (size & ~3);
                    for (; ptr < stop; ptr += 4) {
                        HEAP32[ptr >> 2] = 0
                    }
                    stop = ret + size;
                    while (ptr < stop) {
                        HEAP8[ptr++ >> 0] = 0
                    }
                    return ret
                }
                if (singleType === "i8") {
                    if (slab.subarray || slab.slice) {
                        HEAPU8.set(slab, ret)
                    } else {
                        HEAPU8.set(new Uint8Array(slab), ret)
                    }
                    return ret
                }
                var i = 0,
                    type, typeSize, previousType;
                while (i < size) {
                    var curr = slab[i];
                    type = singleType || types[i];
                    if (type === 0) {
                        i++;
                        continue
                    }
                    if (type == "i64") type = "i32";
                    setValue(ret + i, curr, type);
                    if (previousType !== type) {
                        typeSize = getNativeTypeSize(type);
                        previousType = type
                    }
                    i += typeSize
                }
                return ret
            }

            function getMemory(size) {
                if (!runtimeInitialized) return dynamicAlloc(size);
                return _malloc(size)
            }
            var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;

            function UTF8ArrayToString(heap, idx, maxBytesToRead) {
                var endIdx = idx + maxBytesToRead;
                var endPtr = idx;
                while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
                if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
                    return UTF8Decoder.decode(heap.subarray(idx, endPtr))
                } else {
                    var str = "";
                    while (idx < endPtr) {
                        var u0 = heap[idx++];
                        if (!(u0 & 128)) {
                            str += String.fromCharCode(u0);
                            continue
                        }
                        var u1 = heap[idx++] & 63;
                        if ((u0 & 224) == 192) {
                            str += String.fromCharCode((u0 & 31) << 6 | u1);
                            continue
                        }
                        var u2 = heap[idx++] & 63;
                        if ((u0 & 240) == 224) {
                            u0 = (u0 & 15) << 12 | u1 << 6 | u2
                        } else {
                            u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++] & 63
                        }
                        if (u0 < 65536) {
                            str += String.fromCharCode(u0)
                        } else {
                            var ch = u0 - 65536;
                            str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
                        }
                    }
                }
                return str
            }

            function UTF8ToString(ptr, maxBytesToRead) {
                return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
            }

            function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
                if (!(maxBytesToWrite > 0)) return 0;
                var startIdx = outIdx;
                var endIdx = outIdx + maxBytesToWrite - 1;
                for (var i = 0; i < str.length; ++i) {
                    var u = str.charCodeAt(i);
                    if (u >= 55296 && u <= 57343) {
                        var u1 = str.charCodeAt(++i);
                        u = 65536 + ((u & 1023) << 10) | u1 & 1023
                    }
                    if (u <= 127) {
                        if (outIdx >= endIdx) break;
                        heap[outIdx++] = u
                    } else if (u <= 2047) {
                        if (outIdx + 1 >= endIdx) break;
                        heap[outIdx++] = 192 | u >> 6;
                        heap[outIdx++] = 128 | u & 63
                    } else if (u <= 65535) {
                        if (outIdx + 2 >= endIdx) break;
                        heap[outIdx++] = 224 | u >> 12;
                        heap[outIdx++] = 128 | u >> 6 & 63;
                        heap[outIdx++] = 128 | u & 63
                    } else {
                        if (outIdx + 3 >= endIdx) break;
                        heap[outIdx++] = 240 | u >> 18;
                        heap[outIdx++] = 128 | u >> 12 & 63;
                        heap[outIdx++] = 128 | u >> 6 & 63;
                        heap[outIdx++] = 128 | u & 63
                    }
                }
                heap[outIdx] = 0;
                return outIdx - startIdx
            }

            function stringToUTF8(str, outPtr, maxBytesToWrite) {
                return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
            }

            function lengthBytesUTF8(str) {
                var len = 0;
                for (var i = 0; i < str.length; ++i) {
                    var u = str.charCodeAt(i);
                    if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
                    if (u <= 127) ++len;
                    else if (u <= 2047) len += 2;
                    else if (u <= 65535) len += 3;
                    else len += 4
                }
                return len
            }
            var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;

            function allocateUTF8(str) {
                var size = lengthBytesUTF8(str) + 1;
                var ret = _malloc(size);
                if (ret) stringToUTF8Array(str, HEAP8, ret, size);
                return ret
            }

            function allocateUTF8OnStack(str) {
                var size = lengthBytesUTF8(str) + 1;
                var ret = stackAlloc(size);
                stringToUTF8Array(str, HEAP8, ret, size);
                return ret
            }

            function writeArrayToMemory(array, buffer) {
                HEAP8.set(array, buffer)
            }

            function writeAsciiToMemory(str, buffer, dontAddNull) {
                for (var i = 0; i < str.length; ++i) {
                    HEAP8[buffer++ >> 0] = str.charCodeAt(i)
                }
                if (!dontAddNull) HEAP8[buffer >> 0] = 0
            }
            var WASM_PAGE_SIZE = 65536;

            function alignUp(x, multiple) {
                if (x % multiple > 0) {
                    x += multiple - x % multiple
                }
                return x
            }
            var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;

            function updateGlobalBufferAndViews(buf) {
                buffer = buf;
                Module["HEAP8"] = HEAP8 = new Int8Array(buf);
                Module["HEAP16"] = HEAP16 = new Int16Array(buf);
                Module["HEAP32"] = HEAP32 = new Int32Array(buf);
                Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
                Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
                Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
                Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
                Module["HEAPF64"] = HEAPF64 = new Float64Array(buf)
            }
            var STACK_BASE = 6130032,
                DYNAMIC_BASE = 6130032,
                DYNAMICTOP_PTR = 886976;
            var INITIAL_INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
            if (Module["wasmMemory"]) {
                wasmMemory = Module["wasmMemory"]
            } else {
                wasmMemory = new WebAssembly.Memory({
                    "initial": INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE,
                    "maximum": 2147483648 / WASM_PAGE_SIZE
                })
            }
            if (wasmMemory) {
                buffer = wasmMemory.buffer
            }
            INITIAL_INITIAL_MEMORY = buffer.byteLength;
            updateGlobalBufferAndViews(buffer);
            HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;

            function callRuntimeCallbacks(callbacks) {
                while (callbacks.length > 0) {
                    var callback = callbacks.shift();
                    if (typeof callback == "function") {
                        callback(Module);
                        continue
                    }
                    var func = callback.func;
                    if (typeof func === "number") {
                        if (callback.arg === undefined) {
                            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 initRuntime() {
                runtimeInitialized = true;
                if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
                TTY.init();
                callRuntimeCallbacks(__ATINIT__)
            }

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

            function exitRuntime() {
                runtimeExited = true
            }

            function postRun() {
                if (Module["postRun"]) {
                    if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
                    while (Module["postRun"].length) {
                        addOnPostRun(Module["postRun"].shift())
                    }
                }
                callRuntimeCallbacks(__ATPOSTRUN__)
            }

            function addOnPreRun(cb) {
                __ATPRERUN__.unshift(cb)
            }

            function addOnPostRun(cb) {
                __ATPOSTRUN__.unshift(cb)
            }

            function unSign(value, bits, ignore) {
                if (value >= 0) {
                    return value
                }
                return bits <= 32 ? 2 * Math.abs(1 << bits - 1) + value : Math.pow(2, bits) + value
            }

            function reSign(value, bits, ignore) {
                if (value <= 0) {
                    return value
                }
                var half = bits <= 32 ? Math.abs(1 << bits - 1) : Math.pow(2, bits - 1);
                if (value >= half && (bits <= 32 || value > half)) {
                    value = -2 * half + value
                }
                return value
            }
            var Math_abs = Math.abs;
            var Math_ceil = Math.ceil;
            var Math_floor = Math.floor;
            var Math_min = Math.min;
            var runDependencies = 0;
            var runDependencyWatcher = null;
            var dependenciesFulfilled = null;

            function getUniqueRunDependency(id) {
                return id
            }

            function addRunDependency(id) {
                runDependencies++;
                if (Module["monitorRunDependencies"]) {
                    Module["monitorRunDependencies"](runDependencies)
                }
            }

            function removeRunDependency(id) {
                runDependencies--;
                if (Module["monitorRunDependencies"]) {
                    Module["monitorRunDependencies"](runDependencies)
                }
                if (runDependencies == 0) {
                    if (runDependencyWatcher !== null) {
                        clearInterval(runDependencyWatcher);
                        runDependencyWatcher = null
                    }
                    if (dependenciesFulfilled) {
                        var callback = dependenciesFulfilled;
                        dependenciesFulfilled = null;
                        callback()
                    }
                }
            }
            Module["preloadedImages"] = {};
            Module["preloadedAudios"] = {};

            function abort(what) {
                if (Module["onAbort"]) {
                    Module["onAbort"](what)
                }
                what += "";
                out(what);
                err(what);
                ABORT = true;
                EXITSTATUS = 1;
                what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
                throw new WebAssembly.RuntimeError(what)
            }

            function hasPrefix(str, prefix) {
                return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0
            }
            var dataURIPrefix = "data:application/octet-stream;base64,";

            function isDataURI(filename) {
                return hasPrefix(filename, dataURIPrefix)
            }
            var fileURIPrefix = "file://";
            var wasmBinaryFile = "waflash.wasm";
            if (!isDataURI(wasmBinaryFile)) {
                wasmBinaryFile = locateFile(wasmBinaryFile)
            }

            function getBinary() {
                try {
                    if (wasmBinary) {
                        return new Uint8Array(wasmBinary)
                    }
                    if (readBinary) {
                        return readBinary(wasmBinaryFile)
                    } else {
                        throw "both async and sync fetching of the wasm failed"
                    }
                } catch (err) {
                    abort(err)
                }
            }

            function getBinaryPromise() {
                if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function") {
                    return fetch(wasmBinaryFile, {
                        credentials: "same-origin"
                    }).then(function(response) {
                        if (!response["ok"]) {
                            throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
                        }
                        return response["arrayBuffer"]()
                    }).catch(function() {
                        return getBinary()
                    })
                }
                return new Promise(function(resolve, reject) {
                    resolve(getBinary())
                })
            }

            function createWasm() {
                var info = {
                    "env": asmLibraryArg,
                    "wasi_snapshot_preview1": asmLibraryArg
                };

                function receiveInstance(instance, module) {
                    var exports = instance.exports;
                    Module["asm"] = exports;
                    removeRunDependency("wasm-instantiate")
                }
                addRunDependency("wasm-instantiate");

                function receiveInstantiatedSource(output) {
                    receiveInstance(output["instance"])
                }

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

                function instantiateAsync() {
                    if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
                        fetch(wasmBinaryFile, {
                            credentials: "same-origin"
                        }).then(function(response) {
                            var result = WebAssembly.instantiateStreaming(response, info);
                            return result.then(receiveInstantiatedSource, function(reason) {
                                err("wasm streaming compile failed: " + reason);
                                err("falling back to ArrayBuffer instantiation");
                                instantiateArrayBuffer(receiveInstantiatedSource)
                            })
                        })
                    } else {
                        return instantiateArrayBuffer(receiveInstantiatedSource)
                    }
                }
                if (Module["instantiateWasm"]) {
                    try {
                        var exports = Module["instantiateWasm"](info, receiveInstance);
                        return exports
                    } catch (e) {
                        err("Module.instantiateWasm callback failed with error: " + e);
                        return false
                    }
                }
                instantiateAsync();
                return {}
            }
            var tempDouble;
            var tempI64;
            var ASM_CONSTS = {
                1401: function($0) {
                    const sodir = UTF8ToString($0);
                    FS.mkdir(sodir);
                    FS.mount(IDBFS, {}, sodir);
                    FS.syncfs(true, err => {})
                },
                1523: function() {
                    FS.syncfs(err => {
                        console.log("IDBFS synced.")
                    })
                },
                2028: function() {
                    const urlParams = new URLSearchParams(window.location.search);
                    const mode = urlParams.get("v");
                    return mode == "1"
                },
                2163: function($0) {
                    const page_path = "/user/swf/" + UTF8ToString($0);
                    window.gtag && window.gtag("config", "UA-168755014-1", {
                        page_path: page_path
                    })
                },
                2412: function() {
                    const urlParams = new URLSearchParams(window.location.search);
                    const src = urlParams.get("src");
                    if (src) {
                        let url;
                        if (src.startsWith("http")) {
                            url = src
                        } else if (src[0] == "/") {
                            url = window.location.origin + src
                        } else {
                            url = window.location.origin + window.location.pathname.substr(0, window.location.pathname.lastIndexOf("/") + 1) + src
                        }
                        const lengthBytes = lengthBytesUTF8(url) + 1;
                        const stringOnWasmHeap = _malloc(lengthBytes);
                        stringToUTF8(url, stringOnWasmHeap, lengthBytes);
                        return stringOnWasmHeap
                    }
                    return 0
                },
                2947: function() {
                    const urlParams = new URLSearchParams(window.location.search);
                    const mode = urlParams.get("m");
                    return mode == "gpu"
                },
                749754: function($0) {
                    var str = UTF8ToString($0) + "\n\n" + "Abort/Retry/Ignore/AlwaysIgnore? [ariA] :";
                    var reply = window.prompt(str, "i");
                    if (reply === null) {
                        reply = "i"
                    }
                    return allocate(intArrayFromString(reply), "i8", ALLOC_NORMAL)
                },
                785644: function($0, $1, $2) {
                    var w = $0;
                    var h = $1;
                    var pixels = $2;
                    if (!Module["SDL2"]) Module["SDL2"] = {};
                    var SDL2 = Module["SDL2"];
                    if (SDL2.ctxCanvas !== Module["canvas"]) {
                        SDL2.ctx = Module["createContext"](Module["canvas"], false, true);
                        SDL2.ctxCanvas = Module["canvas"]
                    }
                    if (SDL2.w !== w || SDL2.h !== h || SDL2.imageCtx !== SDL2.ctx) {
                        SDL2.image = SDL2.ctx.createImageData(w, h);
                        SDL2.w = w;
                        SDL2.h = h;
                        SDL2.imageCtx = SDL2.ctx
                    }
                    var data = SDL2.image.data;
                    var src = pixels >> 2;
                    var dst = 0;
                    var num;
                    if (typeof CanvasPixelArray !== "undefined" && data instanceof CanvasPixelArray) {
                        num = data.length;
                        while (dst < num) {
                            var val = HEAP32[src];
                            data[dst] = val & 255;
                            data[dst + 1] = val >> 8 & 255;
                            data[dst + 2] = val >> 16 & 255;
                            data[dst + 3] = 255;
                            src++;
                            dst += 4
                        }
                    } else {
                        if (SDL2.data32Data !== data) {
                            SDL2.data32 = new Int32Array(data.buffer);
                            SDL2.data8 = new Uint8Array(data.buffer)
                        }
                        var data32 = SDL2.data32;
                        num = data32.length;
                        data32.set(HEAP32.subarray(src, src + num));
                        var data8 = SDL2.data8;
                        var i = 3;
                        var j = i + 4 * num;
                        if (num % 8 == 0) {
                            while (i < j) {
                                data8[i] = 255;
                                i = i + 4 | 0;
                                data8[i] = 255;
                                i = i + 4 | 0;
                                data8[i] = 255;
                                i = i + 4 | 0;
                                data8[i] = 255;
                                i = i + 4 | 0;
                                data8[i] = 255;
                                i = i + 4 | 0;
                                data8[i] = 255;
                                i = i + 4 | 0;
                                data8[i] = 255;
                                i = i + 4 | 0;
                                data8[i] = 255;
                                i = i + 4 | 0
                            }
                        } else {
                            while (i < j) {
                                data8[i] = 255;
                                i = i + 4 | 0
                            }
                        }
                    }
                    SDL2.ctx.putImageData(SDL2.image, 0, 0);
                    return 0
                },
                787123: function($0, $1, $2, $3, $4) {
                    var w = $0;
                    var h = $1;
                    var hot_x = $2;
                    var hot_y = $3;
                    var pixels = $4;
                    var canvas = document.createElement("canvas");
                    canvas.width = w;
                    canvas.height = h;
                    var ctx = canvas.getContext("2d");
                    var image = ctx.createImageData(w, h);
                    var data = image.data;
                    var src = pixels >> 2;
                    var dst = 0;
                    var num;
                    if (typeof CanvasPixelArray !== "undefined" && data instanceof CanvasPixelArray) {
                        num = data.length;
                        while (dst < num) {
                            var val = HEAP32[src];
                            data[dst] = val & 255;
                            data[dst + 1] = val >> 8 & 255;
                            data[dst + 2] = val >> 16 & 255;
                            data[dst + 3] = val >> 24 & 255;
                            src++;
                            dst += 4
                        }
                    } else {
                        var data32 = new Int32Array(data.buffer);
                        num = data32.length;
                        data32.set(HEAP32.subarray(src, src + num))
                    }
                    ctx.putImageData(image, 0, 0);
                    var url = hot_x === 0 && hot_y === 0 ? "url(" + canvas.toDataURL() + "), auto" : "url(" + canvas.toDataURL() + ") " + hot_x + " " + hot_y + ", auto";
                    var urlBuf = _malloc(url.length + 1);
                    stringToUTF8(url, urlBuf, url.length + 1);
                    return urlBuf
                },
                788112: function($0) {
                    if (Module["canvas"]) {
                        Module["canvas"].style["cursor"] = UTF8ToString($0)
                    }
                    return 0
                },
                788205: function() {
                    if (Module["canvas"]) {
                        Module["canvas"].style["cursor"] = "none"
                    }
                },
                789430: function() {
                    return screen.width
                },
                789457: function() {
                    return screen.height
                },
                789485: function() {
                    return window.innerWidth
                },
                789517: function() {
                    return window.innerHeight
                },
                789595: function($0) {
                    if (typeof setWindowTitle !== "undefined") {
                        setWindowTitle(UTF8ToString($0))
                    }
                    return 0
                },
                789729: function() {
                    if (typeof AudioContext !== "undefined") {
                        return 1
                    } else if (typeof webkitAudioContext !== "undefined") {
                        return 1
                    }
                    return 0
                },
                789895: function() {
                    if (typeof navigator.mediaDevices !== "undefined" && typeof navigator.mediaDevices.getUserMedia !== "undefined") {
                        return 1
                    } else if (typeof navigator.webkitGetUserMedia !== "undefined") {
                        return 1
                    }
                    return 0
                },
                790121: function($0) {
                    if (typeof Module["SDL2"] === "undefined") {
                        Module["SDL2"] = {}
                    }
                    var SDL2 = Module["SDL2"];
                    if (!$0) {
                        SDL2.audio = {}
                    } else {
                        SDL2.capture = {}
                    }
                    if (!SDL2.audioContext) {
                        if (typeof AudioContext !== "undefined") {
                            SDL2.audioContext = new AudioContext
                        } else if (typeof webkitAudioContext !== "undefined") {
                            SDL2.audioContext = new webkitAudioContext
                        }
                    }
                    return SDL2.audioContext === undefined ? -1 : 0
                },
                790604: function() {
                    var SDL2 = Module["SDL2"];
                    return SDL2.audioContext.sampleRate
                },
                790674: function($0, $1, $2, $3) {
                    var SDL2 = Module["SDL2"];
                    var have_microphone = function(stream) {
                        if (SDL2.capture.silenceTimer !== undefined) {
                            clearTimeout(SDL2.capture.silenceTimer);
                            SDL2.capture.silenceTimer = undefined
                        }
                        SDL2.capture.mediaStreamNode = SDL2.audioContext.createMediaStreamSource(stream);
                        SDL2.capture.scriptProcessorNode = SDL2.audioContext.createScriptProcessor($1, $0, 1);
                        SDL2.capture.scriptProcessorNode.onaudioprocess = function(audioProcessingEvent) {
                            if (SDL2 === undefined || SDL2.capture === undefined) {
                                return
                            }
                            audioProcessingEvent.outputBuffer.getChannelData(0).fill(0);
                            SDL2.capture.currentCaptureBuffer = audioProcessingEvent.inputBuffer;
                            dynCall("vi", $2, [$3])
                        };
                        SDL2.capture.mediaStreamNode.connect(SDL2.capture.scriptProcessorNode);
                        SDL2.capture.scriptProcessorNode.connect(SDL2.audioContext.destination);
                        SDL2.capture.stream = stream
                    };
                    var no_microphone = function(error) {};
                    SDL2.capture.silenceBuffer = SDL2.audioContext.createBuffer($0, $1, SDL2.audioContext.sampleRate);
                    SDL2.capture.silenceBuffer.getChannelData(0).fill(0);
                    var silence_callback = function() {
                        SDL2.capture.currentCaptureBuffer = SDL2.capture.silenceBuffer;
                        dynCall("vi", $2, [$3])
                    };
                    SDL2.capture.silenceTimer = setTimeout(silence_callback, $1 / SDL2.audioContext.sampleRate * 1e3);
                    if (navigator.mediaDevices !== undefined && navigator.mediaDevices.getUserMedia !== undefined) {
                        navigator.mediaDevices.getUserMedia({
                            audio: true,
                            video: false
                        }).then(have_microphone).catch(no_microphone)
                    } else if (navigator.webkitGetUserMedia !== undefined) {
                        navigator.webkitGetUserMedia({
                            audio: true,
                            video: false
                        }, have_microphone, no_microphone)
                    }
                },
                792326: function($0, $1, $2, $3) {
                    var SDL2 = Module["SDL2"];
                    SDL2.audio.scriptProcessorNode = SDL2.audioContext["createScriptProcessor"]($1, 0, $0);
                    SDL2.audio.scriptProcessorNode["onaudioprocess"] = function(e) {
                        if (SDL2 === undefined || SDL2.audio === undefined) {
                            return
                        }
                        SDL2.audio.currentOutputBuffer = e["outputBuffer"];
                        dynCall("vi", $2, [$3])
                    };
                    SDL2.audio.scriptProcessorNode["connect"](SDL2.audioContext["destination"])
                },
                792736: function($0, $1) {
                    var SDL2 = Module["SDL2"];
                    var numChannels = SDL2.capture.currentCaptureBuffer.numberOfChannels;
                    for (var c = 0; c < numChannels; ++c) {
                        var channelData = SDL2.capture.currentCaptureBuffer.getChannelData(c);
                        if (channelData.length != $1) {
                            throw "Web Audio capture buffer length mismatch! Destination size: " + channelData.length + " samples vs expected " + $1 + " samples!"
                        }
                        if (numChannels == 1) {
                            for (var j = 0; j < $1; ++j) {
                                setValue($0 + j * 4, channelData[j], "float")
                            }
                        } else {
                            for (var j = 0; j < $1; ++j) {
                                setValue($0 + (j * numChannels + c) * 4, channelData[j], "float")
                            }
                        }
                    }
                },
                793341: function($0, $1) {
                    var SDL2 = Module["SDL2"];
                    var numChannels = SDL2.audio.currentOutputBuffer["numberOfChannels"];
                    for (var c = 0; c < numChannels; ++c) {
                        var channelData = SDL2.audio.currentOutputBuffer["getChannelData"](c);
                        if (channelData.length != $1) {
                            throw "Web Audio output buffer length mismatch! Destination size: " + channelData.length + " samples vs expected " + $1 + " samples!"
                        }
                        for (var j = 0; j < $1; ++j) {
                            channelData[j] = HEAPF32[$0 + (j * numChannels + c << 2) >> 2]
                        }
                    }
                },
                793821: function($0) {
                    var SDL2 = Module["SDL2"];
                    if ($0) {
                        if (SDL2.capture.silenceTimer !== undefined) {
                            clearTimeout(SDL2.capture.silenceTimer)
                        }
                        if (SDL2.capture.stream !== undefined) {
                            var tracks = SDL2.capture.stream.getAudioTracks();
                            for (var i = 0; i < tracks.length; i++) {
                                SDL2.capture.stream.removeTrack(tracks[i])
                            }
                            SDL2.capture.stream = undefined
                        }
                        if (SDL2.capture.scriptProcessorNode !== undefined) {
                            SDL2.capture.scriptProcessorNode.onaudioprocess = function(audioProcessingEvent) {};
                            SDL2.capture.scriptProcessorNode.disconnect();
                            SDL2.capture.scriptProcessorNode = undefined
                        }
                        if (SDL2.capture.mediaStreamNode !== undefined) {
                            SDL2.capture.mediaStreamNode.disconnect();
                            SDL2.capture.mediaStreamNode = undefined
                        }
                        if (SDL2.capture.silenceBuffer !== undefined) {
                            SDL2.capture.silenceBuffer = undefined
                        }
                        SDL2.capture = undefined
                    } else {
                        if (SDL2.audio.scriptProcessorNode != undefined) {
                            SDL2.audio.scriptProcessorNode.disconnect();
                            SDL2.audio.scriptProcessorNode = undefined
                        }
                        SDL2.audio = undefined
                    }
                    if (SDL2.audioContext !== undefined && SDL2.audio === undefined && SDL2.capture === undefined) {
                        SDL2.audioContext.close();
                        SDL2.audioContext = undefined
                    }
                }
            };

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

            function changeCursor(type) {
                const c = Module["canvas"];
                if (c) c.style.cursor = UTF8ToString(type)
            }

            function getCanvasPaddingLeft() {
                return Module["canvas"].style.paddingLeft
            }

            function getCanvasPaddingTop() {
                return Module["canvas"].style.paddingTop
            }

            function wafjs_hidestatus() {
                typeof Module.hideStatus == "function" && Module.hideStatus()
            }

            function wafjs_setcontentinfo(w, h, fps) {
                Module["canvas"].setAttribute("waf-content-width", w);
                Module["canvas"].setAttribute("waf-content-height", h);
                Module["canvas"].setAttribute("waf-content-fps", fps)
            }

            function wafjs_setstatus(msg) {
                typeof Module.setStatus == "function" && Module.setStatus(UTF8ToString(msg))
            }

            function wafjs_url_transformRequestUrl(purl) {
                const url = UTF8ToString(purl);
                const waf = Module["WAFLASH"];
                const ret = !waf ? url : waf.hal && waf.hal.url_transformRequestUrl(url);
                if (ret) {
                    const len = lengthBytesUTF8(ret) + 1;
                    const buf = _malloc(len);
                    stringToUTF8(ret, buf, len);
                    return buf
                }
                return 0
            }
            __ATINIT__.push({
                func: function() {
                    ___wasm_call_ctors()
                }
            });

            function demangle(func) {
                return func
            }

            function demangleAll(text) {
                var regex = /\b_Z[\w\d_]+/g;
                return text.replace(regex, function(x) {
                    var y = demangle(x);
                    return x === y ? x : y + " [" + x + "]"
                })
            }

            function jsStackTrace() {
                var err = new Error;
                if (!err.stack) {
                    try {
                        throw new Error
                    } catch (e) {
                        err = e
                    }
                    if (!err.stack) {
                        return "(no stack trace available)"
                    }
                }
                return err.stack.toString()
            }

            function stackTrace() {
                var js = jsStackTrace();
                if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
                return demangleAll(js)
            }

            function _atexit(func, arg) {
                __ATEXIT__.unshift({
                    func: func,
                    arg: arg
                })
            }

            function ___cxa_atexit(a0, a1) {
                return _atexit(a0, a1)
            }

            function setErrNo(value) {
                HEAP32[___errno_location() >> 2] = value;
                return value
            }
            var PATH = {
                splitPath: function(filename) {
                    var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
                    return splitPathRe.exec(filename).slice(1)
                },
                normalizeArray: function(parts, allowAboveRoot) {
                    var up = 0;
                    for (var i = parts.length - 1; i >= 0; i--) {
                        var last = parts[i];
                        if (last === ".") {
                            parts.splice(i, 1)
                        } else if (last === "..") {
                            parts.splice(i, 1);
                            up++
                        } else if (up) {
                            parts.splice(i, 1);
                            up--
                        }
                    }
                    if (allowAboveRoot) {
                        for (; up; up--) {
                            parts.unshift("..")
                        }
                    }
                    return parts
                },
                normalize: function(path) {
                    var isAbsolute = path.charAt(0) === "/",
                        trailingSlash = path.substr(-1) === "/";
                    path = PATH.normalizeArray(path.split("/").filter(function(p) {
                        return !!p
                    }), !isAbsolute).join("/");
                    if (!path && !isAbsolute) {
                        path = "."
                    }
                    if (path && trailingSlash) {
                        path += "/"
                    }
                    return (isAbsolute ? "/" : "") + path
                },
                dirname: function(path) {
                    var result = PATH.splitPath(path),
                        root = result[0],
                        dir = result[1];
                    if (!root && !dir) {
                        return "."
                    }
                    if (dir) {
                        dir = dir.substr(0, dir.length - 1)
                    }
                    return root + dir
                },
                basename: function(path) {
                    if (path === "/") return "/";
                    var lastSlash = path.lastIndexOf("/");
                    if (lastSlash === -1) return path;
                    return path.substr(lastSlash + 1)
                },
                extname: function(path) {
                    return PATH.splitPath(path)[3]
                },
                join: function() {
                    var paths = Array.prototype.slice.call(arguments, 0);
                    return PATH.normalize(paths.join("/"))
                },
                join2: function(l, r) {
                    return PATH.normalize(l + "/" + r)
                }
            };
            var PATH_FS = {
                resolve: function() {
                    var resolvedPath = "",
                        resolvedAbsolute = false;
                    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
                        var path = i >= 0 ? arguments[i] : FS.cwd();
                        if (typeof path !== "string") {
                            throw new TypeError("Arguments to path.resolve must be strings")
                        } else if (!path) {
                            return ""
                        }
                        resolvedPath = path + "/" + resolvedPath;
                        resolvedAbsolute = path.charAt(0) === "/"
                    }
                    resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(function(p) {
                        return !!p
                    }), !resolvedAbsolute).join("/");
                    return (resolvedAbsolute ? "/" : "") + resolvedPath || "."
                },
                relative: function(from, to) {
                    from = PATH_FS.resolve(from).substr(1);
                    to = PATH_FS.resolve(to).substr(1);

                    function trim(arr) {
                        var start = 0;
                        for (; start < arr.length; start++) {
                            if (arr[start] !== "") break
                        }
                        var end = arr.length - 1;
                        for (; end >= 0; end--) {
                            if (arr[end] !== "") break
                        }
                        if (start > end) return [];
                        return arr.slice(start, end - start + 1)
                    }
                    var fromParts = trim(from.split("/"));
                    var toParts = trim(to.split("/"));
                    var length = Math.min(fromParts.length, toParts.length);
                    var samePartsLength = length;
                    for (var i = 0; i < length; i++) {
                        if (fromParts[i] !== toParts[i]) {
                            samePartsLength = i;
                            break
                        }
                    }
                    var outputParts = [];
                    for (var i = samePartsLength; i < fromParts.length; i++) {
                        outputParts.push("..")
                    }
                    outputParts = outputParts.concat(toParts.slice(samePartsLength));
                    return outputParts.join("/")
                }
            };
            var TTY = {
                ttys: [],
                init: function() {},
                shutdown: function() {},
                register: function(dev, ops) {
                    TTY.ttys[dev] = {
                        input: [],
                        output: [],
                        ops: ops
                    };
                    FS.registerDevice(dev, TTY.stream_ops)
                },
                stream_ops: {
                    open: function(stream) {
                        var tty = TTY.ttys[stream.node.rdev];
                        if (!tty) {
                            throw new FS.ErrnoError(43)
                        }
                        stream.tty = tty;
                        stream.seekable = false
                    },
                    close: function(stream) {
                        stream.tty.ops.flush(stream.tty)
                    },
                    flush: function(stream) {
                        stream.tty.ops.flush(stream.tty)
                    },
                    read: function(stream, buffer, offset, length, pos) {
                        if (!stream.tty || !stream.tty.ops.get_char) {
                            throw new FS.ErrnoError(60)
                        }
                        var bytesRead = 0;
                        for (var i = 0; i < length; i++) {
                            var result;
                            try {
                                result = stream.tty.ops.get_char(stream.tty)
                            } catch (e) {
                                throw new FS.ErrnoError(29)
                            }
                            if (result === undefined && bytesRead === 0) {
                                throw new FS.ErrnoError(6)
                            }
                            if (result === null || result === undefined) break;
                            bytesRead++;
                            buffer[offset + i] = result
                        }
                        if (bytesRead) {
                            stream.node.timestamp = Date.now()
                        }
                        return bytesRead
                    },
                    write: function(stream, buffer, offset, length, pos) {
                        if (!stream.tty || !stream.tty.ops.put_char) {
                            throw new FS.ErrnoError(60)
                        }
                        try {
                            for (var i = 0; i < length; i++) {
                                stream.tty.ops.put_char(stream.tty, buffer[offset + i])
                            }
                        } catch (e) {
                            throw new FS.ErrnoError(29)
                        }
                        if (length) {
                            stream.node.timestamp = Date.now()
                        }
                        return i
                    }
                },
                default_tty_ops: {
                    get_char: function(tty) {
                        if (!tty.input.length) {
                            var result = null;
                            if (typeof window != "undefined" && typeof window.prompt == "function") {
                                result = window.prompt("Input: ");
                                if (result !== null) {
                                    result += "\n"
                                }
                            } else if (typeof readline == "function") {
                                result = readline();
                                if (result !== null) {
                                    result += "\n"
                                }
                            }
                            if (!result) {
                                return null
                            }
                            tty.input = intArrayFromString(result, true)
                        }
                        return tty.input.shift()
                    },
                    put_char: function(tty, val) {
                        if (val === null || val === 10) {
                            out(UTF8ArrayToString(tty.output, 0));
                            tty.output = []
                        } else {
                            if (val != 0) tty.output.push(val)
                        }
                    },
                    flush: function(tty) {
                        if (tty.output && tty.output.length > 0) {
                            out(UTF8ArrayToString(tty.output, 0));
                            tty.output = []
                        }
                    }
                },
                default_tty1_ops: {
                    put_char: function(tty, val) {
                        if (val === null || val === 10) {
                            err(UTF8ArrayToString(tty.output, 0));
                            tty.output = []
                        } else {
                            if (val != 0) tty.output.push(val)
                        }
                    },
                    flush: function(tty) {
                        if (tty.output && tty.output.length > 0) {
                            err(UTF8ArrayToString(tty.output, 0));
                            tty.output = []
                        }
                    }
                }
            };
            var MEMFS = {
                ops_table: null,
                mount: function(mount) {
                    return MEMFS.createNode(null, "/", 16384 | 511, 0)
                },
                createNode: function(parent, name, mode, dev) {
                    if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
                        throw new FS.ErrnoError(63)
                    }
                    if (!MEMFS.ops_table) {
                        MEMFS.ops_table = {
                            dir: {
                                node: {
                                    getattr: MEMFS.node_ops.getattr,
                                    setattr: MEMFS.node_ops.setattr,
                                    lookup: MEMFS.node_ops.lookup,
                                    mknod: MEMFS.node_ops.mknod,
                                    rename: MEMFS.node_ops.rename,
                                    unlink: MEMFS.node_ops.unlink,
                                    rmdir: MEMFS.node_ops.rmdir,
                                    readdir: MEMFS.node_ops.readdir,
                                    symlink: MEMFS.node_ops.symlink
                                },
                                stream: {
                                    llseek: MEMFS.stream_ops.llseek
                                }
                            },
                            file: {
                                node: {
                                    getattr: MEMFS.node_ops.getattr,
                                    setattr: MEMFS.node_ops.setattr
                                },
                                stream: {
                                    llseek: MEMFS.stream_ops.llseek,
                                    read: MEMFS.stream_ops.read,
                                    write: MEMFS.stream_ops.write,
                                    allocate: MEMFS.stream_ops.allocate,
                                    mmap: MEMFS.stream_ops.mmap,
                                    msync: MEMFS.stream_ops.msync
                                }
                            },
                            link: {
                                node: {
                                    getattr: MEMFS.node_ops.getattr,
                                    setattr: MEMFS.node_ops.setattr,
                                    readlink: MEMFS.node_ops.readlink
                                },
                                stream: {}
                            },
                            chrdev: {
                                node: {
                                    getattr: MEMFS.node_ops.getattr,
                                    setattr: MEMFS.node_ops.setattr
                                },
                                stream: FS.chrdev_stream_ops
                            }
                        }
                    }
                    var node = FS.createNode(parent, name, mode, dev);
                    if (FS.isDir(node.mode)) {
                        node.node_ops = MEMFS.ops_table.dir.node;
                        node.stream_ops = MEMFS.ops_table.dir.stream;
                        node.contents = {}
                    } else if (FS.isFile(node.mode)) {
                        node.node_ops = MEMFS.ops_table.file.node;
                        node.stream_ops = MEMFS.ops_table.file.stream;
                        node.usedBytes = 0;
                        node.contents = null
                    } else if (FS.isLink(node.mode)) {
                        node.node_ops = MEMFS.ops_table.link.node;
                        node.stream_ops = MEMFS.ops_table.link.stream
                    } else if (FS.isChrdev(node.mode)) {
                        node.node_ops = MEMFS.ops_table.chrdev.node;
                        node.stream_ops = MEMFS.ops_table.chrdev.stream
                    }
                    node.timestamp = Date.now();
                    if (parent) {
                        parent.contents[name] = node
                    }
                    return node
                },
                getFileDataAsRegularArray: function(node) {
                    if (node.contents && node.contents.subarray) {
                        var arr = [];
                        for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]);
                        return arr
                    }
                    return node.contents
                },
                getFileDataAsTypedArray: function(node) {
                    if (!node.contents) return new Uint8Array(0);
                    if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
                    return new Uint8Array(node.contents)
                },
                expandFileStorage: function(node, newCapacity) {
                    var prevCapacity = node.contents ? node.contents.length : 0;
                    if (prevCapacity >= newCapacity) return;
                    var CAPACITY_DOUBLING_MAX = 1024 * 1024;
                    newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
                    if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
                    var oldContents = node.contents;
                    node.contents = new Uint8Array(newCapacity);
                    if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
                    return
                },
                resizeFileStorage: function(node, newSize) {
                    if (node.usedBytes == newSize) return;
                    if (newSize == 0) {
                        node.contents = null;
                        node.usedBytes = 0;
                        return
                    }
                    if (!node.contents || node.contents.subarray) {
                        var oldContents = node.contents;
                        node.contents = new Uint8Array(newSize);
                        if (oldContents) {
                            node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)))
                        }
                        node.usedBytes = newSize;
                        return
                    }
                    if (!node.contents) node.contents = [];
                    if (node.contents.length > newSize) node.contents.length = newSize;
                    else
                        while (node.contents.length < newSize) node.contents.push(0);
                    node.usedBytes = newSize
                },
                node_ops: {
                    getattr: function(node) {
                        var attr = {};
                        attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
                        attr.ino = node.id;
                        attr.mode = node.mode;
                        attr.nlink = 1;
                        attr.uid = 0;
                        attr.gid = 0;
                        attr.rdev = node.rdev;
                        if (FS.isDir(node.mode)) {
                            attr.size = 4096
                        } else if (FS.isFile(node.mode)) {
                            attr.size = node.usedBytes
                        } else if (FS.isLink(node.mode)) {
                            attr.size = node.link.length
                        } else {
                            attr.size = 0
                        }
                        attr.atime = new Date(node.timestamp);
                        attr.mtime = new Date(node.timestamp);
                        attr.ctime = new Date(node.timestamp);
                        attr.blksize = 4096;
                        attr.blocks = Math.ceil(attr.size / attr.blksize);
                        return attr
                    },
                    setattr: function(node, attr) {
                        if (attr.mode !== undefined) {
                            node.mode = attr.mode
                        }
                        if (attr.timestamp !== undefined) {
                            node.timestamp = attr.timestamp
                        }
                        if (attr.size !== undefined) {
                            MEMFS.resizeFileStorage(node, attr.size)
                        }
                    },
                    lookup: function(parent, name) {
                        throw FS.genericErrors[44]
                    },
                    mknod: function(parent, name, mode, dev) {
                        return MEMFS.createNode(parent, name, mode, dev)
                    },
                    rename: function(old_node, new_dir, new_name) {
                        if (FS.isDir(old_node.mode)) {
                            var new_node;
                            try {
                                new_node = FS.lookupNode(new_dir, new_name)
                            } catch (e) {}
                            if (new_node) {
                                for (var i in new_node.contents) {
                                    throw new FS.ErrnoError(55)
                                }
                            }
                        }
                        delete old_node.parent.contents[old_node.name];
                        old_node.name = new_name;
                        new_dir.contents[new_name] = old_node;
                        old_node.parent = new_dir
                    },
                    unlink: function(parent, name) {
                        delete parent.contents[name]
                    },
                    rmdir: function(parent, name) {
                        var node = FS.lookupNode(parent, name);
                        for (var i in node.contents) {
                            throw new FS.ErrnoError(55)
                        }
                        delete parent.contents[name]
                    },
                    readdir: function(node) {
                        var entries = [".", ".."];
                        for (var key in node.contents) {
                            if (!node.contents.hasOwnProperty(key)) {
                                continue
                            }
                            entries.push(key)
                        }
                        return entries
                    },
                    symlink: function(parent, newname, oldpath) {
                        var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
                        node.link = oldpath;
                        return node
                    },
                    readlink: function(node) {
                        if (!FS.isLink(node.mode)) {
                            throw new FS.ErrnoError(28)
                        }
                        return node.link
                    }
                },
                stream_ops: {
                    read: function(stream, buffer, offset, length, position) {
                        var contents = stream.node.contents;
                        if (position >= stream.node.usedBytes) return 0;
                        var size = Math.min(stream.node.usedBytes - position, length);
                        if (size > 8 && contents.subarray) {
                            buffer.set(contents.subarray(position, position + size), offset)
                        } else {
                            for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]
                        }
                        return size
                    },
                    write: function(stream, buffer, offset, length, position, canOwn) {
                        if (buffer.buffer === HEAP8.buffer) {
                            canOwn = false
                        }
                        if (!length) return 0;
                        var node = stream.node;
                        node.timestamp = Date.now();
                        if (buffer.subarray && (!node.contents || node.contents.subarray)) {
                            if (canOwn) {
                                node.contents = buffer.subarray(offset, offset + length);
                                node.usedBytes = length;
                                return length
                            } else if (node.usedBytes === 0 && position === 0) {
                                node.contents = buffer.slice(offset, offset + length);
                                node.usedBytes = length;
                                return length
                            } else if (position + length <= node.usedBytes) {
                                node.contents.set(buffer.subarray(offset, offset + length), position);
                                return length
                            }
                        }
                        MEMFS.expandFileStorage(node, position + length);
                        if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position);
                        else {
                            for (var i = 0; i < length; i++) {
                                node.contents[position + i] = buffer[offset + i]
                            }
                        }
                        node.usedBytes = Math.max(node.usedBytes, position + length);
                        return length
                    },
                    llseek: function(stream, offset, whence) {
                        var position = offset;
                        if (whence === 1) {
                            position += stream.position
                        } else if (whence === 2) {
                            if (FS.isFile(stream.node.mode)) {
                                position += stream.node.usedBytes
                            }
                        }
                        if (position < 0) {
                            throw new FS.ErrnoError(28)
                        }
                        return position
                    },
                    allocate: function(stream, offset, length) {
                        MEMFS.expandFileStorage(stream.node, offset + length);
                        stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length)
                    },
                    mmap: function(stream, buffer, offset, length, position, prot, flags) {
                        if (!FS.isFile(stream.node.mode)) {
                            throw new FS.ErrnoError(43)
                        }
                        var ptr;
                        var allocated;
                        var contents = stream.node.contents;
                        if (!(flags & 2) && contents.buffer === buffer.buffer) {
                            allocated = false;
                            ptr = contents.byteOffset
                        } else {
                            if (position > 0 || position + length < contents.length) {
                                if (contents.subarray) {
                                    contents = contents.subarray(position, position + length)
                                } else {
                                    contents = Array.prototype.slice.call(contents, position, position + length)
                                }
                            }
                            allocated = true;
                            var fromHeap = buffer.buffer == HEAP8.buffer;
                            ptr = _malloc(length);
                            if (!ptr) {
                                throw new FS.ErrnoError(48)
                            }(fromHeap ? HEAP8 : buffer).set(contents, ptr)
                        }
                        return {
                            ptr: ptr,
                            allocated: allocated
                        }
                    },
                    msync: function(stream, buffer, offset, length, mmapFlags) {
                        if (!FS.isFile(stream.node.mode)) {
                            throw new FS.ErrnoError(43)
                        }
                        if (mmapFlags & 2) {
                            return 0
                        }
                        var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
                        return 0
                    }
                }
            };
            var IDBFS = {
                dbs: {},
                indexedDB: function() {
                    if (typeof indexedDB !== "undefined") return indexedDB;
                    var ret = null;
                    if (typeof window === "object") ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
                    assert(ret, "IDBFS used, but indexedDB not supported");
                    return ret
                },
                DB_VERSION: 21,
                DB_STORE_NAME: "FILE_DATA",
                mount: function(mount) {
                    return MEMFS.mount.apply(null, arguments)
                },
                syncfs: function(mount, populate, callback) {
                    IDBFS.getLocalSet(mount, function(err, local) {
                        if (err) return callback(err);
                        IDBFS.getRemoteSet(mount, function(err, remote) {
                            if (err) return callback(err);
                            var src = populate ? remote : local;
                            var dst = populate ? local : remote;
                            IDBFS.reconcile(src, dst, callback)
                        })
                    })
                },
                getDB: function(name, callback) {
                    var db = IDBFS.dbs[name];
                    if (db) {
                        return callback(null, db)
                    }
                    var req;
                    try {
                        req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION)
                    } catch (e) {
                        return callback(e)
                    }
                    if (!req) {
                        return callback("Unable to connect to IndexedDB")
                    }
                    req.onupgradeneeded = function(e) {
                        var db = e.target.result;
                        var transaction = e.target.transaction;
                        var fileStore;
                        if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
                            fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME)
                        } else {
                            fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME)
                        }
                        if (!fileStore.indexNames.contains("timestamp")) {
                            fileStore.createIndex("timestamp", "timestamp", {
                                unique: false
                            })
                        }
                    };
                    req.onsuccess = function() {
                        db = req.result;
                        IDBFS.dbs[name] = db;
                        callback(null, db)
                    };
                    req.onerror = function(e) {
                        callback(this.error);
                        e.preventDefault()
                    }
                },
                getLocalSet: function(mount, callback) {
                    var entries = {};

                    function isRealDir(p) {
                        return p !== "." && p !== ".."
                    }

                    function toAbsolute(root) {
                        return function(p) {
                            return PATH.join2(root, p)
                        }
                    }
                    var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
                    while (check.length) {
                        var path = check.pop();
                        var stat;
                        try {
                            stat = FS.stat(path)
                        } catch (e) {
                            return callback(e)
                        }
                        if (FS.isDir(stat.mode)) {
                            check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)))
                        }
                        entries[path] = {
                            "timestamp": stat.mtime
                        }
                    }
                    return callback(null, {
                        type: "local",
                        entries: entries
                    })
                },
                getRemoteSet: function(mount, callback) {
                    var entries = {};
                    IDBFS.getDB(mount.mountpoint, function(err, db) {
                        if (err) return callback(err);
                        try {
                            var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly");
                            transaction.onerror = function(e) {
                                callback(this.error);
                                e.preventDefault()
                            };
                            var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
                            var index = store.index("timestamp");
                            index.openKeyCursor().onsuccess = function(event) {
                                var cursor = event.target.result;
                                if (!cursor) {
                                    return callback(null, {
                                        type: "remote",
                                        db: db,
                                        entries: entries
                                    })
                                }
                                entries[cursor.primaryKey] = {
                                    "timestamp": cursor.key
                                };
                                cursor.continue()
                            }
                        } catch (e) {
                            return callback(e)
                        }
                    })
                },
                loadLocalEntry: function(path, callback) {
                    var stat, node;
                    try {
                        var lookup = FS.lookupPath(path);
                        node = lookup.node;
                        stat = FS.stat(path)
                    } catch (e) {
                        return callback(e)
                    }
                    if (FS.isDir(stat.mode)) {
                        return callback(null, {
                            "timestamp": stat.mtime,
                            "mode": stat.mode
                        })
                    } else if (FS.isFile(stat.mode)) {
                        node.contents = MEMFS.getFileDataAsTypedArray(node);
                        return callback(null, {
                            "timestamp": stat.mtime,
                            "mode": stat.mode,
                            "contents": node.contents
                        })
                    } else {
                        return callback(new Error("node type not supported"))
                    }
                },
                storeLocalEntry: function(path, entry, callback) {
                    try {
                        if (FS.isDir(entry["mode"])) {
                            FS.mkdir(path, entry["mode"])
                        } else if (FS.isFile(entry["mode"])) {
                            FS.writeFile(path, entry["contents"], {
                                canOwn: true
                            })
                        } else {
                            return callback(new Error("node type not supported"))
                        }
                        FS.chmod(path, entry["mode"]);
                        FS.utime(path, entry["timestamp"], entry["timestamp"])
                    } catch (e) {
                        return callback(e)
                    }
                    callback(null)
                },
                removeLocalEntry: function(path, callback) {
                    try {
                        var lookup = FS.lookupPath(path);
                        var stat = FS.stat(path);
                        if (FS.isDir(stat.mode)) {
                            FS.rmdir(path)
                        } else if (FS.isFile(stat.mode)) {
                            FS.unlink(path)
                        }
                    } catch (e) {
                        return callback(e)
                    }
                    callback(null)
                },
                loadRemoteEntry: function(store, path, callback) {
                    var req = store.get(path);
                    req.onsuccess = function(event) {
                        callback(null, event.target.result)
                    };
                    req.onerror = function(e) {
                        callback(this.error);
                        e.preventDefault()
                    }
                },
                storeRemoteEntry: function(store, path, entry, callback) {
                    var req = store.put(entry, path);
                    req.onsuccess = function() {
                        callback(null)
                    };
                    req.onerror = function(e) {
                        callback(this.error);
                        e.preventDefault()
                    }
                },
                removeRemoteEntry: function(store, path, callback) {
                    var req = store.delete(path);
                    req.onsuccess = function() {
                        callback(null)
                    };
                    req.onerror = function(e) {
                        callback(this.error);
                        e.preventDefault()
                    }
                },
                reconcile: function(src, dst, callback) {
                    var total = 0;
                    var create = [];
                    Object.keys(src.entries).forEach(function(key) {
                        var e = src.entries[key];
                        var e2 = dst.entries[key];
                        if (!e2 || e["timestamp"] > e2["timestamp"]) {
                            create.push(key);
                            total++
                        }
                    });
                    var remove = [];
                    Object.keys(dst.entries).forEach(function(key) {
                        var e = dst.entries[key];
                        var e2 = src.entries[key];
                        if (!e2) {
                            remove.push(key);
                            total++
                        }
                    });
                    if (!total) {
                        return callback(null)
                    }
                    var errored = false;
                    var db = src.type === "remote" ? src.db : dst.db;
                    var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readwrite");
                    var store = transaction.objectStore(IDBFS.DB_STORE_NAME);

                    function done(err) {
                        if (err && !errored) {
                            errored = true;
                            return callback(err)
                        }
                    }
                    transaction.onerror = function(e) {
                        done(this.error);
                        e.preventDefault()
                    };
                    transaction.oncomplete = function(e) {
                        if (!errored) {
                            callback(null)
                        }
                    };
                    create.sort().forEach(function(path) {
                        if (dst.type === "local") {
                            IDBFS.loadRemoteEntry(store, path, function(err, entry) {
                                if (err) return done(err);
                                IDBFS.storeLocalEntry(path, entry, done)
                            })
                        } else {
                            IDBFS.loadLocalEntry(path, function(err, entry) {
                                if (err) return done(err);
                                IDBFS.storeRemoteEntry(store, path, entry, done)
                            })
                        }
                    });
                    remove.sort().reverse().forEach(function(path) {
                        if (dst.type === "local") {
                            IDBFS.removeLocalEntry(path, done)
                        } else {
                            IDBFS.removeRemoteEntry(store, path, done)
                        }
                    })
                }
            };
            var FS = {
                root: null,
                mounts: [],
                devices: {},
                streams: [],
                nextInode: 1,
                nameTable: null,
                currentPath: "/",
                initialized: false,
                ignorePermissions: true,
                trackingDelegate: {},
                tracking: {
                    openFlags: {
                        READ: 1,
                        WRITE: 2
                    }
                },
                ErrnoError: null,
                genericErrors: {},
                filesystems: null,
                syncFSRequests: 0,
                handleFSError: function(e) {
                    if (!(e instanceof FS.ErrnoError)) throw e + " : " + stackTrace();
                    return setErrNo(e.errno)
                },
                lookupPath: function(path, opts) {
                    path = PATH_FS.resolve(FS.cwd(), path);
                    opts = opts || {};
                    if (!path) return {
                        path: "",
                        node: null
                    };
                    var defaults = {
                        follow_mount: true,
                        recurse_count: 0
                    };
                    for (var key in defaults) {
                        if (opts[key] === undefined) {
                            opts[key] = defaults[key]
                        }
                    }
                    if (opts.recurse_count > 8) {
                        throw new FS.ErrnoError(32)
                    }
                    var parts = PATH.normalizeArray(path.split("/").filter(function(p) {
                        return !!p
                    }), false);
                    var current = FS.root;
                    var current_path = "/";
                    for (var i = 0; i < parts.length; i++) {
                        var islast = i === parts.length - 1;
                        if (islast && opts.parent) {
                            break
                        }
                        current = FS.lookupNode(current, parts[i]);
                        current_path = PATH.join2(current_path, parts[i]);
                        if (FS.isMountpoint(current)) {
                            if (!islast || islast && opts.follow_mount) {
                                current = current.mounted.root
                            }
                        }
                        if (!islast || opts.follow) {
                            var count = 0;
                            while (FS.isLink(current.mode)) {
                                var link = FS.readlink(current_path);
                                current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
                                var lookup = FS.lookupPath(current_path, {
                                    recurse_count: opts.recurse_count
                                });
                                current = lookup.node;
                                if (count++ > 40) {
                                    throw new FS.ErrnoError(32)
                                }
                            }
                        }
                    }
                    return {
                        path: current_path,
                        node: current
                    }
                },
                getPath: function(node) {
                    var path;
                    while (true) {
                        if (FS.isRoot(node)) {
                            var mount = node.mount.mountpoint;
                            if (!path) return mount;
                            return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path
                        }
                        path = path ? node.name + "/" + path : node.name;
                        node = node.parent
                    }
                },
                hashName: function(parentid, name) {
                    var hash = 0;
                    for (var i = 0; i < name.length; i++) {
                        hash = (hash << 5) - hash + name.charCodeAt(i) | 0
                    }
                    return (parentid + hash >>> 0) % FS.nameTable.length
                },
                hashAddNode: function(node) {
                    var hash = FS.hashName(node.parent.id, node.name);
                    node.name_next = FS.nameTable[hash];
                    FS.nameTable[hash] = node
                },
                hashRemoveNode: function(node) {
                    var hash = FS.hashName(node.parent.id, node.name);
                    if (FS.nameTable[hash] === node) {
                        FS.nameTable[hash] = node.name_next
                    } else {
                        var current = FS.nameTable[hash];
                        while (current) {
                            if (current.name_next === node) {
                                current.name_next = node.name_next;
                                break
                            }
                            current = current.name_next
                        }
                    }
                },
                lookupNode: function(parent, name) {
                    var errCode = FS.mayLookup(parent);
                    if (errCode) {
                        throw new FS.ErrnoError(errCode, parent)
                    }
                    var hash = FS.hashName(parent.id, name);
                    for (var node = FS.nameTable[hash]; node; node = node.name_next) {
                        var nodeName = node.name;
                        if (node.parent.id === parent.id && nodeName === name) {
                            return node
                        }
                    }
                    return FS.lookup(parent, name)
                },
                createNode: function(parent, name, mode, rdev) {
                    var node = new FS.FSNode(parent, name, mode, rdev);
                    FS.hashAddNode(node);
                    return node
                },
                destroyNode: function(node) {
                    FS.hashRemoveNode(node)
                },
                isRoot: function(node) {
                    return node === node.parent
                },
                isMountpoint: function(node) {
                    return !!node.mounted
                },
                isFile: function(mode) {
                    return (mode & 61440) === 32768
                },
                isDir: function(mode) {
                    return (mode & 61440) === 16384
                },
                isLink: function(mode) {
                    return (mode & 61440) === 40960
                },
                isChrdev: function(mode) {
                    return (mode & 61440) === 8192
                },
                isBlkdev: function(mode) {
                    return (mode & 61440) === 24576
                },
                isFIFO: function(mode) {
                    return (mode & 61440) === 4096
                },
                isSocket: function(mode) {
                    return (mode & 49152) === 49152
                },
                flagModes: {
                    "r": 0,
                    "rs": 1052672,
                    "r+": 2,
                    "w": 577,
                    "wx": 705,
                    "xw": 705,
                    "w+": 578,
                    "wx+": 706,
                    "xw+": 706,
                    "a": 1089,
                    "ax": 1217,
                    "xa": 1217,
                    "a+": 1090,
                    "ax+": 1218,
                    "xa+": 1218
                },
                modeStringToFlags: function(str) {
                    var flags = FS.flagModes[str];
                    if (typeof flags === "undefined") {
                        throw new Error("Unknown file open mode: " + str)
                    }
                    return flags
                },
                flagsToPermissionString: function(flag) {
                    var perms = ["r", "w", "rw"][flag & 3];
                    if (flag & 512) {
                        perms += "w"
                    }
                    return perms
                },
                nodePermissions: function(node, perms) {
                    if (FS.ignorePermissions) {
                        return 0
                    }
                    if (perms.indexOf("r") !== -1 && !(node.mode & 292)) {
                        return 2
                    } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) {
                        return 2
                    } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) {
                        return 2
                    }
                    return 0
                },
                mayLookup: function(dir) {
                    var errCode = FS.nodePermissions(dir, "x");
                    if (errCode) return errCode;
                    if (!dir.node_ops.lookup) return 2;
                    return 0
                },
                mayCreate: function(dir, name) {
                    try {
                        var node = FS.lookupNode(dir, name);
                        return 20
                    } catch (e) {}
                    return FS.nodePermissions(dir, "wx")
                },
                mayDelete: function(dir, name, isdir) {
                    var node;
                    try {
                        node = FS.lookupNode(dir, name)
                    } catch (e) {
                        return e.errno
                    }
                    var errCode = FS.nodePermissions(dir, "wx");
                    if (errCode) {
                        return errCode
                    }
                    if (isdir) {
                        if (!FS.isDir(node.mode)) {
                            return 54
                        }
                        if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
                            return 10
                        }
                    } else {
                        if (FS.isDir(node.mode)) {
                            return 31
                        }
                    }
                    return 0
                },
                mayOpen: function(node, flags) {
                    if (!node) {
                        return 44
                    }
                    if (FS.isLink(node.mode)) {
                        return 32
                    } else if (FS.isDir(node.mode)) {
                        if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
                            return 31
                        }
                    }
                    return FS.nodePermissions(node, FS.flagsToPermissionString(flags))
                },
                MAX_OPEN_FDS: 4096,
                nextfd: function(fd_start, fd_end) {
                    fd_start = fd_start || 0;
                    fd_end = fd_end || FS.MAX_OPEN_FDS;
                    for (var fd = fd_start; fd <= fd_end; fd++) {
                        if (!FS.streams[fd]) {
                            return fd
                        }
                    }
                    throw new FS.ErrnoError(33)
                },
                getStream: function(fd) {
                    return FS.streams[fd]
                },
                createStream: function(stream, fd_start, fd_end) {
                    if (!FS.FSStream) {
                        FS.FSStream = function() {};
                        FS.FSStream.prototype = {
                            object: {
                                get: function() {
                                    return this.node
                                },
                                set: function(val) {
                                    this.node = val
                                }
                            },
                            isRead: {
                                get: function() {
                                    return (this.flags & 2097155) !== 1
                                }
                            },
                            isWrite: {
                                get: function() {
                                    return (this.flags & 2097155) !== 0
                                }
                            },
                            isAppend: {
                                get: function() {
                                    return this.flags & 1024
                                }
                            }
                        }
                    }
                    var newStream = new FS.FSStream;
                    for (var p in stream) {
                        newStream[p] = stream[p]
                    }
                    stream = newStream;
                    var fd = FS.nextfd(fd_start, fd_end);
                    stream.fd = fd;
                    FS.streams[fd] = stream;
                    return stream
                },
                closeStream: function(fd) {
                    FS.streams[fd] = null
                },
                chrdev_stream_ops: {
                    open: function(stream) {
                        var device = FS.getDevice(stream.node.rdev);
                        stream.stream_ops = device.stream_ops;
                        if (stream.stream_ops.open) {
                            stream.stream_ops.open(stream)
                        }
                    },
                    llseek: function() {
                        throw new FS.ErrnoError(70)
                    }
                },
                major: function(dev) {
                    return dev >> 8
                },
                minor: function(dev) {
                    return dev & 255
                },
                makedev: function(ma, mi) {
                    return ma << 8 | mi
                },
                registerDevice: function(dev, ops) {
                    FS.devices[dev] = {
                        stream_ops: ops
                    }
                },
                getDevice: function(dev) {
                    return FS.devices[dev]
                },
                getMounts: function(mount) {
                    var mounts = [];
                    var check = [mount];
                    while (check.length) {
                        var m = check.pop();
                        mounts.push(m);
                        check.push.apply(check, m.mounts)
                    }
                    return mounts
                },
                syncfs: function(populate, callback) {
                    if (typeof populate === "function") {
                        callback = populate;
                        populate = false
                    }
                    FS.syncFSRequests++;
                    if (FS.syncFSRequests > 1) {
                        err("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work")
                    }
                    var mounts = FS.getMounts(FS.root.mount);
                    var completed = 0;

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

                    function done(errCode) {
                        if (errCode) {
                            if (!done.errored) {
                                done.errored = true;
                                return doCallback(errCode)
                            }
                            return
                        }
                        if (++completed >= mounts.length) {
                            doCallback(null)
                        }
                    }
                    mounts.forEach(function(mount) {
                        if (!mount.type.syncfs) {
                            return done(null)
                        }
                        mount.type.syncfs(mount, populate, done)
                    })
                },
                mount: function(type, opts, mountpoint) {
                    var root = mountpoint === "/";
                    var pseudo = !mountpoint;
                    var node;
                    if (root && FS.root) {
                        throw new FS.ErrnoError(10)
                    } else if (!root && !pseudo) {
                        var lookup = FS.lookupPath(mountpoint, {
                            follow_mount: false
                        });
                        mountpoint = lookup.path;
                        node = lookup.node;
                        if (FS.isMountpoint(node)) {
                            throw new FS.ErrnoError(10)
                        }
                        if (!FS.isDir(node.mode)) {
                            throw new FS.ErrnoError(54)
                        }
                    }
                    var mount = {
                        type: type,
                        opts: opts,
                        mountpoint: mountpoint,
                        mounts: []
                    };
                    var mountRoot = type.mount(mount);
                    mountRoot.mount = mount;
                    mount.root = mountRoot;
                    if (root) {
                        FS.root = mountRoot
                    } else if (node) {
                        node.mounted = mount;
                        if (node.mount) {
                            node.mount.mounts.push(mount)
                        }
                    }
                    return mountRoot
                },
                unmount: function(mountpoint) {
                    var lookup = FS.lookupPath(mountpoint, {
                        follow_mount: false
                    });
                    if (!FS.isMountpoint(lookup.node)) {
                        throw new FS.ErrnoError(28)
                    }
                    var node = lookup.node;
                    var mount = node.mounted;
                    var mounts = FS.getMounts(mount);
                    Object.keys(FS.nameTable).forEach(function(hash) {
                        var current = FS.nameTable[hash];
                        while (current) {
                            var next = current.name_next;
                            if (mounts.indexOf(current.mount) !== -1) {
                                FS.destroyNode(current)
                            }
                            current = next
                        }
                    });
                    node.mounted = null;
                    var idx = node.mount.mounts.indexOf(mount);
                    node.mount.mounts.splice(idx, 1)
                },
                lookup: function(parent, name) {
                    return parent.node_ops.lookup(parent, name)
                },
                mknod: function(path, mode, dev) {
                    var lookup = FS.lookupPath(path, {
                        parent: true
                    });
                    var parent = lookup.node;
                    var name = PATH.basename(path);
                    if (!name || name === "." || name === "..") {
                        throw new FS.ErrnoError(28)
                    }
                    var errCode = FS.mayCreate(parent, name);
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    if (!parent.node_ops.mknod) {
                        throw new FS.ErrnoError(63)
                    }
                    return parent.node_ops.mknod(parent, name, mode, dev)
                },
                create: function(path, mode) {
                    mode = mode !== undefined ? mode : 438;
                    mode &= 4095;
                    mode |= 32768;
                    return FS.mknod(path, mode, 0)
                },
                mkdir: function(path, mode) {
                    mode = mode !== undefined ? mode : 511;
                    mode &= 511 | 512;
                    mode |= 16384;
                    return FS.mknod(path, mode, 0)
                },
                mkdirTree: function(path, mode) {
                    var dirs = path.split("/");
                    var d = "";
                    for (var i = 0; i < dirs.length; ++i) {
                        if (!dirs[i]) continue;
                        d += "/" + dirs[i];
                        try {
                            FS.mkdir(d, mode)
                        } catch (e) {
                            if (e.errno != 20) throw e
                        }
                    }
                },
                mkdev: function(path, mode, dev) {
                    if (typeof dev === "undefined") {
                        dev = mode;
                        mode = 438
                    }
                    mode |= 8192;
                    return FS.mknod(path, mode, dev)
                },
                symlink: function(oldpath, newpath) {
                    if (!PATH_FS.resolve(oldpath)) {
                        throw new FS.ErrnoError(44)
                    }
                    var lookup = FS.lookupPath(newpath, {
                        parent: true
                    });
                    var parent = lookup.node;
                    if (!parent) {
                        throw new FS.ErrnoError(44)
                    }
                    var newname = PATH.basename(newpath);
                    var errCode = FS.mayCreate(parent, newname);
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    if (!parent.node_ops.symlink) {
                        throw new FS.ErrnoError(63)
                    }
                    return parent.node_ops.symlink(parent, newname, oldpath)
                },
                rename: function(old_path, new_path) {
                    var old_dirname = PATH.dirname(old_path);
                    var new_dirname = PATH.dirname(new_path);
                    var old_name = PATH.basename(old_path);
                    var new_name = PATH.basename(new_path);
                    var lookup, old_dir, new_dir;
                    try {
                        lookup = FS.lookupPath(old_path, {
                            parent: true
                        });
                        old_dir = lookup.node;
                        lookup = FS.lookupPath(new_path, {
                            parent: true
                        });
                        new_dir = lookup.node
                    } catch (e) {
                        throw new FS.ErrnoError(10)
                    }
                    if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
                    if (old_dir.mount !== new_dir.mount) {
                        throw new FS.ErrnoError(75)
                    }
                    var old_node = FS.lookupNode(old_dir, old_name);
                    var relative = PATH_FS.relative(old_path, new_dirname);
                    if (relative.charAt(0) !== ".") {
                        throw new FS.ErrnoError(28)
                    }
                    relative = PATH_FS.relative(new_path, old_dirname);
                    if (relative.charAt(0) !== ".") {
                        throw new FS.ErrnoError(55)
                    }
                    var new_node;
                    try {
                        new_node = FS.lookupNode(new_dir, new_name)
                    } catch (e) {}
                    if (old_node === new_node) {
                        return
                    }
                    var isdir = FS.isDir(old_node.mode);
                    var errCode = FS.mayDelete(old_dir, old_name, isdir);
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    if (!old_dir.node_ops.rename) {
                        throw new FS.ErrnoError(63)
                    }
                    if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
                        throw new FS.ErrnoError(10)
                    }
                    if (new_dir !== old_dir) {
                        errCode = FS.nodePermissions(old_dir, "w");
                        if (errCode) {
                            throw new FS.ErrnoError(errCode)
                        }
                    }
                    try {
                        if (FS.trackingDelegate["willMovePath"]) {
                            FS.trackingDelegate["willMovePath"](old_path, new_path)
                        }
                    } catch (e) {
                        err("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
                    }
                    FS.hashRemoveNode(old_node);
                    try {
                        old_dir.node_ops.rename(old_node, new_dir, new_name)
                    } catch (e) {
                        throw e
                    } finally {
                        FS.hashAddNode(old_node)
                    }
                    try {
                        if (FS.trackingDelegate["onMovePath"]) FS.trackingDelegate["onMovePath"](old_path, new_path)
                    } catch (e) {
                        err("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
                    }
                },
                rmdir: function(path) {
                    var lookup = FS.lookupPath(path, {
                        parent: true
                    });
                    var parent = lookup.node;
                    var name = PATH.basename(path);
                    var node = FS.lookupNode(parent, name);
                    var errCode = FS.mayDelete(parent, name, true);
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    if (!parent.node_ops.rmdir) {
                        throw new FS.ErrnoError(63)
                    }
                    if (FS.isMountpoint(node)) {
                        throw new FS.ErrnoError(10)
                    }
                    try {
                        if (FS.trackingDelegate["willDeletePath"]) {
                            FS.trackingDelegate["willDeletePath"](path)
                        }
                    } catch (e) {
                        err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                    parent.node_ops.rmdir(parent, name);
                    FS.destroyNode(node);
                    try {
                        if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path)
                    } catch (e) {
                        err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                },
                readdir: function(path) {
                    var lookup = FS.lookupPath(path, {
                        follow: true
                    });
                    var node = lookup.node;
                    if (!node.node_ops.readdir) {
                        throw new FS.ErrnoError(54)
                    }
                    return node.node_ops.readdir(node)
                },
                unlink: function(path) {
                    var lookup = FS.lookupPath(path, {
                        parent: true
                    });
                    var parent = lookup.node;
                    var name = PATH.basename(path);
                    var node = FS.lookupNode(parent, name);
                    var errCode = FS.mayDelete(parent, name, false);
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    if (!parent.node_ops.unlink) {
                        throw new FS.ErrnoError(63)
                    }
                    if (FS.isMountpoint(node)) {
                        throw new FS.ErrnoError(10)
                    }
                    try {
                        if (FS.trackingDelegate["willDeletePath"]) {
                            FS.trackingDelegate["willDeletePath"](path)
                        }
                    } catch (e) {
                        err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                    parent.node_ops.unlink(parent, name);
                    FS.destroyNode(node);
                    try {
                        if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path)
                    } catch (e) {
                        err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                },
                readlink: function(path) {
                    var lookup = FS.lookupPath(path);
                    var link = lookup.node;
                    if (!link) {
                        throw new FS.ErrnoError(44)
                    }
                    if (!link.node_ops.readlink) {
                        throw new FS.ErrnoError(28)
                    }
                    return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link))
                },
                stat: function(path, dontFollow) {
                    var lookup = FS.lookupPath(path, {
                        follow: !dontFollow
                    });
                    var node = lookup.node;
                    if (!node) {
                        throw new FS.ErrnoError(44)
                    }
                    if (!node.node_ops.getattr) {
                        throw new FS.ErrnoError(63)
                    }
                    return node.node_ops.getattr(node)
                },
                lstat: function(path) {
                    return FS.stat(path, true)
                },
                chmod: function(path, mode, dontFollow) {
                    var node;
                    if (typeof path === "string") {
                        var lookup = FS.lookupPath(path, {
                            follow: !dontFollow
                        });
                        node = lookup.node
                    } else {
                        node = path
                    }
                    if (!node.node_ops.setattr) {
                        throw new FS.ErrnoError(63)
                    }
                    node.node_ops.setattr(node, {
                        mode: mode & 4095 | node.mode & ~4095,
                        timestamp: Date.now()
                    })
                },
                lchmod: function(path, mode) {
                    FS.chmod(path, mode, true)
                },
                fchmod: function(fd, mode) {
                    var stream = FS.getStream(fd);
                    if (!stream) {
                        throw new FS.ErrnoError(8)
                    }
                    FS.chmod(stream.node, mode)
                },
                chown: function(path, uid, gid, dontFollow) {
                    var node;
                    if (typeof path === "string") {
                        var lookup = FS.lookupPath(path, {
                            follow: !dontFollow
                        });
                        node = lookup.node
                    } else {
                        node = path
                    }
                    if (!node.node_ops.setattr) {
                        throw new FS.ErrnoError(63)
                    }
                    node.node_ops.setattr(node, {
                        timestamp: Date.now()
                    })
                },
                lchown: function(path, uid, gid) {
                    FS.chown(path, uid, gid, true)
                },
                fchown: function(fd, uid, gid) {
                    var stream = FS.getStream(fd);
                    if (!stream) {
                        throw new FS.ErrnoError(8)
                    }
                    FS.chown(stream.node, uid, gid)
                },
                truncate: function(path, len) {
                    if (len < 0) {
                        throw new FS.ErrnoError(28)
                    }
                    var node;
                    if (typeof path === "string") {
                        var lookup = FS.lookupPath(path, {
                            follow: true
                        });
                        node = lookup.node
                    } else {
                        node = path
                    }
                    if (!node.node_ops.setattr) {
                        throw new FS.ErrnoError(63)
                    }
                    if (FS.isDir(node.mode)) {
                        throw new FS.ErrnoError(31)
                    }
                    if (!FS.isFile(node.mode)) {
                        throw new FS.ErrnoError(28)
                    }
                    var errCode = FS.nodePermissions(node, "w");
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    node.node_ops.setattr(node, {
                        size: len,
                        timestamp: Date.now()
                    })
                },
                ftruncate: function(fd, len) {
                    var stream = FS.getStream(fd);
                    if (!stream) {
                        throw new FS.ErrnoError(8)
                    }
                    if ((stream.flags & 2097155) === 0) {
                        throw new FS.ErrnoError(28)
                    }
                    FS.truncate(stream.node, len)
                },
                utime: function(path, atime, mtime) {
                    var lookup = FS.lookupPath(path, {
                        follow: true
                    });
                    var node = lookup.node;
                    node.node_ops.setattr(node, {
                        timestamp: Math.max(atime, mtime)
                    })
                },
                open: function(path, flags, mode, fd_start, fd_end) {
                    if (path === "") {
                        throw new FS.ErrnoError(44)
                    }
                    flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags;
                    mode = typeof mode === "undefined" ? 438 : mode;
                    if (flags & 64) {
                        mode = mode & 4095 | 32768
                    } else {
                        mode = 0
                    }
                    var node;
                    if (typeof path === "object") {
                        node = path
                    } else {
                        path = PATH.normalize(path);
                        try {
                            var lookup = FS.lookupPath(path, {
                                follow: !(flags & 131072)
                            });
                            node = lookup.node
                        } catch (e) {}
                    }
                    var created = false;
                    if (flags & 64) {
                        if (node) {
                            if (flags & 128) {
                                throw new FS.ErrnoError(20)
                            }
                        } else {
                            node = FS.mknod(path, mode, 0);
                            created = true
                        }
                    }
                    if (!node) {
                        throw new FS.ErrnoError(44)
                    }
                    if (FS.isChrdev(node.mode)) {
                        flags &= ~512
                    }
                    if (flags & 65536 && !FS.isDir(node.mode)) {
                        throw new FS.ErrnoError(54)
                    }
                    if (!created) {
                        var errCode = FS.mayOpen(node, flags);
                        if (errCode) {
                            throw new FS.ErrnoError(errCode)
                        }
                    }
                    if (flags & 512) {
                        FS.truncate(node, 0)
                    }
                    flags &= ~(128 | 512 | 131072);
                    var stream = FS.createStream({
                        node: node,
                        path: FS.getPath(node),
                        flags: flags,
                        seekable: true,
                        position: 0,
                        stream_ops: node.stream_ops,
                        ungotten: [],
                        error: false
                    }, fd_start, fd_end);
                    if (stream.stream_ops.open) {
                        stream.stream_ops.open(stream)
                    }
                    if (Module["logReadFiles"] && !(flags & 1)) {
                        if (!FS.readFiles) FS.readFiles = {};
                        if (!(path in FS.readFiles)) {
                            FS.readFiles[path] = 1;
                            err("FS.trackingDelegate error on read file: " + path)
                        }
                    }
                    try {
                        if (FS.trackingDelegate["onOpenFile"]) {
                            var trackingFlags = 0;
                            if ((flags & 2097155) !== 1) {
                                trackingFlags |= FS.tracking.openFlags.READ
                            }
                            if ((flags & 2097155) !== 0) {
                                trackingFlags |= FS.tracking.openFlags.WRITE
                            }
                            FS.trackingDelegate["onOpenFile"](path, trackingFlags)
                        }
                    } catch (e) {
                        err("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message)
                    }
                    return stream
                },
                close: function(stream) {
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(8)
                    }
                    if (stream.getdents) stream.getdents = null;
                    try {
                        if (stream.stream_ops.close) {
                            stream.stream_ops.close(stream)
                        }
                    } catch (e) {
                        throw e
                    } finally {
                        FS.closeStream(stream.fd)
                    }
                    stream.fd = null
                },
                isClosed: function(stream) {
                    return stream.fd === null
                },
                llseek: function(stream, offset, whence) {
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(8)
                    }
                    if (!stream.seekable || !stream.stream_ops.llseek) {
                        throw new FS.ErrnoError(70)
                    }
                    if (whence != 0 && whence != 1 && whence != 2) {
                        throw new FS.ErrnoError(28)
                    }
                    stream.position = stream.stream_ops.llseek(stream, offset, whence);
                    stream.ungotten = [];
                    return stream.position
                },
                read: function(stream, buffer, offset, length, position) {
                    if (length < 0 || position < 0) {
                        throw new FS.ErrnoError(28)
                    }
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(8)
                    }
                    if ((stream.flags & 2097155) === 1) {
                        throw new FS.ErrnoError(8)
                    }
                    if (FS.isDir(stream.node.mode)) {
                        throw new FS.ErrnoError(31)
                    }
                    if (!stream.stream_ops.read) {
                        throw new FS.ErrnoError(28)
                    }
                    var seeking = typeof position !== "undefined";
                    if (!seeking) {
                        position = stream.position
                    } else if (!stream.seekable) {
                        throw new FS.ErrnoError(70)
                    }
                    var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
                    if (!seeking) stream.position += bytesRead;
                    return bytesRead
                },
                write: function(stream, buffer, offset, length, position, canOwn) {
                    if (length < 0 || position < 0) {
                        throw new FS.ErrnoError(28)
                    }
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(8)
                    }
                    if ((stream.flags & 2097155) === 0) {
                        throw new FS.ErrnoError(8)
                    }
                    if (FS.isDir(stream.node.mode)) {
                        throw new FS.ErrnoError(31)
                    }
                    if (!stream.stream_ops.write) {
                        throw new FS.ErrnoError(28)
                    }
                    if (stream.seekable && stream.flags & 1024) {
                        FS.llseek(stream, 0, 2)
                    }
                    var seeking = typeof position !== "undefined";
                    if (!seeking) {
                        position = stream.position
                    } else if (!stream.seekable) {
                        throw new FS.ErrnoError(70)
                    }
                    var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
                    if (!seeking) stream.position += bytesWritten;
                    try {
                        if (stream.path && FS.trackingDelegate["onWriteToFile"]) FS.trackingDelegate["onWriteToFile"](stream.path)
                    } catch (e) {
                        err("FS.trackingDelegate['onWriteToFile']('" + stream.path + "') threw an exception: " + e.message)
                    }
                    return bytesWritten
                },
                allocate: function(stream, offset, length) {
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(8)
                    }
                    if (offset < 0 || length <= 0) {
                        throw new FS.ErrnoError(28)
                    }
                    if ((stream.flags & 2097155) === 0) {
                        throw new FS.ErrnoError(8)
                    }
                    if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
                        throw new FS.ErrnoError(43)
                    }
                    if (!stream.stream_ops.allocate) {
                        throw new FS.ErrnoError(138)
                    }
                    stream.stream_ops.allocate(stream, offset, length)
                },
                mmap: function(stream, buffer, offset, length, position, prot, flags) {
                    if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
                        throw new FS.ErrnoError(2)
                    }
                    if ((stream.flags & 2097155) === 1) {
                        throw new FS.ErrnoError(2)
                    }
                    if (!stream.stream_ops.mmap) {
                        throw new FS.ErrnoError(43)
                    }
                    return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags)
                },
                msync: function(stream, buffer, offset, length, mmapFlags) {
                    if (!stream || !stream.stream_ops.msync) {
                        return 0
                    }
                    return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags)
                },
                munmap: function(stream) {
                    return 0
                },
                ioctl: function(stream, cmd, arg) {
                    if (!stream.stream_ops.ioctl) {
                        throw new FS.ErrnoError(59)
                    }
                    return stream.stream_ops.ioctl(stream, cmd, arg)
                },
                readFile: function(path, opts) {
                    opts = opts || {};
                    opts.flags = opts.flags || "r";
                    opts.encoding = opts.encoding || "binary";
                    if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
                        throw new Error('Invalid encoding type "' + opts.encoding + '"')
                    }
                    var ret;
                    var stream = FS.open(path, opts.flags);
                    var stat = FS.stat(path);
                    var length = stat.size;
                    var buf = new Uint8Array(length);
                    FS.read(stream, buf, 0, length, 0);
                    if (opts.encoding === "utf8") {
                        ret = UTF8ArrayToString(buf, 0)
                    } else if (opts.encoding === "binary") {
                        ret = buf
                    }
                    FS.close(stream);
                    return ret
                },
                writeFile: function(path, data, opts) {
                    opts = opts || {};
                    opts.flags = opts.flags || "w";
                    var stream = FS.open(path, opts.flags, opts.mode);
                    if (typeof data === "string") {
                        var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
                        var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
                        FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn)
                    } else if (ArrayBuffer.isView(data)) {
                        FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn)
                    } else {
                        throw new Error("Unsupported data type")
                    }
                    FS.close(stream)
                },
                cwd: function() {
                    return FS.currentPath
                },
                chdir: function(path) {
                    var lookup = FS.lookupPath(path, {
                        follow: true
                    });
                    if (lookup.node === null) {
                        throw new FS.ErrnoError(44)
                    }
                    if (!FS.isDir(lookup.node.mode)) {
                        throw new FS.ErrnoError(54)
                    }
                    var errCode = FS.nodePermissions(lookup.node, "x");
                    if (errCode) {
                        throw new FS.ErrnoError(errCode)
                    }
                    FS.currentPath = lookup.path
                },
                createDefaultDirectories: function() {
                    FS.mkdir("/tmp");
                    FS.mkdir("/home");
                    FS.mkdir("/home/web_user")
                },
                createDefaultDevices: function() {
                    FS.mkdir("/dev");
                    FS.registerDevice(FS.makedev(1, 3), {
                        read: function() {
                            return 0
                        },
                        write: function(stream, buffer, offset, length, pos) {
                            return length
                        }
                    });
                    FS.mkdev("/dev/null", FS.makedev(1, 3));
                    TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
                    TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
                    FS.mkdev("/dev/tty", FS.makedev(5, 0));
                    FS.mkdev("/dev/tty1", FS.makedev(6, 0));
                    var random_device;
                    if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") {
                        var randomBuffer = new Uint8Array(1);
                        random_device = function() {
                            crypto.getRandomValues(randomBuffer);
                            return randomBuffer[0]
                        }
                    } else {}
                    if (!random_device) {
                        random_device = function() {
                            abort("random_device")
                        }
                    }
                    FS.createDevice("/dev", "random", random_device);
                    FS.createDevice("/dev", "urandom", random_device);
                    FS.mkdir("/dev/shm");
                    FS.mkdir("/dev/shm/tmp")
                },
                createSpecialDirectories: function() {
                    FS.mkdir("/proc");
                    FS.mkdir("/proc/self");
                    FS.mkdir("/proc/self/fd");
                    FS.mount({
                        mount: function() {
                            var node = FS.createNode("/proc/self", "fd", 16384 | 511, 73);
                            node.node_ops = {
                                lookup: function(parent, name) {
                                    var fd = +name;
                                    var stream = FS.getStream(fd);
                                    if (!stream) throw new FS.ErrnoError(8);
                                    var ret = {
                                        parent: null,
                                        mount: {
                                            mountpoint: "fake"
                                        },
                                        node_ops: {
                                            readlink: function() {
                                                return stream.path
                                            }
                                        }
                                    };
                                    ret.parent = ret;
                                    return ret
                                }
                            };
                            return node
                        }
                    }, {}, "/proc/self/fd")
                },
                createStandardStreams: function() {
                    if (Module["stdin"]) {
                        FS.createDevice("/dev", "stdin", Module["stdin"])
                    } else {
                        FS.symlink("/dev/tty", "/dev/stdin")
                    }
                    if (Module["stdout"]) {
                        FS.createDevice("/dev", "stdout", null, Module["stdout"])
                    } else {
                        FS.symlink("/dev/tty", "/dev/stdout")
                    }
                    if (Module["stderr"]) {
                        FS.createDevice("/dev", "stderr", null, Module["stderr"])
                    } else {
                        FS.symlink("/dev/tty1", "/dev/stderr")
                    }
                    var stdin = FS.open("/dev/stdin", "r");
                    var stdout = FS.open("/dev/stdout", "w");
                    var stderr = FS.open("/dev/stderr", "w")
                },
                ensureErrnoError: function() {
                    if (FS.ErrnoError) return;
                    FS.ErrnoError = function ErrnoError(errno, node) {
                        this.node = node;
                        this.setErrno = function(errno) {
                            this.errno = errno
                        };
                        this.setErrno(errno);
                        this.message = "FS error"
                    };
                    FS.ErrnoError.prototype = new Error;
                    FS.ErrnoError.prototype.constructor = FS.ErrnoError;
                    [44].forEach(function(code) {
                        FS.genericErrors[code] = new FS.ErrnoError(code);
                        FS.genericErrors[code].stack = "<generic error, no stack>"
                    })
                },
                staticInit: function() {
                    FS.ensureErrnoError();
                    FS.nameTable = new Array(4096);
                    FS.mount(MEMFS, {}, "/");
                    FS.createDefaultDirectories();
                    FS.createDefaultDevices();
                    FS.createSpecialDirectories();
                    FS.filesystems = {
                        "MEMFS": MEMFS,
                        "IDBFS": IDBFS
                    }
                },
                init: function(input, output, error) {
                    FS.init.initialized = true;
                    FS.ensureErrnoError();
                    Module["stdin"] = input || Module["stdin"];
                    Module["stdout"] = output || Module["stdout"];
                    Module["stderr"] = error || Module["stderr"];
                    FS.createStandardStreams()
                },
                quit: function() {
                    FS.init.initialized = false;
                    var fflush = Module["_fflush"];
                    if (fflush) fflush(0);
                    for (var i = 0; i < FS.streams.length; i++) {
                        var stream = FS.streams[i];
                        if (!stream) {
                            continue
                        }
                        FS.close(stream)
                    }
                },
                getMode: function(canRead, canWrite) {
                    var mode = 0;
                    if (canRead) mode |= 292 | 73;
                    if (canWrite) mode |= 146;
                    return mode
                },
                joinPath: function(parts, forceRelative) {
                    var path = PATH.join.apply(null, parts);
                    if (forceRelative && path[0] == "/") path = path.substr(1);
                    return path
                },
                absolutePath: function(relative, base) {
                    return PATH_FS.resolve(base, relative)
                },
                standardizePath: function(path) {
                    return PATH.normalize(path)
                },
                findObject: function(path, dontResolveLastLink) {
                    var ret = FS.analyzePath(path, dontResolveLastLink);
                    if (ret.exists) {
                        return ret.object
                    } else {
                        setErrNo(ret.error);
                        return null
                    }
                },
                analyzePath: function(path, dontResolveLastLink) {
                    try {
                        var lookup = FS.lookupPath(path, {
                            follow: !dontResolveLastLink
                        });
                        path = lookup.path
                    } catch (e) {}
                    var ret = {
                        isRoot: false,
                        exists: false,
                        error: 0,
                        name: null,
                        path: null,
                        object: null,
                        parentExists: false,
                        parentPath: null,
                        parentObject: null
                    };
                    try {
                        var lookup = FS.lookupPath(path, {
                            parent: true
                        });
                        ret.parentExists = true;
                        ret.parentPath = lookup.path;
                        ret.parentObject = lookup.node;
                        ret.name = PATH.basename(path);
                        lookup = FS.lookupPath(path, {
                            follow: !dontResolveLastLink
                        });
                        ret.exists = true;
                        ret.path = lookup.path;
                        ret.object = lookup.node;
                        ret.name = lookup.node.name;
                        ret.isRoot = lookup.path === "/"
                    } catch (e) {
                        ret.error = e.errno
                    }
                    return ret
                },
                createFolder: function(parent, name, canRead, canWrite) {
                    var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
                    var mode = FS.getMode(canRead, canWrite);
                    return FS.mkdir(path, mode)
                },
                createPath: function(parent, path, canRead, canWrite) {
                    parent = typeof parent === "string" ? parent : FS.getPath(parent);
                    var parts = path.split("/").reverse();
                    while (parts.length) {
                        var part = parts.pop();
                        if (!part) continue;
                        var current = PATH.join2(parent, part);
                        try {
                            FS.mkdir(current)
                        } catch (e) {}
                        parent = current
                    }
                    return current
                },
                createFile: function(parent, name, properties, canRead, canWrite) {
                    var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
                    var mode = FS.getMode(canRead, canWrite);
                    return FS.create(path, mode)
                },
                createDataFile: function(parent, name, data, canRead, canWrite, canOwn) {
                    var path = name ? PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name) : parent;
                    var mode = FS.getMode(canRead, canWrite);
                    var node = FS.create(path, mode);
                    if (data) {
                        if (typeof data === "string") {
                            var arr = new Array(data.length);
                            for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
                            data = arr
                        }
                        FS.chmod(node, mode | 146);
                        var stream = FS.open(node, "w");
                        FS.write(stream, data, 0, data.length, 0, canOwn);
                        FS.close(stream);
                        FS.chmod(node, mode)
                    }
                    return node
                },
                createDevice: function(parent, name, input, output) {
                    var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
                    var mode = FS.getMode(!!input, !!output);
                    if (!FS.createDevice.major) FS.createDevice.major = 64;
                    var dev = FS.makedev(FS.createDevice.major++, 0);
                    FS.registerDevice(dev, {
                        open: function(stream) {
                            stream.seekable = false
                        },
                        close: function(stream) {
                            if (output && output.buffer && output.buffer.length) {
                                output(10)
                            }
                        },
                        read: function(stream, buffer, offset, length, pos) {
                            var bytesRead = 0;
                            for (var i = 0; i < length; i++) {
                                var result;
                                try {
                                    result = input()
                                } catch (e) {
                                    throw new FS.ErrnoError(29)
                                }
                                if (result === undefined && bytesRead === 0) {
                                    throw new FS.ErrnoError(6)
                                }
                                if (result === null || result === undefined) break;
                                bytesRead++;
                                buffer[offset + i] = result
                            }
                            if (bytesRead) {
                                stream.node.timestamp = Date.now()
                            }
                            return bytesRead
                        },
                        write: function(stream, buffer, offset, length, pos) {
                            for (var i = 0; i < length; i++) {
                                try {
                                    output(buffer[offset + i])
                                } catch (e) {
                                    throw new FS.ErrnoError(29)
                                }
                            }
                            if (length) {
                                stream.node.timestamp = Date.now()
                            }
                            return i
                        }
                    });
                    return FS.mkdev(path, mode, dev)
                },
                createLink: function(parent, name, target, canRead, canWrite) {
                    var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
                    return FS.symlink(target, path)
                },
                forceLoadFile: function(obj) {
                    if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
                    var success = true;
                    if (typeof XMLHttpRequest !== "undefined") {
                        throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")
                    } else if (read_) {
                        try {
                            obj.contents = intArrayFromString(read_(obj.url), true);
                            obj.usedBytes = obj.contents.length
                        } catch (e) {
                            success = false
                        }
                    } else {
                        throw new Error("Cannot load without read() or XMLHttpRequest.")
                    }
                    if (!success) setErrNo(29);
                    return success
                },
                createLazyFile: function(parent, name, url, canRead, canWrite) {
                    function LazyUint8Array() {
                        this.lengthKnown = false;
                        this.chunks = []
                    }
                    LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
                        if (idx > this.length - 1 || idx < 0) {
                            return undefined
                        }
                        var chunkOffset = idx % this.chunkSize;
                        var chunkNum = idx / this.chunkSize | 0;
                        return this.getter(chunkNum)[chunkOffset]
                    };
                    LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
                        this.getter = getter
                    };
                    LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
                        var xhr = new XMLHttpRequest;
                        xhr.open("HEAD", url, false);
                        xhr.send(null);
                        if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
                        var datalength = Number(xhr.getResponseHeader("Content-length"));
                        var header;
                        var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
                        var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
                        var chunkSize = 1024 * 1024;
                        if (!hasByteServing) chunkSize = datalength;
                        var doXHR = function(from, to) {
                            if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
                            if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
                            var xhr = new XMLHttpRequest;
                            xhr.open("GET", url, false);
                            if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
                            if (typeof Uint8Array != "undefined") xhr.responseType = "arraybuffer";
                            if (xhr.overrideMimeType) {
                                xhr.overrideMimeType("text/plain; charset=x-user-defined")
                            }
                            xhr.send(null);
                            if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
                            if (xhr.response !== undefined) {
                                return new Uint8Array(xhr.response || [])
                            } else {
                                return intArrayFromString(xhr.responseText || "", true)
                            }
                        };
                        var lazyArray = this;
                        lazyArray.setDataGetter(function(chunkNum) {
                            var start = chunkNum * chunkSize;
                            var end = (chunkNum + 1) * chunkSize - 1;
                            end = Math.min(end, datalength - 1);
                            if (typeof lazyArray.chunks[chunkNum] === "undefined") {
                                lazyArray.chunks[chunkNum] = doXHR(start, end)
                            }
                            if (typeof lazyArray.chunks[chunkNum] === "undefined") throw new Error("doXHR failed!");
                            return lazyArray.chunks[chunkNum]
                        });
                        if (usesGzip || !datalength) {
                            chunkSize = datalength = 1;
                            datalength = this.getter(0).length;
                            chunkSize = datalength;
                            out("LazyFiles on gzip forces download of the whole file when length is accessed")
                        }
                        this._length = datalength;
                        this._chunkSize = chunkSize;
                        this.lengthKnown = true
                    };
                    if (typeof XMLHttpRequest !== "undefined") {
                        if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
                        var lazyArray = new LazyUint8Array;
                        Object.defineProperties(lazyArray, {
                            length: {
                                get: function() {
                                    if (!this.lengthKnown) {
                                        this.cacheLength()
                                    }
                                    return this._length
                                }
                            },
                            chunkSize: {
                                get: function() {
                                    if (!this.lengthKnown) {
                                        this.cacheLength()
                                    }
                                    return this._chunkSize
                                }
                            }
                        });
                        var properties = {
                            isDevice: false,
                            contents: lazyArray
                        }
                    } else {
                        var properties = {
                            isDevice: false,
                            url: url
                        }
                    }
                    var node = FS.createFile(parent, name, properties, canRead, canWrite);
                    if (properties.contents) {
                        node.contents = properties.contents
                    } else if (properties.url) {
                        node.contents = null;
                        node.url = properties.url
                    }
                    Object.defineProperties(node, {
                        usedBytes: {
                            get: function() {
                                return this.contents.length
                            }
                        }
                    });
                    var stream_ops = {};
                    var keys = Object.keys(node.stream_ops);
                    keys.forEach(function(key) {
                        var fn = node.stream_ops[key];
                        stream_ops[key] = function forceLoadLazyFile() {
                            if (!FS.forceLoadFile(node)) {
                                throw new FS.ErrnoError(29)
                            }
                            return fn.apply(null, arguments)
                        }
                    });
                    stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
                        if (!FS.forceLoadFile(node)) {
                            throw new FS.ErrnoError(29)
                        }
                        var contents = stream.node.contents;
                        if (position >= contents.length) return 0;
                        var size = Math.min(contents.length - position, length);
                        if (contents.slice) {
                            for (var i = 0; i < size; i++) {
                                buffer[offset + i] = contents[position + i]
                            }
                        } else {
                            for (var i = 0; i < size; i++) {
                                buffer[offset + i] = contents.get(position + i)
                            }
                        }
                        return size
                    };
                    node.stream_ops = stream_ops;
                    return node
                },
                createPreloadedFile: function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) {
                    Browser.init();
                    var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
                    var dep = getUniqueRunDependency("cp " + fullname);

                    function processData(byteArray) {
                        function finish(byteArray) {
                            if (preFinish) preFinish();
                            if (!dontCreateFile) {
                                FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn)
                            }
                            if (onload) onload();
                            removeRunDependency(dep)
                        }
                        var handled = false;
                        Module["preloadPlugins"].forEach(function(plugin) {
                            if (handled) return;
                            if (plugin["canHandle"](fullname)) {
                                plugin["handle"](byteArray, fullname, finish, function() {
                                    if (onerror) onerror();
                                    removeRunDependency(dep)
                                });
                                handled = true
                            }
                        });
                        if (!handled) finish(byteArray)
                    }
                    addRunDependency(dep);
                    if (typeof url == "string") {
                        Browser.asyncLoad(url, function(byteArray) {
                            processData(byteArray)
                        }, onerror)
                    } else {
                        processData(url)
                    }
                },
                indexedDB: function() {
                    return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB
                },
                DB_NAME: function() {
                    return "EM_FS_" + window.location.pathname
                },
                DB_VERSION: 20,
                DB_STORE_NAME: "FILE_DATA",
                saveFilesToDB: function(paths, onload, onerror) {
                    onload = onload || function() {};
                    onerror = onerror || function() {};
                    var indexedDB = FS.indexedDB();
                    try {
                        var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION)
                    } catch (e) {
                        return onerror(e)
                    }
                    openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
                        out("creating db");
                        var db = openRequest.result;
                        db.createObjectStore(FS.DB_STORE_NAME)
                    };
                    openRequest.onsuccess = function openRequest_onsuccess() {
                        var db = openRequest.result;
                        var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite");
                        var files = transaction.objectStore(FS.DB_STORE_NAME);
                        var ok = 0,
                            fail = 0,
                            total = paths.length;

                        function finish() {
                            if (fail == 0) onload();
                            else onerror()
                        }
                        paths.forEach(function(path) {
                            var putRequest = files.put(FS.analyzePath(path).object.contents, path);
                            putRequest.onsuccess = function putRequest_onsuccess() {
                                ok++;
                                if (ok + fail == total) finish()
                            };
                            putRequest.onerror = function putRequest_onerror() {
                                fail++;
                                if (ok + fail == total) finish()
                            }
                        });
                        transaction.onerror = onerror
                    };
                    openRequest.onerror = onerror
                },
                loadFilesFromDB: function(paths, onload, onerror) {
                    onload = onload || function() {};
                    onerror = onerror || function() {};
                    var indexedDB = FS.indexedDB();
                    try {
                        var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION)
                    } catch (e) {
                        return onerror(e)
                    }
                    openRequest.onupgradeneeded = onerror;
                    openRequest.onsuccess = function openRequest_onsuccess() {
                        var db = openRequest.result;
                        try {
                            var transaction = db.transaction([FS.DB_STORE_NAME], "readonly")
                        } catch (e) {
                            onerror(e);
                            return
                        }
                        var files = transaction.objectStore(FS.DB_STORE_NAME);
                        var ok = 0,
                            fail = 0,
                            total = paths.length;

                        function finish() {
                            if (fail == 0) onload();
                            else onerror()
                        }
                        paths.forEach(function(path) {
                            var getRequest = files.get(path);
                            getRequest.onsuccess = function getRequest_onsuccess() {
                                if (FS.analyzePath(path).exists) {
                                    FS.unlink(path)
                                }
                                FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
                                ok++;
                                if (ok + fail == total) finish()
                            };
                            getRequest.onerror = function getRequest_onerror() {
                                fail++;
                                if (ok + fail == total) finish()
                            }
                        });
                        transaction.onerror = onerror
                    };
                    openRequest.onerror = onerror
                }
            };
            var SYSCALLS = {
                mappings: {},
                DEFAULT_POLLMASK: 5,
                umask: 511,
                calculateAt: function(dirfd, path) {
                    if (path[0] !== "/") {
                        var dir;
                        if (dirfd === -100) {
                            dir = FS.cwd()
                        } else {
                            var dirstream = FS.getStream(dirfd);
                            if (!dirstream) throw new FS.ErrnoError(8);
                            dir = dirstream.path
                        }
                        path = PATH.join2(dir, path)
                    }
                    return path
                },
                doStat: function(func, path, buf) {
                    try {
                        var stat = func(path)
                    } catch (e) {
                        if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
                            return -54
                        }
                        throw e
                    }
                    HEAP32[buf >> 2] = stat.dev;
                    HEAP32[buf + 4 >> 2] = 0;
                    HEAP32[buf + 8 >> 2] = stat.ino;
                    HEAP32[buf + 12 >> 2] = stat.mode;
                    HEAP32[buf + 16 >> 2] = stat.nlink;
                    HEAP32[buf + 20 >> 2] = stat.uid;
                    HEAP32[buf + 24 >> 2] = stat.gid;
                    HEAP32[buf + 28 >> 2] = stat.rdev;
                    HEAP32[buf + 32 >> 2] = 0;
                    tempI64 = [stat.size >>> 0, (tempDouble = stat.size, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 40 >> 2] = tempI64[0], HEAP32[buf + 44 >> 2] = tempI64[1];
                    HEAP32[buf + 48 >> 2] = 4096;
                    HEAP32[buf + 52 >> 2] = stat.blocks;
                    HEAP32[buf + 56 >> 2] = stat.atime.getTime() / 1e3 | 0;
                    HEAP32[buf + 60 >> 2] = 0;
                    HEAP32[buf + 64 >> 2] = stat.mtime.getTime() / 1e3 | 0;
                    HEAP32[buf + 68 >> 2] = 0;
                    HEAP32[buf + 72 >> 2] = stat.ctime.getTime() / 1e3 | 0;
                    HEAP32[buf + 76 >> 2] = 0;
                    tempI64 = [stat.ino >>> 0, (tempDouble = stat.ino, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 80 >> 2] = tempI64[0], HEAP32[buf + 84 >> 2] = tempI64[1];
                    return 0
                },
                doMsync: function(addr, stream, len, flags, offset) {
                    var buffer = HEAPU8.slice(addr, addr + len);
                    FS.msync(stream, buffer, offset, len, flags)
                },
                doMkdir: function(path, mode) {
                    path = PATH.normalize(path);
                    if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1);
                    FS.mkdir(path, mode, 0);
                    return 0
                },
                doMknod: function(path, mode, dev) {
                    switch (mode & 61440) {
                        case 32768:
                        case 8192:
                        case 24576:
                        case 4096:
                        case 49152:
                            break;
                        default:
                            return -28
                    }
                    FS.mknod(path, mode, dev);
                    return 0
                },
                doReadlink: function(path, buf, bufsize) {
                    if (bufsize <= 0) return -28;
                    var ret = FS.readlink(path);
                    var len = Math.min(bufsize, lengthBytesUTF8(ret));
                    var endChar = HEAP8[buf + len];
                    stringToUTF8(ret, buf, bufsize + 1);
                    HEAP8[buf + len] = endChar;
                    return len
                },
                doAccess: function(path, amode) {
                    if (amode & ~7) {
                        return -28
                    }
                    var node;
                    var lookup = FS.lookupPath(path, {
                        follow: true
                    });
                    node = lookup.node;
                    if (!node) {
                        return -44
                    }
                    var perms = "";
                    if (amode & 4) perms += "r";
                    if (amode & 2) perms += "w";
                    if (amode & 1) perms += "x";
                    if (perms && FS.nodePermissions(node, perms)) {
                        return -2
                    }
                    return 0
                },
                doDup: function(path, flags, suggestFD) {
                    var suggest = FS.getStream(suggestFD);
                    if (suggest) FS.close(suggest);
                    return FS.open(path, flags, 0, suggestFD, suggestFD).fd
                },
                doReadv: function(stream, iov, iovcnt, offset) {
                    var ret = 0;
                    for (var i = 0; i < iovcnt; i++) {
                        var ptr = HEAP32[iov + i * 8 >> 2];
                        var len = HEAP32[iov + (i * 8 + 4) >> 2];
                        var curr = FS.read(stream, HEAP8, ptr, len, offset);
                        if (curr < 0) return -1;
                        ret += curr;
                        if (curr < len) break
                    }
                    return ret
                },
                doWritev: function(stream, iov, iovcnt, offset) {
                    var ret = 0;
                    for (var i = 0; i < iovcnt; i++) {
                        var ptr = HEAP32[iov + i * 8 >> 2];
                        var len = HEAP32[iov + (i * 8 + 4) >> 2];
                        var curr = FS.write(stream, HEAP8, ptr, len, offset);
                        if (curr < 0) return -1;
                        ret += curr
                    }
                    return ret
                },
                varargs: undefined,
                get: function() {
                    SYSCALLS.varargs += 4;
                    var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
                    return ret
                },
                getStr: function(ptr) {
                    var ret = UTF8ToString(ptr);
                    return ret
                },
                getStreamFromFD: function(fd) {
                    var stream = FS.getStream(fd);
                    if (!stream) throw new FS.ErrnoError(8);
                    return stream
                },
                get64: function(low, high) {
                    return low
                }
            };

            function ___sys_fcntl64(fd, cmd, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var stream = SYSCALLS.getStreamFromFD(fd);
                    switch (cmd) {
                        case 0: {
                            var arg = SYSCALLS.get();
                            if (arg < 0) {
                                return -28
                            }
                            var newStream;
                            newStream = FS.open(stream.path, stream.flags, 0, arg);
                            return newStream.fd
                        }
                        case 1:
                        case 2:
                            return 0;
                        case 3:
                            return stream.flags;
                        case 4: {
                            var arg = SYSCALLS.get();
                            stream.flags |= arg;
                            return 0
                        }
                        case 12: {
                            var arg = SYSCALLS.get();
                            var offset = 0;
                            HEAP16[arg + offset >> 1] = 2;
                            return 0
                        }
                        case 13:
                        case 14:
                            return 0;
                        case 16:
                        case 8:
                            return -28;
                        case 9:
                            setErrNo(28);
                            return -1;
                        default: {
                            return -28
                        }
                    }
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___sys_fstat64(fd, buf) {
                try {
                    var stream = SYSCALLS.getStreamFromFD(fd);
                    return SYSCALLS.doStat(FS.stat, stream.path, buf)
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___sys_ioctl(fd, op, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var stream = SYSCALLS.getStreamFromFD(fd);
                    switch (op) {
                        case 21509:
                        case 21505: {
                            if (!stream.tty) return -59;
                            return 0
                        }
                        case 21510:
                        case 21511:
                        case 21512:
                        case 21506:
                        case 21507:
                        case 21508: {
                            if (!stream.tty) return -59;
                            return 0
                        }
                        case 21519: {
                            if (!stream.tty) return -59;
                            var argp = SYSCALLS.get();
                            HEAP32[argp >> 2] = 0;
                            return 0
                        }
                        case 21520: {
                            if (!stream.tty) return -59;
                            return -28
                        }
                        case 21531: {
                            var argp = SYSCALLS.get();
                            return FS.ioctl(stream, op, argp)
                        }
                        case 21523: {
                            if (!stream.tty) return -59;
                            return 0
                        }
                        case 21524: {
                            if (!stream.tty) return -59;
                            return 0
                        }
                        default:
                            abort("bad ioctl syscall " + op)
                    }
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

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

            function ___sys_read(fd, buf, count) {
                try {
                    var stream = SYSCALLS.getStreamFromFD(fd);
                    return FS.read(stream, HEAP8, buf, count)
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___sys_stat64(path, buf) {
                try {
                    path = SYSCALLS.getStr(path);
                    return SYSCALLS.doStat(FS.stat, path, buf)
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function __emscripten_fetch_free(id) {
                delete Fetch.xhrs[id - 1]
            }

            function _abort() {
                abort()
            }

            function _emscripten_set_main_loop_timing(mode, value) {
                Browser.mainLoop.timingMode = mode;
                Browser.mainLoop.timingValue = value;
                if (!Browser.mainLoop.func) {
                    return 1
                }
                if (mode == 0) {
                    Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() {
                        var timeUntilNextTick = Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0;
                        setTimeout(Browser.mainLoop.runner, timeUntilNextTick)
                    };
                    Browser.mainLoop.method = "timeout"
                } else if (mode == 1) {
                    Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() {
                        Browser.requestAnimationFrame(Browser.mainLoop.runner)
                    };
                    Browser.mainLoop.method = "rAF"
                } else if (mode == 2) {
                    if (typeof setImmediate === "undefined") {
                        var setImmediates = [];
                        var emscriptenMainLoopMessageId = "setimmediate";
                        var Browser_setImmediate_messageHandler = function(event) {
                            if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) {
                                event.stopPropagation();
                                setImmediates.shift()()
                            }
                        };
                        addEventListener("message", Browser_setImmediate_messageHandler, true);
                        setImmediate = function Browser_emulated_setImmediate(func) {
                            setImmediates.push(func);
                            if (ENVIRONMENT_IS_WORKER) {
                                if (Module["setImmediates"] === undefined) Module["setImmediates"] = [];
                                Module["setImmediates"].push(func);
                                postMessage({
                                    target: emscriptenMainLoopMessageId
                                })
                            } else postMessage(emscriptenMainLoopMessageId, "*")
                        }
                    }
                    Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() {
                        setImmediate(Browser.mainLoop.runner)
                    };
                    Browser.mainLoop.method = "immediate"
                }
                return 0
            }
            var _emscripten_get_now;
            _emscripten_get_now = function() {
                return performance.now()
            };

            function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop, arg, noSetTiming) {
                noExitRuntime = true;
                assert(!Browser.mainLoop.func, "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.");
                Browser.mainLoop.func = func;
                Browser.mainLoop.arg = arg;
                var browserIterationFunc;
                if (typeof arg !== "undefined") {
                    browserIterationFunc = function() {
                        Module["dynCall_vi"](func, arg)
                    }
                } else {
                    browserIterationFunc = function() {
                        Module["dynCall_v"](func)
                    }
                }
                var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop;
                Browser.mainLoop.runner = function Browser_mainLoop_runner() {
                    if (ABORT) return;
                    if (Browser.mainLoop.queue.length > 0) {
                        var start = Date.now();
                        var blocker = Browser.mainLoop.queue.shift();
                        blocker.func(blocker.arg);
                        if (Browser.mainLoop.remainingBlockers) {
                            var remaining = Browser.mainLoop.remainingBlockers;
                            var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
                            if (blocker.counted) {
                                Browser.mainLoop.remainingBlockers = next
                            } else {
                                next = next + .5;
                                Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9
                            }
                        }
                        console.log('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms");
                        Browser.mainLoop.updateStatus();
                        if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
                        setTimeout(Browser.mainLoop.runner, 0);
                        return
                    }
                    if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
                    Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0;
                    if (Browser.mainLoop.timingMode == 1 && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) {
                        Browser.mainLoop.scheduler();
                        return
                    } else if (Browser.mainLoop.timingMode == 0) {
                        Browser.mainLoop.tickStartTime = _emscripten_get_now()
                    }
                    Browser.mainLoop.runIter(browserIterationFunc);
                    if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
                    if (typeof SDL === "object" && SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData();
                    Browser.mainLoop.scheduler()
                };
                if (!noSetTiming) {
                    if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps);
                    else _emscripten_set_main_loop_timing(1, 1);
                    Browser.mainLoop.scheduler()
                }
                if (simulateInfiniteLoop) {
                    throw "unwind"
                }
            }
            var Browser = {
                mainLoop: {
                    scheduler: null,
                    method: "",
                    currentlyRunningMainloop: 0,
                    func: null,
                    arg: 0,
                    timingMode: 0,
                    timingValue: 0,
                    currentFrameNumber: 0,
                    queue: [],
                    pause: function() {
                        Browser.mainLoop.scheduler = null;
                        Browser.mainLoop.currentlyRunningMainloop++
                    },
                    resume: function() {
                        Browser.mainLoop.currentlyRunningMainloop++;
                        var timingMode = Browser.mainLoop.timingMode;
                        var timingValue = Browser.mainLoop.timingValue;
                        var func = Browser.mainLoop.func;
                        Browser.mainLoop.func = null;
                        _emscripten_set_main_loop(func, 0, false, Browser.mainLoop.arg, true);
                        _emscripten_set_main_loop_timing(timingMode, timingValue);
                        Browser.mainLoop.scheduler()
                    },
                    updateStatus: function() {
                        if (Module["setStatus"]) {
                            var message = Module["statusMessage"] || "Please wait...";
                            var remaining = Browser.mainLoop.remainingBlockers;
                            var expected = Browser.mainLoop.expectedBlockers;
                            if (remaining) {
                                if (remaining < expected) {
                                    Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")")
                                } else {
                                    Module["setStatus"](message)
                                }
                            } else {
                                Module["setStatus"]("")
                            }
                        }
                    },
                    runIter: function(func) {
                        if (ABORT) return;
                        if (Module["preMainLoop"]) {
                            var preRet = Module["preMainLoop"]();
                            if (preRet === false) {
                                return
                            }
                        }
                        try {
                            func()
                        } catch (e) {
                            if (e instanceof ExitStatus) {
                                return
                            } else {
                                if (e && typeof e === "object" && e.stack) err("exception thrown: " + [e, e.stack]);
                                throw e
                            }
                        }
                        if (Module["postMainLoop"]) Module["postMainLoop"]()
                    }
                },
                isFullscreen: false,
                pointerLock: false,
                moduleContextCreatedCallbacks: [],
                workers: [],
                init: function() {
                    if (!Module["preloadPlugins"]) Module["preloadPlugins"] = [];
                    if (Browser.initted) return;
                    Browser.initted = true;
                    try {
                        new Blob;
                        Browser.hasBlobConstructor = true
                    } catch (e) {
                        Browser.hasBlobConstructor = false;
                        console.log("warning: no blob constructor, cannot create blobs with mimetypes")
                    }
                    Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : !Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null;
                    Browser.URLObject = typeof window != "undefined" ? window.URL ? window.URL : window.webkitURL : undefined;
                    if (!Module.noImageDecoding && typeof Browser.URLObject === "undefined") {
                        console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
                        Module.noImageDecoding = true
                    }
                    var imagePlugin = {};
                    imagePlugin["canHandle"] = function imagePlugin_canHandle(name) {
                        return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name)
                    };
                    imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) {
                        var b = null;
                        if (Browser.hasBlobConstructor) {
                            try {
                                b = new Blob([byteArray], {
                                    type: Browser.getMimetype(name)
                                });
                                if (b.size !== byteArray.length) {
                                    b = new Blob([new Uint8Array(byteArray).buffer], {
                                        type: Browser.getMimetype(name)
                                    })
                                }
                            } catch (e) {
                                warnOnce("Blob constructor present but fails: " + e + "; falling back to blob builder")
                            }
                        }
                        if (!b) {
                            var bb = new Browser.BlobBuilder;
                            bb.append(new Uint8Array(byteArray).buffer);
                            b = bb.getBlob()
                        }
                        var url = Browser.URLObject.createObjectURL(b);
                        var img = new Image;
                        img.onload = function img_onload() {
                            assert(img.complete, "Image " + name + " could not be decoded");
                            var canvas = document.createElement("canvas");
                            canvas.width = img.width;
                            canvas.height = img.height;
                            var ctx = canvas.getContext("2d");
                            ctx.drawImage(img, 0, 0);
                            Module["preloadedImages"][name] = canvas;
                            Browser.URLObject.revokeObjectURL(url);
                            if (onload) onload(byteArray)
                        };
                        img.onerror = function img_onerror(event) {
                            console.log("Image " + url + " could not be decoded");
                            if (onerror) onerror()
                        };
                        img.src = url
                    };
                    Module["preloadPlugins"].push(imagePlugin);
                    var audioPlugin = {};
                    audioPlugin["canHandle"] = function audioPlugin_canHandle(name) {
                        return !Module.noAudioDecoding && name.substr(-4) in {
                            ".ogg": 1,
                            ".wav": 1,
                            ".mp3": 1
                        }
                    };
                    audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) {
                        var done = false;

                        function finish(audio) {
                            if (done) return;
                            done = true;
                            Module["preloadedAudios"][name] = audio;
                            if (onload) onload(byteArray)
                        }

                        function fail() {
                            if (done) return;
                            done = true;
                            Module["preloadedAudios"][name] = new Audio;
                            if (onerror) onerror()
                        }
                        if (Browser.hasBlobConstructor) {
                            try {
                                var b = new Blob([byteArray], {
                                    type: Browser.getMimetype(name)
                                })
                            } catch (e) {
                                return fail()
                            }
                            var url = Browser.URLObject.createObjectURL(b);
                            var audio = new Audio;
                            audio.addEventListener("canplaythrough", function() {
                                finish(audio)
                            }, false);
                            audio.onerror = function audio_onerror(event) {
                                if (done) return;
                                console.log("warning: browser could not fully decode audio " + name + ", trying slower base64 approach");

                                function encode64(data) {
                                    var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
                                    var PAD = "=";
                                    var ret = "";
                                    var leftchar = 0;
                                    var leftbits = 0;
                                    for (var i = 0; i < data.length; i++) {
                                        leftchar = leftchar << 8 | data[i];
                                        leftbits += 8;
                                        while (leftbits >= 6) {
                                            var curr = leftchar >> leftbits - 6 & 63;
                                            leftbits -= 6;
                                            ret += BASE[curr]
                                        }
                                    }
                                    if (leftbits == 2) {
                                        ret += BASE[(leftchar & 3) << 4];
                                        ret += PAD + PAD
                                    } else if (leftbits == 4) {
                                        ret += BASE[(leftchar & 15) << 2];
                                        ret += PAD
                                    }
                                    return ret
                                }
                                audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray);
                                finish(audio)
                            };
                            audio.src = url;
                            Browser.safeSetTimeout(function() {
                                finish(audio)
                            }, 1e4)
                        } else {
                            return fail()
                        }
                    };
                    Module["preloadPlugins"].push(audioPlugin);

                    function pointerLockChange() {
                        Browser.pointerLock = document["pointerLockElement"] === Module["canvas"] || document["mozPointerLockElement"] === Module["canvas"] || document["webkitPointerLockElement"] === Module["canvas"] || document["msPointerLockElement"] === Module["canvas"]
                    }
                    var canvas = Module["canvas"];
                    if (canvas) {
                        canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || function() {};
                        canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] || function() {};
                        canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
                        document.addEventListener("pointerlockchange", pointerLockChange, false);
                        document.addEventListener("mozpointerlockchange", pointerLockChange, false);
                        document.addEventListener("webkitpointerlockchange", pointerLockChange, false);
                        document.addEventListener("mspointerlockchange", pointerLockChange, false);
                        if (Module["elementPointerLock"]) {
                            canvas.addEventListener("click", function(ev) {
                                if (!Browser.pointerLock && Module["canvas"].requestPointerLock) {
                                    Module["canvas"].requestPointerLock();
                                    ev.preventDefault()
                                }
                            }, false)
                        }
                    }
                },
                createContext: function(canvas, useWebGL, setInModule, webGLContextAttributes) {
                    if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx;
                    var ctx;
                    var contextHandle;
                    if (useWebGL) {
                        var contextAttributes = {
                            antialias: false,
                            alpha: false,
                            majorVersion: 2
                        };
                        if (webGLContextAttributes) {
                            for (var attribute in webGLContextAttributes) {
                                contextAttributes[attribute] = webGLContextAttributes[attribute]
                            }
                        }
                        if (typeof GL !== "undefined") {
                            contextHandle = GL.createContext(canvas, contextAttributes);
                            if (contextHandle) {
                                ctx = GL.getContext(contextHandle).GLctx
                            }
                        }
                    } else {
                        ctx = canvas.getContext("2d")
                    }
                    if (!ctx) return null;
                    if (setInModule) {
                        if (!useWebGL) assert(typeof GLctx === "undefined", "cannot set in module if GLctx is used, but we are a non-GL context that would replace it");
                        Module.ctx = ctx;
                        if (useWebGL) GL.makeContextCurrent(contextHandle);
                        Module.useWebGL = useWebGL;
                        Browser.moduleContextCreatedCallbacks.forEach(function(callback) {
                            callback()
                        });
                        Browser.init()
                    }
                    return ctx
                },
                destroyContext: function(canvas, useWebGL, setInModule) {},
                fullscreenHandlersInstalled: false,
                lockPointer: undefined,
                resizeCanvas: undefined,
                requestFullscreen: function(lockPointer, resizeCanvas) {
                    Browser.lockPointer = lockPointer;
                    Browser.resizeCanvas = resizeCanvas;
                    if (typeof Browser.lockPointer === "undefined") Browser.lockPointer = true;
                    if (typeof Browser.resizeCanvas === "undefined") Browser.resizeCanvas = false;
                    var canvas = Module["canvas"];

                    function fullscreenChange() {
                        Browser.isFullscreen = false;
                        var canvasContainer = canvas.parentNode;
                        if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvasContainer) {
                            canvas.exitFullscreen = Browser.exitFullscreen;
                            if (Browser.lockPointer) canvas.requestPointerLock();
                            Browser.isFullscreen = true;
                            if (Browser.resizeCanvas) {
                                Browser.setFullscreenCanvasSize()
                            } else {
                                Browser.updateCanvasDimensions(canvas)
                            }
                        } else {
                            canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
                            canvasContainer.parentNode.removeChild(canvasContainer);
                            if (Browser.resizeCanvas) {
                                Browser.setWindowedCanvasSize()
                            } else {
                                Browser.updateCanvasDimensions(canvas)
                            }
                        }
                        if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen);
                        if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen)
                    }
                    if (!Browser.fullscreenHandlersInstalled) {
                        Browser.fullscreenHandlersInstalled = true;
                        document.addEventListener("fullscreenchange", fullscreenChange, false);
                        document.addEventListener("mozfullscreenchange", fullscreenChange, false);
                        document.addEventListener("webkitfullscreenchange", fullscreenChange, false);
                        document.addEventListener("MSFullscreenChange", fullscreenChange, false)
                    }
                    var canvasContainer = document.createElement("div");
                    canvas.parentNode.insertBefore(canvasContainer, canvas);
                    canvasContainer.appendChild(canvas);
                    canvasContainer.requestFullscreen = canvasContainer["requestFullscreen"] || canvasContainer["mozRequestFullScreen"] || canvasContainer["msRequestFullscreen"] || (canvasContainer["webkitRequestFullscreen"] ? function() {
                        canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"])
                    } : null) || (canvasContainer["webkitRequestFullScreen"] ? function() {
                        canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"])
                    } : null);
                    canvasContainer.requestFullscreen()
                },
                exitFullscreen: function() {
                    if (!Browser.isFullscreen) {
                        return false
                    }
                    var CFS = document["exitFullscreen"] || document["cancelFullScreen"] || document["mozCancelFullScreen"] || document["msExitFullscreen"] || document["webkitCancelFullScreen"] || function() {};
                    CFS.apply(document, []);
                    return true
                },
                nextRAF: 0,
                fakeRequestAnimationFrame: function(func) {
                    var now = Date.now();
                    if (Browser.nextRAF === 0) {
                        Browser.nextRAF = now + 1e3 / 60
                    } else {
                        while (now + 2 >= Browser.nextRAF) {
                            Browser.nextRAF += 1e3 / 60
                        }
                    }
                    var delay = Math.max(Browser.nextRAF - now, 0);
                    setTimeout(func, delay)
                },
                requestAnimationFrame: function(func) {
                    if (typeof requestAnimationFrame === "function") {
                        requestAnimationFrame(func);
                        return
                    }
                    var RAF = Browser.fakeRequestAnimationFrame;
                    RAF(func)
                },
                safeCallback: function(func) {
                    return function() {
                        if (!ABORT) return func.apply(null, arguments)
                    }
                },
                allowAsyncCallbacks: true,
                queuedAsyncCallbacks: [],
                pauseAsyncCallbacks: function() {
                    Browser.allowAsyncCallbacks = false
                },
                resumeAsyncCallbacks: function() {
                    Browser.allowAsyncCallbacks = true;
                    if (Browser.queuedAsyncCallbacks.length > 0) {
                        var callbacks = Browser.queuedAsyncCallbacks;
                        Browser.queuedAsyncCallbacks = [];
                        callbacks.forEach(function(func) {
                            func()
                        })
                    }
                },
                safeRequestAnimationFrame: function(func) {
                    return Browser.requestAnimationFrame(function() {
                        if (ABORT) return;
                        if (Browser.allowAsyncCallbacks) {
                            func()
                        } else {
                            Browser.queuedAsyncCallbacks.push(func)
                        }
                    })
                },
                safeSetTimeout: function(func, timeout) {
                    noExitRuntime = true;
                    return setTimeout(function() {
                        if (ABORT) return;
                        if (Browser.allowAsyncCallbacks) {
                            func()
                        } else {
                            Browser.queuedAsyncCallbacks.push(func)
                        }
                    }, timeout)
                },
                safeSetInterval: function(func, timeout) {
                    noExitRuntime = true;
                    return setInterval(function() {
                        if (ABORT) return;
                        if (Browser.allowAsyncCallbacks) {
                            func()
                        }
                    }, timeout)
                },
                getMimetype: function(name) {
                    return {
                        "jpg": "image/jpeg",
                        "jpeg": "image/jpeg",
                        "png": "image/png",
                        "bmp": "image/bmp",
                        "ogg": "audio/ogg",
                        "wav": "audio/wav",
                        "mp3": "audio/mpeg"
                    } [name.substr(name.lastIndexOf(".") + 1)]
                },
                getUserMedia: function(func) {
                    if (!window.getUserMedia) {
                        window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"]
                    }
                    window.getUserMedia(func)
                },
                getMovementX: function(event) {
                    return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0
                },
                getMovementY: function(event) {
                    return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0
                },
                getMouseWheelDelta: function(event) {
                    var delta = 0;
                    switch (event.type) {
                        case "DOMMouseScroll":
                            delta = event.detail / 3;
                            break;
                        case "mousewheel":
                            delta = event.wheelDelta / 120;
                            break;
                        case "wheel":
                            delta = event.deltaY;
                            switch (event.deltaMode) {
                                case 0:
                                    delta /= 100;
                                    break;
                                case 1:
                                    delta /= 3;
                                    break;
                                case 2:
                                    delta *= 80;
                                    break;
                                default:
                                    throw "unrecognized mouse wheel delta mode: " + event.deltaMode
                            }
                            break;
                        default:
                            throw "unrecognized mouse wheel event: " + event.type
                    }
                    return delta
                },
                mouseX: 0,
                mouseY: 0,
                mouseMovementX: 0,
                mouseMovementY: 0,
                touches: {},
                lastTouches: {},
                calculateMouseEvent: function(event) {
                    if (Browser.pointerLock) {
                        if (event.type != "mousemove" && "mozMovementX" in event) {
                            Browser.mouseMovementX = Browser.mouseMovementY = 0
                        } else {
                            Browser.mouseMovementX = Browser.getMovementX(event);
                            Browser.mouseMovementY = Browser.getMovementY(event)
                        }
                        if (typeof SDL != "undefined") {
                            Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
                            Browser.mouseY = SDL.mouseY + Browser.mouseMovementY
                        } else {
                            Browser.mouseX += Browser.mouseMovementX;
                            Browser.mouseY += Browser.mouseMovementY
                        }
                    } else {
                        var rect = Module["canvas"].getBoundingClientRect();
                        var cw = Module["canvas"].width;
                        var ch = Module["canvas"].height;
                        var scrollX = typeof window.scrollX !== "undefined" ? window.scrollX : window.pageXOffset;
                        var scrollY = typeof window.scrollY !== "undefined" ? window.scrollY : window.pageYOffset;
                        if (event.type === "touchstart" || event.type === "touchend" || event.type === "touchmove") {
                            var touch = event.touch;
                            if (touch === undefined) {
                                return
                            }
                            var adjustedX = touch.pageX - (scrollX + rect.left);
                            var adjustedY = touch.pageY - (scrollY + rect.top);
                            adjustedX = adjustedX * (cw / rect.width);
                            adjustedY = adjustedY * (ch / rect.height);
                            var coords = {
                                x: adjustedX,
                                y: adjustedY
                            };
                            if (event.type === "touchstart") {
                                Browser.lastTouches[touch.identifier] = coords;
                                Browser.touches[touch.identifier] = coords
                            } else if (event.type === "touchend" || event.type === "touchmove") {
                                var last = Browser.touches[touch.identifier];
                                if (!last) last = coords;
                                Browser.lastTouches[touch.identifier] = last;
                                Browser.touches[touch.identifier] = coords
                            }
                            return
                        }
                        var x = event.pageX - (scrollX + rect.left);
                        var y = event.pageY - (scrollY + rect.top);
                        x = x * (cw / rect.width);
                        y = y * (ch / rect.height);
                        Browser.mouseMovementX = x - Browser.mouseX;
                        Browser.mouseMovementY = y - Browser.mouseY;
                        Browser.mouseX = x;
                        Browser.mouseY = y
                    }
                },
                asyncLoad: function(url, onload, onerror, noRunDep) {
                    var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
                    readAsync(url, function(arrayBuffer) {
                        assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
                        onload(new Uint8Array(arrayBuffer));
                        if (dep) removeRunDependency(dep)
                    }, function(event) {
                        if (onerror) {
                            onerror()
                        } else {
                            throw 'Loading data file "' + url + '" failed.'
                        }
                    });
                    if (dep) addRunDependency(dep)
                },
                resizeListeners: [],
                updateResizeListeners: function() {
                    var canvas = Module["canvas"];
                    Browser.resizeListeners.forEach(function(listener) {
                        listener(canvas.width, canvas.height)
                    })
                },
                setCanvasSize: function(width, height, noUpdates) {
                    var canvas = Module["canvas"];
                    Browser.updateCanvasDimensions(canvas, width, height);
                    if (!noUpdates) Browser.updateResizeListeners()
                },
                windowedWidth: 0,
                windowedHeight: 0,
                setFullscreenCanvasSize: function() {
                    if (typeof SDL != "undefined") {
                        var flags = HEAPU32[SDL.screen >> 2];
                        flags = flags | 8388608;
                        HEAP32[SDL.screen >> 2] = flags
                    }
                    Browser.updateCanvasDimensions(Module["canvas"]);
                    Browser.updateResizeListeners()
                },
                setWindowedCanvasSize: function() {
                    if (typeof SDL != "undefined") {
                        var flags = HEAPU32[SDL.screen >> 2];
                        flags = flags & ~8388608;
                        HEAP32[SDL.screen >> 2] = flags
                    }
                    Browser.updateCanvasDimensions(Module["canvas"]);
                    Browser.updateResizeListeners()
                },
                updateCanvasDimensions: function(canvas, wNative, hNative) {
                    if (wNative && hNative) {
                        canvas.widthNative = wNative;
                        canvas.heightNative = hNative
                    } else {
                        wNative = canvas.widthNative;
                        hNative = canvas.heightNative
                    }
                    var w = wNative;
                    var h = hNative;
                    if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) {
                        if (w / h < Module["forcedAspectRatio"]) {
                            w = Math.round(h * Module["forcedAspectRatio"])
                        } else {
                            h = Math.round(w / Module["forcedAspectRatio"])
                        }
                    }
                    if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvas.parentNode && typeof screen != "undefined") {
                        var factor = Math.min(screen.width / w, screen.height / h);
                        w = Math.round(w * factor);
                        h = Math.round(h * factor)
                    }
                    if (Browser.resizeCanvas) {
                        if (canvas.width != w) canvas.width = w;
                        if (canvas.height != h) canvas.height = h;
                        if (typeof canvas.style != "undefined") {
                            canvas.style.removeProperty("width");
                            canvas.style.removeProperty("height")
                        }
                    } else {
                        if (canvas.width != wNative) canvas.width = wNative;
                        if (canvas.height != hNative) canvas.height = hNative;
                        if (typeof canvas.style != "undefined") {
                            if (w != wNative || h != hNative) {
                                canvas.style.setProperty("width", w + "px", "important");
                                canvas.style.setProperty("height", h + "px", "important")
                            } else {
                                canvas.style.removeProperty("width");
                                canvas.style.removeProperty("height")
                            }
                        }
                    }
                },
                wgetRequests: {},
                nextWgetRequestHandle: 0,
                getNextWgetRequestHandle: function() {
                    var handle = Browser.nextWgetRequestHandle;
                    Browser.nextWgetRequestHandle++;
                    return handle
                }
            };
            var AL = {
                QUEUE_INTERVAL: 25,
                QUEUE_LOOKAHEAD: .1,
                DEVICE_NAME: "Emscripten OpenAL",
                CAPTURE_DEVICE_NAME: "Emscripten OpenAL capture",
                ALC_EXTENSIONS: {
                    ALC_SOFT_pause_device: true,
                    ALC_SOFT_HRTF: true
                },
                AL_EXTENSIONS: {
                    AL_EXT_float32: true,
                    AL_SOFT_loop_points: true,
                    AL_SOFT_source_length: true,
                    AL_EXT_source_distance_model: true,
                    AL_SOFT_source_spatialize: true
                },
                _alcErr: 0,
                alcErr: 0,
                deviceRefCounts: {},
                alcStringCache: {},
                paused: false,
                stringCache: {},
                contexts: {},
                currentCtx: null,
                buffers: {
                    0: {
                        id: 0,
                        refCount: 0,
                        audioBuf: null,
                        frequency: 0,
                        bytesPerSample: 2,
                        channels: 1,
                        length: 0
                    }
                },
                paramArray: [],
                _nextId: 1,
                newId: function() {
                    return AL.freeIds.length > 0 ? AL.freeIds.pop() : AL._nextId++
                },
                freeIds: [],
                scheduleContextAudio: function(ctx) {
                    if (Browser.mainLoop.timingMode === 1 && document["visibilityState"] != "visible") {
                        return
                    }
                    for (var i in ctx.sources) {
                        AL.scheduleSourceAudio(ctx.sources[i])
                    }
                },
                scheduleSourceAudio: function(src, lookahead) {
                    if (Browser.mainLoop.timingMode === 1 && document["visibilityState"] != "visible") {
                        return
                    }
                    if (src.state !== 4114) {
                        return
                    }
                    var currentTime = AL.updateSourceTime(src);
                    var startTime = src.bufStartTime;
                    var startOffset = src.bufOffset;
                    var bufCursor = src.bufsProcessed;
                    for (var i = 0; i < src.audioQueue.length; i++) {
                        var audioSrc = src.audioQueue[i];
                        startTime = audioSrc._startTime + audioSrc._duration;
                        startOffset = 0;
                        bufCursor += audioSrc._skipCount + 1
                    }
                    if (!lookahead) {
                        lookahead = AL.QUEUE_LOOKAHEAD
                    }
                    var lookaheadTime = currentTime + lookahead;
                    var skipCount = 0;
                    while (startTime < lookaheadTime) {
                        if (bufCursor >= src.bufQueue.length) {
                            if (src.looping) {
                                bufCursor %= src.bufQueue.length
                            } else {
                                break
                            }
                        }
                        var buf = src.bufQueue[bufCursor % src.bufQueue.length];
                        if (buf.length === 0) {
                            skipCount++;
                            if (skipCount === src.bufQueue.length) {
                                break
                            }
                        } else {
                            var audioSrc = src.context.audioCtx.createBufferSource();
                            audioSrc.buffer = buf.audioBuf;
                            audioSrc.playbackRate.value = src.playbackRate;
                            if (buf.audioBuf._loopStart || buf.audioBuf._loopEnd) {
                                audioSrc.loopStart = buf.audioBuf._loopStart;
                                audioSrc.loopEnd = buf.audioBuf._loopEnd
                            }
                            var duration = 0;
                            if (src.type === 4136 && src.looping) {
                                duration = Number.POSITIVE_INFINITY;
                                audioSrc.loop = true;
                                if (buf.audioBuf._loopStart) {
                                    audioSrc.loopStart = buf.audioBuf._loopStart
                                }
                                if (buf.audioBuf._loopEnd) {
                                    audioSrc.loopEnd = buf.audioBuf._loopEnd
                                }
                            } else {
                                duration = (buf.audioBuf.duration - startOffset) / src.playbackRate
                            }
                            audioSrc._startOffset = startOffset;
                            audioSrc._duration = duration;
                            audioSrc._skipCount = skipCount;
                            skipCount = 0;
                            audioSrc.connect(src.gain);
                            if (typeof audioSrc.start !== "undefined") {
                                startTime = Math.max(startTime, src.context.audioCtx.currentTime);
                                audioSrc.start(startTime, startOffset)
                            } else if (typeof audioSrc.noteOn !== "undefined") {
                                startTime = Math.max(startTime, src.context.audioCtx.currentTime);
                                audioSrc.noteOn(startTime)
                            }
                            audioSrc._startTime = startTime;
                            src.audioQueue.push(audioSrc);
                            startTime += duration
                        }
                        startOffset = 0;
                        bufCursor++
                    }
                },
                updateSourceTime: function(src) {
                    var currentTime = src.context.audioCtx.currentTime;
                    if (src.state !== 4114) {
                        return currentTime
                    }
                    if (!isFinite(src.bufStartTime)) {
                        src.bufStartTime = currentTime - src.bufOffset / src.playbackRate;
                        src.bufOffset = 0
                    }
                    var nextStartTime = 0;
                    while (src.audioQueue.length) {
                        var audioSrc = src.audioQueue[0];
                        src.bufsProcessed += audioSrc._skipCount;
                        nextStartTime = audioSrc._startTime + audioSrc._duration;
                        if (currentTime < nextStartTime) {
                            break
                        }
                        src.audioQueue.shift();
                        src.bufStartTime = nextStartTime;
                        src.bufOffset = 0;
                        src.bufsProcessed++
                    }
                    if (src.bufsProcessed >= src.bufQueue.length && !src.looping) {
                        AL.setSourceState(src, 4116)
                    } else if (src.type === 4136 && src.looping) {
                        var buf = src.bufQueue[0];
                        if (buf.length === 0) {
                            src.bufOffset = 0
                        } else {
                            var delta = (currentTime - src.bufStartTime) * src.playbackRate;
                            var loopStart = buf.audioBuf._loopStart || 0;
                            var loopEnd = buf.audioBuf._loopEnd || buf.audioBuf.duration;
                            if (loopEnd <= loopStart) {
                                loopEnd = buf.audioBuf.duration
                            }
                            if (delta < loopEnd) {
                                src.bufOffset = delta
                            } else {
                                src.bufOffset = loopStart + (delta - loopStart) % (loopEnd - loopStart)
                            }
                        }
                    } else if (src.audioQueue[0]) {
                        src.bufOffset = (currentTime - src.audioQueue[0]._startTime) * src.playbackRate
                    } else {
                        if (src.type !== 4136 && src.looping) {
                            var srcDuration = AL.sourceDuration(src) / src.playbackRate;
                            if (srcDuration > 0) {
                                src.bufStartTime += Math.floor((currentTime - src.bufStartTime) / srcDuration) * srcDuration
                            }
                        }
                        for (var i = 0; i < src.bufQueue.length; i++) {
                            if (src.bufsProcessed >= src.bufQueue.length) {
                                if (src.looping) {
                                    src.bufsProcessed %= src.bufQueue.length
                                } else {
                                    AL.setSourceState(src, 4116);
                                    break
                                }
                            }
                            var buf = src.bufQueue[src.bufsProcessed];
                            if (buf.length > 0) {
                                nextStartTime = src.bufStartTime + buf.audioBuf.duration / src.playbackRate;
                                if (currentTime < nextStartTime) {
                                    src.bufOffset = (currentTime - src.bufStartTime) * src.playbackRate;
                                    break
                                }
                                src.bufStartTime = nextStartTime
                            }
                            src.bufOffset = 0;
                            src.bufsProcessed++
                        }
                    }
                    return currentTime
                },
                cancelPendingSourceAudio: function(src) {
                    AL.updateSourceTime(src);
                    for (var i = 1; i < src.audioQueue.length; i++) {
                        var audioSrc = src.audioQueue[i];
                        audioSrc.stop()
                    }
                    if (src.audioQueue.length > 1) {
                        src.audioQueue.length = 1
                    }
                },
                stopSourceAudio: function(src) {
                    for (var i = 0; i < src.audioQueue.length; i++) {
                        src.audioQueue[i].stop()
                    }
                    src.audioQueue.length = 0
                },
                setSourceState: function(src, state) {
                    if (state === 4114) {
                        if (src.state === 4114 || src.state == 4116) {
                            src.bufsProcessed = 0;
                            src.bufOffset = 0
                        } else {}
                        AL.stopSourceAudio(src);
                        src.state = 4114;
                        src.bufStartTime = Number.NEGATIVE_INFINITY;
                        AL.scheduleSourceAudio(src)
                    } else if (state === 4115) {
                        if (src.state === 4114) {
                            AL.updateSourceTime(src);
                            AL.stopSourceAudio(src);
                            src.state = 4115
                        }
                    } else if (state === 4116) {
                        if (src.state !== 4113) {
                            src.state = 4116;
                            src.bufsProcessed = src.bufQueue.length;
                            src.bufStartTime = Number.NEGATIVE_INFINITY;
                            src.bufOffset = 0;
                            AL.stopSourceAudio(src)
                        }
                    } else if (state === 4113) {
                        if (src.state !== 4113) {
                            src.state = 4113;
                            src.bufsProcessed = 0;
                            src.bufStartTime = Number.NEGATIVE_INFINITY;
                            src.bufOffset = 0;
                            AL.stopSourceAudio(src)
                        }
                    }
                },
                initSourcePanner: function(src) {
                    if (src.type === 4144) {
                        return
                    }
                    var templateBuf = AL.buffers[0];
                    for (var i = 0; i < src.bufQueue.length; i++) {
                        if (src.bufQueue[i].id !== 0) {
                            templateBuf = src.bufQueue[i];
                            break
                        }
                    }
                    if (src.spatialize === 1 || src.spatialize === 2 && templateBuf.channels === 1) {
                        if (src.panner) {
                            return
                        }
                        src.panner = src.context.audioCtx.createPanner();
                        AL.updateSourceGlobal(src);
                        AL.updateSourceSpace(src);
                        src.panner.connect(src.context.gain);
                        src.gain.disconnect();
                        src.gain.connect(src.panner)
                    } else {
                        if (!src.panner) {
                            return
                        }
                        src.panner.disconnect();
                        src.gain.disconnect();
                        src.gain.connect(src.context.gain);
                        src.panner = null
                    }
                },
                updateContextGlobal: function(ctx) {
                    for (var i in ctx.sources) {
                        AL.updateSourceGlobal(ctx.sources[i])
                    }
                },
                updateSourceGlobal: function(src) {
                    var panner = src.panner;
                    if (!panner) {
                        return
                    }
                    panner.refDistance = src.refDistance;
                    panner.maxDistance = src.maxDistance;
                    panner.rolloffFactor = src.rolloffFactor;
                    panner.panningModel = src.context.hrtf ? "HRTF" : "equalpower";
                    var distanceModel = src.context.sourceDistanceModel ? src.distanceModel : src.context.distanceModel;
                    switch (distanceModel) {
                        case 0:
                            panner.distanceModel = "inverse";
                            panner.refDistance = 3.40282e38;
                            break;
                        case 53249:
                        case 53250:
                            panner.distanceModel = "inverse";
                            break;
                        case 53251:
                        case 53252:
                            panner.distanceModel = "linear";
                            break;
                        case 53253:
                        case 53254:
                            panner.distanceModel = "exponential";
                            break
                    }
                },
                updateListenerSpace: function(ctx) {
                    var listener = ctx.audioCtx.listener;
                    if (listener.positionX) {
                        listener.positionX.value = ctx.listener.position[0];
                        listener.positionY.value = ctx.listener.position[1];
                        listener.positionZ.value = ctx.listener.position[2]
                    } else {
                        listener.setPosition(ctx.listener.position[0], ctx.listener.position[1], ctx.listener.position[2])
                    }
                    if (listener.forwardX) {
                        listener.forwardX.value = ctx.listener.direction[0];
                        listener.forwardY.value = ctx.listener.direction[1];
                        listener.forwardZ.value = ctx.listener.direction[2];
                        listener.upX.value = ctx.listener.up[0];
                        listener.upY.value = ctx.listener.up[1];
                        listener.upZ.value = ctx.listener.up[2]
                    } else {
                        listener.setOrientation(ctx.listener.direction[0], ctx.listener.direction[1], ctx.listener.direction[2], ctx.listener.up[0], ctx.listener.up[1], ctx.listener.up[2])
                    }
                    for (var i in ctx.sources) {
                        AL.updateSourceSpace(ctx.sources[i])
                    }
                },
                updateSourceSpace: function(src) {
                    if (!src.panner) {
                        return
                    }
                    var panner = src.panner;
                    var posX = src.position[0];
                    var posY = src.position[1];
                    var posZ = src.position[2];
                    var dirX = src.direction[0];
                    var dirY = src.direction[1];
                    var dirZ = src.direction[2];
                    var listener = src.context.listener;
                    var lPosX = listener.position[0];
                    var lPosY = listener.position[1];
                    var lPosZ = listener.position[2];
                    if (src.relative) {
                        var lBackX = -listener.direction[0];
                        var lBackY = -listener.direction[1];
                        var lBackZ = -listener.direction[2];
                        var lUpX = listener.up[0];
                        var lUpY = listener.up[1];
                        var lUpZ = listener.up[2];
                        var inverseMagnitude = function(x, y, z) {
                            var length = Math.sqrt(x * x + y * y + z * z);
                            if (length < Number.EPSILON) {
                                return 0
                            }
                            return 1 / length
                        };
                        var invMag = inverseMagnitude(lBackX, lBackY, lBackZ);
                        lBackX *= invMag;
                        lBackY *= invMag;
                        lBackZ *= invMag;
                        invMag = inverseMagnitude(lUpX, lUpY, lUpZ);
                        lUpX *= invMag;
                        lUpY *= invMag;
                        lUpZ *= invMag;
                        var lRightX = lUpY * lBackZ - lUpZ * lBackY;
                        var lRightY = lUpZ * lBackX - lUpX * lBackZ;
                        var lRightZ = lUpX * lBackY - lUpY * lBackX;
                        invMag = inverseMagnitude(lRightX, lRightY, lRightZ);
                        lRightX *= invMag;
                        lRightY *= invMag;
                        lRightZ *= invMag;
                        lUpX = lBackY * lRightZ - lBackZ * lRightY;
                        lUpY = lBackZ * lRightX - lBackX * lRightZ;
                        lUpZ = lBackX * lRightY - lBackY * lRightX;
                        var oldX = dirX;
                        var oldY = dirY;
                        var oldZ = dirZ;
                        dirX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
                        dirY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
                        dirZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
                        oldX = posX;
                        oldY = posY;
                        oldZ = posZ;
                        posX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
                        posY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
                        posZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
                        posX += lPosX;
                        posY += lPosY;
                        posZ += lPosZ
                    }
                    if (panner.positionX) {
                        panner.positionX.value = posX;
                        panner.positionY.value = posY;
                        panner.positionZ.value = posZ
                    } else {
                        panner.setPosition(posX, posY, posZ)
                    }
                    if (panner.orientationX) {
                        panner.orientationX.value = dirX;
                        panner.orientationY.value = dirY;
                        panner.orientationZ.value = dirZ
                    } else {
                        panner.setOrientation(dirX, dirY, dirZ)
                    }
                    var oldShift = src.dopplerShift;
                    var velX = src.velocity[0];
                    var velY = src.velocity[1];
                    var velZ = src.velocity[2];
                    var lVelX = listener.velocity[0];
                    var lVelY = listener.velocity[1];
                    var lVelZ = listener.velocity[2];
                    if (posX === lPosX && posY === lPosY && posZ === lPosZ || velX === lVelX && velY === lVelY && velZ === lVelZ) {
                        src.dopplerShift = 1
                    } else {
                        var speedOfSound = src.context.speedOfSound;
                        var dopplerFactor = src.context.dopplerFactor;
                        var slX = lPosX - posX;
                        var slY = lPosY - posY;
                        var slZ = lPosZ - posZ;
                        var magSl = Math.sqrt(slX * slX + slY * slY + slZ * slZ);
                        var vls = (slX * lVelX + slY * lVelY + slZ * lVelZ) / magSl;
                        var vss = (slX * velX + slY * velY + slZ * velZ) / magSl;
                        vls = Math.min(vls, speedOfSound / dopplerFactor);
                        vss = Math.min(vss, speedOfSound / dopplerFactor);
                        src.dopplerShift = (speedOfSound - dopplerFactor * vls) / (speedOfSound - dopplerFactor * vss)
                    }
                    if (src.dopplerShift !== oldShift) {
                        AL.updateSourceRate(src)
                    }
                },
                updateSourceRate: function(src) {
                    if (src.state === 4114) {
                        AL.cancelPendingSourceAudio(src);
                        var audioSrc = src.audioQueue[0];
                        if (!audioSrc) {
                            return
                        }
                        var duration;
                        if (src.type === 4136 && src.looping) {
                            duration = Number.POSITIVE_INFINITY
                        } else {
                            duration = (audioSrc.buffer.duration - audioSrc._startOffset) / src.playbackRate
                        }
                        audioSrc._duration = duration;
                        audioSrc.playbackRate.value = src.playbackRate;
                        AL.scheduleSourceAudio(src)
                    }
                },
                sourceDuration: function(src) {
                    var length = 0;
                    for (var i = 0; i < src.bufQueue.length; i++) {
                        var audioBuf = src.bufQueue[i].audioBuf;
                        length += audioBuf ? audioBuf.duration : 0
                    }
                    return length
                },
                sourceTell: function(src) {
                    AL.updateSourceTime(src);
                    var offset = 0;
                    for (var i = 0; i < src.bufsProcessed; i++) {
                        offset += src.bufQueue[i].audioBuf.duration
                    }
                    offset += src.bufOffset;
                    return offset
                },
                sourceSeek: function(src, offset) {
                    var playing = src.state == 4114;
                    if (playing) {
                        AL.setSourceState(src, 4113)
                    }
                    if (src.bufQueue[src.bufsProcessed].audioBuf !== null) {
                        src.bufsProcessed = 0;
                        while (offset > src.bufQueue[src.bufsProcessed].audioBuf.duration) {
                            offset -= src.bufQueue[src.bufsProcessed].audiobuf.duration;
                            src.bufsProcessed++
                        }
                        src.bufOffset = offset
                    }
                    if (playing) {
                        AL.setSourceState(src, 4114)
                    }
                },
                getGlobalParam: function(funcname, param) {
                    if (!AL.currentCtx) {
                        return null
                    }
                    switch (param) {
                        case 49152:
                            return AL.currentCtx.dopplerFactor;
                        case 49155:
                            return AL.currentCtx.speedOfSound;
                        case 53248:
                            return AL.currentCtx.distanceModel;
                        default:
                            AL.currentCtx.err = 40962;
                            return null
                    }
                },
                setGlobalParam: function(funcname, param, value) {
                    if (!AL.currentCtx) {
                        return
                    }
                    switch (param) {
                        case 49152:
                            if (!Number.isFinite(value) || value < 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            AL.currentCtx.dopplerFactor = value;
                            AL.updateListenerSpace(AL.currentCtx);
                            break;
                        case 49155:
                            if (!Number.isFinite(value) || value <= 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            AL.currentCtx.speedOfSound = value;
                            AL.updateListenerSpace(AL.currentCtx);
                            break;
                        case 53248:
                            switch (value) {
                                case 0:
                                case 53249:
                                case 53250:
                                case 53251:
                                case 53252:
                                case 53253:
                                case 53254:
                                    AL.currentCtx.distanceModel = value;
                                    AL.updateContextGlobal(AL.currentCtx);
                                    break;
                                default:
                                    AL.currentCtx.err = 40963;
                                    return
                            }
                            break;
                        default:
                            AL.currentCtx.err = 40962;
                            return
                    }
                },
                getListenerParam: function(funcname, param) {
                    if (!AL.currentCtx) {
                        return null
                    }
                    switch (param) {
                        case 4100:
                            return AL.currentCtx.listener.position;
                        case 4102:
                            return AL.currentCtx.listener.velocity;
                        case 4111:
                            return AL.currentCtx.listener.direction.concat(AL.currentCtx.listener.up);
                        case 4106:
                            return AL.currentCtx.gain.gain.value;
                        default:
                            AL.currentCtx.err = 40962;
                            return null
                    }
                },
                setListenerParam: function(funcname, param, value) {
                    if (!AL.currentCtx) {
                        return
                    }
                    if (value === null) {
                        AL.currentCtx.err = 40962;
                        return
                    }
                    var listener = AL.currentCtx.listener;
                    switch (param) {
                        case 4100:
                            if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            listener.position[0] = value[0];
                            listener.position[1] = value[1];
                            listener.position[2] = value[2];
                            AL.updateListenerSpace(AL.currentCtx);
                            break;
                        case 4102:
                            if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            listener.velocity[0] = value[0];
                            listener.velocity[1] = value[1];
                            listener.velocity[2] = value[2];
                            AL.updateListenerSpace(AL.currentCtx);
                            break;
                        case 4106:
                            if (!Number.isFinite(value) || value < 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            AL.currentCtx.gain.gain.value = value;
                            break;
                        case 4111:
                            if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2]) || !Number.isFinite(value[3]) || !Number.isFinite(value[4]) || !Number.isFinite(value[5])) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            listener.direction[0] = value[0];
                            listener.direction[1] = value[1];
                            listener.direction[2] = value[2];
                            listener.up[0] = value[3];
                            listener.up[1] = value[4];
                            listener.up[2] = value[5];
                            AL.updateListenerSpace(AL.currentCtx);
                            break;
                        default:
                            AL.currentCtx.err = 40962;
                            return
                    }
                },
                getBufferParam: function(funcname, bufferId, param) {
                    if (!AL.currentCtx) {
                        return
                    }
                    var buf = AL.buffers[bufferId];
                    if (!buf || bufferId === 0) {
                        AL.currentCtx.err = 40961;
                        return
                    }
                    switch (param) {
                        case 8193:
                            return buf.frequency;
                        case 8194:
                            return buf.bytesPerSample * 8;
                        case 8195:
                            return buf.channels;
                        case 8196:
                            return buf.length * buf.bytesPerSample * buf.channels;
                        case 8213:
                            if (buf.length === 0) {
                                return [0, 0]
                            } else {
                                return [(buf.audioBuf._loopStart || 0) * buf.frequency, (buf.audioBuf._loopEnd || buf.length) * buf.frequency]
                            }
                            default:
                                AL.currentCtx.err = 40962;
                                return null
                    }
                },
                setBufferParam: function(funcname, bufferId, param, value) {
                    if (!AL.currentCtx) {
                        return
                    }
                    var buf = AL.buffers[bufferId];
                    if (!buf || bufferId === 0) {
                        AL.currentCtx.err = 40961;
                        return
                    }
                    if (value === null) {
                        AL.currentCtx.err = 40962;
                        return
                    }
                    switch (param) {
                        case 8196:
                            if (value !== 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            break;
                        case 8213:
                            if (value[0] < 0 || value[0] > buf.length || value[1] < 0 || value[1] > buf.Length || value[0] >= value[1]) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            if (buf.refCount > 0) {
                                AL.currentCtx.err = 40964;
                                return
                            }
                            if (buf.audioBuf) {
                                buf.audioBuf._loopStart = value[0] / buf.frequency;
                                buf.audioBuf._loopEnd = value[1] / buf.frequency
                            }
                            break;
                        default:
                            AL.currentCtx.err = 40962;
                            return
                    }
                },
                getSourceParam: function(funcname, sourceId, param) {
                    if (!AL.currentCtx) {
                        return null
                    }
                    var src = AL.currentCtx.sources[sourceId];
                    if (!src) {
                        AL.currentCtx.err = 40961;
                        return null
                    }
                    switch (param) {
                        case 514:
                            return src.relative;
                        case 4097:
                            return src.coneInnerAngle;
                        case 4098:
                            return src.coneOuterAngle;
                        case 4099:
                            return src.pitch;
                        case 4100:
                            return src.position;
                        case 4101:
                            return src.direction;
                        case 4102:
                            return src.velocity;
                        case 4103:
                            return src.looping;
                        case 4105:
                            if (src.type === 4136) {
                                return src.bufQueue[0].id
                            } else {
                                return 0
                            }
                            case 4106:
                                return src.gain.gain.value;
                            case 4109:
                                return src.minGain;
                            case 4110:
                                return src.maxGain;
                            case 4112:
                                return src.state;
                            case 4117:
                                if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
                                    return 0
                                } else {
                                    return src.bufQueue.length
                                }
                                case 4118:
                                    if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0 || src.looping) {
                                        return 0
                                    } else {
                                        return src.bufsProcessed
                                    }
                                    case 4128:
                                        return src.refDistance;
                                    case 4129:
                                        return src.rolloffFactor;
                                    case 4130:
                                        return src.coneOuterGain;
                                    case 4131:
                                        return src.maxDistance;
                                    case 4132:
                                        return AL.sourceTell(src);
                                    case 4133:
                                        var offset = AL.sourceTell(src);
                                        if (offset > 0) {
                                            offset *= src.bufQueue[0].frequency
                                        }
                                        return offset;
                                    case 4134:
                                        var offset = AL.sourceTell(src);
                                        if (offset > 0) {
                                            offset *= src.bufQueue[0].frequency * src.bufQueue[0].bytesPerSample
                                        }
                                        return offset;
                                    case 4135:
                                        return src.type;
                                    case 4628:
                                        return src.spatialize;
                                    case 8201:
                                        var length = 0;
                                        var bytesPerFrame = 0;
                                        for (var i = 0; i < src.bufQueue.length; i++) {
                                            length += src.bufQueue[i].length;
                                            if (src.bufQueue[i].id !== 0) {
                                                bytesPerFrame = src.bufQueue[i].bytesPerSample * src.bufQueue[i].channels
                                            }
                                        }
                                        return length * bytesPerFrame;
                                    case 8202:
                                        var length = 0;
                                        for (var i = 0; i < src.bufQueue.length; i++) {
                                            length += src.bufQueue[i].length
                                        }
                                        return length;
                                    case 8203:
                                        return AL.sourceDuration(src);
                                    case 53248:
                                        return src.distanceModel;
                                    default:
                                        AL.currentCtx.err = 40962;
                                        return null
                    }
                },
                setSourceParam: function(funcname, sourceId, param, value) {
                    if (!AL.currentCtx) {
                        return
                    }
                    var src = AL.currentCtx.sources[sourceId];
                    if (!src) {
                        AL.currentCtx.err = 40961;
                        return
                    }
                    if (value === null) {
                        AL.currentCtx.err = 40962;
                        return
                    }
                    switch (param) {
                        case 514:
                            if (value === 1) {
                                src.relative = true;
                                AL.updateSourceSpace(src)
                            } else if (value === 0) {
                                src.relative = false;
                                AL.updateSourceSpace(src)
                            } else {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            break;
                        case 4097:
                            if (!Number.isFinite(value)) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.coneInnerAngle = value;
                            if (src.panner) {
                                src.panner.coneInnerAngle = value % 360
                            }
                            break;
                        case 4098:
                            if (!Number.isFinite(value)) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.coneOuterAngle = value;
                            if (src.panner) {
                                src.panner.coneOuterAngle = value % 360
                            }
                            break;
                        case 4099:
                            if (!Number.isFinite(value) || value <= 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            if (src.pitch === value) {
                                break
                            }
                            src.pitch = value;
                            AL.updateSourceRate(src);
                            break;
                        case 4100:
                            if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.position[0] = value[0];
                            src.position[1] = value[1];
                            src.position[2] = value[2];
                            AL.updateSourceSpace(src);
                            break;
                        case 4101:
                            if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.direction[0] = value[0];
                            src.direction[1] = value[1];
                            src.direction[2] = value[2];
                            AL.updateSourceSpace(src);
                            break;
                        case 4102:
                            if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.velocity[0] = value[0];
                            src.velocity[1] = value[1];
                            src.velocity[2] = value[2];
                            AL.updateSourceSpace(src);
                            break;
                        case 4103:
                            if (value === 1) {
                                src.looping = true;
                                AL.updateSourceTime(src);
                                if (src.type === 4136 && src.audioQueue.length > 0) {
                                    var audioSrc = src.audioQueue[0];
                                    audioSrc.loop = true;
                                    audioSrc._duration = Number.POSITIVE_INFINITY
                                }
                            } else if (value === 0) {
                                src.looping = false;
                                var currentTime = AL.updateSourceTime(src);
                                if (src.type === 4136 && src.audioQueue.length > 0) {
                                    var audioSrc = src.audioQueue[0];
                                    audioSrc.loop = false;
                                    audioSrc._duration = src.bufQueue[0].audioBuf.duration / src.playbackRate;
                                    audioSrc._startTime = currentTime - src.bufOffset / src.playbackRate
                                }
                            } else {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            break;
                        case 4105:
                            if (src.state === 4114 || src.state === 4115) {
                                AL.currentCtx.err = 40964;
                                return
                            }
                            if (value === 0) {
                                for (var i = 0; i < src.bufQueue.length; i++) {
                                    src.bufQueue[i].refCount--
                                }
                                src.bufQueue.length = 1;
                                src.bufQueue[0] = AL.buffers[0];
                                src.bufsProcessed = 0;
                                src.type = 4144
                            } else {
                                var buf = AL.buffers[value];
                                if (!buf) {
                                    AL.currentCtx.err = 40963;
                                    return
                                }
                                for (var i = 0; i < src.bufQueue.length; i++) {
                                    src.bufQueue[i].refCount--
                                }
                                src.bufQueue.length = 0;
                                buf.refCount++;
                                src.bufQueue = [buf];
                                src.bufsProcessed = 0;
                                src.type = 4136
                            }
                            AL.initSourcePanner(src);
                            AL.scheduleSourceAudio(src);
                            break;
                        case 4106:
                            if (!Number.isFinite(value) || value < 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.gain.gain.value = value;
                            break;
                        case 4109:
                            if (!Number.isFinite(value) || value < 0 || value > Math.min(src.maxGain, 1)) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.minGain = value;
                            break;
                        case 4110:
                            if (!Number.isFinite(value) || value < Math.max(0, src.minGain) || value > 1) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.maxGain = value;
                            break;
                        case 4128:
                            if (!Number.isFinite(value) || value < 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.refDistance = value;
                            if (src.panner) {
                                src.panner.refDistance = value
                            }
                            break;
                        case 4129:
                            if (!Number.isFinite(value) || value < 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.rolloffFactor = value;
                            if (src.panner) {
                                src.panner.rolloffFactor = value
                            }
                            break;
                        case 4130:
                            if (!Number.isFinite(value) || value < 0 || value > 1) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.coneOuterGain = value;
                            if (src.panner) {
                                src.panner.coneOuterGain = value
                            }
                            break;
                        case 4131:
                            if (!Number.isFinite(value) || value < 0) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.maxDistance = value;
                            if (src.panner) {
                                src.panner.maxDistance = value
                            }
                            break;
                        case 4132:
                            if (value < 0 || value > AL.sourceDuration(src)) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            AL.sourceSeek(src, value);
                            break;
                        case 4133:
                            var srcLen = AL.sourceDuration(src);
                            if (srcLen > 0) {
                                var frequency;
                                for (var bufId in src.bufQueue) {
                                    if (bufId) {
                                        frequency = src.bufQueue[bufId].frequency;
                                        break
                                    }
                                }
                                value /= frequency
                            }
                            if (value < 0 || value > srcLen) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            AL.sourceSeek(src, value);
                            break;
                        case 4134:
                            var srcLen = AL.sourceDuration(src);
                            if (srcLen > 0) {
                                var bytesPerSec;
                                for (var bufId in src.bufQueue) {
                                    if (bufId) {
                                        var buf = src.bufQueue[bufId];
                                        bytesPerSec = buf.frequency * buf.bytesPerSample * buf.channels;
                                        break
                                    }
                                }
                                value /= bytesPerSec
                            }
                            if (value < 0 || value > srcLen) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            AL.sourceSeek(src, value);
                            break;
                        case 4628:
                            if (value !== 0 && value !== 1 && value !== 2) {
                                AL.currentCtx.err = 40963;
                                return
                            }
                            src.spatialize = value;
                            AL.initSourcePanner(src);
                            break;
                        case 8201:
                        case 8202:
                        case 8203:
                            AL.currentCtx.err = 40964;
                            break;
                        case 53248:
                            switch (value) {
                                case 0:
                                case 53249:
                                case 53250:
                                case 53251:
                                case 53252:
                                case 53253:
                                case 53254:
                                    src.distanceModel = value;
                                    if (AL.currentCtx.sourceDistanceModel) {
                                        AL.updateContextGlobal(AL.currentCtx)
                                    }
                                    break;
                                default:
                                    AL.currentCtx.err = 40963;
                                    return
                            }
                            break;
                        default:
                            AL.currentCtx.err = 40962;
                            return
                    }
                },
                captures: {},
                sharedCaptureAudioCtx: null,
                requireValidCaptureDevice: function(deviceId, funcname) {
                    if (deviceId === 0) {
                        AL.alcErr = 40961;
                        return null
                    }
                    var c = AL.captures[deviceId];
                    if (!c) {
                        AL.alcErr = 40961;
                        return null
                    }
                    var err = c.mediaStreamError;
                    if (err) {
                        AL.alcErr = 40961;
                        return null
                    }
                    return c
                }
            };

            function _alBufferData(bufferId, format, pData, size, freq) {
                if (!AL.currentCtx) {
                    return
                }
                var buf = AL.buffers[bufferId];
                if (!buf) {
                    AL.currentCtx.err = 40963;
                    return
                }
                if (freq <= 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                var audioBuf = null;
                try {
                    switch (format) {
                        case 4352:
                            if (size > 0) {
                                audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size, freq);
                                var channel0 = audioBuf.getChannelData(0);
                                for (var i = 0; i < size; ++i) {
                                    channel0[i] = HEAPU8[pData++] * .0078125 - 1
                                }
                            }
                            buf.bytesPerSample = 1;
                            buf.channels = 1;
                            buf.length = size;
                            break;
                        case 4353:
                            if (size > 0) {
                                audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 1, freq);
                                var channel0 = audioBuf.getChannelData(0);
                                pData >>= 1;
                                for (var i = 0; i < size >> 1; ++i) {
                                    channel0[i] = HEAP16[pData++] * 30517578125e-15
                                }
                            }
                            buf.bytesPerSample = 2;
                            buf.channels = 1;
                            buf.length = size >> 1;
                            break;
                        case 4354:
                            if (size > 0) {
                                audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 1, freq);
                                var channel0 = audioBuf.getChannelData(0);
                                var channel1 = audioBuf.getChannelData(1);
                                for (var i = 0; i < size >> 1; ++i) {
                                    channel0[i] = HEAPU8[pData++] * .0078125 - 1;
                                    channel1[i] = HEAPU8[pData++] * .0078125 - 1
                                }
                            }
                            buf.bytesPerSample = 1;
                            buf.channels = 2;
                            buf.length = size >> 1;
                            break;
                        case 4355:
                            if (size > 0) {
                                audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 2, freq);
                                var channel0 = audioBuf.getChannelData(0);
                                var channel1 = audioBuf.getChannelData(1);
                                pData >>= 1;
                                for (var i = 0; i < size >> 2; ++i) {
                                    channel0[i] = HEAP16[pData++] * 30517578125e-15;
                                    channel1[i] = HEAP16[pData++] * 30517578125e-15
                                }
                            }
                            buf.bytesPerSample = 2;
                            buf.channels = 2;
                            buf.length = size >> 2;
                            break;
                        case 65552:
                            if (size > 0) {
                                audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 2, freq);
                                var channel0 = audioBuf.getChannelData(0);
                                pData >>= 2;
                                for (var i = 0; i < size >> 2; ++i) {
                                    channel0[i] = HEAPF32[pData++]
                                }
                            }
                            buf.bytesPerSample = 4;
                            buf.channels = 1;
                            buf.length = size >> 2;
                            break;
                        case 65553:
                            if (size > 0) {
                                audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 3, freq);
                                var channel0 = audioBuf.getChannelData(0);
                                var channel1 = audioBuf.getChannelData(1);
                                pData >>= 2;
                                for (var i = 0; i < size >> 3; ++i) {
                                    channel0[i] = HEAPF32[pData++];
                                    channel1[i] = HEAPF32[pData++]
                                }
                            }
                            buf.bytesPerSample = 4;
                            buf.channels = 2;
                            buf.length = size >> 3;
                            break;
                        default:
                            AL.currentCtx.err = 40963;
                            return
                    }
                    buf.frequency = freq;
                    buf.audioBuf = audioBuf
                } catch (e) {
                    AL.currentCtx.err = 40963;
                    return
                }
            }

            function _alDeleteBuffers(count, pBufferIds) {
                if (!AL.currentCtx) {
                    return
                }
                for (var i = 0; i < count; ++i) {
                    var bufId = HEAP32[pBufferIds + i * 4 >> 2];
                    if (bufId === 0) {
                        continue
                    }
                    if (!AL.buffers[bufId]) {
                        AL.currentCtx.err = 40961;
                        return
                    }
                    if (AL.buffers[bufId].refCount) {
                        AL.currentCtx.err = 40964;
                        return
                    }
                }
                for (var i = 0; i < count; ++i) {
                    var bufId = HEAP32[pBufferIds + i * 4 >> 2];
                    if (bufId === 0) {
                        continue
                    }
                    AL.deviceRefCounts[AL.buffers[bufId].deviceId]--;
                    delete AL.buffers[bufId];
                    AL.freeIds.push(bufId)
                }
            }

            function _alSourcei(sourceId, param, value) {
                switch (param) {
                    case 514:
                    case 4097:
                    case 4098:
                    case 4103:
                    case 4105:
                    case 4128:
                    case 4129:
                    case 4131:
                    case 4132:
                    case 4133:
                    case 4134:
                    case 4628:
                    case 8201:
                    case 8202:
                    case 53248:
                        AL.setSourceParam("alSourcei", sourceId, param, value);
                        break;
                    default:
                        AL.setSourceParam("alSourcei", sourceId, param, null);
                        break
                }
            }

            function _alDeleteSources(count, pSourceIds) {
                if (!AL.currentCtx) {
                    return
                }
                for (var i = 0; i < count; ++i) {
                    var srcId = HEAP32[pSourceIds + i * 4 >> 2];
                    if (!AL.currentCtx.sources[srcId]) {
                        AL.currentCtx.err = 40961;
                        return
                    }
                }
                for (var i = 0; i < count; ++i) {
                    var srcId = HEAP32[pSourceIds + i * 4 >> 2];
                    AL.setSourceState(AL.currentCtx.sources[srcId], 4116);
                    _alSourcei(srcId, 4105, 0);
                    delete AL.currentCtx.sources[srcId];
                    AL.freeIds.push(srcId)
                }
            }

            function _alGenBuffers(count, pBufferIds) {
                if (!AL.currentCtx) {
                    return
                }
                for (var i = 0; i < count; ++i) {
                    var buf = {
                        deviceId: AL.currentCtx.deviceId,
                        id: AL.newId(),
                        refCount: 0,
                        audioBuf: null,
                        frequency: 0,
                        bytesPerSample: 2,
                        channels: 1,
                        length: 0
                    };
                    AL.deviceRefCounts[buf.deviceId]++;
                    AL.buffers[buf.id] = buf;
                    HEAP32[pBufferIds + i * 4 >> 2] = buf.id
                }
            }

            function _alGenSources(count, pSourceIds) {
                if (!AL.currentCtx) {
                    return
                }
                for (var i = 0; i < count; ++i) {
                    var gain = AL.currentCtx.audioCtx.createGain();
                    gain.connect(AL.currentCtx.gain);
                    if (window.proc_gain) proc_gain(gain);
                    var src = {
                        context: AL.currentCtx,
                        id: AL.newId(),
                        type: 4144,
                        state: 4113,
                        bufQueue: [AL.buffers[0]],
                        audioQueue: [],
                        looping: false,
                        pitch: 1,
                        dopplerShift: 1,
                        gain: gain,
                        minGain: 0,
                        maxGain: 1,
                        panner: null,
                        bufsProcessed: 0,
                        bufStartTime: Number.NEGATIVE_INFINITY,
                        bufOffset: 0,
                        relative: false,
                        refDistance: 1,
                        maxDistance: 3.40282e38,
                        rolloffFactor: 1,
                        position: [0, 0, 0],
                        velocity: [0, 0, 0],
                        direction: [0, 0, 0],
                        coneOuterGain: 0,
                        coneInnerAngle: 360,
                        coneOuterAngle: 360,
                        distanceModel: 53250,
                        spatialize: 2,
                        get playbackRate() {
                            return this.pitch * this.dopplerShift
                        }
                    };
                    AL.currentCtx.sources[src.id] = src;
                    HEAP32[pSourceIds + i * 4 >> 2] = src.id
                }
            }

            function _alGetSourcei(sourceId, param, pValue) {
                var val = AL.getSourceParam("alGetSourcei", sourceId, param);
                if (val === null) {
                    return
                }
                if (!pValue) {
                    AL.currentCtx.err = 40963;
                    return
                }
                switch (param) {
                    case 514:
                    case 4097:
                    case 4098:
                    case 4103:
                    case 4105:
                    case 4112:
                    case 4117:
                    case 4118:
                    case 4128:
                    case 4129:
                    case 4131:
                    case 4132:
                    case 4133:
                    case 4134:
                    case 4135:
                    case 4628:
                    case 8201:
                    case 8202:
                    case 53248:
                        HEAP32[pValue >> 2] = val;
                        break;
                    default:
                        AL.currentCtx.err = 40962;
                        return
                }
            }

            function _alSource3i(sourceId, param, value0, value1, value2) {
                switch (param) {
                    case 4100:
                    case 4101:
                    case 4102:
                        AL.paramArray[0] = value0;
                        AL.paramArray[1] = value1;
                        AL.paramArray[2] = value2;
                        AL.setSourceParam("alSource3i", sourceId, param, AL.paramArray);
                        break;
                    default:
                        AL.setSourceParam("alSource3i", sourceId, param, null);
                        break
                }
            }

            function _alSourcePlay(sourceId) {
                if (!AL.currentCtx) {
                    return
                }
                var src = AL.currentCtx.sources[sourceId];
                if (!src) {
                    AL.currentCtx.err = 40961;
                    return
                }
                AL.setSourceState(src, 4114)
            }

            function _alSourceQueueBuffers(sourceId, count, pBufferIds) {
                if (!AL.currentCtx) {
                    return
                }
                var src = AL.currentCtx.sources[sourceId];
                if (!src) {
                    AL.currentCtx.err = 40961;
                    return
                }
                if (src.type === 4136) {
                    AL.currentCtx.err = 40964;
                    return
                }
                if (count === 0) {
                    return
                }
                var templateBuf = AL.buffers[0];
                for (var i = 0; i < src.bufQueue.length; i++) {
                    if (src.bufQueue[i].id !== 0) {
                        templateBuf = src.bufQueue[i];
                        break
                    }
                }
                for (var i = 0; i < count; ++i) {
                    var bufId = HEAP32[pBufferIds + i * 4 >> 2];
                    var buf = AL.buffers[bufId];
                    if (!buf) {
                        AL.currentCtx.err = 40961;
                        return
                    }
                    if (templateBuf.id !== 0 && (buf.frequency !== templateBuf.frequency || buf.bytesPerSample !== templateBuf.bytesPerSample || buf.channels !== templateBuf.channels)) {
                        AL.currentCtx.err = 40964
                    }
                }
                if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
                    src.bufQueue.length = 0
                }
                src.type = 4137;
                for (var i = 0; i < count; ++i) {
                    var bufId = HEAP32[pBufferIds + i * 4 >> 2];
                    var buf = AL.buffers[bufId];
                    buf.refCount++;
                    src.bufQueue.push(buf)
                }
                if (src.looping) {
                    AL.cancelPendingSourceAudio(src)
                }
                AL.initSourcePanner(src);
                AL.scheduleSourceAudio(src)
            }

            function _alSourceStop(sourceId) {
                if (!AL.currentCtx) {
                    return
                }
                var src = AL.currentCtx.sources[sourceId];
                if (!src) {
                    AL.currentCtx.err = 40961;
                    return
                }
                AL.setSourceState(src, 4116)
            }

            function _alSourceUnqueueBuffers(sourceId, count, pBufferIds) {
                if (!AL.currentCtx) {
                    return
                }
                var src = AL.currentCtx.sources[sourceId];
                if (!src) {
                    AL.currentCtx.err = 40961;
                    return
                }
                if (count > (src.bufQueue.length === 1 && src.bufQueue[0].id === 0 ? 0 : src.bufsProcessed)) {
                    AL.currentCtx.err = 40963;
                    return
                }
                if (count === 0) {
                    return
                }
                for (var i = 0; i < count; i++) {
                    var buf = src.bufQueue.shift();
                    buf.refCount--;
                    HEAP32[pBufferIds + i * 4 >> 2] = buf.id;
                    src.bufsProcessed--
                }
                if (src.bufQueue.length === 0) {
                    src.bufQueue.push(AL.buffers[0])
                }
                AL.initSourcePanner(src);
                AL.scheduleSourceAudio(src)
            }

            function _alSourcef(sourceId, param, value) {
                switch (param) {
                    case 4097:
                    case 4098:
                    case 4099:
                    case 4106:
                    case 4109:
                    case 4110:
                    case 4128:
                    case 4129:
                    case 4130:
                    case 4131:
                    case 4132:
                    case 4133:
                    case 4134:
                    case 8203:
                        AL.setSourceParam("alSourcef", sourceId, param, value);
                        break;
                    default:
                        AL.setSourceParam("alSourcef", sourceId, param, null);
                        break
                }
            }

            function _alcCloseDevice(deviceId) {
                if (!(deviceId in AL.deviceRefCounts) || AL.deviceRefCounts[deviceId] > 0) {
                    return 0
                }
                delete AL.deviceRefCounts[deviceId];
                AL.freeIds.push(deviceId);
                return 1
            }

            function _alcCreateContext(deviceId, pAttrList) {
                if (!(deviceId in AL.deviceRefCounts)) {
                    AL.alcErr = 40961;
                    return 0
                }
                var options = null;
                var attrs = [];
                var hrtf = null;
                pAttrList >>= 2;
                if (pAttrList) {
                    var attr = 0;
                    var val = 0;
                    while (true) {
                        attr = HEAP32[pAttrList++];
                        attrs.push(attr);
                        if (attr === 0) {
                            break
                        }
                        val = HEAP32[pAttrList++];
                        attrs.push(val);
                        switch (attr) {
                            case 4103:
                                if (!options) {
                                    options = {}
                                }
                                options.sampleRate = val;
                                break;
                            case 4112:
                            case 4113:
                                break;
                            case 6546:
                                switch (val) {
                                    case 0:
                                        hrtf = false;
                                        break;
                                    case 1:
                                        hrtf = true;
                                        break;
                                    case 2:
                                        break;
                                    default:
                                        AL.alcErr = 40964;
                                        return 0
                                }
                                break;
                            case 6550:
                                if (val !== 0) {
                                    AL.alcErr = 40964;
                                    return 0
                                }
                                break;
                            default:
                                AL.alcErr = 40964;
                                return 0
                        }
                    }
                }
                var AudioContext = window.AudioContext || window.webkitAudioContext;
                var ac = null;
                try {
                    if (options) {
                        ac = new AudioContext(options)
                    } else {
                        ac = new AudioContext
                    }
                } catch (e) {
                    if (e.name === "NotSupportedError") {
                        AL.alcErr = 40964
                    } else {
                        AL.alcErr = 40961
                    }
                    return 0
                }
                if (typeof ac.createGain === "undefined") {
                    ac.createGain = ac.createGainNode
                }
                var gain = ac.createGain();
                gain.connect(ac.destination);
                var ctx = {
                    deviceId: deviceId,
                    id: AL.newId(),
                    attrs: attrs,
                    audioCtx: ac,
                    listener: {
                        position: [0, 0, 0],
                        velocity: [0, 0, 0],
                        direction: [0, 0, 0],
                        up: [0, 0, 0]
                    },
                    sources: [],
                    interval: setInterval(function() {
                        AL.scheduleContextAudio(ctx)
                    }, AL.QUEUE_INTERVAL),
                    gain: gain,
                    distanceModel: 53250,
                    speedOfSound: 343.3,
                    dopplerFactor: 1,
                    sourceDistanceModel: false,
                    hrtf: hrtf || false,
                    _err: 0,
                    get err() {
                        return this._err
                    },
                    set err(val) {
                        if (this._err === 0 || val === 0) {
                            this._err = val
                        }
                    }
                };
                AL.deviceRefCounts[deviceId]++;
                AL.contexts[ctx.id] = ctx;
                if (hrtf !== null) {
                    for (var ctxId in AL.contexts) {
                        var c = AL.contexts[ctxId];
                        if (c.deviceId === deviceId) {
                            c.hrtf = hrtf;
                            AL.updateContextGlobal(c)
                        }
                    }
                }
                return ctx.id
            }

            function _alcDestroyContext(contextId) {
                var ctx = AL.contexts[contextId];
                if (AL.currentCtx === ctx) {
                    AL.alcErr = 40962;
                    return
                }
                if (AL.contexts[contextId].interval) {
                    clearInterval(AL.contexts[contextId].interval)
                }
                AL.deviceRefCounts[ctx.deviceId]--;
                delete AL.contexts[contextId];
                AL.freeIds.push(contextId)
            }

            function _alcGetIntegerv(deviceId, param, size, pValues) {
                if (size === 0 || !pValues) {
                    return
                }
                switch (param) {
                    case 4096:
                        HEAP32[pValues >> 2] = 1;
                        break;
                    case 4097:
                        HEAP32[pValues >> 2] = 1;
                        break;
                    case 4098:
                        if (!(deviceId in AL.deviceRefCounts)) {
                            AL.alcErr = 40961;
                            return
                        }
                        if (!AL.currentCtx) {
                            AL.alcErr = 40962;
                            return
                        }
                        HEAP32[pValues >> 2] = AL.currentCtx.attrs.length;
                        break;
                    case 4099:
                        if (!(deviceId in AL.deviceRefCounts)) {
                            AL.alcErr = 40961;
                            return
                        }
                        if (!AL.currentCtx) {
                            AL.alcErr = 40962;
                            return
                        }
                        for (var i = 0; i < AL.currentCtx.attrs.length; i++) {
                            HEAP32[pValues + i * 4 >> 2] = AL.currentCtx.attrs[i]
                        }
                        break;
                    case 4103:
                        if (!(deviceId in AL.deviceRefCounts)) {
                            AL.alcErr = 40961;
                            return
                        }
                        if (!AL.currentCtx) {
                            AL.alcErr = 40962;
                            return
                        }
                        HEAP32[pValues >> 2] = AL.currentCtx.audioCtx.sampleRate;
                        break;
                    case 4112:
                    case 4113:
                        if (!(deviceId in AL.deviceRefCounts)) {
                            AL.alcErr = 40961;
                            return
                        }
                        if (!AL.currentCtx) {
                            AL.alcErr = 40962;
                            return
                        }
                        HEAP32[pValues >> 2] = 2147483647;
                        break;
                    case 6546:
                    case 6547:
                        if (!(deviceId in AL.deviceRefCounts)) {
                            AL.alcErr = 40961;
                            return
                        }
                        var hrtfStatus = 0;
                        for (var ctxId in AL.contexts) {
                            var ctx = AL.contexts[ctxId];
                            if (ctx.deviceId === deviceId) {
                                hrtfStatus = ctx.hrtf ? 1 : 0
                            }
                        }
                        HEAP32[pValues >> 2] = hrtfStatus;
                        break;
                    case 6548:
                        if (!(deviceId in AL.deviceRefCounts)) {
                            AL.alcErr = 40961;
                            return
                        }
                        HEAP32[pValues >> 2] = 1;
                        break;
                    case 131075:
                        if (!(deviceId in AL.deviceRefCounts)) {
                            AL.alcErr = 40961;
                            return
                        }
                        if (!AL.currentCtx) {
                            AL.alcErr = 40962;
                            return
                        }
                        HEAP32[pValues >> 2] = 1;
                    case 786:
                        var c = AL.requireValidCaptureDevice(deviceId, "alcGetIntegerv");
                        if (!c) {
                            return
                        }
                        var n = c.capturedFrameCount;
                        var dstfreq = c.requestedSampleRate;
                        var srcfreq = c.audioCtx.sampleRate;
                        var nsamples = Math.floor(n * (dstfreq / srcfreq));
                        HEAP32[pValues >> 2] = nsamples;
                        break;
                    default:
                        AL.alcErr = 40963;
                        return
                }
            }

            function _alcMakeContextCurrent(contextId) {
                if (contextId === 0) {
                    AL.currentCtx = null;
                    return 0
                } else {
                    AL.currentCtx = AL.contexts[contextId];
                    return 1
                }
            }

            function _alcOpenDevice(pDeviceName) {
                if (pDeviceName) {
                    var name = UTF8ToString(pDeviceName);
                    if (name !== AL.DEVICE_NAME) {
                        return 0
                    }
                }
                if (typeof AudioContext !== "undefined" || typeof webkitAudioContext !== "undefined") {
                    var deviceId = AL.newId();
                    AL.deviceRefCounts[deviceId] = 0;
                    return deviceId
                } else {
                    return 0
                }
            }
            var _emscripten_get_now_is_monotonic = true;

            function _clock_gettime(clk_id, tp) {
                var now;
                if (clk_id === 0) {
                    now = Date.now()
                } else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) {
                    now = _emscripten_get_now()
                } else {
                    setErrNo(28);
                    return -1
                }
                HEAP32[tp >> 2] = now / 1e3 | 0;
                HEAP32[tp + 4 >> 2] = now % 1e3 * 1e3 * 1e3 | 0;
                return 0
            }

            function _dlclose(handle) {
                abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking")
            }
            var EGL = {
                errorCode: 12288,
                defaultDisplayInitialized: false,
                currentContext: 0,
                currentReadSurface: 0,
                currentDrawSurface: 0,
                contextAttributes: {
                    alpha: false,
                    depth: false,
                    stencil: false,
                    antialias: false
                },
                stringCache: {},
                setErrorCode: function(code) {
                    EGL.errorCode = code
                },
                chooseConfig: function(display, attribList, config, config_size, numConfigs) {
                    if (display != 62e3) {
                        EGL.setErrorCode(12296);
                        return 0
                    }
                    if (attribList) {
                        for (;;) {
                            var param = HEAP32[attribList >> 2];
                            if (param == 12321) {
                                var alphaSize = HEAP32[attribList + 4 >> 2];
                                EGL.contextAttributes.alpha = alphaSize > 0
                            } else if (param == 12325) {
                                var depthSize = HEAP32[attribList + 4 >> 2];
                                EGL.contextAttributes.depth = depthSize > 0
                            } else if (param == 12326) {
                                var stencilSize = HEAP32[attribList + 4 >> 2];
                                EGL.contextAttributes.stencil = stencilSize > 0
                            } else if (param == 12337) {
                                var samples = HEAP32[attribList + 4 >> 2];
                                EGL.contextAttributes.antialias = samples > 0
                            } else if (param == 12338) {
                                var samples = HEAP32[attribList + 4 >> 2];
                                EGL.contextAttributes.antialias = samples == 1
                            } else if (param == 12544) {
                                var requestedPriority = HEAP32[attribList + 4 >> 2];
                                EGL.contextAttributes.lowLatency = requestedPriority != 12547
                            } else if (param == 12344) {
                                break
                            }
                            attribList += 8
                        }
                    }
                    if ((!config || !config_size) && !numConfigs) {
                        EGL.setErrorCode(12300);
                        return 0
                    }
                    if (numConfigs) {
                        HEAP32[numConfigs >> 2] = 1
                    }
                    if (config && config_size > 0) {
                        HEAP32[config >> 2] = 62002
                    }
                    EGL.setErrorCode(12288);
                    return 1
                }
            };

            function _eglBindAPI(api) {
                if (api == 12448) {
                    EGL.setErrorCode(12288);
                    return 1
                } else {
                    EGL.setErrorCode(12300);
                    return 0
                }
            }

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

            function __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) {
                return !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"))
            }
            var GL = {
                counter: 1,
                lastError: 0,
                buffers: [],
                mappedBuffers: {},
                programs: [],
                framebuffers: [],
                renderbuffers: [],
                textures: [],
                uniforms: [],
                shaders: [],
                vaos: [],
                contexts: [],
                currentContext: null,
                offscreenCanvases: {},
                timerQueriesEXT: [],
                queries: [],
                samplers: [],
                transformFeedbacks: [],
                syncs: [],
                programInfos: {},
                stringCache: {},
                stringiCache: {},
                unpackAlignment: 4,
                init: function() {
                    var miniTempFloatBuffer = new Float32Array(GL.MINI_TEMP_BUFFER_SIZE);
                    for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) {
                        GL.miniTempBufferFloatViews[i] = miniTempFloatBuffer.subarray(0, i + 1)
                    }
                    var miniTempIntBuffer = new Int32Array(GL.MINI_TEMP_BUFFER_SIZE);
                    for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) {
                        GL.miniTempBufferIntViews[i] = miniTempIntBuffer.subarray(0, i + 1)
                    }
                },
                recordError: function recordError(errorCode) {
                    if (!GL.lastError) {
                        GL.lastError = errorCode
                    }
                },
                getNewId: function(table) {
                    var ret = GL.counter++;
                    for (var i = table.length; i < ret; i++) {
                        table[i] = null
                    }
                    return ret
                },
                MINI_TEMP_BUFFER_SIZE: 256,
                miniTempBufferFloatViews: [0],
                miniTempBufferIntViews: [0],
                getSource: function(shader, count, string, length) {
                    var source = "";
                    for (var i = 0; i < count; ++i) {
                        var len = length ? HEAP32[length + i * 4 >> 2] : -1;
                        source += UTF8ToString(HEAP32[string + i * 4 >> 2], len < 0 ? undefined : len)
                    }
                    return source
                },
                createContext: function(canvas, webGLContextAttributes) {
                    var ctx = webGLContextAttributes.majorVersion > 1 ? canvas.getContext("webgl2", webGLContextAttributes) : canvas.getContext("webgl", webGLContextAttributes);
                    if (!ctx) return 0;
                    var handle = GL.registerContext(ctx, webGLContextAttributes);
                    return handle
                },
                registerContext: function(ctx, webGLContextAttributes) {
                    var handle = GL.getNewId(GL.contexts);
                    var context = {
                        handle: handle,
                        attributes: webGLContextAttributes,
                        version: webGLContextAttributes.majorVersion,
                        GLctx: ctx
                    };
                    if (ctx.canvas) ctx.canvas.GLctxObject = context;
                    GL.contexts[handle] = context;
                    if (typeof webGLContextAttributes.enableExtensionsByDefault === "undefined" || webGLContextAttributes.enableExtensionsByDefault) {
                        GL.initExtensions(context)
                    }
                    return handle
                },
                makeContextCurrent: function(contextHandle) {
                    GL.currentContext = GL.contexts[contextHandle];
                    Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx;
                    return !(contextHandle && !GLctx)
                },
                getContext: function(contextHandle) {
                    return GL.contexts[contextHandle]
                },
                deleteContext: function(contextHandle) {
                    if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null;
                    if (typeof JSEvents === "object") JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
                    if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
                    GL.contexts[contextHandle] = null
                },
                initExtensions: function(context) {
                    if (!context) context = GL.currentContext;
                    if (context.initExtensionsDone) return;
                    context.initExtensionsDone = true;
                    var GLctx = context.GLctx;
                    __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);
                    GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
                    var automaticallyEnabledExtensions = ["OES_texture_float", "OES_texture_half_float", "OES_standard_derivatives", "OES_vertex_array_object", "WEBGL_compressed_texture_s3tc", "WEBGL_depth_texture", "OES_element_index_uint", "EXT_texture_filter_anisotropic", "EXT_frag_depth", "WEBGL_draw_buffers", "ANGLE_instanced_arrays", "OES_texture_float_linear", "OES_texture_half_float_linear", "EXT_blend_minmax", "EXT_shader_texture_lod", "EXT_texture_norm16", "WEBGL_compressed_texture_pvrtc", "EXT_color_buffer_half_float", "WEBGL_color_buffer_float", "EXT_sRGB", "WEBGL_compressed_texture_etc1", "EXT_disjoint_timer_query", "WEBGL_compressed_texture_etc", "WEBGL_compressed_texture_astc", "EXT_color_buffer_float", "WEBGL_compressed_texture_s3tc_srgb", "EXT_disjoint_timer_query_webgl2", "WEBKIT_WEBGL_compressed_texture_pvrtc"];
                    var exts = GLctx.getSupportedExtensions() || [];
                    exts.forEach(function(ext) {
                        if (automaticallyEnabledExtensions.indexOf(ext) != -1) {
                            GLctx.getExtension(ext)
                        }
                    })
                },
                populateUniformTable: function(program) {
                    var p = GL.programs[program];
                    var ptable = GL.programInfos[program] = {
                        uniforms: {},
                        maxUniformLength: 0,
                        maxAttributeLength: -1,
                        maxUniformBlockNameLength: -1
                    };
                    var utable = ptable.uniforms;
                    var numUniforms = GLctx.getProgramParameter(p, 35718);
                    for (var i = 0; i < numUniforms; ++i) {
                        var u = GLctx.getActiveUniform(p, i);
                        var name = u.name;
                        ptable.maxUniformLength = Math.max(ptable.maxUniformLength, name.length + 1);
                        if (name.slice(-1) == "]") {
                            name = name.slice(0, name.lastIndexOf("["))
                        }
                        var loc = GLctx.getUniformLocation(p, name);
                        if (loc) {
                            var id = GL.getNewId(GL.uniforms);
                            utable[name] = [u.size, id];
                            GL.uniforms[id] = loc;
                            for (var j = 1; j < u.size; ++j) {
                                var n = name + "[" + j + "]";
                                loc = GLctx.getUniformLocation(p, n);
                                id = GL.getNewId(GL.uniforms);
                                GL.uniforms[id] = loc
                            }
                        }
                    }
                }
            };

            function _eglCreateContext(display, config, hmm, contextAttribs) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                var glesContextVersion = 1;
                for (;;) {
                    var param = HEAP32[contextAttribs >> 2];
                    if (param == 12440) {
                        glesContextVersion = HEAP32[contextAttribs + 4 >> 2]
                    } else if (param == 12344) {
                        break
                    } else {
                        EGL.setErrorCode(12292);
                        return 0
                    }
                    contextAttribs += 8
                }
                if (glesContextVersion < 2 || glesContextVersion > 3) {
                    EGL.setErrorCode(12293);
                    return 0
                }
                EGL.contextAttributes.majorVersion = glesContextVersion - 1;
                EGL.contextAttributes.minorVersion = 0;
                EGL.context = GL.createContext(Module["canvas"], EGL.contextAttributes);
                if (EGL.context != 0) {
                    EGL.setErrorCode(12288);
                    GL.makeContextCurrent(EGL.context);
                    Module.useWebGL = true;
                    Browser.moduleContextCreatedCallbacks.forEach(function(callback) {
                        callback()
                    });
                    GL.makeContextCurrent(null);
                    return 62004
                } else {
                    EGL.setErrorCode(12297);
                    return 0
                }
            }

            function _eglCreateWindowSurface(display, config, win, attrib_list) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                if (config != 62002) {
                    EGL.setErrorCode(12293);
                    return 0
                }
                EGL.setErrorCode(12288);
                return 62006
            }

            function _eglDestroyContext(display, context) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                if (context != 62004) {
                    EGL.setErrorCode(12294);
                    return 0
                }
                GL.deleteContext(EGL.context);
                EGL.setErrorCode(12288);
                if (EGL.currentContext == context) {
                    EGL.currentContext = 0
                }
                return 1
            }

            function _eglDestroySurface(display, surface) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                if (surface != 62006) {
                    EGL.setErrorCode(12301);
                    return 1
                }
                if (EGL.currentReadSurface == surface) {
                    EGL.currentReadSurface = 0
                }
                if (EGL.currentDrawSurface == surface) {
                    EGL.currentDrawSurface = 0
                }
                EGL.setErrorCode(12288);
                return 1
            }

            function _eglGetConfigAttrib(display, config, attribute, value) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                if (config != 62002) {
                    EGL.setErrorCode(12293);
                    return 0
                }
                if (!value) {
                    EGL.setErrorCode(12300);
                    return 0
                }
                EGL.setErrorCode(12288);
                switch (attribute) {
                    case 12320:
                        HEAP32[value >> 2] = EGL.contextAttributes.alpha ? 32 : 24;
                        return 1;
                    case 12321:
                        HEAP32[value >> 2] = EGL.contextAttributes.alpha ? 8 : 0;
                        return 1;
                    case 12322:
                        HEAP32[value >> 2] = 8;
                        return 1;
                    case 12323:
                        HEAP32[value >> 2] = 8;
                        return 1;
                    case 12324:
                        HEAP32[value >> 2] = 8;
                        return 1;
                    case 12325:
                        HEAP32[value >> 2] = EGL.contextAttributes.depth ? 24 : 0;
                        return 1;
                    case 12326:
                        HEAP32[value >> 2] = EGL.contextAttributes.stencil ? 8 : 0;
                        return 1;
                    case 12327:
                        HEAP32[value >> 2] = 12344;
                        return 1;
                    case 12328:
                        HEAP32[value >> 2] = 62002;
                        return 1;
                    case 12329:
                        HEAP32[value >> 2] = 0;
                        return 1;
                    case 12330:
                        HEAP32[value >> 2] = 4096;
                        return 1;
                    case 12331:
                        HEAP32[value >> 2] = 16777216;
                        return 1;
                    case 12332:
                        HEAP32[value >> 2] = 4096;
                        return 1;
                    case 12333:
                        HEAP32[value >> 2] = 0;
                        return 1;
                    case 12334:
                        HEAP32[value >> 2] = 0;
                        return 1;
                    case 12335:
                        HEAP32[value >> 2] = 12344;
                        return 1;
                    case 12337:
                        HEAP32[value >> 2] = EGL.contextAttributes.antialias ? 4 : 0;
                        return 1;
                    case 12338:
                        HEAP32[value >> 2] = EGL.contextAttributes.antialias ? 1 : 0;
                        return 1;
                    case 12339:
                        HEAP32[value >> 2] = 4;
                        return 1;
                    case 12340:
                        HEAP32[value >> 2] = 12344;
                        return 1;
                    case 12341:
                    case 12342:
                    case 12343:
                        HEAP32[value >> 2] = -1;
                        return 1;
                    case 12345:
                    case 12346:
                        HEAP32[value >> 2] = 0;
                        return 1;
                    case 12347:
                        HEAP32[value >> 2] = 0;
                        return 1;
                    case 12348:
                        HEAP32[value >> 2] = 1;
                        return 1;
                    case 12349:
                    case 12350:
                        HEAP32[value >> 2] = 0;
                        return 1;
                    case 12351:
                        HEAP32[value >> 2] = 12430;
                        return 1;
                    case 12352:
                        HEAP32[value >> 2] = 4;
                        return 1;
                    case 12354:
                        HEAP32[value >> 2] = 0;
                        return 1;
                    default:
                        EGL.setErrorCode(12292);
                        return 0
                }
            }

            function _eglGetDisplay(nativeDisplayType) {
                EGL.setErrorCode(12288);
                return 62e3
            }

            function _eglGetError() {
                return EGL.errorCode
            }

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

            function _eglInitialize(display, majorVersion, minorVersion) {
                if (display == 62e3) {
                    if (majorVersion) {
                        HEAP32[majorVersion >> 2] = 1
                    }
                    if (minorVersion) {
                        HEAP32[minorVersion >> 2] = 4
                    }
                    EGL.defaultDisplayInitialized = true;
                    EGL.setErrorCode(12288);
                    return 1
                } else {
                    EGL.setErrorCode(12296);
                    return 0
                }
            }

            function _eglMakeCurrent(display, draw, read, context) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                if (context != 0 && context != 62004) {
                    EGL.setErrorCode(12294);
                    return 0
                }
                if (read != 0 && read != 62006 || draw != 0 && draw != 62006) {
                    EGL.setErrorCode(12301);
                    return 0
                }
                GL.makeContextCurrent(context ? EGL.context : null);
                EGL.currentContext = context;
                EGL.currentDrawSurface = draw;
                EGL.currentReadSurface = read;
                EGL.setErrorCode(12288);
                return 1
            }

            function _eglQueryString(display, name) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                EGL.setErrorCode(12288);
                if (EGL.stringCache[name]) return EGL.stringCache[name];
                var ret;
                switch (name) {
                    case 12371:
                        ret = allocateUTF8("Emscripten");
                        break;
                    case 12372:
                        ret = allocateUTF8("1.4 Emscripten EGL");
                        break;
                    case 12373:
                        ret = allocateUTF8("");
                        break;
                    case 12429:
                        ret = allocateUTF8("OpenGL_ES");
                        break;
                    default:
                        EGL.setErrorCode(12300);
                        return 0
                }
                EGL.stringCache[name] = ret;
                return ret
            }

            function _eglSwapBuffers() {
                if (!EGL.defaultDisplayInitialized) {
                    EGL.setErrorCode(12289)
                } else if (!Module.ctx) {
                    EGL.setErrorCode(12290)
                } else if (Module.ctx.isContextLost()) {
                    EGL.setErrorCode(12302)
                } else {
                    EGL.setErrorCode(12288);
                    return 1
                }
                return 0
            }

            function _eglSwapInterval(display, interval) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                if (interval == 0) _emscripten_set_main_loop_timing(0, 0);
                else _emscripten_set_main_loop_timing(1, interval);
                EGL.setErrorCode(12288);
                return 1
            }

            function _eglTerminate(display) {
                if (display != 62e3) {
                    EGL.setErrorCode(12296);
                    return 0
                }
                EGL.currentContext = 0;
                EGL.currentReadSurface = 0;
                EGL.currentDrawSurface = 0;
                EGL.defaultDisplayInitialized = false;
                EGL.setErrorCode(12288);
                return 1
            }

            function _eglWaitClient() {
                EGL.setErrorCode(12288);
                return 1
            }

            function _eglWaitGL() {
                return _eglWaitClient()
            }

            function _eglWaitNative(nativeEngineId) {
                EGL.setErrorCode(12288);
                return 1
            }

            function _emscripten_cancel_main_loop() {
                Browser.mainLoop.pause();
                Browser.mainLoop.func = null
            }
            var JSEvents = {
                keyEvent: 0,
                mouseEvent: 0,
                wheelEvent: 0,
                uiEvent: 0,
                focusEvent: 0,
                deviceOrientationEvent: 0,
                deviceMotionEvent: 0,
                fullscreenChangeEvent: 0,
                pointerlockChangeEvent: 0,
                visibilityChangeEvent: 0,
                touchEvent: 0,
                previousFullscreenElement: null,
                previousScreenX: null,
                previousScreenY: null,
                removeEventListenersRegistered: false,
                removeAllEventListeners: function() {
                    for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) {
                        JSEvents._removeHandler(i)
                    }
                    JSEvents.eventHandlers = [];
                    JSEvents.deferredCalls = []
                },
                registerRemoveEventListeners: function() {
                    if (!JSEvents.removeEventListenersRegistered) {
                        __ATEXIT__.push(JSEvents.removeAllEventListeners);
                        JSEvents.removeEventListenersRegistered = true
                    }
                },
                deferredCalls: [],
                deferCall: function(targetFunction, precedence, argsList) {
                    function arraysHaveEqualContent(arrA, arrB) {
                        if (arrA.length != arrB.length) return false;
                        for (var i in arrA) {
                            if (arrA[i] != arrB[i]) return false
                        }
                        return true
                    }
                    for (var i in JSEvents.deferredCalls) {
                        var call = JSEvents.deferredCalls[i];
                        if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
                            return
                        }
                    }
                    JSEvents.deferredCalls.push({
                        targetFunction: targetFunction,
                        precedence: precedence,
                        argsList: argsList
                    });
                    JSEvents.deferredCalls.sort(function(x, y) {
                        return x.precedence < y.precedence
                    })
                },
                removeDeferredCalls: function(targetFunction) {
                    for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
                        if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
                            JSEvents.deferredCalls.splice(i, 1);
                            --i
                        }
                    }
                },
                canPerformEventHandlerRequests: function() {
                    return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls
                },
                runDeferredCalls: function() {
                    if (!JSEvents.canPerformEventHandlerRequests()) {
                        return
                    }
                    for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
                        var call = JSEvents.deferredCalls[i];
                        JSEvents.deferredCalls.splice(i, 1);
                        --i;
                        call.targetFunction.apply(null, call.argsList)
                    }
                },
                inEventHandler: 0,
                currentEventHandler: null,
                eventHandlers: [],
                removeAllHandlersOnTarget: function(target, eventTypeString) {
                    for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
                        if (JSEvents.eventHandlers[i].target == target && (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
                            JSEvents._removeHandler(i--)
                        }
                    }
                },
                _removeHandler: function(i) {
                    var h = JSEvents.eventHandlers[i];
                    h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
                    JSEvents.eventHandlers.splice(i, 1)
                },
                registerOrRemoveHandler: function(eventHandler) {
                    var jsEventHandler = function jsEventHandler(event) {
                        ++JSEvents.inEventHandler;
                        JSEvents.currentEventHandler = eventHandler;
                        JSEvents.runDeferredCalls();
                        eventHandler.handlerFunc(event);
                        JSEvents.runDeferredCalls();
                        --JSEvents.inEventHandler
                    };
                    if (eventHandler.callbackfunc) {
                        eventHandler.eventListenerFunc = jsEventHandler;
                        eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
                        JSEvents.eventHandlers.push(eventHandler);
                        JSEvents.registerRemoveEventListeners()
                    } else {
                        for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
                            if (JSEvents.eventHandlers[i].target == eventHandler.target && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
                                JSEvents._removeHandler(i--)
                            }
                        }
                    }
                },
                getNodeNameForTarget: function(target) {
                    if (!target) return "";
                    if (target == window) return "#window";
                    if (target == screen) return "#screen";
                    return target && target.nodeName ? target.nodeName : ""
                },
                fullscreenEnabled: function() {
                    return document.fullscreenEnabled || document.webkitFullscreenEnabled
                }
            };
            var __currentFullscreenStrategy = {};

            function __maybeCStringToJsString(cString) {
                return cString > 2 ? UTF8ToString(cString) : cString
            }
            var specialHTMLTargets = [0, document, window];

            function __findEventTarget(target) {
                target = __maybeCStringToJsString(target);
                var domElement = specialHTMLTargets[target] || document.querySelector(target);
                return domElement
            }

            function __findCanvasEventTarget(target) {
                return __findEventTarget(target)
            }

            function _emscripten_get_canvas_element_size(target, width, height) {
                var canvas = __findCanvasEventTarget(target);
                if (!canvas) return -4;
                HEAP32[width >> 2] = canvas.width;
                HEAP32[height >> 2] = canvas.height
            }

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

            function _emscripten_set_canvas_element_size(target, width, height) {
                var canvas = __findCanvasEventTarget(target);
                if (!canvas) return -4;
                canvas.width = width;
                canvas.height = height;
                return 0
            }

            function __set_canvas_element_size(target, width, height) {
                if (!target.controlTransferredOffscreen) {
                    target.width = width;
                    target.height = height
                } else {
                    var stackTop = stackSave();
                    var targetInt = stackAlloc(target.id.length + 1);
                    stringToUTF8(target.id, targetInt, target.id.length + 1);
                    _emscripten_set_canvas_element_size(targetInt, width, height);
                    stackRestore(stackTop)
                }
            }

            function __registerRestoreOldStyle(canvas) {
                var canvasSize = __get_canvas_element_size(canvas);
                var oldWidth = canvasSize[0];
                var oldHeight = canvasSize[1];
                var oldCssWidth = canvas.style.width;
                var oldCssHeight = canvas.style.height;
                var oldBackgroundColor = canvas.style.backgroundColor;
                var oldDocumentBackgroundColor = document.body.style.backgroundColor;
                var oldPaddingLeft = canvas.style.paddingLeft;
                var oldPaddingRight = canvas.style.paddingRight;
                var oldPaddingTop = canvas.style.paddingTop;
                var oldPaddingBottom = canvas.style.paddingBottom;
                var oldMarginLeft = canvas.style.marginLeft;
                var oldMarginRight = canvas.style.marginRight;
                var oldMarginTop = canvas.style.marginTop;
                var oldMarginBottom = canvas.style.marginBottom;
                var oldDocumentBodyMargin = document.body.style.margin;
                var oldDocumentOverflow = document.documentElement.style.overflow;
                var oldDocumentScroll = document.body.scroll;
                var oldImageRendering = canvas.style.imageRendering;

                function restoreOldStyle() {
                    var fullscreenElement = document.fullscreenElement || document.webkitFullscreenElement || document.msFullscreenElement;
                    if (!fullscreenElement) {
                        document.removeEventListener("fullscreenchange", restoreOldStyle);
                        document.removeEventListener("webkitfullscreenchange", restoreOldStyle);
                        __set_canvas_element_size(canvas, oldWidth, oldHeight);
                        canvas.style.width = oldCssWidth;
                        canvas.style.height = oldCssHeight;
                        canvas.style.backgroundColor = oldBackgroundColor;
                        if (!oldDocumentBackgroundColor) document.body.style.backgroundColor = "white";
                        document.body.style.backgroundColor = oldDocumentBackgroundColor;
                        canvas.style.paddingLeft = oldPaddingLeft;
                        canvas.style.paddingRight = oldPaddingRight;
                        canvas.style.paddingTop = oldPaddingTop;
                        canvas.style.paddingBottom = oldPaddingBottom;
                        canvas.style.marginLeft = oldMarginLeft;
                        canvas.style.marginRight = oldMarginRight;
                        canvas.style.marginTop = oldMarginTop;
                        canvas.style.marginBottom = oldMarginBottom;
                        document.body.style.margin = oldDocumentBodyMargin;
                        document.documentElement.style.overflow = oldDocumentOverflow;
                        document.body.scroll = oldDocumentScroll;
                        canvas.style.imageRendering = oldImageRendering;
                        if (canvas.GLctxObject) canvas.GLctxObject.GLctx.viewport(0, 0, oldWidth, oldHeight);
                        if (__currentFullscreenStrategy.canvasResizedCallback) {
                            dynCall_iiii(__currentFullscreenStrategy.canvasResizedCallback, 37, 0, __currentFullscreenStrategy.canvasResizedCallbackUserData)
                        }
                    }
                }
                document.addEventListener("fullscreenchange", restoreOldStyle);
                document.addEventListener("webkitfullscreenchange", restoreOldStyle);
                return restoreOldStyle
            }

            function __setLetterbox(element, topBottom, leftRight) {
                element.style.paddingLeft = element.style.paddingRight = leftRight + "px";
                element.style.paddingTop = element.style.paddingBottom = topBottom + "px"
            }

            function __getBoundingClientRect(e) {
                return specialHTMLTargets.indexOf(e) < 0 ? e.getBoundingClientRect() : {
                    "left": 0,
                    "top": 0
                }
            }

            function _JSEvents_resizeCanvasForFullscreen(target, strategy) {
                var restoreOldStyle = __registerRestoreOldStyle(target);
                var cssWidth = strategy.softFullscreen ? innerWidth : screen.width;
                var cssHeight = strategy.softFullscreen ? innerHeight : screen.height;
                var rect = __getBoundingClientRect(target);
                var windowedCssWidth = rect.width;
                var windowedCssHeight = rect.height;
                var canvasSize = __get_canvas_element_size(target);
                var windowedRttWidth = canvasSize[0];
                var windowedRttHeight = canvasSize[1];
                if (strategy.scaleMode == 3) {
                    __setLetterbox(target, (cssHeight - windowedCssHeight) / 2, (cssWidth - windowedCssWidth) / 2);
                    cssWidth = windowedCssWidth;
                    cssHeight = windowedCssHeight
                } else if (strategy.scaleMode == 2) {
                    if (cssWidth * windowedRttHeight < windowedRttWidth * cssHeight) {
                        var desiredCssHeight = windowedRttHeight * cssWidth / windowedRttWidth;
                        __setLetterbox(target, (cssHeight - desiredCssHeight) / 2, 0);
                        cssHeight = desiredCssHeight
                    } else {
                        var desiredCssWidth = windowedRttWidth * cssHeight / windowedRttHeight;
                        __setLetterbox(target, 0, (cssWidth - desiredCssWidth) / 2);
                        cssWidth = desiredCssWidth
                    }
                }
                if (!target.style.backgroundColor) target.style.backgroundColor = "black";
                if (!document.body.style.backgroundColor) document.body.style.backgroundColor = "black";
                target.style.width = cssWidth + "px";
                target.style.height = cssHeight + "px";
                if (strategy.filteringMode == 1) {
                    target.style.imageRendering = "optimizeSpeed";
                    target.style.imageRendering = "-moz-crisp-edges";
                    target.style.imageRendering = "-o-crisp-edges";
                    target.style.imageRendering = "-webkit-optimize-contrast";
                    target.style.imageRendering = "optimize-contrast";
                    target.style.imageRendering = "crisp-edges";
                    target.style.imageRendering = "pixelated"
                }
                var dpiScale = strategy.canvasResolutionScaleMode == 2 ? devicePixelRatio : 1;
                if (strategy.canvasResolutionScaleMode != 0) {
                    var newWidth = cssWidth * dpiScale | 0;
                    var newHeight = cssHeight * dpiScale | 0;
                    __set_canvas_element_size(target, newWidth, newHeight);
                    if (target.GLctxObject) target.GLctxObject.GLctx.viewport(0, 0, newWidth, newHeight)
                }
                return restoreOldStyle
            }

            function _JSEvents_requestFullscreen(target, strategy) {
                if (strategy.scaleMode != 0 || strategy.canvasResolutionScaleMode != 0) {
                    _JSEvents_resizeCanvasForFullscreen(target, strategy)
                }
                if (target.requestFullscreen) {
                    target.requestFullscreen()
                } else if (target.webkitRequestFullscreen) {
                    target.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT)
                } else {
                    return JSEvents.fullscreenEnabled() ? -3 : -1
                }
                __currentFullscreenStrategy = strategy;
                if (strategy.canvasResizedCallback) {
                    dynCall_iiii(strategy.canvasResizedCallback, 37, 0, strategy.canvasResizedCallbackUserData)
                }
                return 0
            }

            function _emscripten_exit_fullscreen() {
                if (!JSEvents.fullscreenEnabled()) return -1;
                JSEvents.removeDeferredCalls(_JSEvents_requestFullscreen);
                var d = specialHTMLTargets[1];
                if (d.exitFullscreen) {
                    d.fullscreenElement && d.exitFullscreen()
                } else if (d.webkitExitFullscreen) {
                    d.webkitFullscreenElement && d.webkitExitFullscreen()
                } else {
                    return -1
                }
                return 0
            }

            function __requestPointerLock(target) {
                if (target.requestPointerLock) {
                    target.requestPointerLock()
                } else if (target.msRequestPointerLock) {
                    target.msRequestPointerLock()
                } else {
                    if (document.body.requestPointerLock || document.body.msRequestPointerLock) {
                        return -3
                    } else {
                        return -1
                    }
                }
                return 0
            }

            function _emscripten_exit_pointerlock() {
                JSEvents.removeDeferredCalls(__requestPointerLock);
                if (document.exitPointerLock) {
                    document.exitPointerLock()
                } else if (document.msExitPointerLock) {
                    document.msExitPointerLock()
                } else {
                    return -1
                }
                return 0
            }

            function _emscripten_get_device_pixel_ratio() {
                return devicePixelRatio
            }

            function _emscripten_get_element_css_size(target, width, height) {
                target = __findEventTarget(target);
                if (!target) return -4;
                var rect = __getBoundingClientRect(target);
                HEAPF64[width >> 3] = rect.width;
                HEAPF64[height >> 3] = rect.height;
                return 0
            }

            function __fillFullscreenChangeEventData(eventStruct) {
                var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement;
                var isFullscreen = !!fullscreenElement;
                HEAP32[eventStruct >> 2] = isFullscreen;
                HEAP32[eventStruct + 4 >> 2] = JSEvents.fullscreenEnabled();
                var reportedElement = isFullscreen ? fullscreenElement : JSEvents.previousFullscreenElement;
                var nodeName = JSEvents.getNodeNameForTarget(reportedElement);
                var id = reportedElement && reportedElement.id ? reportedElement.id : "";
                stringToUTF8(nodeName, eventStruct + 8, 128);
                stringToUTF8(id, eventStruct + 136, 128);
                HEAP32[eventStruct + 264 >> 2] = reportedElement ? reportedElement.clientWidth : 0;
                HEAP32[eventStruct + 268 >> 2] = reportedElement ? reportedElement.clientHeight : 0;
                HEAP32[eventStruct + 272 >> 2] = screen.width;
                HEAP32[eventStruct + 276 >> 2] = screen.height;
                if (isFullscreen) {
                    JSEvents.previousFullscreenElement = fullscreenElement
                }
            }

            function _emscripten_get_fullscreen_status(fullscreenStatus) {
                if (!JSEvents.fullscreenEnabled()) return -1;
                __fillFullscreenChangeEventData(fullscreenStatus);
                return 0
            }

            function __fillGamepadEventData(eventStruct, e) {
                HEAPF64[eventStruct >> 3] = e.timestamp;
                for (var i = 0; i < e.axes.length; ++i) {
                    HEAPF64[eventStruct + i * 8 + 16 >> 3] = e.axes[i]
                }
                for (var i = 0; i < e.buttons.length; ++i) {
                    if (typeof e.buttons[i] === "object") {
                        HEAPF64[eventStruct + i * 8 + 528 >> 3] = e.buttons[i].value
                    } else {
                        HEAPF64[eventStruct + i * 8 + 528 >> 3] = e.buttons[i]
                    }
                }
                for (var i = 0; i < e.buttons.length; ++i) {
                    if (typeof e.buttons[i] === "object") {
                        HEAP32[eventStruct + i * 4 + 1040 >> 2] = e.buttons[i].pressed
                    } else {
                        HEAP32[eventStruct + i * 4 + 1040 >> 2] = e.buttons[i] == 1
                    }
                }
                HEAP32[eventStruct + 1296 >> 2] = e.connected;
                HEAP32[eventStruct + 1300 >> 2] = e.index;
                HEAP32[eventStruct + 8 >> 2] = e.axes.length;
                HEAP32[eventStruct + 12 >> 2] = e.buttons.length;
                stringToUTF8(e.id, eventStruct + 1304, 64);
                stringToUTF8(e.mapping, eventStruct + 1368, 64)
            }

            function _emscripten_get_gamepad_status(index, gamepadState) {
                if (index < 0 || index >= JSEvents.lastGamepadState.length) return -5;
                if (!JSEvents.lastGamepadState[index]) return -7;
                __fillGamepadEventData(gamepadState, JSEvents.lastGamepadState[index]);
                return 0
            }

            function _emscripten_get_num_gamepads() {
                return JSEvents.lastGamepadState.length
            }

            function _emscripten_get_sbrk_ptr() {
                return 886976
            }

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

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

            function _emscripten_glBeginQuery(target, id) {
                GLctx["beginQuery"](target, GL.queries[id])
            }

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

            function _emscripten_glBeginTransformFeedback(x0) {
                GLctx["beginTransformFeedback"](x0)
            }

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

            function _emscripten_glBindBuffer(target, buffer) {
                if (target == 35051) {
                    GLctx.currentPixelPackBufferBinding = buffer
                } else if (target == 35052) {
                    GLctx.currentPixelUnpackBufferBinding = buffer
                }
                GLctx.bindBuffer(target, GL.buffers[buffer])
            }

            function _emscripten_glBindBufferBase(target, index, buffer) {
                GLctx["bindBufferBase"](target, index, GL.buffers[buffer])
            }

            function _emscripten_glBindBufferRange(target, index, buffer, offset, ptrsize) {
                GLctx["bindBufferRange"](target, index, GL.buffers[buffer], offset, ptrsize)
            }

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

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

            function _emscripten_glBindSampler(unit, sampler) {
                GLctx["bindSampler"](unit, GL.samplers[sampler])
            }

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

            function _emscripten_glBindTransformFeedback(target, id) {
                GLctx["bindTransformFeedback"](target, GL.transformFeedbacks[id])
            }

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

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

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

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

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

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

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

            function _emscripten_glBlitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) {
                GLctx["blitFramebuffer"](x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
            }

            function _emscripten_glBufferData(target, size, data, usage) {
                if (GL.currentContext.version >= 2) {
                    if (data) {
                        GLctx.bufferData(target, HEAPU8, usage, data, size)
                    } else {
                        GLctx.bufferData(target, size, usage)
                    }
                } else {
                    GLctx.bufferData(target, data ? HEAPU8.subarray(data, data + size) : size, usage)
                }
            }

            function _emscripten_glBufferSubData(target, offset, size, data) {
                if (GL.currentContext.version >= 2) {
                    GLctx.bufferSubData(target, offset, HEAPU8, data, size);
                    return
                }
                GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size))
            }

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

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

            function _emscripten_glClearBufferfi(x0, x1, x2, x3) {
                GLctx["clearBufferfi"](x0, x1, x2, x3)
            }

            function _emscripten_glClearBufferfv(buffer, drawbuffer, value) {
                GLctx["clearBufferfv"](buffer, drawbuffer, HEAPF32, value >> 2)
            }

            function _emscripten_glClearBufferiv(buffer, drawbuffer, value) {
                GLctx["clearBufferiv"](buffer, drawbuffer, HEAP32, value >> 2)
            }

            function _emscripten_glClearBufferuiv(buffer, drawbuffer, value) {
                GLctx["clearBufferuiv"](buffer, drawbuffer, HEAPU32, value >> 2)
            }

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

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

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

            function convertI32PairToI53(lo, hi) {
                return (lo >>> 0) + hi * 4294967296
            }

            function _emscripten_glClientWaitSync(sync, flags, timeoutLo, timeoutHi) {
                return GLctx.clientWaitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi))
            }

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

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

            function _emscripten_glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data) {
                if (GL.currentContext.version >= 2) {
                    if (GLctx.currentPixelUnpackBufferBinding) {
                        GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, imageSize, data)
                    } else {
                        GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, HEAPU8, data, imageSize)
                    }
                    return
                }
                GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, data ? HEAPU8.subarray(data, data + imageSize) : null)
            }

            function _emscripten_glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data) {
                if (GLctx.currentPixelUnpackBufferBinding) {
                    GLctx["compressedTexImage3D"](target, level, internalFormat, width, height, depth, border, imageSize, data)
                } else {
                    GLctx["compressedTexImage3D"](target, level, internalFormat, width, height, depth, border, HEAPU8, data, imageSize)
                }
            }

            function _emscripten_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) {
                if (GL.currentContext.version >= 2) {
                    if (GLctx.currentPixelUnpackBufferBinding) {
                        GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, imageSize, data)
                    } else {
                        GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize)
                    }
                    return
                }
                GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, data ? HEAPU8.subarray(data, data + imageSize) : null)
            }

            function _emscripten_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) {
                if (GLctx.currentPixelUnpackBufferBinding) {
                    GLctx["compressedTexSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
                } else {
                    GLctx["compressedTexSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize)
                }
            }

            function _emscripten_glCopyBufferSubData(x0, x1, x2, x3, x4) {
                GLctx["copyBufferSubData"](x0, x1, x2, x3, x4)
            }

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

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

            function _emscripten_glCopyTexSubImage3D(x0, x1, x2, x3, x4, x5, x6, x7, x8) {
                GLctx["copyTexSubImage3D"](x0, x1, x2, x3, x4, x5, x6, x7, x8)
            }

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

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

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

            function _emscripten_glDeleteBuffers(n, buffers) {
                for (var i = 0; i < n; i++) {
                    var id = HEAP32[buffers + i * 4 >> 2];
                    var buffer = GL.buffers[id];
                    if (!buffer) continue;
                    GLctx.deleteBuffer(buffer);
                    buffer.name = 0;
                    GL.buffers[id] = null;
                    if (id == GL.currArrayBuffer) GL.currArrayBuffer = 0;
                    if (id == GL.currElementArrayBuffer) GL.currElementArrayBuffer = 0;
                    if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0;
                    if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0
                }
            }

            function _emscripten_glDeleteFramebuffers(n, framebuffers) {
                for (var i = 0; i < n; ++i) {
                    var id = HEAP32[framebuffers + i * 4 >> 2];
                    var framebuffer = GL.framebuffers[id];
                    if (!framebuffer) continue;
                    GLctx.deleteFramebuffer(framebuffer);
                    framebuffer.name = 0;
                    GL.framebuffers[id] = null
                }
            }

            function _emscripten_glDeleteProgram(id) {
                if (!id) return;
                var program = GL.programs[id];
                if (!program) {
                    GL.recordError(1281);
                    return
                }
                GLctx.deleteProgram(program);
                program.name = 0;
                GL.programs[id] = null;
                GL.programInfos[id] = null
            }

            function _emscripten_glDeleteQueries(n, ids) {
                for (var i = 0; i < n; i++) {
                    var id = HEAP32[ids + i * 4 >> 2];
                    var query = GL.queries[id];
                    if (!query) continue;
                    GLctx["deleteQuery"](query);
                    GL.queries[id] = null
                }
            }

            function _emscripten_glDeleteQueriesEXT(n, ids) {
                for (var i = 0; i < n; i++) {
                    var id = HEAP32[ids + i * 4 >> 2];
                    var query = GL.timerQueriesEXT[id];
                    if (!query) continue;
                    GLctx.disjointTimerQueryExt["deleteQueryEXT"](query);
                    GL.timerQueriesEXT[id] = null
                }
            }

            function _emscripten_glDeleteRenderbuffers(n, renderbuffers) {
                for (var i = 0; i < n; i++) {
                    var id = HEAP32[renderbuffers + i * 4 >> 2];
                    var renderbuffer = GL.renderbuffers[id];
                    if (!renderbuffer) continue;
                    GLctx.deleteRenderbuffer(renderbuffer);
                    renderbuffer.name = 0;
                    GL.renderbuffers[id] = null
                }
            }

            function _emscripten_glDeleteSamplers(n, samplers) {
                for (var i = 0; i < n; i++) {
                    var id = HEAP32[samplers + i * 4 >> 2];
                    var sampler = GL.samplers[id];
                    if (!sampler) continue;
                    GLctx["deleteSampler"](sampler);
                    sampler.name = 0;
                    GL.samplers[id] = null
                }
            }

            function _emscripten_glDeleteShader(id) {
                if (!id) return;
                var shader = GL.shaders[id];
                if (!shader) {
                    GL.recordError(1281);
                    return
                }
                GLctx.deleteShader(shader);
                GL.shaders[id] = null
            }

            function _emscripten_glDeleteSync(id) {
                if (!id) return;
                var sync = GL.syncs[id];
                if (!sync) {
                    GL.recordError(1281);
                    return
                }
                GLctx.deleteSync(sync);
                sync.name = 0;
                GL.syncs[id] = null
            }

            function _emscripten_glDeleteTextures(n, textures) {
                for (var i = 0; i < n; i++) {
                    var id = HEAP32[textures + i * 4 >> 2];
                    var texture = GL.textures[id];
                    if (!texture) continue;
                    GLctx.deleteTexture(texture);
                    texture.name = 0;
                    GL.textures[id] = null
                }
            }

            function _emscripten_glDeleteTransformFeedbacks(n, ids) {
                for (var i = 0; i < n; i++) {
                    var id = HEAP32[ids + i * 4 >> 2];
                    var transformFeedback = GL.transformFeedbacks[id];
                    if (!transformFeedback) continue;
                    GLctx["deleteTransformFeedback"](transformFeedback);
                    transformFeedback.name = 0;
                    GL.transformFeedbacks[id] = null
                }
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

            function _emscripten_glDrawArraysInstancedNV(mode, first, count, primcount) {
                GLctx["drawArraysInstanced"](mode, first, count, primcount)
            }
            var __tempFixedLengthArray = [];

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

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

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

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

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

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

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

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

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

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

            function _emscripten_glDrawRangeElements(mode, start, end, count, type, indices) {
                _glDrawElements(mode, count, type, indices)
            }

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

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

            function _emscripten_glEndQuery(x0) {
                GLctx["endQuery"](x0)
            }

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

            function _emscripten_glEndTransformFeedback() {
                GLctx["endTransformFeedback"]()
            }

            function _emscripten_glFenceSync(condition, flags) {
                var sync = GLctx.fenceSync(condition, flags);
                if (sync) {
                    var id = GL.getNewId(GL.syncs);
                    sync.name = id;
                    GL.syncs[id] = sync;
                    return id
                } else {
                    return 0
                }
            }

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

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

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

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

            function _emscripten_glFramebufferTextureLayer(target, attachment, texture, level, layer) {
                GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer)
            }

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

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

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

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

            function _emscripten_glGenQueries(n, ids) {
                __glGenObject(n, ids, "createQuery", GL.queries)
            }

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

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

            function _emscripten_glGenSamplers(n, samplers) {
                __glGenObject(n, samplers, "createSampler", GL.samplers)
            }

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

            function _emscripten_glGenTransformFeedbacks(n, ids) {
                __glGenObject(n, ids, "createTransformFeedback", GL.transformFeedbacks)
            }

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

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

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

            function _emscripten_glGetActiveAttrib(program, index, bufSize, length, size, type, name) {
                program = GL.programs[program];
                var info = GLctx.getActiveAttrib(program, index);
                if (!info) return;
                var numBytesWrittenExclNull = bufSize > 0 && name ? stringToUTF8(info.name, name, bufSize) : 0;
                if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
                if (size) HEAP32[size >> 2] = info.size;
                if (type) HEAP32[type >> 2] = info.type
            }

            function _emscripten_glGetActiveUniform(program, index, bufSize, length, size, type, name) {
                program = GL.programs[program];
                var info = GLctx.getActiveUniform(program, index);
                if (!info) return;
                var numBytesWrittenExclNull = bufSize > 0 && name ? stringToUTF8(info.name, name, bufSize) : 0;
                if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
                if (size) HEAP32[size >> 2] = info.size;
                if (type) HEAP32[type >> 2] = info.type
            }

            function _emscripten_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName) {
                program = GL.programs[program];
                var result = GLctx["getActiveUniformBlockName"](program, uniformBlockIndex);
                if (!result) return;
                if (uniformBlockName && bufSize > 0) {
                    var numBytesWrittenExclNull = stringToUTF8(result, uniformBlockName, bufSize);
                    if (length) HEAP32[length >> 2] = numBytesWrittenExclNull
                } else {
                    if (length) HEAP32[length >> 2] = 0
                }
            }

            function _emscripten_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                program = GL.programs[program];
                switch (pname) {
                    case 35393:
                        var name = GLctx["getActiveUniformBlockName"](program, uniformBlockIndex);
                        HEAP32[params >> 2] = name.length + 1;
                        return;
                    default:
                        var result = GLctx["getActiveUniformBlockParameter"](program, uniformBlockIndex, pname);
                        if (!result) return;
                        if (typeof result == "number") {
                            HEAP32[params >> 2] = result
                        } else {
                            for (var i = 0; i < result.length; i++) {
                                HEAP32[params + i * 4 >> 2] = result[i]
                            }
                        }
                }
            }

            function _emscripten_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                if (uniformCount > 0 && uniformIndices == 0) {
                    GL.recordError(1281);
                    return
                }
                program = GL.programs[program];
                var ids = [];
                for (var i = 0; i < uniformCount; i++) {
                    ids.push(HEAP32[uniformIndices + i * 4 >> 2])
                }
                var result = GLctx["getActiveUniforms"](program, ids, pname);
                if (!result) return;
                var len = result.length;
                for (var i = 0; i < len; i++) {
                    HEAP32[params + i * 4 >> 2] = result[i]
                }
            }

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

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

            function writeI53ToI64(ptr, num) {
                HEAPU32[ptr >> 2] = num;
                HEAPU32[ptr + 4 >> 2] = (num - HEAPU32[ptr >> 2]) / 4294967296
            }

            function emscriptenWebGLGet(name_, p, type) {
                if (!p) {
                    GL.recordError(1281);
                    return
                }
                var ret = undefined;
                switch (name_) {
                    case 36346:
                        ret = 1;
                        break;
                    case 36344:
                        if (type != 0 && type != 1) {
                            GL.recordError(1280)
                        }
                        return;
                    case 34814:
                    case 36345:
                        ret = 0;
                        break;
                    case 34466:
                        var formats = GLctx.getParameter(34467);
                        ret = formats ? formats.length : 0;
                        break;
                    case 33309:
                        if (GL.currentContext.version < 2) {
                            GL.recordError(1282);
                            return
                        }
                        var exts = GLctx.getSupportedExtensions() || [];
                        ret = 2 * exts.length;
                        break;
                    case 33307:
                    case 33308:
                        if (GL.currentContext.version < 2) {
                            GL.recordError(1280);
                            return
                        }
                        ret = name_ == 33307 ? 3 : 0;
                        break
                }
                if (ret === undefined) {
                    var result = GLctx.getParameter(name_);
                    switch (typeof result) {
                        case "number":
                            ret = result;
                            break;
                        case "boolean":
                            ret = result ? 1 : 0;
                            break;
                        case "string":
                            GL.recordError(1280);
                            return;
                        case "object":
                            if (result === null) {
                                switch (name_) {
                                    case 34964:
                                    case 35725:
                                    case 34965:
                                    case 36006:
                                    case 36007:
                                    case 32873:
                                    case 34229:
                                    case 36662:
                                    case 36663:
                                    case 35053:
                                    case 35055:
                                    case 36010:
                                    case 35097:
                                    case 35869:
                                    case 32874:
                                    case 36389:
                                    case 35983:
                                    case 35368:
                                    case 34068: {
                                        ret = 0;
                                        break
                                    }
                                    default: {
                                        GL.recordError(1280);
                                        return
                                    }
                                }
                            } else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) {
                                for (var i = 0; i < result.length; ++i) {
                                    switch (type) {
                                        case 0:
                                            HEAP32[p + i * 4 >> 2] = result[i];
                                            break;
                                        case 2:
                                            HEAPF32[p + i * 4 >> 2] = result[i];
                                            break;
                                        case 4:
                                            HEAP8[p + i >> 0] = result[i] ? 1 : 0;
                                            break
                                    }
                                }
                                return
                            } else {
                                try {
                                    ret = result.name | 0
                                } catch (e) {
                                    GL.recordError(1280);
                                    err("GL_INVALID_ENUM in glGet" + type + "v: Unknown object returned from WebGL getParameter(" + name_ + ")! (error: " + e + ")");
                                    return
                                }
                            }
                            break;
                        default:
                            GL.recordError(1280);
                            err("GL_INVALID_ENUM in glGet" + type + "v: Native code calling glGet" + type + "v(" + name_ + ") and it returns " + result + " of type " + typeof result + "!");
                            return
                    }
                }
                switch (type) {
                    case 1:
                        writeI53ToI64(p, ret);
                        break;
                    case 0:
                        HEAP32[p >> 2] = ret;
                        break;
                    case 2:
                        HEAPF32[p >> 2] = ret;
                        break;
                    case 4:
                        HEAP8[p >> 0] = ret ? 1 : 0;
                        break
                }
            }

            function _emscripten_glGetBooleanv(name_, p) {
                emscriptenWebGLGet(name_, p, 4)
            }

            function _emscripten_glGetBufferParameteri64v(target, value, data) {
                if (!data) {
                    GL.recordError(1281);
                    return
                }
                writeI53ToI64(data, GLctx.getBufferParameter(target, value))
            }

            function _emscripten_glGetBufferParameteriv(target, value, data) {
                if (!data) {
                    GL.recordError(1281);
                    return
                }
                HEAP32[data >> 2] = GLctx.getBufferParameter(target, value)
            }

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

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

            function _emscripten_glGetFragDataLocation(program, name) {
                return GLctx["getFragDataLocation"](GL.programs[program], UTF8ToString(name))
            }

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

            function emscriptenWebGLGetIndexed(target, index, data, type) {
                if (!data) {
                    GL.recordError(1281);
                    return
                }
                var result = GLctx["getIndexedParameter"](target, index);
                var ret;
                switch (typeof result) {
                    case "boolean":
                        ret = result ? 1 : 0;
                        break;
                    case "number":
                        ret = result;
                        break;
                    case "object":
                        if (result === null) {
                            switch (target) {
                                case 35983:
                                case 35368:
                                    ret = 0;
                                    break;
                                default: {
                                    GL.recordError(1280);
                                    return
                                }
                            }
                        } else if (result instanceof WebGLBuffer) {
                            ret = result.name | 0
                        } else {
                            GL.recordError(1280);
                            return
                        }
                        break;
                    default:
                        GL.recordError(1280);
                        return
                }
                switch (type) {
                    case 1:
                        writeI53ToI64(data, ret);
                        break;
                    case 0:
                        HEAP32[data >> 2] = ret;
                        break;
                    case 2:
                        HEAPF32[data >> 2] = ret;
                        break;
                    case 4:
                        HEAP8[data >> 0] = ret ? 1 : 0;
                        break;
                    default:
                        throw "internal emscriptenWebGLGetIndexed() error, bad type: " + type
                }
            }

            function _emscripten_glGetInteger64i_v(target, index, data) {
                emscriptenWebGLGetIndexed(target, index, data, 1)
            }

            function _emscripten_glGetInteger64v(name_, p) {
                emscriptenWebGLGet(name_, p, 1)
            }

            function _emscripten_glGetIntegeri_v(target, index, data) {
                emscriptenWebGLGetIndexed(target, index, data, 0)
            }

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

            function _emscripten_glGetInternalformativ(target, internalformat, pname, bufSize, params) {
                if (bufSize < 0) {
                    GL.recordError(1281);
                    return
                }
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var ret = GLctx["getInternalformatParameter"](target, internalformat, pname);
                if (ret === null) return;
                for (var i = 0; i < ret.length && i < bufSize; ++i) {
                    HEAP32[params + i >> 2] = ret[i]
                }
            }

            function _emscripten_glGetProgramBinary(program, bufSize, length, binaryFormat, binary) {
                GL.recordError(1282)
            }

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

            function _emscripten_glGetProgramiv(program, pname, p) {
                if (!p) {
                    GL.recordError(1281);
                    return
                }
                if (program >= GL.counter) {
                    GL.recordError(1281);
                    return
                }
                var ptable = GL.programInfos[program];
                if (!ptable) {
                    GL.recordError(1282);
                    return
                }
                if (pname == 35716) {
                    var log = GLctx.getProgramInfoLog(GL.programs[program]);
                    if (log === null) log = "(unknown error)";
                    HEAP32[p >> 2] = log.length + 1
                } else if (pname == 35719) {
                    HEAP32[p >> 2] = ptable.maxUniformLength
                } else if (pname == 35722) {
                    if (ptable.maxAttributeLength == -1) {
                        program = GL.programs[program];
                        var numAttribs = GLctx.getProgramParameter(program, 35721);
                        ptable.maxAttributeLength = 0;
                        for (var i = 0; i < numAttribs; ++i) {
                            var activeAttrib = GLctx.getActiveAttrib(program, i);
                            ptable.maxAttributeLength = Math.max(ptable.maxAttributeLength, activeAttrib.name.length + 1)
                        }
                    }
                    HEAP32[p >> 2] = ptable.maxAttributeLength
                } else if (pname == 35381) {
                    if (ptable.maxUniformBlockNameLength == -1) {
                        program = GL.programs[program];
                        var numBlocks = GLctx.getProgramParameter(program, 35382);
                        ptable.maxUniformBlockNameLength = 0;
                        for (var i = 0; i < numBlocks; ++i) {
                            var activeBlockName = GLctx.getActiveUniformBlockName(program, i);
                            ptable.maxUniformBlockNameLength = Math.max(ptable.maxUniformBlockNameLength, activeBlockName.length + 1)
                        }
                    }
                    HEAP32[p >> 2] = ptable.maxUniformBlockNameLength
                } else {
                    HEAP32[p >> 2] = GLctx.getProgramParameter(GL.programs[program], pname)
                }
            }

            function _emscripten_glGetQueryObjecti64vEXT(id, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var query = GL.timerQueriesEXT[id];
                var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
                var ret;
                if (typeof param == "boolean") {
                    ret = param ? 1 : 0
                } else {
                    ret = param
                }
                writeI53ToI64(params, ret)
            }

            function _emscripten_glGetQueryObjectivEXT(id, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var query = GL.timerQueriesEXT[id];
                var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
                var ret;
                if (typeof param == "boolean") {
                    ret = param ? 1 : 0
                } else {
                    ret = param
                }
                HEAP32[params >> 2] = ret
            }

            function _emscripten_glGetQueryObjectui64vEXT(id, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var query = GL.timerQueriesEXT[id];
                var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
                var ret;
                if (typeof param == "boolean") {
                    ret = param ? 1 : 0
                } else {
                    ret = param
                }
                writeI53ToI64(params, ret)
            }

            function _emscripten_glGetQueryObjectuiv(id, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var query = GL.queries[id];
                var param = GLctx["getQueryParameter"](query, pname);
                var ret;
                if (typeof param == "boolean") {
                    ret = param ? 1 : 0
                } else {
                    ret = param
                }
                HEAP32[params >> 2] = ret
            }

            function _emscripten_glGetQueryObjectuivEXT(id, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var query = GL.timerQueriesEXT[id];
                var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
                var ret;
                if (typeof param == "boolean") {
                    ret = param ? 1 : 0
                } else {
                    ret = param
                }
                HEAP32[params >> 2] = ret
            }

            function _emscripten_glGetQueryiv(target, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                HEAP32[params >> 2] = GLctx["getQuery"](target, pname)
            }

            function _emscripten_glGetQueryivEXT(target, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                HEAP32[params >> 2] = GLctx.disjointTimerQueryExt["getQueryEXT"](target, pname)
            }

            function _emscripten_glGetRenderbufferParameteriv(target, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname)
            }

            function _emscripten_glGetSamplerParameterfv(sampler, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                sampler = GL.samplers[sampler];
                HEAPF32[params >> 2] = GLctx["getSamplerParameter"](sampler, pname)
            }

            function _emscripten_glGetSamplerParameteriv(sampler, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                sampler = GL.samplers[sampler];
                HEAP32[params >> 2] = GLctx["getSamplerParameter"](sampler, pname)
            }

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

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

            function _emscripten_glGetShaderSource(shader, bufSize, length, source) {
                var result = GLctx.getShaderSource(GL.shaders[shader]);
                if (!result) return;
                var numBytesWrittenExclNull = bufSize > 0 && source ? stringToUTF8(result, source, bufSize) : 0;
                if (length) HEAP32[length >> 2] = numBytesWrittenExclNull
            }

            function _emscripten_glGetShaderiv(shader, pname, p) {
                if (!p) {
                    GL.recordError(1281);
                    return
                }
                if (pname == 35716) {
                    var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
                    if (log === null) log = "(unknown error)";
                    HEAP32[p >> 2] = log.length + 1
                } else if (pname == 35720) {
                    var source = GLctx.getShaderSource(GL.shaders[shader]);
                    var sourceLength = source === null || source.length == 0 ? 0 : source.length + 1;
                    HEAP32[p >> 2] = sourceLength
                } else {
                    HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname)
                }
            }

            function stringToNewUTF8(jsString) {
                var length = lengthBytesUTF8(jsString) + 1;
                var cString = _malloc(length);
                stringToUTF8(jsString, cString, length);
                return cString
            }

            function _emscripten_glGetString(name_) {
                if (GL.stringCache[name_]) return GL.stringCache[name_];
                var ret;
                switch (name_) {
                    case 7939:
                        var exts = GLctx.getSupportedExtensions() || [];
                        exts = exts.concat(exts.map(function(e) {
                            return "GL_" + e
                        }));
                        ret = stringToNewUTF8(exts.join(" "));
                        break;
                    case 7936:
                    case 7937:
                    case 37445:
                    case 37446:
                        var s = GLctx.getParameter(name_);
                        if (!s) {
                            GL.recordError(1280)
                        }
                        ret = stringToNewUTF8(s);
                        break;
                    case 7938:
                        var glVersion = GLctx.getParameter(7938);
                        if (GL.currentContext.version >= 2) glVersion = "OpenGL ES 3.0 (" + glVersion + ")";
                        else {
                            glVersion = "OpenGL ES 2.0 (" + glVersion + ")"
                        }
                        ret = stringToNewUTF8(glVersion);
                        break;
                    case 35724:
                        var glslVersion = GLctx.getParameter(35724);
                        var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;
                        var ver_num = glslVersion.match(ver_re);
                        if (ver_num !== null) {
                            if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0";
                            glslVersion = "OpenGL ES GLSL ES " + ver_num[1] + " (" + glslVersion + ")"
                        }
                        ret = stringToNewUTF8(glslVersion);
                        break;
                    default:
                        GL.recordError(1280);
                        return 0
                }
                GL.stringCache[name_] = ret;
                return ret
            }

            function _emscripten_glGetStringi(name, index) {
                if (GL.currentContext.version < 2) {
                    GL.recordError(1282);
                    return 0
                }
                var stringiCache = GL.stringiCache[name];
                if (stringiCache) {
                    if (index < 0 || index >= stringiCache.length) {
                        GL.recordError(1281);
                        return 0
                    }
                    return stringiCache[index]
                }
                switch (name) {
                    case 7939:
                        var exts = GLctx.getSupportedExtensions() || [];
                        exts = exts.concat(exts.map(function(e) {
                            return "GL_" + e
                        }));
                        exts = exts.map(function(e) {
                            return stringToNewUTF8(e)
                        });
                        stringiCache = GL.stringiCache[name] = exts;
                        if (index < 0 || index >= stringiCache.length) {
                            GL.recordError(1281);
                            return 0
                        }
                        return stringiCache[index];
                    default:
                        GL.recordError(1280);
                        return 0
                }
            }

            function _emscripten_glGetSynciv(sync, pname, bufSize, length, values) {
                if (bufSize < 0) {
                    GL.recordError(1281);
                    return
                }
                if (!values) {
                    GL.recordError(1281);
                    return
                }
                var ret = GLctx.getSyncParameter(GL.syncs[sync], pname);
                HEAP32[length >> 2] = ret;
                if (ret !== null && length) HEAP32[length >> 2] = 1
            }

            function _emscripten_glGetTexParameterfv(target, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                HEAPF32[params >> 2] = GLctx.getTexParameter(target, pname)
            }

            function _emscripten_glGetTexParameteriv(target, pname, params) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                HEAP32[params >> 2] = GLctx.getTexParameter(target, pname)
            }

            function _emscripten_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name) {
                program = GL.programs[program];
                var info = GLctx["getTransformFeedbackVarying"](program, index);
                if (!info) return;
                if (name && bufSize > 0) {
                    var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize);
                    if (length) HEAP32[length >> 2] = numBytesWrittenExclNull
                } else {
                    if (length) HEAP32[length >> 2] = 0
                }
                if (size) HEAP32[size >> 2] = info.size;
                if (type) HEAP32[type >> 2] = info.type
            }

            function _emscripten_glGetUniformBlockIndex(program, uniformBlockName) {
                return GLctx["getUniformBlockIndex"](GL.programs[program], UTF8ToString(uniformBlockName))
            }

            function _emscripten_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices) {
                if (!uniformIndices) {
                    GL.recordError(1281);
                    return
                }
                if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) {
                    GL.recordError(1281);
                    return
                }
                program = GL.programs[program];
                var names = [];
                for (var i = 0; i < uniformCount; i++) names.push(UTF8ToString(HEAP32[uniformNames + i * 4 >> 2]));
                var result = GLctx["getUniformIndices"](program, names);
                if (!result) return;
                var len = result.length;
                for (var i = 0; i < len; i++) {
                    HEAP32[uniformIndices + i * 4 >> 2] = result[i]
                }
            }

            function jstoi_q(str) {
                return parseInt(str)
            }

            function _emscripten_glGetUniformLocation(program, name) {
                name = UTF8ToString(name);
                var arrayIndex = 0;
                if (name[name.length - 1] == "]") {
                    var leftBrace = name.lastIndexOf("[");
                    arrayIndex = name[leftBrace + 1] != "]" ? jstoi_q(name.slice(leftBrace + 1)) : 0;
                    name = name.slice(0, leftBrace)
                }
                var uniformInfo = GL.programInfos[program] && GL.programInfos[program].uniforms[name];
                if (uniformInfo && arrayIndex >= 0 && arrayIndex < uniformInfo[0]) {
                    return uniformInfo[1] + arrayIndex
                } else {
                    return -1
                }
            }

            function emscriptenWebGLGetUniform(program, location, params, type) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var data = GLctx.getUniform(GL.programs[program], GL.uniforms[location]);
                if (typeof data == "number" || typeof data == "boolean") {
                    switch (type) {
                        case 0:
                            HEAP32[params >> 2] = data;
                            break;
                        case 2:
                            HEAPF32[params >> 2] = data;
                            break;
                        default:
                            throw "internal emscriptenWebGLGetUniform() error, bad type: " + type
                    }
                } else {
                    for (var i = 0; i < data.length; i++) {
                        switch (type) {
                            case 0:
                                HEAP32[params + i * 4 >> 2] = data[i];
                                break;
                            case 2:
                                HEAPF32[params + i * 4 >> 2] = data[i];
                                break;
                            default:
                                throw "internal emscriptenWebGLGetUniform() error, bad type: " + type
                        }
                    }
                }
            }

            function _emscripten_glGetUniformfv(program, location, params) {
                emscriptenWebGLGetUniform(program, location, params, 2)
            }

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

            function _emscripten_glGetUniformuiv(program, location, params) {
                emscriptenWebGLGetUniform(program, location, params, 0)
            }

            function emscriptenWebGLGetVertexAttrib(index, pname, params, type) {
                if (!params) {
                    GL.recordError(1281);
                    return
                }
                var data = GLctx.getVertexAttrib(index, pname);
                if (pname == 34975) {
                    HEAP32[params >> 2] = data && data["name"]
                } else if (typeof data == "number" || typeof data == "boolean") {
                    switch (type) {
                        case 0:
                            HEAP32[params >> 2] = data;
                            break;
                        case 2:
                            HEAPF32[params >> 2] = data;
                            break;
                        case 5:
                            HEAP32[params >> 2] = Math.fround(data);
                            break;
                        default:
                            throw "internal emscriptenWebGLGetVertexAttrib() error, bad type: " + type
                    }
                } else {
                    for (var i = 0; i < data.length; i++) {
                        switch (type) {
                            case 0:
                                HEAP32[params + i * 4 >> 2] = data[i];
                                break;
                            case 2:
                                HEAPF32[params + i * 4 >> 2] = data[i];
                                break;
                            case 5:
                                HEAP32[params + i * 4 >> 2] = Math.fround(data[i]);
                                break;
                            default:
                                throw "internal emscriptenWebGLGetVertexAttrib() error, bad type: " + type
                        }
                    }
                }
            }

            function _emscripten_glGetVertexAttribIiv(index, pname, params) {
                emscriptenWebGLGetVertexAttrib(index, pname, params, 0)
            }

            function _emscripten_glGetVertexAttribIuiv(index, pname, params) {
                emscriptenWebGLGetVertexAttrib(index, pname, params, 0)
            }

            function _emscripten_glGetVertexAttribPointerv(index, pname, pointer) {
                if (!pointer) {
                    GL.recordError(1281);
                    return
                }
                HEAP32[pointer >> 2] = GLctx.getVertexAttribOffset(index, pname)
            }

            function _emscripten_glGetVertexAttribfv(index, pname, params) {
                emscriptenWebGLGetVertexAttrib(index, pname, params, 2)
            }

            function _emscripten_glGetVertexAttribiv(index, pname, params) {
                emscriptenWebGLGetVertexAttrib(index, pname, params, 5)
            }

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

            function _emscripten_glInvalidateFramebuffer(target, numAttachments, attachments) {
                var list = __tempFixedLengthArray[numAttachments];
                for (var i = 0; i < numAttachments; i++) {
                    list[i] = HEAP32[attachments + i * 4 >> 2]
                }
                GLctx["invalidateFramebuffer"](target, list)
            }

            function _emscripten_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height) {
                var list = __tempFixedLengthArray[numAttachments];
                for (var i = 0; i < numAttachments; i++) {
                    list[i] = HEAP32[attachments + i * 4 >> 2]
                }
                GLctx["invalidateSubFramebuffer"](target, list, x, y, width, height)
            }

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

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

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

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

            function _emscripten_glIsQuery(id) {
                var query = GL.queries[id];
                if (!query) return 0;
                return GLctx["isQuery"](query)
            }

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

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

            function _emscripten_glIsSampler(id) {
                var sampler = GL.samplers[id];
                if (!sampler) return 0;
                return GLctx["isSampler"](sampler)
            }

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

            function _emscripten_glIsSync(sync) {
                return GLctx.isSync(GL.syncs[sync])
            }

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

            function _emscripten_glIsTransformFeedback(id) {
                return GLctx["isTransformFeedback"](GL.transformFeedbacks[id])
            }

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

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

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

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

            function _emscripten_glPauseTransformFeedback() {
                GLctx["pauseTransformFeedback"]()
            }

            function _emscripten_glPixelStorei(pname, param) {
                if (pname == 3317) {
                    GL.unpackAlignment = param
                }
                GLctx.pixelStorei(pname, param)
            }

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

            function _emscripten_glProgramBinary(program, binaryFormat, binary, length) {
                GL.recordError(1280)
            }

            function _emscripten_glProgramParameteri(program, pname, value) {
                GL.recordError(1280)
            }

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

            function _emscripten_glReadBuffer(x0) {
                GLctx["readBuffer"](x0)
            }

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

            function __colorChannelsInGlTextureFormat(format) {
                var colorChannels = {
                    5: 3,
                    6: 4,
                    8: 2,
                    29502: 3,
                    29504: 4,
                    26917: 2,
                    26918: 2,
                    29846: 3,
                    29847: 4
                };
                return colorChannels[format - 6402] || 1
            }

            function __heapObjectForWebGLType(type) {
                type -= 5120;
                if (type == 0) return HEAP8;
                if (type == 1) return HEAPU8;
                if (type == 2) return HEAP16;
                if (type == 4) return HEAP32;
                if (type == 6) return HEAPF32;
                if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) return HEAPU32;
                return HEAPU16
            }

            function __heapAccessShiftForWebGLHeap(heap) {
                return 31 - Math.clz32(heap.BYTES_PER_ELEMENT)
            }

            function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) {
                var heap = __heapObjectForWebGLType(type);
                var shift = __heapAccessShiftForWebGLHeap(heap);
                var byteSize = 1 << shift;
                var sizePerPixel = __colorChannelsInGlTextureFormat(format) * byteSize;
                var bytes = __computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment);
                return heap.subarray(pixels >> shift, pixels + bytes >> shift)
            }

            function _emscripten_glReadPixels(x, y, width, height, format, type, pixels) {
                if (GL.currentContext.version >= 2) {
                    if (GLctx.currentPixelPackBufferBinding) {
                        GLctx.readPixels(x, y, width, height, format, type, pixels)
                    } else {
                        var heap = __heapObjectForWebGLType(type);
                        GLctx.readPixels(x, y, width, height, format, type, heap, pixels >> __heapAccessShiftForWebGLHeap(heap))
                    }
                    return
                }
                var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format);
                if (!pixelData) {
                    GL.recordError(1280);
                    return
                }
                GLctx.readPixels(x, y, width, height, format, type, pixelData)
            }

            function _emscripten_glReleaseShaderCompiler() {}

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

            function _emscripten_glRenderbufferStorageMultisample(x0, x1, x2, x3, x4) {
                GLctx["renderbufferStorageMultisample"](x0, x1, x2, x3, x4)
            }

            function _emscripten_glResumeTransformFeedback() {
                GLctx["resumeTransformFeedback"]()
            }

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

            function _emscripten_glSamplerParameterf(sampler, pname, param) {
                GLctx["samplerParameterf"](GL.samplers[sampler], pname, param)
            }

            function _emscripten_glSamplerParameterfv(sampler, pname, params) {
                var param = HEAPF32[params >> 2];
                GLctx["samplerParameterf"](GL.samplers[sampler], pname, param)
            }

            function _emscripten_glSamplerParameteri(sampler, pname, param) {
                GLctx["samplerParameteri"](GL.samplers[sampler], pname, param)
            }

            function _emscripten_glSamplerParameteriv(sampler, pname, params) {
                var param = HEAP32[params >> 2];
                GLctx["samplerParameteri"](GL.samplers[sampler], pname, param)
            }

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

            function _emscripten_glShaderBinary() {
                GL.recordError(1280)
            }

            function _emscripten_glShaderSource(shader, count, string, length) {
                var source = GL.getSource(shader, count, string, length);
                GLctx.shaderSource(GL.shaders[shader], source)
            }

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

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

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

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

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

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

            function _emscripten_glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) {
                if (GL.currentContext.version >= 2) {
                    if (GLctx.currentPixelUnpackBufferBinding) {
                        GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels)
                    } else if (pixels) {
                        var heap = __heapObjectForWebGLType(type);
                        GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, pixels >> __heapAccessShiftForWebGLHeap(heap))
                    } else {
                        GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, null)
                    }
                    return
                }
                GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null)
            }

            function _emscripten_glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels) {
                if (GLctx.currentPixelUnpackBufferBinding) {
                    GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, pixels)
                } else if (pixels) {
                    var heap = __heapObjectForWebGLType(type);
                    GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, heap, pixels >> __heapAccessShiftForWebGLHeap(heap))
                } else {
                    GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, null)
                }
            }

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

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

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

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

            function _emscripten_glTexStorage2D(x0, x1, x2, x3, x4) {
                GLctx["texStorage2D"](x0, x1, x2, x3, x4)
            }

            function _emscripten_glTexStorage3D(x0, x1, x2, x3, x4, x5) {
                GLctx["texStorage3D"](x0, x1, x2, x3, x4, x5)
            }

            function _emscripten_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) {
                if (GL.currentContext.version >= 2) {
                    if (GLctx.currentPixelUnpackBufferBinding) {
                        GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels)
                    } else if (pixels) {
                        var heap = __heapObjectForWebGLType(type);
                        GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, pixels >> __heapAccessShiftForWebGLHeap(heap))
                    } else {
                        GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, null)
                    }
                    return
                }
                var pixelData = null;
                if (pixels) pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0);
                GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData)
            }

            function _emscripten_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) {
                if (GLctx.currentPixelUnpackBufferBinding) {
                    GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
                } else if (pixels) {
                    var heap = __heapObjectForWebGLType(type);
                    GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, heap, pixels >> __heapAccessShiftForWebGLHeap(heap))
                } else {
                    GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null)
                }
            }

            function _emscripten_glTransformFeedbackVaryings(program, count, varyings, bufferMode) {
                program = GL.programs[program];
                var vars = [];
                for (var i = 0; i < count; i++) vars.push(UTF8ToString(HEAP32[varyings + i * 4 >> 2]));
                GLctx["transformFeedbackVaryings"](program, vars, bufferMode)
            }

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

            function _emscripten_glUniform1fv(location, count, value) {
                if (GL.currentContext.version >= 2) {
                    GLctx.uniform1fv(GL.uniforms[location], HEAPF32, value >> 2, count);
                    return
                }
                if (count <= GL.MINI_TEMP_BUFFER_SIZE) {
                    var view = GL.miniTempBufferFloatViews[count - 1];
                    for (var i = 0; i < count; ++i) {
                        view[i] = HEAPF32[value + 4 * i >> 2]
                    }
                } else {
                    var view = HEAPF32.subarray(value >> 2, value + count * 4 >> 2)
                }
                GLctx.uniform1fv(GL.uniforms[location], view)
            }

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

            function _emscripten_glUniform1iv(location, count, value) {
                if (GL.currentContext.version >= 2) {
                    GLctx.uniform1iv(GL.uniforms[location], HEAP32, value >> 2, count);
                    return
                }
                if (count <= GL.MINI_TEMP_BUFFER_SIZE) {
                    var view = GL.miniTempBufferIntViews[count - 1];
                    for (var i = 0; i < count; ++i) {
                        view[i] = HEAP32[value + 4 * i >> 2]
                    }
                } else {
                    var view = HEAP32.subarray(value >> 2, value + count * 4 >> 2)
                }
                GLctx.uniform1iv(GL.uniforms[location], view)
            }

            function _emscripten_glUniform1ui(location, v0) {
                GLctx.uniform1ui(GL.uniforms[location], v0)
            }

            function _emscripten_glUniform1uiv(location, count, value) {
                GLctx.uniform1uiv(GL.uniforms[location], HEAPU32, value >> 2, count)
            }

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

            function _emscripten_glUniform2fv(location, count, value) {
                if (GL.currentContext.version >= 2) {
                    GLctx.uniform2fv(GL.uniforms[location], HEAPF32, value >> 2, count * 2);
                    return
                }
                if (2 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
                    var view = GL.miniTempBufferFloatViews[2 * count - 1];
                    for (var i = 0; i < 2 * count; i += 2) {
                        view[i] = HEAPF32[value + 4 * i >> 2];
                        view[i + 1] = HEAPF32[value + (4 * i + 4) >> 2]
                    }
                } else {
                    var view = HEAPF32.subarray(value >> 2, value + count * 8 >> 2)
                }
                GLctx.uniform2fv(GL.uniforms[location], view)
            }

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

            function _emscripten_glUniform2iv(location, count, value) {
                if (GL.currentContext.version >= 2) {
                    GLctx.uniform2iv(GL.uniforms[location], HEAP32, value >> 2, count * 2);
                    return
                }
                if (2 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
                    var view = GL.miniTempBufferIntViews[2 * count - 1];
                    for (var i = 0; i < 2 * count; i += 2) {
                        view[i] = HEAP32[value + 4 * i >> 2];
                        view[i + 1] = HEAP32[value + (4 * i + 4) >> 2]
                    }
                } else {
                    var view = HEAP32.subarray(value >> 2, value + count * 8 >> 2)
                }
                GLctx.uniform2iv(GL.uniforms[location], view)
            }

            function _emscripten_glUniform2ui(location, v0, v1) {
                GLctx.uniform2ui(GL.uniforms[location], v0, v1)
            }

            function _emscripten_glUniform2uiv(location, count, value) {
                GLctx.uniform2uiv(GL.uniforms[location], HEAPU32, value >> 2, count * 2)
            }

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

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

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

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

            function _emscripten_glUniform3ui(location, v0, v1, v2) {
                GLctx.uniform3ui(GL.uniforms[location], v0, v1, v2)
            }

            function _emscripten_glUniform3uiv(location, count, value) {
                GLctx.uniform3uiv(GL.uniforms[location], HEAPU32, value >> 2, count * 3)
            }

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

            function _emscripten_glUniform4fv(location, count, value) {
                if (GL.currentContext.version >= 2) {
                    GLctx.uniform4fv(GL.uniforms[location], HEAPF32, value >> 2, count * 4);
                    return
                }
                if (4 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
                    var view = GL.miniTempBufferFloatViews[4 * count - 1];
                    var heap = HEAPF32;
                    value >>= 2;
                    for (var i = 0; i < 4 * count; i += 4) {
                        var dst = value + i;
                        view[i] = heap[dst];
                        view[i + 1] = heap[dst + 1];
                        view[i + 2] = heap[dst + 2];
                        view[i + 3] = heap[dst + 3]
                    }
                } else {
                    var view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2)
                }
                GLctx.uniform4fv(GL.uniforms[location], view)
            }

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

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

            function _emscripten_glUniform4ui(location, v0, v1, v2, v3) {
                GLctx.uniform4ui(GL.uniforms[location], v0, v1, v2, v3)
            }

            function _emscripten_glUniform4uiv(location, count, value) {
                GLctx.uniform4uiv(GL.uniforms[location], HEAPU32, value >> 2, count * 4)
            }

            function _emscripten_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) {
                program = GL.programs[program];
                GLctx["uniformBlockBinding"](program, uniformBlockIndex, uniformBlockBinding)
            }

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

            function _emscripten_glUniformMatrix2x3fv(location, count, transpose, value) {
                GLctx.uniformMatrix2x3fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 6)
            }

            function _emscripten_glUniformMatrix2x4fv(location, count, transpose, value) {
                GLctx.uniformMatrix2x4fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 8)
            }

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

            function _emscripten_glUniformMatrix3x2fv(location, count, transpose, value) {
                GLctx.uniformMatrix3x2fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 6)
            }

            function _emscripten_glUniformMatrix3x4fv(location, count, transpose, value) {
                GLctx.uniformMatrix3x4fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 12)
            }

            function _emscripten_glUniformMatrix4fv(location, count, transpose, value) {
                if (GL.currentContext.version >= 2) {
                    GLctx.uniformMatrix4fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 16);
                    return
                }
                if (16 * count <= GL.MINI_TEMP_BUFFER_SIZE) {
                    var view = GL.miniTempBufferFloatViews[16 * count - 1];
                    var heap = HEAPF32;
                    value >>= 2;
                    for (var i = 0; i < 16 * count; i += 16) {
                        var dst = value + i;
                        view[i] = heap[dst];
                        view[i + 1] = heap[dst + 1];
                        view[i + 2] = heap[dst + 2];
                        view[i + 3] = heap[dst + 3];
                        view[i + 4] = heap[dst + 4];
                        view[i + 5] = heap[dst + 5];
                        view[i + 6] = heap[dst + 6];
                        view[i + 7] = heap[dst + 7];
                        view[i + 8] = heap[dst + 8];
                        view[i + 9] = heap[dst + 9];
                        view[i + 10] = heap[dst + 10];
                        view[i + 11] = heap[dst + 11];
                        view[i + 12] = heap[dst + 12];
                        view[i + 13] = heap[dst + 13];
                        view[i + 14] = heap[dst + 14];
                        view[i + 15] = heap[dst + 15]
                    }
                } else {
                    var view = HEAPF32.subarray(value >> 2, value + count * 64 >> 2)
                }
                GLctx.uniformMatrix4fv(GL.uniforms[location], !!transpose, view)
            }

            function _emscripten_glUniformMatrix4x2fv(location, count, transpose, value) {
                GLctx.uniformMatrix4x2fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 8)
            }

            function _emscripten_glUniformMatrix4x3fv(location, count, transpose, value) {
                GLctx.uniformMatrix4x3fv(GL.uniforms[location], !!transpose, HEAPF32, value >> 2, count * 12)
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            function _emscripten_glVertexAttribI4i(x0, x1, x2, x3, x4) {
                GLctx["vertexAttribI4i"](x0, x1, x2, x3, x4)
            }

            function _emscripten_glVertexAttribI4iv(index, v) {
                GLctx.vertexAttribI4i(index, HEAP32[v >> 2], HEAP32[v + 4 >> 2], HEAP32[v + 8 >> 2], HEAP32[v + 12 >> 2])
            }

            function _emscripten_glVertexAttribI4ui(x0, x1, x2, x3, x4) {
                GLctx["vertexAttribI4ui"](x0, x1, x2, x3, x4)
            }

            function _emscripten_glVertexAttribI4uiv(index, v) {
                GLctx.vertexAttribI4ui(index, HEAPU32[v >> 2], HEAPU32[v + 4 >> 2], HEAPU32[v + 8 >> 2], HEAPU32[v + 12 >> 2])
            }

            function _emscripten_glVertexAttribIPointer(index, size, type, stride, ptr) {
                GLctx["vertexAttribIPointer"](index, size, type, stride, ptr)
            }

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

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

            function _emscripten_glWaitSync(sync, flags, timeoutLo, timeoutHi) {
                GLctx.waitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi))
            }

            function _emscripten_has_asyncify() {
                return 0
            }

            function _emscripten_is_main_browser_thread() {
                return !ENVIRONMENT_IS_WORKER
            }

            function reallyNegative(x) {
                return x < 0 || x === 0 && 1 / x === -Infinity
            }

            function convertU32PairToI53(lo, hi) {
                return (lo >>> 0) + (hi >>> 0) * 4294967296
            }

            function formatString(format, varargs) {
                var textIndex = format;
                var argIndex = varargs;

                function prepVararg(ptr, type) {
                    if (type === "double" || type === "i64") {
                        if (ptr & 7) {
                            ptr += 4
                        }
                    } else {}
                    return ptr
                }

                function getNextArg(type) {
                    var ret;
                    argIndex = prepVararg(argIndex, type);
                    if (type === "double") {
                        ret = HEAPF64[argIndex >> 3];
                        argIndex += 8
                    } else if (type == "i64") {
                        ret = [HEAP32[argIndex >> 2], HEAP32[argIndex + 4 >> 2]];
                        argIndex += 8
                    } else {
                        type = "i32";
                        ret = HEAP32[argIndex >> 2];
                        argIndex += 4
                    }
                    return ret
                }
                var ret = [];
                var curr, next, currArg;
                while (1) {
                    var startTextIndex = textIndex;
                    curr = HEAP8[textIndex >> 0];
                    if (curr === 0) break;
                    next = HEAP8[textIndex + 1 >> 0];
                    if (curr == 37) {
                        var flagAlwaysSigned = false;
                        var flagLeftAlign = false;
                        var flagAlternative = false;
                        var flagZeroPad = false;
                        var flagPadSign = false;
                        flagsLoop: while (1) {
                            switch (next) {
                                case 43:
                                    flagAlwaysSigned = true;
                                    break;
                                case 45:
                                    flagLeftAlign = true;
                                    break;
                                case 35:
                                    flagAlternative = true;
                                    break;
                                case 48:
                                    if (flagZeroPad) {
                                        break flagsLoop
                                    } else {
                                        flagZeroPad = true;
                                        break
                                    }
                                    case 32:
                                        flagPadSign = true;
                                        break;
                                    default:
                                        break flagsLoop
                            }
                            textIndex++;
                            next = HEAP8[textIndex + 1 >> 0]
                        }
                        var width = 0;
                        if (next == 42) {
                            width = getNextArg("i32");
                            textIndex++;
                            next = HEAP8[textIndex + 1 >> 0]
                        } else {
                            while (next >= 48 && next <= 57) {
                                width = width * 10 + (next - 48);
                                textIndex++;
                                next = HEAP8[textIndex + 1 >> 0]
                            }
                        }
                        var precisionSet = false,
                            precision = -1;
                        if (next == 46) {
                            precision = 0;
                            precisionSet = true;
                            textIndex++;
                            next = HEAP8[textIndex + 1 >> 0];
                            if (next == 42) {
                                precision = getNextArg("i32");
                                textIndex++
                            } else {
                                while (1) {
                                    var precisionChr = HEAP8[textIndex + 1 >> 0];
                                    if (precisionChr < 48 || precisionChr > 57) break;
                                    precision = precision * 10 + (precisionChr - 48);
                                    textIndex++
                                }
                            }
                            next = HEAP8[textIndex + 1 >> 0]
                        }
                        if (precision < 0) {
                            precision = 6;
                            precisionSet = false
                        }
                        var argSize;
                        switch (String.fromCharCode(next)) {
                            case "h":
                                var nextNext = HEAP8[textIndex + 2 >> 0];
                                if (nextNext == 104) {
                                    textIndex++;
                                    argSize = 1
                                } else {
                                    argSize = 2
                                }
                                break;
                            case "l":
                                var nextNext = HEAP8[textIndex + 2 >> 0];
                                if (nextNext == 108) {
                                    textIndex++;
                                    argSize = 8
                                } else {
                                    argSize = 4
                                }
                                break;
                            case "L":
                            case "q":
                            case "j":
                                argSize = 8;
                                break;
                            case "z":
                            case "t":
                            case "I":
                                argSize = 4;
                                break;
                            default:
                                argSize = null
                        }
                        if (argSize) textIndex++;
                        next = HEAP8[textIndex + 1 >> 0];
                        switch (String.fromCharCode(next)) {
                            case "d":
                            case "i":
                            case "u":
                            case "o":
                            case "x":
                            case "X":
                            case "p": {
                                var signed = next == 100 || next == 105;
                                argSize = argSize || 4;
                                currArg = getNextArg("i" + argSize * 8);
                                var argText;
                                if (argSize == 8) {
                                    currArg = next == 117 ? convertU32PairToI53(currArg[0], currArg[1]) : convertI32PairToI53(currArg[0], currArg[1])
                                }
                                if (argSize <= 4) {
                                    var limit = Math.pow(256, argSize) - 1;
                                    currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8)
                                }
                                var currAbsArg = Math.abs(currArg);
                                var prefix = "";
                                if (next == 100 || next == 105) {
                                    argText = reSign(currArg, 8 * argSize, 1).toString(10)
                                } else if (next == 117) {
                                    argText = unSign(currArg, 8 * argSize, 1).toString(10);
                                    currArg = Math.abs(currArg)
                                } else if (next == 111) {
                                    argText = (flagAlternative ? "0" : "") + currAbsArg.toString(8)
                                } else if (next == 120 || next == 88) {
                                    prefix = flagAlternative && currArg != 0 ? "0x" : "";
                                    if (currArg < 0) {
                                        currArg = -currArg;
                                        argText = (currAbsArg - 1).toString(16);
                                        var buffer = [];
                                        for (var i = 0; i < argText.length; i++) {
                                            buffer.push((15 - parseInt(argText[i], 16)).toString(16))
                                        }
                                        argText = buffer.join("");
                                        while (argText.length < argSize * 2) argText = "f" + argText
                                    } else {
                                        argText = currAbsArg.toString(16)
                                    }
                                    if (next == 88) {
                                        prefix = prefix.toUpperCase();
                                        argText = argText.toUpperCase()
                                    }
                                } else if (next == 112) {
                                    if (currAbsArg === 0) {
                                        argText = "(nil)"
                                    } else {
                                        prefix = "0x";
                                        argText = currAbsArg.toString(16)
                                    }
                                }
                                if (precisionSet) {
                                    while (argText.length < precision) {
                                        argText = "0" + argText
                                    }
                                }
                                if (currArg >= 0) {
                                    if (flagAlwaysSigned) {
                                        prefix = "+" + prefix
                                    } else if (flagPadSign) {
                                        prefix = " " + prefix
                                    }
                                }
                                if (argText.charAt(0) == "-") {
                                    prefix = "-" + prefix;
                                    argText = argText.substr(1)
                                }
                                while (prefix.length + argText.length < width) {
                                    if (flagLeftAlign) {
                                        argText += " "
                                    } else {
                                        if (flagZeroPad) {
                                            argText = "0" + argText
                                        } else {
                                            prefix = " " + prefix
                                        }
                                    }
                                }
                                argText = prefix + argText;
                                argText.split("").forEach(function(chr) {
                                    ret.push(chr.charCodeAt(0))
                                });
                                break
                            }
                            case "f":
                            case "F":
                            case "e":
                            case "E":
                            case "g":
                            case "G": {
                                currArg = getNextArg("double");
                                var argText;
                                if (isNaN(currArg)) {
                                    argText = "nan";
                                    flagZeroPad = false
                                } else if (!isFinite(currArg)) {
                                    argText = (currArg < 0 ? "-" : "") + "inf";
                                    flagZeroPad = false
                                } else {
                                    var isGeneral = false;
                                    var effectivePrecision = Math.min(precision, 20);
                                    if (next == 103 || next == 71) {
                                        isGeneral = true;
                                        precision = precision || 1;
                                        var exponent = parseInt(currArg.toExponential(effectivePrecision).split("e")[1], 10);
                                        if (precision > exponent && exponent >= -4) {
                                            next = (next == 103 ? "f" : "F").charCodeAt(0);
                                            precision -= exponent + 1
                                        } else {
                                            next = (next == 103 ? "e" : "E").charCodeAt(0);
                                            precision--
                                        }
                                        effectivePrecision = Math.min(precision, 20)
                                    }
                                    if (next == 101 || next == 69) {
                                        argText = currArg.toExponential(effectivePrecision);
                                        if (/[eE][-+]\d$/.test(argText)) {
                                            argText = argText.slice(0, -1) + "0" + argText.slice(-1)
                                        }
                                    } else if (next == 102 || next == 70) {
                                        argText = currArg.toFixed(effectivePrecision);
                                        if (currArg === 0 && reallyNegative(currArg)) {
                                            argText = "-" + argText
                                        }
                                    }
                                    var parts = argText.split("e");
                                    if (isGeneral && !flagAlternative) {
                                        while (parts[0].length > 1 && parts[0].indexOf(".") != -1 && (parts[0].slice(-1) == "0" || parts[0].slice(-1) == ".")) {
                                            parts[0] = parts[0].slice(0, -1)
                                        }
                                    } else {
                                        if (flagAlternative && argText.indexOf(".") == -1) parts[0] += ".";
                                        while (precision > effectivePrecision++) parts[0] += "0"
                                    }
                                    argText = parts[0] + (parts.length > 1 ? "e" + parts[1] : "");
                                    if (next == 69) argText = argText.toUpperCase();
                                    if (currArg >= 0) {
                                        if (flagAlwaysSigned) {
                                            argText = "+" + argText
                                        } else if (flagPadSign) {
                                            argText = " " + argText
                                        }
                                    }
                                }
                                while (argText.length < width) {
                                    if (flagLeftAlign) {
                                        argText += " "
                                    } else {
                                        if (flagZeroPad && (argText[0] == "-" || argText[0] == "+")) {
                                            argText = argText[0] + "0" + argText.slice(1)
                                        } else {
                                            argText = (flagZeroPad ? "0" : " ") + argText
                                        }
                                    }
                                }
                                if (next < 97) argText = argText.toUpperCase();
                                argText.split("").forEach(function(chr) {
                                    ret.push(chr.charCodeAt(0))
                                });
                                break
                            }
                            case "s": {
                                var arg = getNextArg("i8*");
                                var argLength = arg ? _strlen(arg) : "(null)".length;
                                if (precisionSet) argLength = Math.min(argLength, precision);
                                if (!flagLeftAlign) {
                                    while (argLength < width--) {
                                        ret.push(32)
                                    }
                                }
                                if (arg) {
                                    for (var i = 0; i < argLength; i++) {
                                        ret.push(HEAPU8[arg++ >> 0])
                                    }
                                } else {
                                    ret = ret.concat(intArrayFromString("(null)".substr(0, argLength), true))
                                }
                                if (flagLeftAlign) {
                                    while (argLength < width--) {
                                        ret.push(32)
                                    }
                                }
                                break
                            }
                            case "c": {
                                if (flagLeftAlign) ret.push(getNextArg("i8"));
                                while (--width > 0) {
                                    ret.push(32)
                                }
                                if (!flagLeftAlign) ret.push(getNextArg("i8"));
                                break
                            }
                            case "n": {
                                var ptr = getNextArg("i32*");
                                HEAP32[ptr >> 2] = ret.length;
                                break
                            }
                            case "%": {
                                ret.push(curr);
                                break
                            }
                            default: {
                                for (var i = startTextIndex; i < textIndex + 2; i++) {
                                    ret.push(HEAP8[i >> 0])
                                }
                            }
                        }
                        textIndex += 2
                    } else {
                        ret.push(curr);
                        textIndex += 1
                    }
                }
                return ret
            }

            function __emscripten_traverse_stack(args) {
                if (!args || !args.callee || !args.callee.name) {
                    return [null, "", ""]
                }
                var funstr = args.callee.toString();
                var funcname = args.callee.name;
                var str = "(";
                var first = true;
                for (var i in args) {
                    var a = args[i];
                    if (!first) {
                        str += ", "
                    }
                    first = false;
                    if (typeof a === "number" || typeof a === "string") {
                        str += a
                    } else {
                        str += "(" + typeof a + ")"
                    }
                }
                str += ")";
                var caller = args.callee.caller;
                args = caller ? caller.arguments : [];
                if (first) str = "";
                return [args, funcname, str]
            }

            function _emscripten_get_callstack_js(flags) {
                var callstack = jsStackTrace();
                var iThisFunc = callstack.lastIndexOf("_emscripten_log");
                var iThisFunc2 = callstack.lastIndexOf("_emscripten_get_callstack");
                var iNextLine = callstack.indexOf("\n", Math.max(iThisFunc, iThisFunc2)) + 1;
                callstack = callstack.slice(iNextLine);
                if (flags & 8 && typeof emscripten_source_map === "undefined") {
                    warnOnce('Source map information is not available, emscripten_log with EM_LOG_C_STACK will be ignored. Build with "--pre-js $EMSCRIPTEN/src/emscripten-source-map.min.js" linker flag to add source map loading to code.');
                    flags ^= 8;
                    flags |= 16
                }
                var stack_args = null;
                if (flags & 128) {
                    stack_args = __emscripten_traverse_stack(arguments);
                    while (stack_args[1].indexOf("_emscripten_") >= 0) stack_args = __emscripten_traverse_stack(stack_args[0])
                }
                var lines = callstack.split("\n");
                callstack = "";
                var newFirefoxRe = new RegExp("\\s*(.*?)@(.*?):([0-9]+):([0-9]+)");
                var firefoxRe = new RegExp("\\s*(.*?)@(.*):(.*)(:(.*))?");
                var chromeRe = new RegExp("\\s*at (.*?) \\((.*):(.*):(.*)\\)");
                for (var l in lines) {
                    var line = lines[l];
                    var jsSymbolName = "";
                    var file = "";
                    var lineno = 0;
                    var column = 0;
                    var parts = chromeRe.exec(line);
                    if (parts && parts.length == 5) {
                        jsSymbolName = parts[1];
                        file = parts[2];
                        lineno = parts[3];
                        column = parts[4]
                    } else {
                        parts = newFirefoxRe.exec(line);
                        if (!parts) parts = firefoxRe.exec(line);
                        if (parts && parts.length >= 4) {
                            jsSymbolName = parts[1];
                            file = parts[2];
                            lineno = parts[3];
                            column = parts[4] | 0
                        } else {
                            callstack += line + "\n";
                            continue
                        }
                    }
                    var cSymbolName = flags & 32 ? demangle(jsSymbolName) : jsSymbolName;
                    if (!cSymbolName) {
                        cSymbolName = jsSymbolName
                    }
                    var haveSourceMap = false;
                    if (flags & 8) {
                        var orig = emscripten_source_map.originalPositionFor({
                            line: lineno,
                            column: column
                        });
                        haveSourceMap = orig && orig.source;
                        if (haveSourceMap) {
                            if (flags & 64) {
                                orig.source = orig.source.substring(orig.source.replace(/\\/g, "/").lastIndexOf("/") + 1)
                            }
                            callstack += "    at " + cSymbolName + " (" + orig.source + ":" + orig.line + ":" + orig.column + ")\n"
                        }
                    }
                    if (flags & 16 || !haveSourceMap) {
                        if (flags & 64) {
                            file = file.substring(file.replace(/\\/g, "/").lastIndexOf("/") + 1)
                        }
                        callstack += (haveSourceMap ? "     = " + jsSymbolName : "    at " + cSymbolName) + " (" + file + ":" + lineno + ":" + column + ")\n"
                    }
                    if (flags & 128 && stack_args[0]) {
                        if (stack_args[1] == jsSymbolName && stack_args[2].length > 0) {
                            callstack = callstack.replace(/\s+$/, "");
                            callstack += " with values: " + stack_args[1] + stack_args[2] + "\n"
                        }
                        stack_args = __emscripten_traverse_stack(stack_args[0])
                    }
                }
                callstack = callstack.replace(/\s+$/, "");
                return callstack
            }

            function _emscripten_log_js(flags, str) {
                if (flags & 24) {
                    str = str.replace(/\s+$/, "");
                    str += (str.length > 0 ? "\n" : "") + _emscripten_get_callstack_js(flags)
                }
                if (flags & 1) {
                    if (flags & 4) {
                        console.error(str)
                    } else if (flags & 2) {
                        console.warn(str)
                    } else if (flags & 512) {
                        console.info(str)
                    } else if (flags & 256) {
                        console.debug(str)
                    } else {
                        console.log(str)
                    }
                } else if (flags & 6) {
                    err(str)
                } else {
                    out(str)
                }
            }

            function _emscripten_log(flags, format, varargs) {
                var str = "";
                var result = formatString(format, varargs);
                for (var i = 0; i < result.length; ++i) {
                    str += String.fromCharCode(result[i])
                }
                _emscripten_log_js(flags, str)
            }
            var setjmpId = 0;

            function _saveSetjmp(env, label, table, size) {
                env = env | 0;
                label = label | 0;
                table = table | 0;
                size = size | 0;
                var i = 0;
                setjmpId = setjmpId + 1 | 0;
                HEAP32[env >> 2] = setjmpId;
                while ((i | 0) < (size | 0)) {
                    if ((HEAP32[table + (i << 3) >> 2] | 0) == 0) {
                        HEAP32[table + (i << 3) >> 2] = setjmpId;
                        HEAP32[table + ((i << 3) + 4) >> 2] = label;
                        HEAP32[table + ((i << 3) + 8) >> 2] = 0;
                        setTempRet0(size | 0);
                        return table | 0
                    }
                    i = i + 1 | 0
                }
                size = size * 2 | 0;
                table = _realloc(table | 0, 8 * (size + 1 | 0) | 0) | 0;
                table = _saveSetjmp(env | 0, label | 0, table | 0, size | 0) | 0;
                setTempRet0(size | 0);
                return table | 0
            }

            function _testSetjmp(id, table, size) {
                id = id | 0;
                table = table | 0;
                size = size | 0;
                var i = 0,
                    curr = 0;
                while ((i | 0) < (size | 0)) {
                    curr = HEAP32[table + (i << 3) >> 2] | 0;
                    if ((curr | 0) == 0) break;
                    if ((curr | 0) == (id | 0)) {
                        return HEAP32[table + ((i << 3) + 4) >> 2] | 0
                    }
                    i = i + 1 | 0
                }
                return 0
            }

            function _longjmp(env, value) {
                _setThrew(env, value || 1);
                throw "longjmp"
            }

            function _emscripten_longjmp(env, value) {
                _longjmp(env, value)
            }

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

            function __emscripten_do_request_fullscreen(target, strategy) {
                if (!JSEvents.fullscreenEnabled()) return -1;
                target = __findEventTarget(target);
                if (!target) return -4;
                if (!target.requestFullscreen && !target.webkitRequestFullscreen) {
                    return -3
                }
                var canPerformRequests = JSEvents.canPerformEventHandlerRequests();
                if (!canPerformRequests) {
                    if (strategy.deferUntilInEventHandler) {
                        JSEvents.deferCall(_JSEvents_requestFullscreen, 1, [target, strategy]);
                        return 1
                    } else {
                        return -2
                    }
                }
                return _JSEvents_requestFullscreen(target, strategy)
            }

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

            function _emscripten_request_pointerlock(target, deferUntilInEventHandler) {
                target = __findEventTarget(target);
                if (!target) return -4;
                if (!target.requestPointerLock && !target.msRequestPointerLock) {
                    return -1
                }
                var canPerformRequests = JSEvents.canPerformEventHandlerRequests();
                if (!canPerformRequests) {
                    if (deferUntilInEventHandler) {
                        JSEvents.deferCall(__requestPointerLock, 2, [target]);
                        return 1
                    } else {
                        return -2
                    }
                }
                return __requestPointerLock(target)
            }

            function _emscripten_get_heap_size() {
                return HEAPU8.length
            }

            function emscripten_realloc_buffer(size) {
                try {
                    wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
                    updateGlobalBufferAndViews(wasmMemory.buffer);
                    return 1
                } catch (e) {}
            }

            function _emscripten_resize_heap(requestedSize) {
                requestedSize = requestedSize >>> 0;
                var oldSize = _emscripten_get_heap_size();
                var PAGE_MULTIPLE = 65536;
                var maxHeapSize = 2147483648;
                if (requestedSize > maxHeapSize) {
                    return false
                }
                var minHeapSize = 16777216;
                for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
                    var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
                    overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
                    var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), PAGE_MULTIPLE));
                    var replacement = emscripten_realloc_buffer(newSize);
                    if (replacement) {
                        return true
                    }
                }
                return false
            }

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

            function __registerBeforeUnloadEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
                var beforeUnloadEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    var confirmationMessage = dynCall_iiii(callbackfunc, eventTypeId, 0, userData);
                    if (confirmationMessage) {
                        confirmationMessage = UTF8ToString(confirmationMessage)
                    }
                    if (confirmationMessage) {
                        e.preventDefault();
                        e.returnValue = confirmationMessage;
                        return confirmationMessage
                    }
                };
                var eventHandler = {
                    target: __findEventTarget(target),
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: beforeUnloadEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_beforeunload_callback_on_thread(userData, callbackfunc, targetThread) {
                if (typeof onbeforeunload === "undefined") return -1;
                if (targetThread !== 1) return -5;
                __registerBeforeUnloadEventCallback(2, userData, true, callbackfunc, 28, "beforeunload");
                return 0
            }

            function __registerFocusEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.focusEvent) JSEvents.focusEvent = _malloc(256);
                var focusEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    var nodeName = JSEvents.getNodeNameForTarget(e.target);
                    var id = e.target.id ? e.target.id : "";
                    var focusEvent = JSEvents.focusEvent;
                    stringToUTF8(nodeName, focusEvent + 0, 128);
                    stringToUTF8(id, focusEvent + 128, 128);
                    if (dynCall_iiii(callbackfunc, eventTypeId, focusEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: __findEventTarget(target),
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: focusEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_blur_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                __registerFocusEventCallback(target, userData, useCapture, callbackfunc, 12, "blur", targetThread);
                return 0
            }

            function _emscripten_set_element_css_size(target, width, height) {
                target = __findEventTarget(target);
                if (!target) return -4;
                target.style.width = width + "px";
                target.style.height = height + "px";
                return 0
            }

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

            function __registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.fullscreenChangeEvent) JSEvents.fullscreenChangeEvent = _malloc(280);
                var fullscreenChangeEventhandlerFunc = function(ev) {
                    var e = ev || event;
                    var fullscreenChangeEvent = JSEvents.fullscreenChangeEvent;
                    __fillFullscreenChangeEventData(fullscreenChangeEvent);
                    if (dynCall_iiii(callbackfunc, eventTypeId, fullscreenChangeEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: target,
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: fullscreenChangeEventhandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_fullscreenchange_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                if (!JSEvents.fullscreenEnabled()) return -1;
                target = __findEventTarget(target);
                if (!target) return -4;
                __registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "fullscreenchange", targetThread);
                __registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "webkitfullscreenchange", targetThread);
                return 0
            }

            function __registerGamepadEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.gamepadEvent) JSEvents.gamepadEvent = _malloc(1432);
                var gamepadEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    var gamepadEvent = JSEvents.gamepadEvent;
                    __fillGamepadEventData(gamepadEvent, e["gamepad"]);
                    if (dynCall_iiii(callbackfunc, eventTypeId, gamepadEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: __findEventTarget(target),
                    allowsDeferredCalls: true,
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: gamepadEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

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

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

            function __registerKeyEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.keyEvent) JSEvents.keyEvent = _malloc(164);
                var keyEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    var keyEventData = JSEvents.keyEvent;
                    stringToUTF8(e.key ? e.key : "", keyEventData + 0, 32);
                    stringToUTF8(e.code ? e.code : "", keyEventData + 32, 32);
                    HEAP32[keyEventData + 64 >> 2] = e.location;
                    HEAP32[keyEventData + 68 >> 2] = e.ctrlKey;
                    HEAP32[keyEventData + 72 >> 2] = e.shiftKey;
                    HEAP32[keyEventData + 76 >> 2] = e.altKey;
                    HEAP32[keyEventData + 80 >> 2] = e.metaKey;
                    HEAP32[keyEventData + 84 >> 2] = e.repeat;
                    stringToUTF8(e.locale ? e.locale : "", keyEventData + 88, 32);
                    stringToUTF8(e.char ? e.char : "", keyEventData + 120, 32);
                    HEAP32[keyEventData + 152 >> 2] = e.charCode;
                    HEAP32[keyEventData + 156 >> 2] = e.keyCode;
                    HEAP32[keyEventData + 160 >> 2] = e.which;
                    if (dynCall_iiii(callbackfunc, eventTypeId, keyEventData, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: __findEventTarget(target),
                    allowsDeferredCalls: true,
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: keyEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_keydown_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                __registerKeyEventCallback(target, userData, useCapture, callbackfunc, 2, "keydown", targetThread);
                return 0
            }

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

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

            function _emscripten_set_main_loop_arg(func, arg, fps, simulateInfiniteLoop) {
                _emscripten_set_main_loop(func, fps, simulateInfiniteLoop, arg)
            }

            function __fillMouseEventData(eventStruct, e, target) {
                HEAP32[eventStruct >> 2] = e.screenX;
                HEAP32[eventStruct + 4 >> 2] = e.screenY;
                HEAP32[eventStruct + 8 >> 2] = e.clientX;
                HEAP32[eventStruct + 12 >> 2] = e.clientY;
                HEAP32[eventStruct + 16 >> 2] = e.ctrlKey;
                HEAP32[eventStruct + 20 >> 2] = e.shiftKey;
                HEAP32[eventStruct + 24 >> 2] = e.altKey;
                HEAP32[eventStruct + 28 >> 2] = e.metaKey;
                HEAP16[eventStruct + 32 >> 1] = e.button;
                HEAP16[eventStruct + 34 >> 1] = e.buttons;
                var movementX = e["movementX"] || e.screenX - JSEvents.previousScreenX;
                var movementY = e["movementY"] || e.screenY - JSEvents.previousScreenY;
                HEAP32[eventStruct + 36 >> 2] = movementX;
                HEAP32[eventStruct + 40 >> 2] = movementY;
                var rect = __getBoundingClientRect(target);
                HEAP32[eventStruct + 44 >> 2] = e.clientX - rect.left;
                HEAP32[eventStruct + 48 >> 2] = e.clientY - rect.top;
                if (e.type !== "wheel" && e.type !== "mousewheel") {
                    JSEvents.previousScreenX = e.screenX;
                    JSEvents.previousScreenY = e.screenY
                }
            }

            function __registerMouseEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.mouseEvent) JSEvents.mouseEvent = _malloc(64);
                target = __findEventTarget(target);
                var mouseEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    __fillMouseEventData(JSEvents.mouseEvent, e, target);
                    if (dynCall_iiii(callbackfunc, eventTypeId, JSEvents.mouseEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: target,
                    allowsDeferredCalls: eventTypeString != "mousemove" && eventTypeString != "mouseenter" && eventTypeString != "mouseleave",
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: mouseEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_mousedown_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                __registerMouseEventCallback(target, userData, useCapture, callbackfunc, 5, "mousedown", targetThread);
                return 0
            }

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

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

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

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

            function __fillPointerlockChangeEventData(eventStruct) {
                var pointerLockElement = document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement || document.msPointerLockElement;
                var isPointerlocked = !!pointerLockElement;
                HEAP32[eventStruct >> 2] = isPointerlocked;
                var nodeName = JSEvents.getNodeNameForTarget(pointerLockElement);
                var id = pointerLockElement && pointerLockElement.id ? pointerLockElement.id : "";
                stringToUTF8(nodeName, eventStruct + 4, 128);
                stringToUTF8(id, eventStruct + 132, 128)
            }

            function __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.pointerlockChangeEvent) JSEvents.pointerlockChangeEvent = _malloc(260);
                var pointerlockChangeEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    var pointerlockChangeEvent = JSEvents.pointerlockChangeEvent;
                    __fillPointerlockChangeEventData(pointerlockChangeEvent);
                    if (dynCall_iiii(callbackfunc, eventTypeId, pointerlockChangeEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: target,
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: pointerlockChangeEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_pointerlockchange_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                if (!document || !document.body || !document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock) {
                    return -1
                }
                target = __findEventTarget(target);
                if (!target) return -4;
                __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "pointerlockchange", targetThread);
                __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "mozpointerlockchange", targetThread);
                __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "webkitpointerlockchange", targetThread);
                __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "mspointerlockchange", targetThread);
                return 0
            }

            function __registerUiEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.uiEvent) JSEvents.uiEvent = _malloc(36);
                target = __findEventTarget(target);
                var uiEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    if (e.target != target) {
                        return
                    }
                    var uiEvent = JSEvents.uiEvent;
                    var b = document.body;
                    HEAP32[uiEvent >> 2] = e.detail;
                    HEAP32[uiEvent + 4 >> 2] = b.clientWidth;
                    HEAP32[uiEvent + 8 >> 2] = b.clientHeight;
                    HEAP32[uiEvent + 12 >> 2] = innerWidth;
                    HEAP32[uiEvent + 16 >> 2] = innerHeight;
                    HEAP32[uiEvent + 20 >> 2] = outerWidth;
                    HEAP32[uiEvent + 24 >> 2] = outerHeight;
                    HEAP32[uiEvent + 28 >> 2] = pageXOffset;
                    HEAP32[uiEvent + 32 >> 2] = pageYOffset;
                    if (dynCall_iiii(callbackfunc, eventTypeId, uiEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: target,
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: uiEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_resize_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                __registerUiEventCallback(target, userData, useCapture, callbackfunc, 10, "resize", targetThread);
                return 0
            }

            function __registerTouchEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.touchEvent) JSEvents.touchEvent = _malloc(1684);
                target = __findEventTarget(target);
                var touchEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    var touches = {};
                    for (var i = 0; i < e.touches.length; ++i) {
                        var touch = e.touches[i];
                        touch.changed = false;
                        touches[touch.identifier] = touch
                    }
                    for (var i = 0; i < e.changedTouches.length; ++i) {
                        var touch = e.changedTouches[i];
                        touches[touch.identifier] = touch;
                        touch.changed = true
                    }
                    for (var i = 0; i < e.targetTouches.length; ++i) {
                        var touch = e.targetTouches[i];
                        touches[touch.identifier].onTarget = true
                    }
                    var touchEvent = JSEvents.touchEvent;
                    var ptr = touchEvent;
                    HEAP32[ptr + 4 >> 2] = e.ctrlKey;
                    HEAP32[ptr + 8 >> 2] = e.shiftKey;
                    HEAP32[ptr + 12 >> 2] = e.altKey;
                    HEAP32[ptr + 16 >> 2] = e.metaKey;
                    ptr += 20;
                    var targetRect = __getBoundingClientRect(target);
                    var numTouches = 0;
                    for (var i in touches) {
                        var t = touches[i];
                        HEAP32[ptr >> 2] = t.identifier;
                        HEAP32[ptr + 4 >> 2] = t.screenX;
                        HEAP32[ptr + 8 >> 2] = t.screenY;
                        HEAP32[ptr + 12 >> 2] = t.clientX;
                        HEAP32[ptr + 16 >> 2] = t.clientY;
                        HEAP32[ptr + 20 >> 2] = t.pageX;
                        HEAP32[ptr + 24 >> 2] = t.pageY;
                        HEAP32[ptr + 28 >> 2] = t.changed;
                        HEAP32[ptr + 32 >> 2] = t.onTarget;
                        HEAP32[ptr + 36 >> 2] = t.clientX - targetRect.left;
                        HEAP32[ptr + 40 >> 2] = t.clientY - targetRect.top;
                        ptr += 52;
                        if (++numTouches >= 32) {
                            break
                        }
                    }
                    HEAP32[touchEvent >> 2] = numTouches;
                    if (dynCall_iiii(callbackfunc, eventTypeId, touchEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: target,
                    allowsDeferredCalls: eventTypeString == "touchstart" || eventTypeString == "touchend",
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: touchEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_touchcancel_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                __registerTouchEventCallback(target, userData, useCapture, callbackfunc, 25, "touchcancel", targetThread);
                return 0
            }

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

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

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

            function __fillVisibilityChangeEventData(eventStruct) {
                var visibilityStates = ["hidden", "visible", "prerender", "unloaded"];
                var visibilityState = visibilityStates.indexOf(document.visibilityState);
                HEAP32[eventStruct >> 2] = document.hidden;
                HEAP32[eventStruct + 4 >> 2] = visibilityState
            }

            function __registerVisibilityChangeEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.visibilityChangeEvent) JSEvents.visibilityChangeEvent = _malloc(8);
                var visibilityChangeEventHandlerFunc = function(ev) {
                    var e = ev || event;
                    var visibilityChangeEvent = JSEvents.visibilityChangeEvent;
                    __fillVisibilityChangeEventData(visibilityChangeEvent);
                    if (dynCall_iiii(callbackfunc, eventTypeId, visibilityChangeEvent, userData)) e.preventDefault()
                };
                var eventHandler = {
                    target: target,
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: visibilityChangeEventHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_visibilitychange_callback_on_thread(userData, useCapture, callbackfunc, targetThread) {
                __registerVisibilityChangeEventCallback(specialHTMLTargets[1], userData, useCapture, callbackfunc, 21, "visibilitychange", targetThread);
                return 0
            }

            function __registerWheelEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
                if (!JSEvents.wheelEvent) JSEvents.wheelEvent = _malloc(96);
                var wheelHandlerFunc = function(ev) {
                    var e = ev || event;
                    var wheelEvent = JSEvents.wheelEvent;
                    __fillMouseEventData(wheelEvent, e, target);
                    HEAPF64[wheelEvent + 64 >> 3] = e["deltaX"];
                    HEAPF64[wheelEvent + 72 >> 3] = e["deltaY"];
                    HEAPF64[wheelEvent + 80 >> 3] = e["deltaZ"];
                    HEAP32[wheelEvent + 88 >> 2] = e["deltaMode"];
                    if (dynCall_iiii(callbackfunc, eventTypeId, wheelEvent, userData)) e.preventDefault()
                };
                var mouseWheelHandlerFunc = function(ev) {
                    var e = ev || event;
                    __fillMouseEventData(JSEvents.wheelEvent, e, target);
                    HEAPF64[JSEvents.wheelEvent + 64 >> 3] = e["wheelDeltaX"] || 0;
                    var wheelDeltaY = -(e["wheelDeltaY"] || e["wheelDelta"]);
                    HEAPF64[JSEvents.wheelEvent + 72 >> 3] = wheelDeltaY;
                    HEAPF64[JSEvents.wheelEvent + 80 >> 3] = 0;
                    HEAP32[JSEvents.wheelEvent + 88 >> 2] = 0;
                    var shouldCancel = dynCall_iiii(callbackfunc, eventTypeId, JSEvents.wheelEvent, userData);
                    if (shouldCancel) {
                        e.preventDefault()
                    }
                };
                var eventHandler = {
                    target: target,
                    allowsDeferredCalls: true,
                    eventTypeString: eventTypeString,
                    callbackfunc: callbackfunc,
                    handlerFunc: eventTypeString == "wheel" ? wheelHandlerFunc : mouseWheelHandlerFunc,
                    useCapture: useCapture
                };
                JSEvents.registerOrRemoveHandler(eventHandler)
            }

            function _emscripten_set_wheel_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
                target = __findEventTarget(target);
                if (typeof target.onwheel !== "undefined") {
                    __registerWheelEventCallback(target, userData, useCapture, callbackfunc, 9, "wheel", targetThread);
                    return 0
                } else if (typeof target.onmousewheel !== "undefined") {
                    __registerWheelEventCallback(target, userData, useCapture, callbackfunc, 9, "mousewheel", targetThread);
                    return 0
                } else {
                    return -1
                }
            }

            function _emscripten_sleep() {
                throw "Please compile your program with async support in order to use asynchronous operations like emscripten_sleep"
            }
            var Fetch = {
                xhrs: [],
                setu64: function(addr, val) {
                    HEAPU32[addr >> 2] = val;
                    HEAPU32[addr + 4 >> 2] = val / 4294967296 | 0
                },
                openDatabase: function(dbname, dbversion, onsuccess, onerror) {
                    try {
                        var openRequest = indexedDB.open(dbname, dbversion)
                    } catch (e) {
                        return onerror(e)
                    }
                    openRequest.onupgradeneeded = function(event) {
                        var db = event.target.result;
                        if (db.objectStoreNames.contains("FILES")) {
                            db.deleteObjectStore("FILES")
                        }
                        db.createObjectStore("FILES")
                    };
                    openRequest.onsuccess = function(event) {
                        onsuccess(event.target.result)
                    };
                    openRequest.onerror = function(error) {
                        onerror(error)
                    }
                },
                staticInit: function() {
                    var isMainThread = true;
                    var onsuccess = function(db) {
                        Fetch.dbInstance = db;
                        if (isMainThread) {
                            removeRunDependency("library_fetch_init")
                        }
                    };
                    var onerror = function() {
                        Fetch.dbInstance = false;
                        if (isMainThread) {
                            removeRunDependency("library_fetch_init")
                        }
                    };
                    Fetch.openDatabase("emscripten_filesystem", 1, onsuccess, onerror);
                    if (typeof ENVIRONMENT_IS_FETCH_WORKER === "undefined" || !ENVIRONMENT_IS_FETCH_WORKER) addRunDependency("library_fetch_init")
                }
            };

            function __emscripten_fetch_xhr(fetch, onsuccess, onerror, onprogress, onreadystatechange) {
                var url = HEAPU32[fetch + 8 >> 2];
                if (!url) {
                    onerror(fetch, 0, "no url specified!");
                    return
                }
                var url_ = UTF8ToString(url);
                var fetch_attr = fetch + 112;
                var requestMethod = UTF8ToString(fetch_attr);
                if (!requestMethod) requestMethod = "GET";
                var userData = HEAPU32[fetch_attr + 32 >> 2];
                var fetchAttributes = HEAPU32[fetch_attr + 52 >> 2];
                var timeoutMsecs = HEAPU32[fetch_attr + 56 >> 2];
                var withCredentials = !!HEAPU32[fetch_attr + 60 >> 2];
                var destinationPath = HEAPU32[fetch_attr + 64 >> 2];
                var userName = HEAPU32[fetch_attr + 68 >> 2];
                var password = HEAPU32[fetch_attr + 72 >> 2];
                var requestHeaders = HEAPU32[fetch_attr + 76 >> 2];
                var overriddenMimeType = HEAPU32[fetch_attr + 80 >> 2];
                var dataPtr = HEAPU32[fetch_attr + 84 >> 2];
                var dataLength = HEAPU32[fetch_attr + 88 >> 2];
                var fetchAttrLoadToMemory = !!(fetchAttributes & 1);
                var fetchAttrStreamData = !!(fetchAttributes & 2);
                var fetchAttrSynchronous = !!(fetchAttributes & 64);
                var userNameStr = userName ? UTF8ToString(userName) : undefined;
                var passwordStr = password ? UTF8ToString(password) : undefined;
                var overriddenMimeTypeStr = overriddenMimeType ? UTF8ToString(overriddenMimeType) : undefined;
                var xhr = new XMLHttpRequest;
                xhr.withCredentials = withCredentials;
                //console.log('url_: '+url_);
                xhr.open(requestMethod, url_, !fetchAttrSynchronous, userNameStr, passwordStr);
                if (!fetchAttrSynchronous) xhr.timeout = timeoutMsecs;
                xhr.url_ = url_;
                xhr.responseType = "arraybuffer";
                if (overriddenMimeType) {
                    xhr.overrideMimeType(overriddenMimeTypeStr)
                }
                if (requestHeaders) {
                    for (;;) {
                        var key = HEAPU32[requestHeaders >> 2];
                        if (!key) break;
                        var value = HEAPU32[requestHeaders + 4 >> 2];
                        if (!value) break;
                        requestHeaders += 8;
                        var keyStr = UTF8ToString(key);
                        var valueStr = UTF8ToString(value);
                        xhr.setRequestHeader(keyStr, valueStr)
                    }
                }
                Fetch.xhrs.push(xhr);
                var id = Fetch.xhrs.length;
                HEAPU32[fetch + 0 >> 2] = id;
                var data = dataPtr && dataLength ? HEAPU8.slice(dataPtr, dataPtr + dataLength) : null;
                xhr.onload = function(e) {
                    var len = xhr.response ? xhr.response.byteLength : 0;
                    var ptr = 0;
                    var ptrLen = 0;
                    if (fetchAttrLoadToMemory && !fetchAttrStreamData) {
                        ptrLen = len;
                        ptr = _malloc(ptrLen);
                        HEAPU8.set(new Uint8Array(xhr.response), ptr)
                    }
                    HEAPU32[fetch + 12 >> 2] = ptr;
                    Fetch.setu64(fetch + 16, ptrLen);
                    Fetch.setu64(fetch + 24, 0);
                    if (len) {
                        Fetch.setu64(fetch + 32, len)
                    }
                    HEAPU16[fetch + 40 >> 1] = xhr.readyState;
                    if (xhr.readyState === 4 && xhr.status === 0) {
                        if (len > 0) xhr.status = 200;
                        else xhr.status = 404
                    }
                    HEAPU16[fetch + 42 >> 1] = xhr.status;
                    if (xhr.statusText) stringToUTF8(xhr.statusText, fetch + 44, 64);
                    if (xhr.status >= 200 && xhr.status < 300) {
                        if (onsuccess) onsuccess(fetch, xhr, e)
                    } else {
                        if (onerror) onerror(fetch, xhr, e)
                    }
                };

                xhr.onerror = function(e) {
                    var status = xhr.status;
                    if (xhr.readyState === 4 && status === 0) status = 404;
                    HEAPU32[fetch + 12 >> 2] = 0;
                    Fetch.setu64(fetch + 16, 0);
                    Fetch.setu64(fetch + 24, 0);
                    Fetch.setu64(fetch + 32, 0);
                    HEAPU16[fetch + 40 >> 1] = xhr.readyState;
                    HEAPU16[fetch + 42 >> 1] = status;
                    if (onerror) onerror(fetch, xhr, e)
                };
                xhr.ontimeout = function(e) {
                    if (onerror) onerror(fetch, xhr, e)
                };
                xhr.onprogress = function(e) {
                    var ptrLen = fetchAttrLoadToMemory && fetchAttrStreamData && xhr.response ? xhr.response.byteLength : 0;
                    var ptr = 0;
                    if (fetchAttrLoadToMemory && fetchAttrStreamData) {
                        ptr = _malloc(ptrLen);
                        HEAPU8.set(new Uint8Array(xhr.response), ptr)
                    }
                    HEAPU32[fetch + 12 >> 2] = ptr;
                    Fetch.setu64(fetch + 16, ptrLen);
                    Fetch.setu64(fetch + 24, e.loaded - ptrLen);
                    Fetch.setu64(fetch + 32, e.total);
                    HEAPU16[fetch + 40 >> 1] = xhr.readyState;
                    if (xhr.readyState >= 3 && xhr.status === 0 && e.loaded > 0) xhr.status = 200;
                    HEAPU16[fetch + 42 >> 1] = xhr.status;
                    if (xhr.statusText) stringToUTF8(xhr.statusText, fetch + 44, 64);
                    if (onprogress) onprogress(fetch, xhr, e)
                };
                xhr.onreadystatechange = function(e) {
                    HEAPU16[fetch + 40 >> 1] = xhr.readyState;
                    if (xhr.readyState >= 2) {
                        HEAPU16[fetch + 42 >> 1] = xhr.status
                    }
                    if (onreadystatechange) onreadystatechange(fetch, xhr, e)
                };
                try {
                    xhr.send(data)
                } catch (e) {
                    if (onerror) onerror(fetch, xhr, e)
                }
            }

            function __emscripten_fetch_cache_data(db, fetch, data, onsuccess, onerror) {
                if (!db) {
                    onerror(fetch, 0, "IndexedDB not available!");
                    return
                }
                var fetch_attr = fetch + 112;
                var destinationPath = HEAPU32[fetch_attr + 64 >> 2];
                if (!destinationPath) destinationPath = HEAPU32[fetch + 8 >> 2];
                var destinationPathStr = UTF8ToString(destinationPath);
                try {
                    var transaction = db.transaction(["FILES"], "readwrite");
                    var packages = transaction.objectStore("FILES");
                    var putRequest = packages.put(data, destinationPathStr);
                    putRequest.onsuccess = function(event) {
                        HEAPU16[fetch + 40 >> 1] = 4;
                        HEAPU16[fetch + 42 >> 1] = 200;
                        stringToUTF8("OK", fetch + 44, 64);
                        onsuccess(fetch, 0, destinationPathStr)
                    };
                    putRequest.onerror = function(error) {
                        HEAPU16[fetch + 40 >> 1] = 4;
                        HEAPU16[fetch + 42 >> 1] = 413;
                        stringToUTF8("Payload Too Large", fetch + 44, 64);
                        onerror(fetch, 0, error)
                    }
                } catch (e) {
                    onerror(fetch, 0, e)
                }
            }

            function __emscripten_fetch_load_cached_data(db, fetch, onsuccess, onerror) {
                if (!db) {
                    onerror(fetch, 0, "IndexedDB not available!");
                    return
                }
                var fetch_attr = fetch + 112;
                var path = HEAPU32[fetch_attr + 64 >> 2];
                if (!path) path = HEAPU32[fetch + 8 >> 2];
                var pathStr = UTF8ToString(path);
                try {
                    var transaction = db.transaction(["FILES"], "readonly");
                    var packages = transaction.objectStore("FILES");
                    var getRequest = packages.get(pathStr);
                    getRequest.onsuccess = function(event) {
                        if (event.target.result) {
                            var value = event.target.result;
                            var len = value.byteLength || value.length;
                            var ptr = _malloc(len);
                            HEAPU8.set(new Uint8Array(value), ptr);
                            HEAPU32[fetch + 12 >> 2] = ptr;
                            Fetch.setu64(fetch + 16, len);
                            Fetch.setu64(fetch + 24, 0);
                            Fetch.setu64(fetch + 32, len);
                            HEAPU16[fetch + 40 >> 1] = 4;
                            HEAPU16[fetch + 42 >> 1] = 200;
                            stringToUTF8("OK", fetch + 44, 64);
                            onsuccess(fetch, 0, value)
                        } else {
                            HEAPU16[fetch + 40 >> 1] = 4;
                            HEAPU16[fetch + 42 >> 1] = 404;
                            stringToUTF8("Not Found", fetch + 44, 64);
                            onerror(fetch, 0, "no data")
                        }
                    };
                    getRequest.onerror = function(error) {
                        HEAPU16[fetch + 40 >> 1] = 4;
                        HEAPU16[fetch + 42 >> 1] = 404;
                        stringToUTF8("Not Found", fetch + 44, 64);
                        onerror(fetch, 0, error)
                    }
                } catch (e) {
                    onerror(fetch, 0, e)
                }
            }

            function __emscripten_fetch_delete_cached_data(db, fetch, onsuccess, onerror) {
                if (!db) {
                    onerror(fetch, 0, "IndexedDB not available!");
                    return
                }
                var fetch_attr = fetch + 112;
                var path = HEAPU32[fetch_attr + 64 >> 2];
                if (!path) path = HEAPU32[fetch + 8 >> 2];
                var pathStr = UTF8ToString(path);
                try {
                    var transaction = db.transaction(["FILES"], "readwrite");
                    var packages = transaction.objectStore("FILES");
                    var request = packages.delete(pathStr);
                    request.onsuccess = function(event) {
                        var value = event.target.result;
                        HEAPU32[fetch + 12 >> 2] = 0;
                        Fetch.setu64(fetch + 16, 0);
                        Fetch.setu64(fetch + 24, 0);
                        Fetch.setu64(fetch + 32, 0);
                        HEAPU16[fetch + 40 >> 1] = 4;
                        HEAPU16[fetch + 42 >> 1] = 200;
                        stringToUTF8("OK", fetch + 44, 64);
                        onsuccess(fetch, 0, value)
                    };
                    request.onerror = function(error) {
                        HEAPU16[fetch + 40 >> 1] = 4;
                        HEAPU16[fetch + 42 >> 1] = 404;
                        stringToUTF8("Not Found", fetch + 44, 64);
                        onerror(fetch, 0, error)
                    }
                } catch (e) {
                    onerror(fetch, 0, e)
                }
            }
            var _fetch_work_queue = 887136;

            function _emscripten_start_fetch(fetch, successcb, errorcb, progresscb, readystatechangecb) {
                if (typeof noExitRuntime !== "undefined") noExitRuntime = true;
                var fetch_attr = fetch + 112;
                var requestMethod = UTF8ToString(fetch_attr);
                var onsuccess = HEAPU32[fetch_attr + 36 >> 2];
                var onerror = HEAPU32[fetch_attr + 40 >> 2];
                var onprogress = HEAPU32[fetch_attr + 44 >> 2];
                var onreadystatechange = HEAPU32[fetch_attr + 48 >> 2];
                var fetchAttributes = HEAPU32[fetch_attr + 52 >> 2];
                var fetchAttrPersistFile = !!(fetchAttributes & 4);
                var fetchAttrNoDownload = !!(fetchAttributes & 32);
                var fetchAttrReplace = !!(fetchAttributes & 16);
                var reportSuccess = function(fetch, xhr, e) {
                    if (onsuccess) dynCall_vi(onsuccess, fetch);
                    else if (successcb) successcb(fetch)
                };
                var reportProgress = function(fetch, xhr, e) {
                    if (onprogress) dynCall_vi(onprogress, fetch);
                    else if (progresscb) progresscb(fetch)
                };
                var reportError = function(fetch, xhr, e) {
                    if (onerror) dynCall_vi(onerror, fetch);
                    else if (errorcb) errorcb(fetch)
                };
                var reportReadyStateChange = function(fetch, xhr, e) {
                    if (onreadystatechange) dynCall_vi(onreadystatechange, fetch);
                    else if (readystatechangecb) readystatechangecb(fetch)
                };
                var performUncachedXhr = function(fetch, xhr, e) {
                    __emscripten_fetch_xhr(fetch, reportSuccess, reportError, reportProgress, reportReadyStateChange)
                };
                var cacheResultAndReportSuccess = function(fetch, xhr, e) {
                    var storeSuccess = function(fetch, xhr, e) {
                        if (onsuccess) dynCall_vi(onsuccess, fetch);
                        else if (successcb) successcb(fetch)
                    };
                    var storeError = function(fetch, xhr, e) {
                        if (onsuccess) dynCall_vi(onsuccess, fetch);
                        else if (successcb) successcb(fetch)
                    };
                    __emscripten_fetch_cache_data(Fetch.dbInstance, fetch, xhr.response, storeSuccess, storeError)
                };
                var performCachedXhr = function(fetch, xhr, e) {
                    __emscripten_fetch_xhr(fetch, cacheResultAndReportSuccess, reportError, reportProgress, reportReadyStateChange)
                };
                if (requestMethod === "EM_IDB_STORE") {
                    var ptr = HEAPU32[fetch_attr + 84 >> 2];
                    __emscripten_fetch_cache_data(Fetch.dbInstance, fetch, HEAPU8.slice(ptr, ptr + HEAPU32[fetch_attr + 88 >> 2]), reportSuccess, reportError)
                } else if (requestMethod === "EM_IDB_DELETE") {
                    __emscripten_fetch_delete_cached_data(Fetch.dbInstance, fetch, reportSuccess, reportError)
                } else if (!fetchAttrReplace) {
                    __emscripten_fetch_load_cached_data(Fetch.dbInstance, fetch, reportSuccess, fetchAttrNoDownload ? reportError : fetchAttrPersistFile ? performCachedXhr : performUncachedXhr)
                } else if (!fetchAttrNoDownload) {
                    __emscripten_fetch_xhr(fetch, fetchAttrPersistFile ? cacheResultAndReportSuccess : reportSuccess, reportError, reportProgress, reportReadyStateChange)
                } else {
                    return 0
                }
                return fetch
            }
            var ENV = {};

            function __getExecutableName() {
                return thisProgram || "./this.program"
            }

            function getEnvStrings() {
                if (!getEnvStrings.strings) {
                    var env = {
                        "USER": "web_user",
                        "LOGNAME": "web_user",
                        "PATH": "/",
                        "PWD": "/",
                        "HOME": "/home/web_user",
                        "LANG": (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8",
                        "_": __getExecutableName()
                    };
                    for (var x in ENV) {
                        env[x] = ENV[x]
                    }
                    var strings = [];
                    for (var x in env) {
                        strings.push(x + "=" + env[x])
                    }
                    getEnvStrings.strings = strings
                }
                return getEnvStrings.strings
            }

            function _environ_get(__environ, environ_buf) {
                var bufSize = 0;
                getEnvStrings().forEach(function(string, i) {
                    var ptr = environ_buf + bufSize;
                    HEAP32[__environ + i * 4 >> 2] = ptr;
                    writeAsciiToMemory(string, ptr);
                    bufSize += string.length + 1
                });
                return 0
            }

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

            function _exit(status) {
                exit(status)
            }

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

            function _fd_fdstat_get(fd, pbuf) {
                try {
                    var stream = SYSCALLS.getStreamFromFD(fd);
                    var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
                    HEAP8[pbuf >> 0] = type;
                    return 0
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return e.errno
                }
            }

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

            function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
                try {
                    var stream = SYSCALLS.getStreamFromFD(fd);
                    var HIGH_OFFSET = 4294967296;
                    var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0);
                    var DOUBLE_LIMIT = 9007199254740992;
                    if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) {
                        return -61
                    }
                    FS.llseek(stream, offset, whence);
                    tempI64 = [stream.position >>> 0, (tempDouble = stream.position, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[newOffset >> 2] = tempI64[0], HEAP32[newOffset + 4 >> 2] = tempI64[1];
                    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 _fd_write(fd, iov, iovcnt, pnum) {
                try {
                    var stream = SYSCALLS.getStreamFromFD(fd);
                    var num = SYSCALLS.doWritev(stream, iov, iovcnt);
                    HEAP32[pnum >> 2] = num;
                    return 0
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return e.errno
                }
            }

            function _getTempRet0() {
                return getTempRet0() | 0
            }

            function _gettimeofday(ptr) {
                var now = Date.now();
                HEAP32[ptr >> 2] = now / 1e3 | 0;
                HEAP32[ptr + 4 >> 2] = now % 1e3 * 1e3 | 0;
                return 0
            }
            var ___tm_timezone = (stringToUTF8("GMT", 887040, 4), 887040);

            function _gmtime_r(time, tmPtr) {
                var date = new Date(HEAP32[time >> 2] * 1e3);
                HEAP32[tmPtr >> 2] = date.getUTCSeconds();
                HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
                HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
                HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
                HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
                HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
                HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
                HEAP32[tmPtr + 36 >> 2] = 0;
                HEAP32[tmPtr + 32 >> 2] = 0;
                var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
                var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
                HEAP32[tmPtr + 28 >> 2] = yday;
                HEAP32[tmPtr + 40 >> 2] = ___tm_timezone;
                return tmPtr
            }
            var ___tm_current = 886992;

            function _tzset() {
                if (_tzset.called) return;
                _tzset.called = true;
                HEAP32[__get_timezone() >> 2] = (new Date).getTimezoneOffset() * 60;
                var currentYear = (new Date).getFullYear();
                var winter = new Date(currentYear, 0, 1);
                var summer = new Date(currentYear, 6, 1);
                HEAP32[__get_daylight() >> 2] = Number(winter.getTimezoneOffset() != summer.getTimezoneOffset());

                function extractZone(date) {
                    var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/);
                    return match ? match[1] : "GMT"
                }
                var winterName = extractZone(winter);
                var summerName = extractZone(summer);
                var winterNamePtr = allocateUTF8(winterName);
                var summerNamePtr = allocateUTF8(summerName);
                if (summer.getTimezoneOffset() < winter.getTimezoneOffset()) {
                    HEAP32[__get_tzname() >> 2] = winterNamePtr;
                    HEAP32[__get_tzname() + 4 >> 2] = summerNamePtr
                } else {
                    HEAP32[__get_tzname() >> 2] = summerNamePtr;
                    HEAP32[__get_tzname() + 4 >> 2] = winterNamePtr
                }
            }

            function _localtime_r(time, tmPtr) {
                _tzset();
                var date = new Date(HEAP32[time >> 2] * 1e3);
                HEAP32[tmPtr >> 2] = date.getSeconds();
                HEAP32[tmPtr + 4 >> 2] = date.getMinutes();
                HEAP32[tmPtr + 8 >> 2] = date.getHours();
                HEAP32[tmPtr + 12 >> 2] = date.getDate();
                HEAP32[tmPtr + 16 >> 2] = date.getMonth();
                HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900;
                HEAP32[tmPtr + 24 >> 2] = date.getDay();
                var start = new Date(date.getFullYear(), 0, 1);
                var yday = (date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24) | 0;
                HEAP32[tmPtr + 28 >> 2] = yday;
                HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60);
                var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
                var winterOffset = start.getTimezoneOffset();
                var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
                HEAP32[tmPtr + 32 >> 2] = dst;
                var zonePtr = HEAP32[__get_tzname() + (dst ? 4 : 0) >> 2];
                HEAP32[tmPtr + 40 >> 2] = zonePtr;
                return tmPtr
            }

            function _localtime(time) {
                return _localtime_r(time, ___tm_current)
            }

            function _mktime(tmPtr) {
                _tzset();
                var date = new Date(HEAP32[tmPtr + 20 >> 2] + 1900, HEAP32[tmPtr + 16 >> 2], HEAP32[tmPtr + 12 >> 2], HEAP32[tmPtr + 8 >> 2], HEAP32[tmPtr + 4 >> 2], HEAP32[tmPtr >> 2], 0);
                var dst = HEAP32[tmPtr + 32 >> 2];
                var guessedOffset = date.getTimezoneOffset();
                var start = new Date(date.getFullYear(), 0, 1);
                var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
                var winterOffset = start.getTimezoneOffset();
                var dstOffset = Math.min(winterOffset, summerOffset);
                if (dst < 0) {
                    HEAP32[tmPtr + 32 >> 2] = Number(summerOffset != winterOffset && dstOffset == guessedOffset)
                } else if (dst > 0 != (dstOffset == guessedOffset)) {
                    var nonDstOffset = Math.max(winterOffset, summerOffset);
                    var trueOffset = dst > 0 ? dstOffset : nonDstOffset;
                    date.setTime(date.getTime() + (trueOffset - guessedOffset) * 6e4)
                }
                HEAP32[tmPtr + 24 >> 2] = date.getDay();
                var yday = (date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24) | 0;
                HEAP32[tmPtr + 28 >> 2] = yday;
                return date.getTime() / 1e3 | 0
            }

            function _usleep(useconds) {
                var start = _emscripten_get_now();
                while (_emscripten_get_now() - start < useconds / 1e3) {}
            }

            function _nanosleep(rqtp, rmtp) {
                if (rqtp === 0) {
                    setErrNo(28);
                    return -1
                }
                var seconds = HEAP32[rqtp >> 2];
                var nanoseconds = HEAP32[rqtp + 4 >> 2];
                if (nanoseconds < 0 || nanoseconds > 999999999 || seconds < 0) {
                    setErrNo(28);
                    return -1
                }
                if (rmtp !== 0) {
                    HEAP32[rmtp >> 2] = 0;
                    HEAP32[rmtp + 4 >> 2] = 0
                }
                return _usleep(seconds * 1e6 + nanoseconds / 1e3)
            }

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

            function _sigaction(signum, act, oldact) {
                return 0
            }
            var __sigalrm_handler = 0;

            function _signal(sig, func) {
                if (sig == 14) {
                    __sigalrm_handler = func
                } else {}
                return 0
            }

            function _sysconf(name) {
                switch (name) {
                    case 30:
                        return 16384;
                    case 85:
                        var maxHeapSize = 2147483648;
                        return maxHeapSize / 16384;
                    case 132:
                    case 133:
                    case 12:
                    case 137:
                    case 138:
                    case 15:
                    case 235:
                    case 16:
                    case 17:
                    case 18:
                    case 19:
                    case 20:
                    case 149:
                    case 13:
                    case 10:
                    case 236:
                    case 153:
                    case 9:
                    case 21:
                    case 22:
                    case 159:
                    case 154:
                    case 14:
                    case 77:
                    case 78:
                    case 139:
                    case 80:
                    case 81:
                    case 82:
                    case 68:
                    case 67:
                    case 164:
                    case 11:
                    case 29:
                    case 47:
                    case 48:
                    case 95:
                    case 52:
                    case 51:
                    case 46:
                    case 79:
                        return 200809;
                    case 27:
                    case 246:
                    case 127:
                    case 128:
                    case 23:
                    case 24:
                    case 160:
                    case 161:
                    case 181:
                    case 182:
                    case 242:
                    case 183:
                    case 184:
                    case 243:
                    case 244:
                    case 245:
                    case 165:
                    case 178:
                    case 179:
                    case 49:
                    case 50:
                    case 168:
                    case 169:
                    case 175:
                    case 170:
                    case 171:
                    case 172:
                    case 97:
                    case 76:
                    case 32:
                    case 173:
                    case 35:
                        return -1;
                    case 176:
                    case 177:
                    case 7:
                    case 155:
                    case 8:
                    case 157:
                    case 125:
                    case 126:
                    case 92:
                    case 93:
                    case 129:
                    case 130:
                    case 131:
                    case 94:
                    case 91:
                        return 1;
                    case 74:
                    case 60:
                    case 69:
                    case 70:
                    case 4:
                        return 1024;
                    case 31:
                    case 42:
                    case 72:
                        return 32;
                    case 87:
                    case 26:
                    case 33:
                        return 2147483647;
                    case 34:
                    case 1:
                        return 47839;
                    case 38:
                    case 36:
                        return 99;
                    case 43:
                    case 37:
                        return 2048;
                    case 0:
                        return 2097152;
                    case 3:
                        return 65536;
                    case 28:
                        return 32768;
                    case 44:
                        return 32767;
                    case 75:
                        return 16384;
                    case 39:
                        return 1e3;
                    case 89:
                        return 700;
                    case 71:
                        return 256;
                    case 40:
                        return 255;
                    case 2:
                        return 100;
                    case 180:
                        return 64;
                    case 25:
                        return 20;
                    case 5:
                        return 16;
                    case 6:
                        return 6;
                    case 73:
                        return 4;
                    case 84: {
                        if (typeof navigator === "object") return navigator["hardwareConcurrency"] || 1;
                        return 1
                    }
                }
                setErrNo(28);
                return -1
            }

            function _time(ptr) {
                var ret = Date.now() / 1e3 | 0;
                if (ptr) {
                    HEAP32[ptr >> 2] = ret
                }
                return ret
            }

            function readAsmConstArgs(sigPtr, buf) {
                if (!readAsmConstArgs.array) {
                    readAsmConstArgs.array = []
                }
                var args = readAsmConstArgs.array;
                args.length = 0;
                var ch;
                while (ch = HEAPU8[sigPtr++]) {
                    if (ch === 100 || ch === 102) {
                        buf = buf + 7 & ~7;
                        args.push(HEAPF64[buf >> 3]);
                        buf += 8
                    } else {
                        buf = buf + 3 & ~3;
                        args.push(HEAP32[buf >> 2]);
                        buf += 4
                    }
                }
                return args
            }
            var FSNode = function(parent, name, mode, rdev) {
                if (!parent) {
                    parent = this
                }
                this.parent = parent;
                this.mount = parent.mount;
                this.mounted = null;
                this.id = FS.nextInode++;
                this.name = name;
                this.mode = mode;
                this.node_ops = {};
                this.stream_ops = {};
                this.rdev = rdev
            };
            var readMode = 292 | 73;
            var writeMode = 146;
            Object.defineProperties(FSNode.prototype, {
                read: {
                    get: function() {
                        return (this.mode & readMode) === readMode
                    },
                    set: function(val) {
                        val ? this.mode |= readMode : this.mode &= ~readMode
                    }
                },
                write: {
                    get: function() {
                        return (this.mode & writeMode) === writeMode
                    },
                    set: function(val) {
                        val ? this.mode |= writeMode : this.mode &= ~writeMode
                    }
                },
                isFolder: {
                    get: function() {
                        return FS.isDir(this.mode)
                    }
                },
                isDevice: {
                    get: function() {
                        return FS.isChrdev(this.mode)
                    }
                }
            });
            FS.FSNode = FSNode;
            FS.staticInit();
            Module["FS_createFolder"] = FS.createFolder;
            Module["FS_createPath"] = FS.createPath;
            Module["FS_createDataFile"] = FS.createDataFile;
            Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
            Module["FS_createLazyFile"] = FS.createLazyFile;
            Module["FS_createLink"] = FS.createLink;
            Module["FS_createDevice"] = FS.createDevice;
            Module["FS_unlink"] = FS.unlink;
            Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas) {
                Browser.requestFullscreen(lockPointer, resizeCanvas)
            };
            Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) {
                Browser.requestAnimationFrame(func)
            };
            Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) {
                Browser.setCanvasSize(width, height, noUpdates)
            };
            Module["pauseMainLoop"] = function Module_pauseMainLoop() {
                Browser.mainLoop.pause()
            };
            Module["resumeMainLoop"] = function Module_resumeMainLoop() {
                Browser.mainLoop.resume()
            };
            Module["getUserMedia"] = function Module_getUserMedia() {
                Browser.getUserMedia()
            };
            Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) {
                return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes)
            };
            var GLctx;
            GL.init();
            for (var i = 0; i < 32; i++) __tempFixedLengthArray.push(new Array(i));
            Fetch.staticInit();
            var ASSERTIONS = false;

            function intArrayFromString(stringy, dontAddNull, length) {
                var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
                var u8array = new Array(len);
                var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
                if (dontAddNull) u8array.length = numBytesWritten;
                return u8array
            }
            var asmLibraryArg = {
                "__cxa_atexit": ___cxa_atexit,
                "__sys_fcntl64": ___sys_fcntl64,
                "__sys_fstat64": ___sys_fstat64,
                "__sys_ioctl": ___sys_ioctl,
                "__sys_open": ___sys_open,
                "__sys_read": ___sys_read,
                "__sys_stat64": ___sys_stat64,
                "_emscripten_fetch_free": __emscripten_fetch_free,
                "abort": _abort,
                "alBufferData": _alBufferData,
                "alDeleteBuffers": _alDeleteBuffers,
                "alDeleteSources": _alDeleteSources,
                "alGenBuffers": _alGenBuffers,
                "alGenSources": _alGenSources,
                "alGetSourcei": _alGetSourcei,
                "alSource3i": _alSource3i,
                "alSourcePlay": _alSourcePlay,
                "alSourceQueueBuffers": _alSourceQueueBuffers,
                "alSourceStop": _alSourceStop,
                "alSourceUnqueueBuffers": _alSourceUnqueueBuffers,
                "alSourcef": _alSourcef,
                "alSourcei": _alSourcei,
                "alcCloseDevice": _alcCloseDevice,
                "alcCreateContext": _alcCreateContext,
                "alcDestroyContext": _alcDestroyContext,
                "alcGetIntegerv": _alcGetIntegerv,
                "alcMakeContextCurrent": _alcMakeContextCurrent,
                "alcOpenDevice": _alcOpenDevice,
                "changeCursor": changeCursor,
                "clock_gettime": _clock_gettime,
                "dlclose": _dlclose,
                "eglBindAPI": _eglBindAPI,
                "eglChooseConfig": _eglChooseConfig,
                "eglCreateContext": _eglCreateContext,
                "eglCreateWindowSurface": _eglCreateWindowSurface,
                "eglDestroyContext": _eglDestroyContext,
                "eglDestroySurface": _eglDestroySurface,
                "eglGetConfigAttrib": _eglGetConfigAttrib,
                "eglGetDisplay": _eglGetDisplay,
                "eglGetError": _eglGetError,
                "eglGetProcAddress": _eglGetProcAddress,
                "eglInitialize": _eglInitialize,
                "eglMakeCurrent": _eglMakeCurrent,
                "eglQueryString": _eglQueryString,
                "eglSwapBuffers": _eglSwapBuffers,
                "eglSwapInterval": _eglSwapInterval,
                "eglTerminate": _eglTerminate,
                "eglWaitGL": _eglWaitGL,
                "eglWaitNative": _eglWaitNative,
                "emscripten_asm_const_iii": _emscripten_asm_const_iii,
                "emscripten_cancel_main_loop": _emscripten_cancel_main_loop,
                "emscripten_exit_fullscreen": _emscripten_exit_fullscreen,
                "emscripten_exit_pointerlock": _emscripten_exit_pointerlock,
                "emscripten_get_canvas_element_size": _emscripten_get_canvas_element_size,
                "emscripten_get_device_pixel_ratio": _emscripten_get_device_pixel_ratio,
                "emscripten_get_element_css_size": _emscripten_get_element_css_size,
                "emscripten_get_fullscreen_status": _emscripten_get_fullscreen_status,
                "emscripten_get_gamepad_status": _emscripten_get_gamepad_status,
                "emscripten_get_now": _emscripten_get_now,
                "emscripten_get_num_gamepads": _emscripten_get_num_gamepads,
                "emscripten_get_sbrk_ptr": _emscripten_get_sbrk_ptr,
                "emscripten_glActiveTexture": _emscripten_glActiveTexture,
                "emscripten_glAttachShader": _emscripten_glAttachShader,
                "emscripten_glBeginQuery": _emscripten_glBeginQuery,
                "emscripten_glBeginQueryEXT": _emscripten_glBeginQueryEXT,
                "emscripten_glBeginTransformFeedback": _emscripten_glBeginTransformFeedback,
                "emscripten_glBindAttribLocation": _emscripten_glBindAttribLocation,
                "emscripten_glBindBuffer": _emscripten_glBindBuffer,
                "emscripten_glBindBufferBase": _emscripten_glBindBufferBase,
                "emscripten_glBindBufferRange": _emscripten_glBindBufferRange,
                "emscripten_glBindFramebuffer": _emscripten_glBindFramebuffer,
                "emscripten_glBindRenderbuffer": _emscripten_glBindRenderbuffer,
                "emscripten_glBindSampler": _emscripten_glBindSampler,
                "emscripten_glBindTexture": _emscripten_glBindTexture,
                "emscripten_glBindTransformFeedback": _emscripten_glBindTransformFeedback,
                "emscripten_glBindVertexArray": _emscripten_glBindVertexArray,
                "emscripten_glBindVertexArrayOES": _emscripten_glBindVertexArrayOES,
                "emscripten_glBlendColor": _emscripten_glBlendColor,
                "emscripten_glBlendEquation": _emscripten_glBlendEquation,
                "emscripten_glBlendEquationSeparate": _emscripten_glBlendEquationSeparate,
                "emscripten_glBlendFunc": _emscripten_glBlendFunc,
                "emscripten_glBlendFuncSeparate": _emscripten_glBlendFuncSeparate,
                "emscripten_glBlitFramebuffer": _emscripten_glBlitFramebuffer,
                "emscripten_glBufferData": _emscripten_glBufferData,
                "emscripten_glBufferSubData": _emscripten_glBufferSubData,
                "emscripten_glCheckFramebufferStatus": _emscripten_glCheckFramebufferStatus,
                "emscripten_glClear": _emscripten_glClear,
                "emscripten_glClearBufferfi": _emscripten_glClearBufferfi,
                "emscripten_glClearBufferfv": _emscripten_glClearBufferfv,
                "emscripten_glClearBufferiv": _emscripten_glClearBufferiv,
                "emscripten_glClearBufferuiv": _emscripten_glClearBufferuiv,
                "emscripten_glClearColor": _emscripten_glClearColor,
                "emscripten_glClearDepthf": _emscripten_glClearDepthf,
                "emscripten_glClearStencil": _emscripten_glClearStencil,
                "emscripten_glClientWaitSync": _emscripten_glClientWaitSync,
                "emscripten_glColorMask": _emscripten_glColorMask,
                "emscripten_glCompileShader": _emscripten_glCompileShader,
                "emscripten_glCompressedTexImage2D": _emscripten_glCompressedTexImage2D,
                "emscripten_glCompressedTexImage3D": _emscripten_glCompressedTexImage3D,
                "emscripten_glCompressedTexSubImage2D": _emscripten_glCompressedTexSubImage2D,
                "emscripten_glCompressedTexSubImage3D": _emscripten_glCompressedTexSubImage3D,
                "emscripten_glCopyBufferSubData": _emscripten_glCopyBufferSubData,
                "emscripten_glCopyTexImage2D": _emscripten_glCopyTexImage2D,
                "emscripten_glCopyTexSubImage2D": _emscripten_glCopyTexSubImage2D,
                "emscripten_glCopyTexSubImage3D": _emscripten_glCopyTexSubImage3D,
                "emscripten_glCreateProgram": _emscripten_glCreateProgram,
                "emscripten_glCreateShader": _emscripten_glCreateShader,
                "emscripten_glCullFace": _emscripten_glCullFace,
                "emscripten_glDeleteBuffers": _emscripten_glDeleteBuffers,
                "emscripten_glDeleteFramebuffers": _emscripten_glDeleteFramebuffers,
                "emscripten_glDeleteProgram": _emscripten_glDeleteProgram,
                "emscripten_glDeleteQueries": _emscripten_glDeleteQueries,
                "emscripten_glDeleteQueriesEXT": _emscripten_glDeleteQueriesEXT,
                "emscripten_glDeleteRenderbuffers": _emscripten_glDeleteRenderbuffers,
                "emscripten_glDeleteSamplers": _emscripten_glDeleteSamplers,
                "emscripten_glDeleteShader": _emscripten_glDeleteShader,
                "emscripten_glDeleteSync": _emscripten_glDeleteSync,
                "emscripten_glDeleteTextures": _emscripten_glDeleteTextures,
                "emscripten_glDeleteTransformFeedbacks": _emscripten_glDeleteTransformFeedbacks,
                "emscripten_glDeleteVertexArrays": _emscripten_glDeleteVertexArrays,
                "emscripten_glDeleteVertexArraysOES": _emscripten_glDeleteVertexArraysOES,
                "emscripten_glDepthFunc": _emscripten_glDepthFunc,
                "emscripten_glDepthMask": _emscripten_glDepthMask,
                "emscripten_glDepthRangef": _emscripten_glDepthRangef,
                "emscripten_glDetachShader": _emscripten_glDetachShader,
                "emscripten_glDisable": _emscripten_glDisable,
                "emscripten_glDisableVertexAttribArray": _emscripten_glDisableVertexAttribArray,
                "emscripten_glDrawArrays": _emscripten_glDrawArrays,
                "emscripten_glDrawArraysInstanced": _emscripten_glDrawArraysInstanced,
                "emscripten_glDrawArraysInstancedANGLE": _emscripten_glDrawArraysInstancedANGLE,
                "emscripten_glDrawArraysInstancedARB": _emscripten_glDrawArraysInstancedARB,
                "emscripten_glDrawArraysInstancedEXT": _emscripten_glDrawArraysInstancedEXT,
                "emscripten_glDrawArraysInstancedNV": _emscripten_glDrawArraysInstancedNV,
                "emscripten_glDrawBuffers": _emscripten_glDrawBuffers,
                "emscripten_glDrawBuffersEXT": _emscripten_glDrawBuffersEXT,
                "emscripten_glDrawBuffersWEBGL": _emscripten_glDrawBuffersWEBGL,
                "emscripten_glDrawElements": _emscripten_glDrawElements,
                "emscripten_glDrawElementsInstanced": _emscripten_glDrawElementsInstanced,
                "emscripten_glDrawElementsInstancedANGLE": _emscripten_glDrawElementsInstancedANGLE,
                "emscripten_glDrawElementsInstancedARB": _emscripten_glDrawElementsInstancedARB,
                "emscripten_glDrawElementsInstancedEXT": _emscripten_glDrawElementsInstancedEXT,
                "emscripten_glDrawElementsInstancedNV": _emscripten_glDrawElementsInstancedNV,
                "emscripten_glDrawRangeElements": _emscripten_glDrawRangeElements,
                "emscripten_glEnable": _emscripten_glEnable,
                "emscripten_glEnableVertexAttribArray": _emscripten_glEnableVertexAttribArray,
                "emscripten_glEndQuery": _emscripten_glEndQuery,
                "emscripten_glEndQueryEXT": _emscripten_glEndQueryEXT,
                "emscripten_glEndTransformFeedback": _emscripten_glEndTransformFeedback,
                "emscripten_glFenceSync": _emscripten_glFenceSync,
                "emscripten_glFinish": _emscripten_glFinish,
                "emscripten_glFlush": _emscripten_glFlush,
                "emscripten_glFramebufferRenderbuffer": _emscripten_glFramebufferRenderbuffer,
                "emscripten_glFramebufferTexture2D": _emscripten_glFramebufferTexture2D,
                "emscripten_glFramebufferTextureLayer": _emscripten_glFramebufferTextureLayer,
                "emscripten_glFrontFace": _emscripten_glFrontFace,
                "emscripten_glGenBuffers": _emscripten_glGenBuffers,
                "emscripten_glGenFramebuffers": _emscripten_glGenFramebuffers,
                "emscripten_glGenQueries": _emscripten_glGenQueries,
                "emscripten_glGenQueriesEXT": _emscripten_glGenQueriesEXT,
                "emscripten_glGenRenderbuffers": _emscripten_glGenRenderbuffers,
                "emscripten_glGenSamplers": _emscripten_glGenSamplers,
                "emscripten_glGenTextures": _emscripten_glGenTextures,
                "emscripten_glGenTransformFeedbacks": _emscripten_glGenTransformFeedbacks,
                "emscripten_glGenVertexArrays": _emscripten_glGenVertexArrays,
                "emscripten_glGenVertexArraysOES": _emscripten_glGenVertexArraysOES,
                "emscripten_glGenerateMipmap": _emscripten_glGenerateMipmap,
                "emscripten_glGetActiveAttrib": _emscripten_glGetActiveAttrib,
                "emscripten_glGetActiveUniform": _emscripten_glGetActiveUniform,
                "emscripten_glGetActiveUniformBlockName": _emscripten_glGetActiveUniformBlockName,
                "emscripten_glGetActiveUniformBlockiv": _emscripten_glGetActiveUniformBlockiv,
                "emscripten_glGetActiveUniformsiv": _emscripten_glGetActiveUniformsiv,
                "emscripten_glGetAttachedShaders": _emscripten_glGetAttachedShaders,
                "emscripten_glGetAttribLocation": _emscripten_glGetAttribLocation,
                "emscripten_glGetBooleanv": _emscripten_glGetBooleanv,
                "emscripten_glGetBufferParameteri64v": _emscripten_glGetBufferParameteri64v,
                "emscripten_glGetBufferParameteriv": _emscripten_glGetBufferParameteriv,
                "emscripten_glGetError": _emscripten_glGetError,
                "emscripten_glGetFloatv": _emscripten_glGetFloatv,
                "emscripten_glGetFragDataLocation": _emscripten_glGetFragDataLocation,
                "emscripten_glGetFramebufferAttachmentParameteriv": _emscripten_glGetFramebufferAttachmentParameteriv,
                "emscripten_glGetInteger64i_v": _emscripten_glGetInteger64i_v,
                "emscripten_glGetInteger64v": _emscripten_glGetInteger64v,
                "emscripten_glGetIntegeri_v": _emscripten_glGetIntegeri_v,
                "emscripten_glGetIntegerv": _emscripten_glGetIntegerv,
                "emscripten_glGetInternalformativ": _emscripten_glGetInternalformativ,
                "emscripten_glGetProgramBinary": _emscripten_glGetProgramBinary,
                "emscripten_glGetProgramInfoLog": _emscripten_glGetProgramInfoLog,
                "emscripten_glGetProgramiv": _emscripten_glGetProgramiv,
                "emscripten_glGetQueryObjecti64vEXT": _emscripten_glGetQueryObjecti64vEXT,
                "emscripten_glGetQueryObjectivEXT": _emscripten_glGetQueryObjectivEXT,
                "emscripten_glGetQueryObjectui64vEXT": _emscripten_glGetQueryObjectui64vEXT,
                "emscripten_glGetQueryObjectuiv": _emscripten_glGetQueryObjectuiv,
                "emscripten_glGetQueryObjectuivEXT": _emscripten_glGetQueryObjectuivEXT,
                "emscripten_glGetQueryiv": _emscripten_glGetQueryiv,
                "emscripten_glGetQueryivEXT": _emscripten_glGetQueryivEXT,
                "emscripten_glGetRenderbufferParameteriv": _emscripten_glGetRenderbufferParameteriv,
                "emscripten_glGetSamplerParameterfv": _emscripten_glGetSamplerParameterfv,
                "emscripten_glGetSamplerParameteriv": _emscripten_glGetSamplerParameteriv,
                "emscripten_glGetShaderInfoLog": _emscripten_glGetShaderInfoLog,
                "emscripten_glGetShaderPrecisionFormat": _emscripten_glGetShaderPrecisionFormat,
                "emscripten_glGetShaderSource": _emscripten_glGetShaderSource,
                "emscripten_glGetShaderiv": _emscripten_glGetShaderiv,
                "emscripten_glGetString": _emscripten_glGetString,
                "emscripten_glGetStringi": _emscripten_glGetStringi,
                "emscripten_glGetSynciv": _emscripten_glGetSynciv,
                "emscripten_glGetTexParameterfv": _emscripten_glGetTexParameterfv,
                "emscripten_glGetTexParameteriv": _emscripten_glGetTexParameteriv,
                "emscripten_glGetTransformFeedbackVarying": _emscripten_glGetTransformFeedbackVarying,
                "emscripten_glGetUniformBlockIndex": _emscripten_glGetUniformBlockIndex,
                "emscripten_glGetUniformIndices": _emscripten_glGetUniformIndices,
                "emscripten_glGetUniformLocation": _emscripten_glGetUniformLocation,
                "emscripten_glGetUniformfv": _emscripten_glGetUniformfv,
                "emscripten_glGetUniformiv": _emscripten_glGetUniformiv,
                "emscripten_glGetUniformuiv": _emscripten_glGetUniformuiv,
                "emscripten_glGetVertexAttribIiv": _emscripten_glGetVertexAttribIiv,
                "emscripten_glGetVertexAttribIuiv": _emscripten_glGetVertexAttribIuiv,
                "emscripten_glGetVertexAttribPointerv": _emscripten_glGetVertexAttribPointerv,
                "emscripten_glGetVertexAttribfv": _emscripten_glGetVertexAttribfv,
                "emscripten_glGetVertexAttribiv": _emscripten_glGetVertexAttribiv,
                "emscripten_glHint": _emscripten_glHint,
                "emscripten_glInvalidateFramebuffer": _emscripten_glInvalidateFramebuffer,
                "emscripten_glInvalidateSubFramebuffer": _emscripten_glInvalidateSubFramebuffer,
                "emscripten_glIsBuffer": _emscripten_glIsBuffer,
                "emscripten_glIsEnabled": _emscripten_glIsEnabled,
                "emscripten_glIsFramebuffer": _emscripten_glIsFramebuffer,
                "emscripten_glIsProgram": _emscripten_glIsProgram,
                "emscripten_glIsQuery": _emscripten_glIsQuery,
                "emscripten_glIsQueryEXT": _emscripten_glIsQueryEXT,
                "emscripten_glIsRenderbuffer": _emscripten_glIsRenderbuffer,
                "emscripten_glIsSampler": _emscripten_glIsSampler,
                "emscripten_glIsShader": _emscripten_glIsShader,
                "emscripten_glIsSync": _emscripten_glIsSync,
                "emscripten_glIsTexture": _emscripten_glIsTexture,
                "emscripten_glIsTransformFeedback": _emscripten_glIsTransformFeedback,
                "emscripten_glIsVertexArray": _emscripten_glIsVertexArray,
                "emscripten_glIsVertexArrayOES": _emscripten_glIsVertexArrayOES,
                "emscripten_glLineWidth": _emscripten_glLineWidth,
                "emscripten_glLinkProgram": _emscripten_glLinkProgram,
                "emscripten_glPauseTransformFeedback": _emscripten_glPauseTransformFeedback,
                "emscripten_glPixelStorei": _emscripten_glPixelStorei,
                "emscripten_glPolygonOffset": _emscripten_glPolygonOffset,
                "emscripten_glProgramBinary": _emscripten_glProgramBinary,
                "emscripten_glProgramParameteri": _emscripten_glProgramParameteri,
                "emscripten_glQueryCounterEXT": _emscripten_glQueryCounterEXT,
                "emscripten_glReadBuffer": _emscripten_glReadBuffer,
                "emscripten_glReadPixels": _emscripten_glReadPixels,
                "emscripten_glReleaseShaderCompiler": _emscripten_glReleaseShaderCompiler,
                "emscripten_glRenderbufferStorage": _emscripten_glRenderbufferStorage,
                "emscripten_glRenderbufferStorageMultisample": _emscripten_glRenderbufferStorageMultisample,
                "emscripten_glResumeTransformFeedback": _emscripten_glResumeTransformFeedback,
                "emscripten_glSampleCoverage": _emscripten_glSampleCoverage,
                "emscripten_glSamplerParameterf": _emscripten_glSamplerParameterf,
                "emscripten_glSamplerParameterfv": _emscripten_glSamplerParameterfv,
                "emscripten_glSamplerParameteri": _emscripten_glSamplerParameteri,
                "emscripten_glSamplerParameteriv": _emscripten_glSamplerParameteriv,
                "emscripten_glScissor": _emscripten_glScissor,
                "emscripten_glShaderBinary": _emscripten_glShaderBinary,
                "emscripten_glShaderSource": _emscripten_glShaderSource,
                "emscripten_glStencilFunc": _emscripten_glStencilFunc,
                "emscripten_glStencilFuncSeparate": _emscripten_glStencilFuncSeparate,
                "emscripten_glStencilMask": _emscripten_glStencilMask,
                "emscripten_glStencilMaskSeparate": _emscripten_glStencilMaskSeparate,
                "emscripten_glStencilOp": _emscripten_glStencilOp,
                "emscripten_glStencilOpSeparate": _emscripten_glStencilOpSeparate,
                "emscripten_glTexImage2D": _emscripten_glTexImage2D,
                "emscripten_glTexImage3D": _emscripten_glTexImage3D,
                "emscripten_glTexParameterf": _emscripten_glTexParameterf,
                "emscripten_glTexParameterfv": _emscripten_glTexParameterfv,
                "emscripten_glTexParameteri": _emscripten_glTexParameteri,
                "emscripten_glTexParameteriv": _emscripten_glTexParameteriv,
                "emscripten_glTexStorage2D": _emscripten_glTexStorage2D,
                "emscripten_glTexStorage3D": _emscripten_glTexStorage3D,
                "emscripten_glTexSubImage2D": _emscripten_glTexSubImage2D,
                "emscripten_glTexSubImage3D": _emscripten_glTexSubImage3D,
                "emscripten_glTransformFeedbackVaryings": _emscripten_glTransformFeedbackVaryings,
                "emscripten_glUniform1f": _emscripten_glUniform1f,
                "emscripten_glUniform1fv": _emscripten_glUniform1fv,
                "emscripten_glUniform1i": _emscripten_glUniform1i,
                "emscripten_glUniform1iv": _emscripten_glUniform1iv,
                "emscripten_glUniform1ui": _emscripten_glUniform1ui,
                "emscripten_glUniform1uiv": _emscripten_glUniform1uiv,
                "emscripten_glUniform2f": _emscripten_glUniform2f,
                "emscripten_glUniform2fv": _emscripten_glUniform2fv,
                "emscripten_glUniform2i": _emscripten_glUniform2i,
                "emscripten_glUniform2iv": _emscripten_glUniform2iv,
                "emscripten_glUniform2ui": _emscripten_glUniform2ui,
                "emscripten_glUniform2uiv": _emscripten_glUniform2uiv,
                "emscripten_glUniform3f": _emscripten_glUniform3f,
                "emscripten_glUniform3fv": _emscripten_glUniform3fv,
                "emscripten_glUniform3i": _emscripten_glUniform3i,
                "emscripten_glUniform3iv": _emscripten_glUniform3iv,
                "emscripten_glUniform3ui": _emscripten_glUniform3ui,
                "emscripten_glUniform3uiv": _emscripten_glUniform3uiv,
                "emscripten_glUniform4f": _emscripten_glUniform4f,
                "emscripten_glUniform4fv": _emscripten_glUniform4fv,
                "emscripten_glUniform4i": _emscripten_glUniform4i,
                "emscripten_glUniform4iv": _emscripten_glUniform4iv,
                "emscripten_glUniform4ui": _emscripten_glUniform4ui,
                "emscripten_glUniform4uiv": _emscripten_glUniform4uiv,
                "emscripten_glUniformBlockBinding": _emscripten_glUniformBlockBinding,
                "emscripten_glUniformMatrix2fv": _emscripten_glUniformMatrix2fv,
                "emscripten_glUniformMatrix2x3fv": _emscripten_glUniformMatrix2x3fv,
                "emscripten_glUniformMatrix2x4fv": _emscripten_glUniformMatrix2x4fv,
                "emscripten_glUniformMatrix3fv": _emscripten_glUniformMatrix3fv,
                "emscripten_glUniformMatrix3x2fv": _emscripten_glUniformMatrix3x2fv,
                "emscripten_glUniformMatrix3x4fv": _emscripten_glUniformMatrix3x4fv,
                "emscripten_glUniformMatrix4fv": _emscripten_glUniformMatrix4fv,
                "emscripten_glUniformMatrix4x2fv": _emscripten_glUniformMatrix4x2fv,
                "emscripten_glUniformMatrix4x3fv": _emscripten_glUniformMatrix4x3fv,
                "emscripten_glUseProgram": _emscripten_glUseProgram,
                "emscripten_glValidateProgram": _emscripten_glValidateProgram,
                "emscripten_glVertexAttrib1f": _emscripten_glVertexAttrib1f,
                "emscripten_glVertexAttrib1fv": _emscripten_glVertexAttrib1fv,
                "emscripten_glVertexAttrib2f": _emscripten_glVertexAttrib2f,
                "emscripten_glVertexAttrib2fv": _emscripten_glVertexAttrib2fv,
                "emscripten_glVertexAttrib3f": _emscripten_glVertexAttrib3f,
                "emscripten_glVertexAttrib3fv": _emscripten_glVertexAttrib3fv,
                "emscripten_glVertexAttrib4f": _emscripten_glVertexAttrib4f,
                "emscripten_glVertexAttrib4fv": _emscripten_glVertexAttrib4fv,
                "emscripten_glVertexAttribDivisor": _emscripten_glVertexAttribDivisor,
                "emscripten_glVertexAttribDivisorANGLE": _emscripten_glVertexAttribDivisorANGLE,
                "emscripten_glVertexAttribDivisorARB": _emscripten_glVertexAttribDivisorARB,
                "emscripten_glVertexAttribDivisorEXT": _emscripten_glVertexAttribDivisorEXT,
                "emscripten_glVertexAttribDivisorNV": _emscripten_glVertexAttribDivisorNV,
                "emscripten_glVertexAttribI4i": _emscripten_glVertexAttribI4i,
                "emscripten_glVertexAttribI4iv": _emscripten_glVertexAttribI4iv,
                "emscripten_glVertexAttribI4ui": _emscripten_glVertexAttribI4ui,
                "emscripten_glVertexAttribI4uiv": _emscripten_glVertexAttribI4uiv,
                "emscripten_glVertexAttribIPointer": _emscripten_glVertexAttribIPointer,
                "emscripten_glVertexAttribPointer": _emscripten_glVertexAttribPointer,
                "emscripten_glViewport": _emscripten_glViewport,
                "emscripten_glWaitSync": _emscripten_glWaitSync,
                "emscripten_has_asyncify": _emscripten_has_asyncify,
                "emscripten_is_main_browser_thread": _emscripten_is_main_browser_thread,
                "emscripten_log": _emscripten_log,
                "emscripten_longjmp": _emscripten_longjmp,
                "emscripten_memcpy_big": _emscripten_memcpy_big,
                "emscripten_request_fullscreen_strategy": _emscripten_request_fullscreen_strategy,
                "emscripten_request_pointerlock": _emscripten_request_pointerlock,
                "emscripten_resize_heap": _emscripten_resize_heap,
                "emscripten_sample_gamepad_data": _emscripten_sample_gamepad_data,
                "emscripten_set_beforeunload_callback_on_thread": _emscripten_set_beforeunload_callback_on_thread,
                "emscripten_set_blur_callback_on_thread": _emscripten_set_blur_callback_on_thread,
                "emscripten_set_canvas_element_size": _emscripten_set_canvas_element_size,
                "emscripten_set_element_css_size": _emscripten_set_element_css_size,
                "emscripten_set_focus_callback_on_thread": _emscripten_set_focus_callback_on_thread,
                "emscripten_set_fullscreenchange_callback_on_thread": _emscripten_set_fullscreenchange_callback_on_thread,
                "emscripten_set_gamepadconnected_callback_on_thread": _emscripten_set_gamepadconnected_callback_on_thread,
                "emscripten_set_gamepaddisconnected_callback_on_thread": _emscripten_set_gamepaddisconnected_callback_on_thread,
                "emscripten_set_keydown_callback_on_thread": _emscripten_set_keydown_callback_on_thread,
                "emscripten_set_keypress_callback_on_thread": _emscripten_set_keypress_callback_on_thread,
                "emscripten_set_keyup_callback_on_thread": _emscripten_set_keyup_callback_on_thread,
                "emscripten_set_main_loop_arg": _emscripten_set_main_loop_arg,
                "emscripten_set_mousedown_callback_on_thread": _emscripten_set_mousedown_callback_on_thread,
                "emscripten_set_mouseenter_callback_on_thread": _emscripten_set_mouseenter_callback_on_thread,
                "emscripten_set_mouseleave_callback_on_thread": _emscripten_set_mouseleave_callback_on_thread,
                "emscripten_set_mousemove_callback_on_thread": _emscripten_set_mousemove_callback_on_thread,
                "emscripten_set_mouseup_callback_on_thread": _emscripten_set_mouseup_callback_on_thread,
                "emscripten_set_pointerlockchange_callback_on_thread": _emscripten_set_pointerlockchange_callback_on_thread,
                "emscripten_set_resize_callback_on_thread": _emscripten_set_resize_callback_on_thread,
                "emscripten_set_touchcancel_callback_on_thread": _emscripten_set_touchcancel_callback_on_thread,
                "emscripten_set_touchend_callback_on_thread": _emscripten_set_touchend_callback_on_thread,
                "emscripten_set_touchmove_callback_on_thread": _emscripten_set_touchmove_callback_on_thread,
                "emscripten_set_touchstart_callback_on_thread": _emscripten_set_touchstart_callback_on_thread,
                "emscripten_set_visibilitychange_callback_on_thread": _emscripten_set_visibilitychange_callback_on_thread,
                "emscripten_set_wheel_callback_on_thread": _emscripten_set_wheel_callback_on_thread,
                "emscripten_sleep": _emscripten_sleep,
                "emscripten_start_fetch": _emscripten_start_fetch,
                "environ_get": _environ_get,
                "environ_sizes_get": _environ_sizes_get,
                "exit": _exit,
                "fd_close": _fd_close,
                "fd_fdstat_get": _fd_fdstat_get,
                "fd_read": _fd_read,
                "fd_seek": _fd_seek,
                "fd_write": _fd_write,
                "getCanvasPaddingLeft": getCanvasPaddingLeft,
                "getCanvasPaddingTop": getCanvasPaddingTop,
                "getTempRet0": _getTempRet0,
                "gettimeofday": _gettimeofday,
                "gmtime_r": _gmtime_r,
                "invoke_di": invoke_di,
                "invoke_i": invoke_i,
                "invoke_ii": invoke_ii,
                "invoke_iid": invoke_iid,
                "invoke_iii": invoke_iii,
                "invoke_iiii": invoke_iiii,
                "invoke_iiiii": invoke_iiiii,
                "invoke_iiiiii": invoke_iiiiii,
                "invoke_iiiiiii": invoke_iiiiiii,
                "invoke_iiiiiiii": invoke_iiiiiiii,
                "invoke_vi": invoke_vi,
                "invoke_vii": invoke_vii,
                "invoke_viii": invoke_viii,
                "invoke_viiii": invoke_viiii,
                "invoke_viiiii": invoke_viiiii,
                "invoke_viiiiii": invoke_viiiiii,
                "localtime": _localtime,
                "localtime_r": _localtime_r,
                "memory": wasmMemory,
                "mktime": _mktime,
                "nanosleep": _nanosleep,
                "saveSetjmp": _saveSetjmp,
                "setTempRet0": _setTempRet0,
                "sigaction": _sigaction,
                "signal": _signal,
                "sysconf": _sysconf,
                "table": wasmTable,
                "testSetjmp": _testSetjmp,
                "time": _time,
                "usleep": _usleep,
                "wafjs_hidestatus": wafjs_hidestatus,
                "wafjs_setcontentinfo": wafjs_setcontentinfo,
                "wafjs_setstatus": wafjs_setstatus,
                "wafjs_url_transformRequestUrl": wafjs_url_transformRequestUrl
            };
            var asm = createWasm();
            Module["asm"] = asm;
            var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
                return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments)
            };
            var _reopenBuffer = Module["_reopenBuffer"] = function() {
                return (_reopenBuffer = Module["_reopenBuffer"] = Module["asm"]["reopenBuffer"]).apply(null, arguments)
            };
            var _invokeExternalCallback = Module["_invokeExternalCallback"] = function() {
                return (_invokeExternalCallback = Module["_invokeExternalCallback"] = Module["asm"]["invokeExternalCallback"]).apply(null, arguments)
            };
            var ___em_js__wafjs_setstatus = Module["___em_js__wafjs_setstatus"] = function() {
                return (___em_js__wafjs_setstatus = Module["___em_js__wafjs_setstatus"] = Module["asm"]["__em_js__wafjs_setstatus"]).apply(null, arguments)
            };
            var ___em_js__wafjs_hidestatus = Module["___em_js__wafjs_hidestatus"] = function() {
                return (___em_js__wafjs_hidestatus = Module["___em_js__wafjs_hidestatus"] = Module["asm"]["__em_js__wafjs_hidestatus"]).apply(null, arguments)
            };
            var ___em_js__wafjs_setcontentinfo = Module["___em_js__wafjs_setcontentinfo"] = function() {
                return (___em_js__wafjs_setcontentinfo = Module["___em_js__wafjs_setcontentinfo"] = Module["asm"]["__em_js__wafjs_setcontentinfo"]).apply(null, arguments)
            };
            var ___em_js__getCanvasPaddingLeft = Module["___em_js__getCanvasPaddingLeft"] = function() {
                return (___em_js__getCanvasPaddingLeft = Module["___em_js__getCanvasPaddingLeft"] = Module["asm"]["__em_js__getCanvasPaddingLeft"]).apply(null, arguments)
            };
            var ___em_js__getCanvasPaddingTop = Module["___em_js__getCanvasPaddingTop"] = function() {
                return (___em_js__getCanvasPaddingTop = Module["___em_js__getCanvasPaddingTop"] = Module["asm"]["__em_js__getCanvasPaddingTop"]).apply(null, arguments)
            };
            var _main = Module["_main"] = function() {
                return (_main = Module["_main"] = Module["asm"]["main"]).apply(null, arguments)
            };
            var _memset = Module["_memset"] = function() {
                return (_memset = Module["_memset"] = Module["asm"]["memset"]).apply(null, arguments)
            };
            var _strlen = Module["_strlen"] = function() {
                return (_strlen = Module["_strlen"] = Module["asm"]["strlen"]).apply(null, arguments)
            };
            var _free = Module["_free"] = function() {
                return (_free = Module["_free"] = Module["asm"]["free"]).apply(null, arguments)
            };
            var _fileno = Module["_fileno"] = function() {
                return (_fileno = Module["_fileno"] = Module["asm"]["fileno"]).apply(null, arguments)
            };
            var _malloc = Module["_malloc"] = function() {
                return (_malloc = Module["_malloc"] = Module["asm"]["malloc"]).apply(null, arguments)
            };
            var _memcpy = Module["_memcpy"] = function() {
                return (_memcpy = Module["_memcpy"] = Module["asm"]["memcpy"]).apply(null, arguments)
            };
            var ___em_js__wafjs_url_transformRequestUrl = Module["___em_js__wafjs_url_transformRequestUrl"] = function() {
                return (___em_js__wafjs_url_transformRequestUrl = Module["___em_js__wafjs_url_transformRequestUrl"] = Module["asm"]["__em_js__wafjs_url_transformRequestUrl"]).apply(null, arguments)
            };
            var _strstr = Module["_strstr"] = function() {
                return (_strstr = Module["_strstr"] = Module["asm"]["strstr"]).apply(null, arguments)
            };
            var ___em_js__changeCursor = Module["___em_js__changeCursor"] = function() {
                return (___em_js__changeCursor = Module["___em_js__changeCursor"] = Module["asm"]["__em_js__changeCursor"]).apply(null, arguments)
            };
            var _realloc = Module["_realloc"] = function() {
                return (_realloc = Module["_realloc"] = Module["asm"]["realloc"]).apply(null, arguments)
            };
            var ___errno_location = Module["___errno_location"] = function() {
                return (___errno_location = Module["___errno_location"] = Module["asm"]["__errno_location"]).apply(null, arguments)
            };
            var _emscripten_GetProcAddress = Module["_emscripten_GetProcAddress"] = function() {
                return (_emscripten_GetProcAddress = Module["_emscripten_GetProcAddress"] = Module["asm"]["emscripten_GetProcAddress"]).apply(null, arguments)
            };
            var __get_tzname = Module["__get_tzname"] = function() {
                return (__get_tzname = Module["__get_tzname"] = Module["asm"]["_get_tzname"]).apply(null, arguments)
            };
            var __get_daylight = Module["__get_daylight"] = function() {
                return (__get_daylight = Module["__get_daylight"] = Module["asm"]["_get_daylight"]).apply(null, arguments)
            };
            var __get_timezone = Module["__get_timezone"] = function() {
                return (__get_timezone = Module["__get_timezone"] = Module["asm"]["_get_timezone"]).apply(null, arguments)
            };
            var _setThrew = Module["_setThrew"] = function() {
                return (_setThrew = Module["_setThrew"] = Module["asm"]["setThrew"]).apply(null, arguments)
            };
            var _emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = function() {
                return (_emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = Module["asm"]["emscripten_main_thread_process_queued_calls"]).apply(null, arguments)
            };
            var dynCall_vi = Module["dynCall_vi"] = function() {
                return (dynCall_vi = Module["dynCall_vi"] = Module["asm"]["dynCall_vi"]).apply(null, arguments)
            };
            var dynCall_vii = Module["dynCall_vii"] = function() {
                return (dynCall_vii = Module["dynCall_vii"] = Module["asm"]["dynCall_vii"]).apply(null, arguments)
            };
            var dynCall_viii = Module["dynCall_viii"] = function() {
                return (dynCall_viii = Module["dynCall_viii"] = Module["asm"]["dynCall_viii"]).apply(null, arguments)
            };
            var dynCall_viiii = Module["dynCall_viiii"] = function() {
                return (dynCall_viiii = Module["dynCall_viiii"] = Module["asm"]["dynCall_viiii"]).apply(null, arguments)
            };
            var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
                return (dynCall_viiiii = Module["dynCall_viiiii"] = Module["asm"]["dynCall_viiiii"]).apply(null, arguments)
            };
            var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() {
                return (dynCall_viiiiii = Module["dynCall_viiiiii"] = Module["asm"]["dynCall_viiiiii"]).apply(null, arguments)
            };
            var dynCall_i = Module["dynCall_i"] = function() {
                return (dynCall_i = Module["dynCall_i"] = Module["asm"]["dynCall_i"]).apply(null, arguments)
            };
            var dynCall_ii = Module["dynCall_ii"] = function() {
                return (dynCall_ii = Module["dynCall_ii"] = Module["asm"]["dynCall_ii"]).apply(null, arguments)
            };
            var dynCall_iii = Module["dynCall_iii"] = function() {
                return (dynCall_iii = Module["dynCall_iii"] = Module["asm"]["dynCall_iii"]).apply(null, arguments)
            };
            var dynCall_iiii = Module["dynCall_iiii"] = function() {
                return (dynCall_iiii = Module["dynCall_iiii"] = Module["asm"]["dynCall_iiii"]).apply(null, arguments)
            };
            var dynCall_iiiii = Module["dynCall_iiiii"] = function() {
                return (dynCall_iiiii = Module["dynCall_iiiii"] = Module["asm"]["dynCall_iiiii"]).apply(null, arguments)
            };
            var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() {
                return (dynCall_iiiiii = Module["dynCall_iiiiii"] = Module["asm"]["dynCall_iiiiii"]).apply(null, arguments)
            };
            var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() {
                return (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = Module["asm"]["dynCall_iiiiiii"]).apply(null, arguments)
            };
            var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = function() {
                return (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = Module["asm"]["dynCall_iiiiiiii"]).apply(null, arguments)
            };
            var dynCall_iid = Module["dynCall_iid"] = function() {
                return (dynCall_iid = Module["dynCall_iid"] = Module["asm"]["dynCall_iid"]).apply(null, arguments)
            };
            var dynCall_di = Module["dynCall_di"] = function() {
                return (dynCall_di = Module["dynCall_di"] = Module["asm"]["dynCall_di"]).apply(null, arguments)
            };
            var stackSave = Module["stackSave"] = function() {
                return (stackSave = Module["stackSave"] = Module["asm"]["stackSave"]).apply(null, arguments)
            };
            var stackAlloc = Module["stackAlloc"] = function() {
                return (stackAlloc = Module["stackAlloc"] = Module["asm"]["stackAlloc"]).apply(null, arguments)
            };
            var stackRestore = Module["stackRestore"] = function() {
                return (stackRestore = Module["stackRestore"] = Module["asm"]["stackRestore"]).apply(null, arguments)
            };
            var __growWasmMemory = Module["__growWasmMemory"] = function() {
                return (__growWasmMemory = Module["__growWasmMemory"] = Module["asm"]["__growWasmMemory"]).apply(null, arguments)
            };
            var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() {
                return (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = Module["asm"]["dynCall_viiiiiii"]).apply(null, arguments)
            };
            var dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = function() {
                return (dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = Module["asm"]["dynCall_viiiiiiiii"]).apply(null, arguments)
            };
            var dynCall_v = Module["dynCall_v"] = function() {
                return (dynCall_v = Module["dynCall_v"] = Module["asm"]["dynCall_v"]).apply(null, arguments)
            };
            var dynCall_diii = Module["dynCall_diii"] = function() {
                return (dynCall_diii = Module["dynCall_diii"] = Module["asm"]["dynCall_diii"]).apply(null, arguments)
            };
            var dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = function() {
                return (dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = Module["asm"]["dynCall_viiiiiiii"]).apply(null, arguments)
            };
            var dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = function() {
                return (dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = Module["asm"]["dynCall_iiiiiiiiii"]).apply(null, arguments)
            };
            var dynCall_jiji = Module["dynCall_jiji"] = function() {
                return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["dynCall_jiji"]).apply(null, arguments)
            };
            var dynCall_ji = Module["dynCall_ji"] = function() {
                return (dynCall_ji = Module["dynCall_ji"] = Module["asm"]["dynCall_ji"]).apply(null, arguments)
            };
            var dynCall_iiiiiidii = Module["dynCall_iiiiiidii"] = function() {
                return (dynCall_iiiiiidii = Module["dynCall_iiiiiidii"] = Module["asm"]["dynCall_iiiiiidii"]).apply(null, arguments)
            };
            var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = function() {
                return (dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = Module["asm"]["dynCall_iiiiiiiii"]).apply(null, arguments)
            };
            var dynCall_viiiiiiiiiii = Module["dynCall_viiiiiiiiiii"] = function() {
                return (dynCall_viiiiiiiiiii = Module["dynCall_viiiiiiiiiii"] = Module["asm"]["dynCall_viiiiiiiiiii"]).apply(null, arguments)
            };
            var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() {
                return (dynCall_iidiiii = Module["dynCall_iidiiii"] = Module["asm"]["dynCall_iidiiii"]).apply(null, arguments)
            };
            var dynCall_vffff = Module["dynCall_vffff"] = function() {
                return (dynCall_vffff = Module["dynCall_vffff"] = Module["asm"]["dynCall_vffff"]).apply(null, arguments)
            };
            var dynCall_vf = Module["dynCall_vf"] = function() {
                return (dynCall_vf = Module["dynCall_vf"] = Module["asm"]["dynCall_vf"]).apply(null, arguments)
            };
            var dynCall_vff = Module["dynCall_vff"] = function() {
                return (dynCall_vff = Module["dynCall_vff"] = Module["asm"]["dynCall_vff"]).apply(null, arguments)
            };
            var dynCall_vfi = Module["dynCall_vfi"] = function() {
                return (dynCall_vfi = Module["dynCall_vfi"] = Module["asm"]["dynCall_vfi"]).apply(null, arguments)
            };
            var dynCall_viif = Module["dynCall_viif"] = function() {
                return (dynCall_viif = Module["dynCall_viif"] = Module["asm"]["dynCall_viif"]).apply(null, arguments)
            };
            var dynCall_vif = Module["dynCall_vif"] = function() {
                return (dynCall_vif = Module["dynCall_vif"] = Module["asm"]["dynCall_vif"]).apply(null, arguments)
            };
            var dynCall_viff = Module["dynCall_viff"] = function() {
                return (dynCall_viff = Module["dynCall_viff"] = Module["asm"]["dynCall_viff"]).apply(null, arguments)
            };
            var dynCall_vifff = Module["dynCall_vifff"] = function() {
                return (dynCall_vifff = Module["dynCall_vifff"] = Module["asm"]["dynCall_vifff"]).apply(null, arguments)
            };
            var dynCall_viffff = Module["dynCall_viffff"] = function() {
                return (dynCall_viffff = Module["dynCall_viffff"] = Module["asm"]["dynCall_viffff"]).apply(null, arguments)
            };
            var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = function() {
                return (dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = Module["asm"]["dynCall_viiiiiiiiii"]).apply(null, arguments)
            };
            var dynCall_viifi = Module["dynCall_viifi"] = function() {
                return (dynCall_viifi = Module["dynCall_viifi"] = Module["asm"]["dynCall_viifi"]).apply(null, arguments)
            };

            function invoke_iiiii(index, a1, a2, a3, a4) {
                var sp = stackSave();
                try {
                    return dynCall_iiiii(index, a1, a2, a3, a4)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_ii(index, a1) {
                var sp = stackSave();
                try {
                    return dynCall_ii(index, a1)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_viii(index, a1, a2, a3) {
                var sp = stackSave();
                try {
                    dynCall_viii(index, a1, a2, a3)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_iiii(index, a1, a2, a3) {
                var sp = stackSave();
                try {
                    return dynCall_iiii(index, a1, a2, a3)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_vii(index, a1, a2) {
                var sp = stackSave();
                try {
                    dynCall_vii(index, a1, a2)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_iii(index, a1, a2) {
                var sp = stackSave();
                try {
                    return dynCall_iii(index, a1, a2)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_vi(index, a1) {
                var sp = stackSave();
                try {
                    dynCall_vi(index, a1)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
                var sp = stackSave();
                try {
                    return dynCall_iiiiii(index, a1, a2, a3, a4, a5)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_i(index) {
                var sp = stackSave();
                try {
                    return dynCall_i(index)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_iid(index, a1, a2) {
                var sp = stackSave();
                try {
                    return dynCall_iid(index, a1, a2)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_viiii(index, a1, a2, a3, a4) {
                var sp = stackSave();
                try {
                    dynCall_viiii(index, a1, a2, a3, a4)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_viiiii(index, a1, a2, a3, a4, a5) {
                var sp = stackSave();
                try {
                    dynCall_viiiii(index, a1, a2, a3, a4, a5)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_di(index, a1) {
                var sp = stackSave();
                try {
                    return dynCall_di(index, a1)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
                var sp = stackSave();
                try {
                    return dynCall_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
                var sp = stackSave();
                try {
                    dynCall_viiiiii(index, a1, a2, a3, a4, a5, a6)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }

            function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
                var sp = stackSave();
                try {
                    return dynCall_iiiiiii(index, a1, a2, a3, a4, a5, a6)
                } catch (e) {
                    stackRestore(sp);
                    if (e !== e + 0 && e !== "longjmp") throw e;
                    _setThrew(1, 0)
                }
            }
            Module["asm"] = asm;
            Module["ccall"] = ccall;
            Module["cwrap"] = cwrap;
            Module["getMemory"] = getMemory;
            Module["addRunDependency"] = addRunDependency;
            Module["removeRunDependency"] = removeRunDependency;
            Module["FS_createFolder"] = FS.createFolder;
            Module["FS_createPath"] = FS.createPath;
            Module["FS_createDataFile"] = FS.createDataFile;
            Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
            Module["FS_createLazyFile"] = FS.createLazyFile;
            Module["FS_createLink"] = FS.createLink;
            Module["FS_createDevice"] = FS.createDevice;
            Module["FS_unlink"] = FS.unlink;
            var calledRun;

            function ExitStatus(status) {
                this.name = "ExitStatus";
                this.message = "Program terminated with exit(" + status + ")";
                this.status = status
            }
            var calledMain = false;
            dependenciesFulfilled = function runCaller() {
                if (!calledRun) run();
                if (!calledRun) dependenciesFulfilled = runCaller
            };

            function callMain(args) {
                var entryFunction = Module["_main"];
                args = args || [];
                var argc = args.length + 1;
                var argv = stackAlloc((argc + 1) * 4);
                HEAP32[argv >> 2] = allocateUTF8OnStack(thisProgram);
                for (var i = 1; i < argc; i++) {
                    HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1])
                }
                HEAP32[(argv >> 2) + argc] = 0;
                try {
                    var ret = entryFunction(argc, argv);
                    exit(ret, true)
                } catch (e) {
                    if (e instanceof ExitStatus) {
                        return
                    } else if (e == "unwind") {
                        noExitRuntime = true;
                        return
                    } else {
                        var toLog = e;
                        if (e && typeof e === "object" && e.stack) {
                            toLog = [e, e.stack]
                        }
                        err("exception thrown: " + toLog);
                        quit_(1, e)
                    }
                } finally {
                    calledMain = true
                }
            }

            function run(args) {
                args = args || arguments_;
                if (runDependencies > 0) {
                    return
                }
                preRun();
                if (runDependencies > 0) return;

                function doRun() {
                    if (calledRun) return;
                    calledRun = true;
                    Module["calledRun"] = true;
                    if (ABORT) return;
                    initRuntime();
                    preMain();
                    readyPromiseResolve(Module);
                    if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
                    if (shouldRunNow) callMain(args);
                    postRun()
                }
                if (Module["setStatus"]) {
                    Module["setStatus"]("Running...");
                    setTimeout(function() {
                        setTimeout(function() {
                            Module["setStatus"]("")
                        }, 1);
                        doRun()
                    }, 1)
                } else {
                    doRun()
                }
            }
            Module["run"] = run;

            function exit(status, implicit) {
                if (implicit && noExitRuntime && status === 0) {
                    return
                }
                if (noExitRuntime) {} else {
                    ABORT = true;
                    EXITSTATUS = status;
                    exitRuntime();
                    if (Module["onExit"]) Module["onExit"](status)
                }
                quit_(status, new ExitStatus(status))
            }
            if (Module["preInit"]) {
                if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
                while (Module["preInit"].length > 0) {
                    Module["preInit"].pop()()
                }
            }
            var shouldRunNow = true;
            if (Module["noInitialRun"]) shouldRunNow = false;
            noExitRuntime = true;
            run();


            return Module.ready
        }
    );
})();
export default Module;