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 moduleOverrides = {};
            var key;
            for (key in Module) {
                if (Module.hasOwnProperty(key)) {
                    moduleOverrides[key] = Module[key]
                }
            }
            Module["arguments"] = [];
            Module["thisProgram"] = "./this.program";
            Module["quit"] = function(status, toThrow) {
                throw toThrow
            };
            Module["preRun"] = [];
            Module["postRun"] = [];
            var ENVIRONMENT_IS_WEB = false;
            var ENVIRONMENT_IS_WORKER = false;
            var ENVIRONMENT_IS_NODE = false;
            var ENVIRONMENT_IS_SHELL = false;
            ENVIRONMENT_IS_WEB = typeof window === "object";
            ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
            ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
            ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
            var scriptDirectory = "";

            function locateFile(path) {
                if (Module["locateFile"]) {
                    return Module["locateFile"](path, scriptDirectory)
                } else {
                    return scriptDirectory + path
                }
            }
            if (ENVIRONMENT_IS_NODE) {
                scriptDirectory = __dirname + "/";
                var nodeFS;
                var nodePath;
                Module["read"] = function shell_read(filename, binary) {
                    var ret;
                    if (!nodeFS) nodeFS = require("fs");
                    if (!nodePath) nodePath = require("path");
                    filename = nodePath["normalize"](filename);
                    ret = nodeFS["readFileSync"](filename);
                    return binary ? ret : ret.toString()
                };
                Module["readBinary"] = function readBinary(filename) {
                    var ret = Module["read"](filename, true);
                    if (!ret.buffer) {
                        ret = new Uint8Array(ret)
                    }
                    assert(ret.buffer);
                    return ret
                };
                if (process["argv"].length > 1) {
                    Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/")
                }
                Module["arguments"] = process["argv"].slice(2);
                process["on"]("uncaughtException", function(ex) {
                    if (!(ex instanceof ExitStatus)) {
                        throw ex
                    }
                });
                process["on"]("unhandledRejection", abort);
                Module["quit"] = function(status) {
                    process["exit"](status)
                };
                Module["inspect"] = function() {
                    return "[Emscripten Module object]"
                }
            } else if (ENVIRONMENT_IS_SHELL) {
                if (typeof read != "undefined") {
                    Module["read"] = function shell_read(f) {
                        return read(f)
                    }
                }
                Module["readBinary"] = function readBinary(f) {
                    var data;
                    if (typeof readbuffer === "function") {
                        return new Uint8Array(readbuffer(f))
                    }
                    data = read(f, "binary");
                    assert(typeof data === "object");
                    return data
                };
                if (typeof scriptArgs != "undefined") {
                    Module["arguments"] = scriptArgs
                } else if (typeof arguments != "undefined") {
                    Module["arguments"] = arguments
                }
                if (typeof quit === "function") {
                    Module["quit"] = function(status) {
                        quit(status)
                    }
                }
            } else 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 = ""
                }
                Module["read"] = function shell_read(url) {
                    var xhr = new XMLHttpRequest;
                    xhr.open("GET", url, false);
                    xhr.send(null);
                    return xhr.responseText
                };
                if (ENVIRONMENT_IS_WORKER) {
                    Module["readBinary"] = function readBinary(url) {
                        var xhr = new XMLHttpRequest;
                        xhr.open("GET", url, false);
                        xhr.responseType = "arraybuffer";
                        xhr.send(null);
                        return new Uint8Array(xhr.response)
                    }
                }
                Module["readAsync"] = function readAsync(url, onload, onerror) {
                    var xhr = new XMLHttpRequest;
                    xhr.open("GET", url, true);
                    xhr.responseType = "arraybuffer";
                    xhr.onload = function xhr_onload() {
                        if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
                            onload(xhr.response);
                            return
                        }
                        onerror()
                    };
                    xhr.onerror = onerror;
                    xhr.send(null)
                };
                Module["setWindowTitle"] = function(title) {
                    document.title = title
                }
            } else {}
            var out = Module["print"] || (typeof console !== "undefined" ? console.log.bind(console) : typeof print !== "undefined" ? print : null);
            var err = Module["printErr"] || (typeof printErr !== "undefined" ? printErr : typeof console !== "undefined" && console.warn.bind(console) || out);
            for (key in moduleOverrides) {
                if (moduleOverrides.hasOwnProperty(key)) {
                    Module[key] = moduleOverrides[key]
                }
            }
            moduleOverrides = undefined;

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

            function getNativeTypeSize(type) {
                switch (type) {
                    case "i1":
                    case "i8":
                        return 1;
                    case "i16":
                        return 2;
                    case "i32":
                        return 4;
                    case "i64":
                        return 8;
                    case "float":
                        return 4;
                    case "double":
                        return 8;
                    default:
                        {
                            if (type[type.length - 1] === "*") {
                                return 4
                            } else if (type[0] === "i") {
                                var bits = parseInt(type.substr(1));
                                assert(bits % 8 === 0, "getNativeTypeSize invalid bits " + bits + ", type " + type);
                                return bits / 8
                            } else {
                                return 0
                            }
                        }
                }
            }
            var asm2wasmImports = {
                "f64-rem": function(x, y) {
                    return x % y
                },
                "debugger": function() {
                    debugger
                }
            };
            var functionPointers = new Array(0);
            if (typeof WebAssembly !== "object") {
                err("no native wasm support detected")
            }
            var wasmMemory;
            var wasmTable;
            var ABORT = false;
            var EXITSTATUS = 0;

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

            function setValue(ptr, value, type, noSafe) {
                type = type || "i8";
                if (type.charAt(type.length - 1) === "*") type = "i32";
                switch (type) {
                    case "i1":
                        HEAP8[ptr >> 0] = value;
                        break;
                    case "i8":
                        HEAP8[ptr >> 0] = value;
                        break;
                    case "i16":
                        HEAP16[ptr >> 1] = value;
                        break;
                    case "i32":
                        HEAP32[ptr >> 2] = value;
                        break;
                    case "i64":
                        tempI64 = [value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
                        break;
                    case "float":
                        HEAPF32[ptr >> 2] = value;
                        break;
                    case "double":
                        HEAPF64[ptr >> 3] = value;
                        break;
                    default:
                        abort("invalid type for setValue: " + type)
                }
            }
            var ALLOC_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(u8Array, idx, maxBytesToRead) {
                var endIdx = idx + maxBytesToRead;
                var endPtr = idx;
                while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr;
                if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
                    return UTF8Decoder.decode(u8Array.subarray(idx, endPtr))
                } else {
                    var str = "";
                    while (idx < endPtr) {
                        var u0 = u8Array[idx++];
                        if (!(u0 & 128)) {
                            str += String.fromCharCode(u0);
                            continue
                        }
                        var u1 = u8Array[idx++] & 63;
                        if ((u0 & 224) == 192) {
                            str += String.fromCharCode((u0 & 31) << 6 | u1);
                            continue
                        }
                        var u2 = u8Array[idx++] & 63;
                        if ((u0 & 240) == 224) {
                            u0 = (u0 & 15) << 12 | u1 << 6 | u2
                        } else {
                            u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u8Array[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, outU8Array, outIdx, maxBytesToWrite) {
                if (!(maxBytesToWrite > 0)) return 0;
                var startIdx = outIdx;
                var endIdx = outIdx + maxBytesToWrite - 1;
                for (var i = 0; i < str.length; ++i) {
                    var u = str.charCodeAt(i);
                    if (u >= 55296 && u <= 57343) {
                        var u1 = str.charCodeAt(++i);
                        u = 65536 + ((u & 1023) << 10) | u1 & 1023
                    }
                    if (u <= 127) {
                        if (outIdx >= endIdx) break;
                        outU8Array[outIdx++] = u
                    } else if (u <= 2047) {
                        if (outIdx + 1 >= endIdx) break;
                        outU8Array[outIdx++] = 192 | u >> 6;
                        outU8Array[outIdx++] = 128 | u & 63
                    } else if (u <= 65535) {
                        if (outIdx + 2 >= endIdx) break;
                        outU8Array[outIdx++] = 224 | u >> 12;
                        outU8Array[outIdx++] = 128 | u >> 6 & 63;
                        outU8Array[outIdx++] = 128 | u & 63
                    } else {
                        if (outIdx + 3 >= endIdx) break;
                        outU8Array[outIdx++] = 240 | u >> 18;
                        outU8Array[outIdx++] = 128 | u >> 12 & 63;
                        outU8Array[outIdx++] = 128 | u >> 6 & 63;
                        outU8Array[outIdx++] = 128 | u & 63
                    }
                }
                outU8Array[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 writeAsciiToMemory(str, buffer, dontAddNull) {
                for (var i = 0; i < str.length; ++i) {
                    HEAP8[buffer++ >> 0] = str.charCodeAt(i)
                }
                if (!dontAddNull) HEAP8[buffer >> 0] = 0
            }

            function demangle(func) {
                return func
            }

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

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

            function stackTrace() {
                var js = jsStackTrace();
                if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
                return demangleAll(js)
            }
            var PAGE_SIZE = 16384;
            var WASM_PAGE_SIZE = 65536;
            var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;

            function updateGlobalBufferViews() {
                Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
                Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
                Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
                Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
                Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
                Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
                Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
                Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer)
            }
            var DYNAMIC_BASE = 5606656,
                DYNAMICTOP_PTR = 363520;
            var TOTAL_STACK = 5242880;
            var INITIAL_TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 67108864;
            if (INITIAL_TOTAL_MEMORY < TOTAL_STACK) err("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + INITIAL_TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
            if (Module["buffer"]) {
                buffer = Module["buffer"]
            } else {
                if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") {
                    wasmMemory = new WebAssembly.Memory({
                        "initial": INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE,
                        "maximum": INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE
                    });
                    buffer = wasmMemory.buffer
                } else {
                    buffer = new ArrayBuffer(INITIAL_TOTAL_MEMORY)
                }
            }
            updateGlobalBufferViews();
            HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;

            function callRuntimeCallbacks(callbacks) {
                while (callbacks.length > 0) {
                    var callback = callbacks.shift();
                    if (typeof callback == "function") {
                        callback();
                        continue
                    }
                    var func = callback.func;
                    if (typeof func === "number") {
                        if (callback.arg === undefined) {
                            Module["dynCall_v"](func)
                        } else {
                            Module["dynCall_vi"](func, callback.arg)
                        }
                    } else {
                        func(callback.arg === undefined ? null : callback.arg)
                    }
                }
            }
            var __ATPRERUN__ = [];
            var __ATINIT__ = [];
            var __ATMAIN__ = [];
            var __ATPOSTRUN__ = [];
            var runtimeInitialized = false;

            function preRun() {
                if (Module["preRun"]) {
                    if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
                    while (Module["preRun"].length) {
                        addOnPreRun(Module["preRun"].shift())
                    }
                }
                callRuntimeCallbacks(__ATPRERUN__)
            }

            function ensureInitRuntime() {
                if (runtimeInitialized) return;
                runtimeInitialized = true;
                if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
                TTY.init();
                callRuntimeCallbacks(__ATINIT__)
            }

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

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

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

            function addOnPostRun(cb) {
                __ATPOSTRUN__.unshift(cb)
            }
            var 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"] = {};
            var dataURIPrefix = "data:application/octet-stream;base64,";

            function isDataURI(filename) {
                return String.prototype.startsWith ? filename.startsWith(dataURIPrefix) : filename.indexOf(dataURIPrefix) === 0
            }
            var wasmBinaryFile = "harfbuzzjs.wasm";
            if (!isDataURI(wasmBinaryFile)) {
                wasmBinaryFile = locateFile(wasmBinaryFile)
            }

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

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

            function createWasm(env) {
                var info = {
                    "env": env,
                    "global": {
                        "NaN": NaN,
                        Infinity: Infinity
                    },
                    "global.Math": Math,
                    "asm2wasm": asm2wasmImports
                };

                function receiveInstance(instance, module) {
                    var exports = instance.exports;
                    Module["asm"] = exports;
                    removeRunDependency("wasm-instantiate")
                }
                addRunDependency("wasm-instantiate");
                if (Module["instantiateWasm"]) {
                    try {
                        return Module["instantiateWasm"](info, receiveInstance)
                    } catch (e) {
                        err("Module.instantiateWasm callback failed with error: " + e);
                        return false
                    }
                }

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

                function instantiateArrayBuffer(receiver) {
                    getBinaryPromise().then(function(binary) {
                        return WebAssembly.instantiate(binary, info)
                    }).then(receiver, function(reason) {
                        err("failed to asynchronously prepare wasm: " + reason);
                        abort(reason)
                    })
                }
                if (!Module["wasmBinary"] && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
                    WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, {
                        credentials: "same-origin"
                    }), info).then(receiveInstantiatedSource, function(reason) {
                        err("wasm streaming compile failed: " + reason);
                        err("falling back to ArrayBuffer instantiation");
                        instantiateArrayBuffer(receiveInstantiatedSource)
                    })
                } else {
                    instantiateArrayBuffer(receiveInstantiatedSource)
                }
                return {}
            }
            Module["asm"] = function(global, env, providedBuffer) {
                env["memory"] = wasmMemory;
                env["table"] = wasmTable = new WebAssembly.Table({
                    "initial": 310,
                    "maximum": 310,
                    "element": "anyfunc"
                });
                env["__memory_base"] = 1024;
                env["__table_base"] = 0;
                var exports = createWasm(env);
                return exports
            };
            __ATINIT__.push({
                func: function() {
                    ___emscripten_environ_constructor()
                }
            });

            function ___assert_fail(condition, filename, line, func) {
                abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"])
            }
            var ENV = {};

            function ___buildEnvironment(environ) {
                var MAX_ENV_VALUES = 64;
                var TOTAL_ENV_SIZE = 1024;
                var poolPtr;
                var envPtr;
                if (!___buildEnvironment.called) {
                    ___buildEnvironment.called = true;
                    ENV["USER"] = ENV["LOGNAME"] = "web_user";
                    ENV["PATH"] = "/";
                    ENV["PWD"] = "/";
                    ENV["HOME"] = "/home/web_user";
                    ENV["LANG"] = "C.UTF-8";
                    ENV["_"] = Module["thisProgram"];
                    poolPtr = getMemory(TOTAL_ENV_SIZE);
                    envPtr = getMemory(MAX_ENV_VALUES * 4);
                    HEAP32[envPtr >> 2] = poolPtr;
                    HEAP32[environ >> 2] = envPtr
                } else {
                    envPtr = HEAP32[environ >> 2];
                    poolPtr = HEAP32[envPtr >> 2]
                }
                var strings = [];
                var totalSize = 0;
                for (var key in ENV) {
                    if (typeof ENV[key] === "string") {
                        var line = key + "=" + ENV[key];
                        strings.push(line);
                        totalSize += line.length
                    }
                }
                if (totalSize > TOTAL_ENV_SIZE) {
                    throw new Error("Environment size exceeded TOTAL_ENV_SIZE!")
                }
                var ptrSize = 4;
                for (var i = 0; i < strings.length; i++) {
                    var line = strings[i];
                    writeAsciiToMemory(line, poolPtr);
                    HEAP32[envPtr + i * ptrSize >> 2] = poolPtr;
                    poolPtr += line.length + 1
                }
                HEAP32[envPtr + strings.length * ptrSize >> 2] = 0
            }

            function ___lock() {}

            function ___setErrNo(value) {
                if (Module["___errno_location"]) HEAP32[Module["___errno_location"]() >> 2] = value;
                return value
            }

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

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

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

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

                    function done(err) {
                        if (err) {
                            if (!done.errored) {
                                done.errored = true;
                                return callback(err)
                            }
                            return
                        }
                        if (++completed >= total) {
                            return callback(null)
                        }
                    }
                    transaction.onerror = function(e) {
                        done(this.error);
                        e.preventDefault()
                    };
                    create.sort().forEach(function(path) {
                        if (dst.type === "local") {
                            IDBFS.loadRemoteEntry(store, path, function(err, entry) {
                                if (err) return done(err);
                                IDBFS.storeLocalEntry(path, entry, done)
                            })
                        } else {
                            IDBFS.loadLocalEntry(path, function(err, entry) {
                                if (err) return done(err);
                                IDBFS.storeRemoteEntry(store, path, entry, done)
                            })
                        }
                    });
                    remove.sort().reverse().forEach(function(path) {
                        if (dst.type === "local") {
                            IDBFS.removeLocalEntry(path, done)
                        } else {
                            IDBFS.removeRemoteEntry(store, path, done)
                        }
                    })
                }
            };
            var NODEFS = {
                isWindows: false,
                staticInit: function() {
                    NODEFS.isWindows = !!process.platform.match(/^win/);
                    var flags = process["binding"]("constants");
                    if (flags["fs"]) {
                        flags = flags["fs"]
                    }
                    NODEFS.flagsForNodeMap = {
                        1024: flags["O_APPEND"],
                        64: flags["O_CREAT"],
                        128: flags["O_EXCL"],
                        0: flags["O_RDONLY"],
                        2: flags["O_RDWR"],
                        4096: flags["O_SYNC"],
                        512: flags["O_TRUNC"],
                        1: flags["O_WRONLY"]
                    }
                },
                bufferFrom: function(arrayBuffer) {
                    return Buffer.alloc ? Buffer.from(arrayBuffer) : new Buffer(arrayBuffer)
                },
                mount: function(mount) {
                    assert(ENVIRONMENT_IS_NODE);
                    return NODEFS.createNode(null, "/", NODEFS.getMode(mount.opts.root), 0)
                },
                createNode: function(parent, name, mode, dev) {
                    if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
                        throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
                    }
                    var node = FS.createNode(parent, name, mode);
                    node.node_ops = NODEFS.node_ops;
                    node.stream_ops = NODEFS.stream_ops;
                    return node
                },
                getMode: function(path) {
                    var stat;
                    try {
                        stat = fs.lstatSync(path);
                        if (NODEFS.isWindows) {
                            stat.mode = stat.mode | (stat.mode & 292) >> 2
                        }
                    } catch (e) {
                        if (!e.code) throw e;
                        throw new FS.ErrnoError(ERRNO_CODES[e.code])
                    }
                    return stat.mode
                },
                realPath: function(node) {
                    var parts = [];
                    while (node.parent !== node) {
                        parts.push(node.name);
                        node = node.parent
                    }
                    parts.push(node.mount.opts.root);
                    parts.reverse();
                    return PATH.join.apply(null, parts)
                },
                flagsForNode: function(flags) {
                    flags &= ~2097152;
                    flags &= ~2048;
                    flags &= ~32768;
                    flags &= ~524288;
                    var newFlags = 0;
                    for (var k in NODEFS.flagsForNodeMap) {
                        if (flags & k) {
                            newFlags |= NODEFS.flagsForNodeMap[k];
                            flags ^= k
                        }
                    }
                    if (!flags) {
                        return newFlags
                    } else {
                        throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
                    }
                },
                node_ops: {
                    getattr: function(node) {
                        var path = NODEFS.realPath(node);
                        var stat;
                        try {
                            stat = fs.lstatSync(path)
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                        if (NODEFS.isWindows && !stat.blksize) {
                            stat.blksize = 4096
                        }
                        if (NODEFS.isWindows && !stat.blocks) {
                            stat.blocks = (stat.size + stat.blksize - 1) / stat.blksize | 0
                        }
                        return {
                            dev: stat.dev,
                            ino: stat.ino,
                            mode: stat.mode,
                            nlink: stat.nlink,
                            uid: stat.uid,
                            gid: stat.gid,
                            rdev: stat.rdev,
                            size: stat.size,
                            atime: stat.atime,
                            mtime: stat.mtime,
                            ctime: stat.ctime,
                            blksize: stat.blksize,
                            blocks: stat.blocks
                        }
                    },
                    setattr: function(node, attr) {
                        var path = NODEFS.realPath(node);
                        try {
                            if (attr.mode !== undefined) {
                                fs.chmodSync(path, attr.mode);
                                node.mode = attr.mode
                            }
                            if (attr.timestamp !== undefined) {
                                var date = new Date(attr.timestamp);
                                fs.utimesSync(path, date, date)
                            }
                            if (attr.size !== undefined) {
                                fs.truncateSync(path, attr.size)
                            }
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    lookup: function(parent, name) {
                        var path = PATH.join2(NODEFS.realPath(parent), name);
                        var mode = NODEFS.getMode(path);
                        return NODEFS.createNode(parent, name, mode)
                    },
                    mknod: function(parent, name, mode, dev) {
                        var node = NODEFS.createNode(parent, name, mode, dev);
                        var path = NODEFS.realPath(node);
                        try {
                            if (FS.isDir(node.mode)) {
                                fs.mkdirSync(path, node.mode)
                            } else {
                                fs.writeFileSync(path, "", {
                                    mode: node.mode
                                })
                            }
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                        return node
                    },
                    rename: function(oldNode, newDir, newName) {
                        var oldPath = NODEFS.realPath(oldNode);
                        var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
                        try {
                            fs.renameSync(oldPath, newPath)
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    unlink: function(parent, name) {
                        var path = PATH.join2(NODEFS.realPath(parent), name);
                        try {
                            fs.unlinkSync(path)
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    rmdir: function(parent, name) {
                        var path = PATH.join2(NODEFS.realPath(parent), name);
                        try {
                            fs.rmdirSync(path)
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    readdir: function(node) {
                        var path = NODEFS.realPath(node);
                        try {
                            return fs.readdirSync(path)
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    symlink: function(parent, newName, oldPath) {
                        var newPath = PATH.join2(NODEFS.realPath(parent), newName);
                        try {
                            fs.symlinkSync(oldPath, newPath)
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    readlink: function(node) {
                        var path = NODEFS.realPath(node);
                        try {
                            path = fs.readlinkSync(path);
                            path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path);
                            return path
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    }
                },
                stream_ops: {
                    open: function(stream) {
                        var path = NODEFS.realPath(stream.node);
                        try {
                            if (FS.isFile(stream.node.mode)) {
                                stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags))
                            }
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    close: function(stream) {
                        try {
                            if (FS.isFile(stream.node.mode) && stream.nfd) {
                                fs.closeSync(stream.nfd)
                            }
                        } catch (e) {
                            if (!e.code) throw e;
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    read: function(stream, buffer, offset, length, position) {
                        if (length === 0) return 0;
                        try {
                            return fs.readSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position)
                        } catch (e) {
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    write: function(stream, buffer, offset, length, position) {
                        try {
                            return fs.writeSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position)
                        } catch (e) {
                            throw new FS.ErrnoError(ERRNO_CODES[e.code])
                        }
                    },
                    llseek: function(stream, offset, whence) {
                        var position = offset;
                        if (whence === 1) {
                            position += stream.position
                        } else if (whence === 2) {
                            if (FS.isFile(stream.node.mode)) {
                                try {
                                    var stat = fs.fstatSync(stream.nfd);
                                    position += stat.size
                                } catch (e) {
                                    throw new FS.ErrnoError(ERRNO_CODES[e.code])
                                }
                            }
                        }
                        if (position < 0) {
                            throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
                        }
                        return position
                    }
                }
            };
            var WORKERFS = {
                DIR_MODE: 16895,
                FILE_MODE: 33279,
                reader: null,
                mount: function(mount) {
                    assert(ENVIRONMENT_IS_WORKER);
                    if (!WORKERFS.reader) WORKERFS.reader = new FileReaderSync;
                    var root = WORKERFS.createNode(null, "/", WORKERFS.DIR_MODE, 0);
                    var createdParents = {};

                    function ensureParent(path) {
                        var parts = path.split("/");
                        var parent = root;
                        for (var i = 0; i < parts.length - 1; i++) {
                            var curr = parts.slice(0, i + 1).join("/");
                            if (!createdParents[curr]) {
                                createdParents[curr] = WORKERFS.createNode(parent, parts[i], WORKERFS.DIR_MODE, 0)
                            }
                            parent = createdParents[curr]
                        }
                        return parent
                    }

                    function base(path) {
                        var parts = path.split("/");
                        return parts[parts.length - 1]
                    }
                    Array.prototype.forEach.call(mount.opts["files"] || [], function(file) {
                        WORKERFS.createNode(ensureParent(file.name), base(file.name), WORKERFS.FILE_MODE, 0, file, file.lastModifiedDate)
                    });
                    (mount.opts["blobs"] || []).forEach(function(obj) {
                        WORKERFS.createNode(ensureParent(obj["name"]), base(obj["name"]), WORKERFS.FILE_MODE, 0, obj["data"])
                    });
                    (mount.opts["packages"] || []).forEach(function(pack) {
                        pack["metadata"].files.forEach(function(file) {
                            var name = file.filename.substr(1);
                            WORKERFS.createNode(ensureParent(name), base(name), WORKERFS.FILE_MODE, 0, pack["blob"].slice(file.start, file.end))
                        })
                    });
                    return root
                },
                createNode: function(parent, name, mode, dev, contents, mtime) {
                    var node = FS.createNode(parent, name, mode);
                    node.mode = mode;
                    node.node_ops = WORKERFS.node_ops;
                    node.stream_ops = WORKERFS.stream_ops;
                    node.timestamp = (mtime || new Date).getTime();
                    assert(WORKERFS.FILE_MODE !== WORKERFS.DIR_MODE);
                    if (mode === WORKERFS.FILE_MODE) {
                        node.size = contents.size;
                        node.contents = contents
                    } else {
                        node.size = 4096;
                        node.contents = {}
                    }
                    if (parent) {
                        parent.contents[name] = node
                    }
                    return node
                },
                node_ops: {
                    getattr: function(node) {
                        return {
                            dev: 1,
                            ino: undefined,
                            mode: node.mode,
                            nlink: 1,
                            uid: 0,
                            gid: 0,
                            rdev: undefined,
                            size: node.size,
                            atime: new Date(node.timestamp),
                            mtime: new Date(node.timestamp),
                            ctime: new Date(node.timestamp),
                            blksize: 4096,
                            blocks: Math.ceil(node.size / 4096)
                        }
                    },
                    setattr: function(node, attr) {
                        if (attr.mode !== undefined) {
                            node.mode = attr.mode
                        }
                        if (attr.timestamp !== undefined) {
                            node.timestamp = attr.timestamp
                        }
                    },
                    lookup: function(parent, name) {
                        throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
                    },
                    mknod: function(parent, name, mode, dev) {
                        throw new FS.ErrnoError(ERRNO_CODES.EPERM)
                    },
                    rename: function(oldNode, newDir, newName) {
                        throw new FS.ErrnoError(ERRNO_CODES.EPERM)
                    },
                    unlink: function(parent, name) {
                        throw new FS.ErrnoError(ERRNO_CODES.EPERM)
                    },
                    rmdir: function(parent, name) {
                        throw new FS.ErrnoError(ERRNO_CODES.EPERM)
                    },
                    readdir: function(node) {
                        var entries = [".", ".."];
                        for (var key in node.contents) {
                            if (!node.contents.hasOwnProperty(key)) {
                                continue
                            }
                            entries.push(key)
                        }
                        return entries
                    },
                    symlink: function(parent, newName, oldPath) {
                        throw new FS.ErrnoError(ERRNO_CODES.EPERM)
                    },
                    readlink: function(node) {
                        throw new FS.ErrnoError(ERRNO_CODES.EPERM)
                    }
                },
                stream_ops: {
                    read: function(stream, buffer, offset, length, position) {
                        if (position >= stream.node.size) return 0;
                        var chunk = stream.node.contents.slice(position, position + length);
                        var ab = WORKERFS.reader.readAsArrayBuffer(chunk);
                        buffer.set(new Uint8Array(ab), offset);
                        return chunk.size
                    },
                    write: function(stream, buffer, offset, length, position) {
                        throw new FS.ErrnoError(ERRNO_CODES.EIO)
                    },
                    llseek: function(stream, offset, whence) {
                        var position = offset;
                        if (whence === 1) {
                            position += stream.position
                        } else if (whence === 2) {
                            if (FS.isFile(stream.node.mode)) {
                                position += stream.node.size
                            }
                        }
                        if (position < 0) {
                            throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
                        }
                        return position
                    }
                }
            };
            var FS = {
                root: null,
                mounts: [],
                devices: {},
                streams: [],
                nextInode: 1,
                nameTable: null,
                currentPath: "/",
                initialized: false,
                ignorePermissions: true,
                trackingDelegate: {},
                tracking: {
                    openFlags: {
                        READ: 1,
                        WRITE: 2
                    }
                },
                ErrnoError: null,
                genericErrors: {},
                filesystems: null,
                syncFSRequests: 0,
                handleFSError: function(e) {
                    if (!(e instanceof FS.ErrnoError)) throw e + " : " + stackTrace();
                    return ___setErrNo(e.errno)
                },
                lookupPath: function(path, opts) {
                    path = PATH.resolve(FS.cwd(), path);
                    opts = opts || {};
                    if (!path) return {
                        path: "",
                        node: null
                    };
                    var defaults = {
                        follow_mount: true,
                        recurse_count: 0
                    };
                    for (var key in defaults) {
                        if (opts[key] === undefined) {
                            opts[key] = defaults[key]
                        }
                    }
                    if (opts.recurse_count > 8) {
                        throw new FS.ErrnoError(40)
                    }
                    var parts = PATH.normalizeArray(path.split("/").filter(function(p) {
                        return !!p
                    }), false);
                    var current = FS.root;
                    var current_path = "/";
                    for (var i = 0; i < parts.length; i++) {
                        var islast = i === parts.length - 1;
                        if (islast && opts.parent) {
                            break
                        }
                        current = FS.lookupNode(current, parts[i]);
                        current_path = PATH.join2(current_path, parts[i]);
                        if (FS.isMountpoint(current)) {
                            if (!islast || islast && opts.follow_mount) {
                                current = current.mounted.root
                            }
                        }
                        if (!islast || opts.follow) {
                            var count = 0;
                            while (FS.isLink(current.mode)) {
                                var link = FS.readlink(current_path);
                                current_path = PATH.resolve(PATH.dirname(current_path), link);
                                var lookup = FS.lookupPath(current_path, {
                                    recurse_count: opts.recurse_count
                                });
                                current = lookup.node;
                                if (count++ > 40) {
                                    throw new FS.ErrnoError(40)
                                }
                            }
                        }
                    }
                    return {
                        path: current_path,
                        node: current
                    }
                },
                getPath: function(node) {
                    var path;
                    while (true) {
                        if (FS.isRoot(node)) {
                            var mount = node.mount.mountpoint;
                            if (!path) return mount;
                            return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path
                        }
                        path = path ? node.name + "/" + path : node.name;
                        node = node.parent
                    }
                },
                hashName: function(parentid, name) {
                    var hash = 0;
                    for (var i = 0; i < name.length; i++) {
                        hash = (hash << 5) - hash + name.charCodeAt(i) | 0
                    }
                    return (parentid + hash >>> 0) % FS.nameTable.length
                },
                hashAddNode: function(node) {
                    var hash = FS.hashName(node.parent.id, node.name);
                    node.name_next = FS.nameTable[hash];
                    FS.nameTable[hash] = node
                },
                hashRemoveNode: function(node) {
                    var hash = FS.hashName(node.parent.id, node.name);
                    if (FS.nameTable[hash] === node) {
                        FS.nameTable[hash] = node.name_next
                    } else {
                        var current = FS.nameTable[hash];
                        while (current) {
                            if (current.name_next === node) {
                                current.name_next = node.name_next;
                                break
                            }
                            current = current.name_next
                        }
                    }
                },
                lookupNode: function(parent, name) {
                    var err = FS.mayLookup(parent);
                    if (err) {
                        throw new FS.ErrnoError(err, parent)
                    }
                    var hash = FS.hashName(parent.id, name);
                    for (var node = FS.nameTable[hash]; node; node = node.name_next) {
                        var nodeName = node.name;
                        if (node.parent.id === parent.id && nodeName === name) {
                            return node
                        }
                    }
                    return FS.lookup(parent, name)
                },
                createNode: function(parent, name, mode, rdev) {
                    if (!FS.FSNode) {
                        FS.FSNode = function(parent, name, mode, rdev) {
                            if (!parent) {
                                parent = this
                            }
                            this.parent = parent;
                            this.mount = parent.mount;
                            this.mounted = null;
                            this.id = FS.nextInode++;
                            this.name = name;
                            this.mode = mode;
                            this.node_ops = {};
                            this.stream_ops = {};
                            this.rdev = rdev
                        };
                        FS.FSNode.prototype = {};
                        var readMode = 292 | 73;
                        var writeMode = 146;
                        Object.defineProperties(FS.FSNode.prototype, {
                            read: {
                                get: function() {
                                    return (this.mode & readMode) === readMode
                                },
                                set: function(val) {
                                    val ? this.mode |= readMode : this.mode &= ~readMode
                                }
                            },
                            write: {
                                get: function() {
                                    return (this.mode & writeMode) === writeMode
                                },
                                set: function(val) {
                                    val ? this.mode |= writeMode : this.mode &= ~writeMode
                                }
                            },
                            isFolder: {
                                get: function() {
                                    return FS.isDir(this.mode)
                                }
                            },
                            isDevice: {
                                get: function() {
                                    return FS.isChrdev(this.mode)
                                }
                            }
                        })
                    }
                    var node = new FS.FSNode(parent, name, mode, rdev);
                    FS.hashAddNode(node);
                    return node
                },
                destroyNode: function(node) {
                    FS.hashRemoveNode(node)
                },
                isRoot: function(node) {
                    return node === node.parent
                },
                isMountpoint: function(node) {
                    return !!node.mounted
                },
                isFile: function(mode) {
                    return (mode & 61440) === 32768
                },
                isDir: function(mode) {
                    return (mode & 61440) === 16384
                },
                isLink: function(mode) {
                    return (mode & 61440) === 40960
                },
                isChrdev: function(mode) {
                    return (mode & 61440) === 8192
                },
                isBlkdev: function(mode) {
                    return (mode & 61440) === 24576
                },
                isFIFO: function(mode) {
                    return (mode & 61440) === 4096
                },
                isSocket: function(mode) {
                    return (mode & 49152) === 49152
                },
                flagModes: {
                    "r": 0,
                    "rs": 1052672,
                    "r+": 2,
                    "w": 577,
                    "wx": 705,
                    "xw": 705,
                    "w+": 578,
                    "wx+": 706,
                    "xw+": 706,
                    "a": 1089,
                    "ax": 1217,
                    "xa": 1217,
                    "a+": 1090,
                    "ax+": 1218,
                    "xa+": 1218
                },
                modeStringToFlags: function(str) {
                    var flags = FS.flagModes[str];
                    if (typeof flags === "undefined") {
                        throw new Error("Unknown file open mode: " + str)
                    }
                    return flags
                },
                flagsToPermissionString: function(flag) {
                    var perms = ["r", "w", "rw"][flag & 3];
                    if (flag & 512) {
                        perms += "w"
                    }
                    return perms
                },
                nodePermissions: function(node, perms) {
                    if (FS.ignorePermissions) {
                        return 0
                    }
                    if (perms.indexOf("r") !== -1 && !(node.mode & 292)) {
                        return 13
                    } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) {
                        return 13
                    } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) {
                        return 13
                    }
                    return 0
                },
                mayLookup: function(dir) {
                    var err = FS.nodePermissions(dir, "x");
                    if (err) return err;
                    if (!dir.node_ops.lookup) return 13;
                    return 0
                },
                mayCreate: function(dir, name) {
                    try {
                        var node = FS.lookupNode(dir, name);
                        return 17
                    } catch (e) {}
                    return FS.nodePermissions(dir, "wx")
                },
                mayDelete: function(dir, name, isdir) {
                    var node;
                    try {
                        node = FS.lookupNode(dir, name)
                    } catch (e) {
                        return e.errno
                    }
                    var err = FS.nodePermissions(dir, "wx");
                    if (err) {
                        return err
                    }
                    if (isdir) {
                        if (!FS.isDir(node.mode)) {
                            return 20
                        }
                        if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
                            return 16
                        }
                    } else {
                        if (FS.isDir(node.mode)) {
                            return 21
                        }
                    }
                    return 0
                },
                mayOpen: function(node, flags) {
                    if (!node) {
                        return 2
                    }
                    if (FS.isLink(node.mode)) {
                        return 40
                    } else if (FS.isDir(node.mode)) {
                        if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
                            return 21
                        }
                    }
                    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(24)
                },
                getStream: function(fd) {
                    return FS.streams[fd]
                },
                createStream: function(stream, fd_start, fd_end) {
                    if (!FS.FSStream) {
                        FS.FSStream = function() {};
                        FS.FSStream.prototype = {};
                        Object.defineProperties(FS.FSStream.prototype, {
                            object: {
                                get: function() {
                                    return this.node
                                },
                                set: function(val) {
                                    this.node = val
                                }
                            },
                            isRead: {
                                get: function() {
                                    return (this.flags & 2097155) !== 1
                                }
                            },
                            isWrite: {
                                get: function() {
                                    return (this.flags & 2097155) !== 0
                                }
                            },
                            isAppend: {
                                get: function() {
                                    return this.flags & 1024
                                }
                            }
                        })
                    }
                    var newStream = new FS.FSStream;
                    for (var p in stream) {
                        newStream[p] = stream[p]
                    }
                    stream = newStream;
                    var fd = FS.nextfd(fd_start, fd_end);
                    stream.fd = fd;
                    FS.streams[fd] = stream;
                    return stream
                },
                closeStream: function(fd) {
                    FS.streams[fd] = null
                },
                chrdev_stream_ops: {
                    open: function(stream) {
                        var device = FS.getDevice(stream.node.rdev);
                        stream.stream_ops = device.stream_ops;
                        if (stream.stream_ops.open) {
                            stream.stream_ops.open(stream)
                        }
                    },
                    llseek: function() {
                        throw new FS.ErrnoError(29)
                    }
                },
                major: function(dev) {
                    return dev >> 8
                },
                minor: function(dev) {
                    return dev & 255
                },
                makedev: function(ma, mi) {
                    return ma << 8 | mi
                },
                registerDevice: function(dev, ops) {
                    FS.devices[dev] = {
                        stream_ops: ops
                    }
                },
                getDevice: function(dev) {
                    return FS.devices[dev]
                },
                getMounts: function(mount) {
                    var mounts = [];
                    var check = [mount];
                    while (check.length) {
                        var m = check.pop();
                        mounts.push(m);
                        check.push.apply(check, m.mounts)
                    }
                    return mounts
                },
                syncfs: function(populate, callback) {
                    if (typeof populate === "function") {
                        callback = populate;
                        populate = false
                    }
                    FS.syncFSRequests++;
                    if (FS.syncFSRequests > 1) {
                        console.log("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work")
                    }
                    var mounts = FS.getMounts(FS.root.mount);
                    var completed = 0;

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

                    function done(err) {
                        if (err) {
                            if (!done.errored) {
                                done.errored = true;
                                return doCallback(err)
                            }
                            return
                        }
                        if (++completed >= mounts.length) {
                            doCallback(null)
                        }
                    }
                    mounts.forEach(function(mount) {
                        if (!mount.type.syncfs) {
                            return done(null)
                        }
                        mount.type.syncfs(mount, populate, done)
                    })
                },
                mount: function(type, opts, mountpoint) {
                    var root = mountpoint === "/";
                    var pseudo = !mountpoint;
                    var node;
                    if (root && FS.root) {
                        throw new FS.ErrnoError(16)
                    } 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(16)
                        }
                        if (!FS.isDir(node.mode)) {
                            throw new FS.ErrnoError(20)
                        }
                    }
                    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(22)
                    }
                    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(22)
                    }
                    var err = FS.mayCreate(parent, name);
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    if (!parent.node_ops.mknod) {
                        throw new FS.ErrnoError(1)
                    }
                    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 != 17) throw e
                        }
                    }
                },
                mkdev: function(path, mode, dev) {
                    if (typeof dev === "undefined") {
                        dev = mode;
                        mode = 438
                    }
                    mode |= 8192;
                    return FS.mknod(path, mode, dev)
                },
                symlink: function(oldpath, newpath) {
                    if (!PATH.resolve(oldpath)) {
                        throw new FS.ErrnoError(2)
                    }
                    var lookup = FS.lookupPath(newpath, {
                        parent: true
                    });
                    var parent = lookup.node;
                    if (!parent) {
                        throw new FS.ErrnoError(2)
                    }
                    var newname = PATH.basename(newpath);
                    var err = FS.mayCreate(parent, newname);
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    if (!parent.node_ops.symlink) {
                        throw new FS.ErrnoError(1)
                    }
                    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(16)
                    }
                    if (!old_dir || !new_dir) throw new FS.ErrnoError(2);
                    if (old_dir.mount !== new_dir.mount) {
                        throw new FS.ErrnoError(18)
                    }
                    var old_node = FS.lookupNode(old_dir, old_name);
                    var relative = PATH.relative(old_path, new_dirname);
                    if (relative.charAt(0) !== ".") {
                        throw new FS.ErrnoError(22)
                    }
                    relative = PATH.relative(new_path, old_dirname);
                    if (relative.charAt(0) !== ".") {
                        throw new FS.ErrnoError(39)
                    }
                    var new_node;
                    try {
                        new_node = FS.lookupNode(new_dir, new_name)
                    } catch (e) {}
                    if (old_node === new_node) {
                        return
                    }
                    var isdir = FS.isDir(old_node.mode);
                    var err = FS.mayDelete(old_dir, old_name, isdir);
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    err = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    if (!old_dir.node_ops.rename) {
                        throw new FS.ErrnoError(1)
                    }
                    if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
                        throw new FS.ErrnoError(16)
                    }
                    if (new_dir !== old_dir) {
                        err = FS.nodePermissions(old_dir, "w");
                        if (err) {
                            throw new FS.ErrnoError(err)
                        }
                    }
                    try {
                        if (FS.trackingDelegate["willMovePath"]) {
                            FS.trackingDelegate["willMovePath"](old_path, new_path)
                        }
                    } catch (e) {
                        console.log("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
                    }
                    FS.hashRemoveNode(old_node);
                    try {
                        old_dir.node_ops.rename(old_node, new_dir, new_name)
                    } catch (e) {
                        throw e
                    } finally {
                        FS.hashAddNode(old_node)
                    }
                    try {
                        if (FS.trackingDelegate["onMovePath"]) FS.trackingDelegate["onMovePath"](old_path, new_path)
                    } catch (e) {
                        console.log("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
                    }
                },
                rmdir: function(path) {
                    var lookup = FS.lookupPath(path, {
                        parent: true
                    });
                    var parent = lookup.node;
                    var name = PATH.basename(path);
                    var node = FS.lookupNode(parent, name);
                    var err = FS.mayDelete(parent, name, true);
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    if (!parent.node_ops.rmdir) {
                        throw new FS.ErrnoError(1)
                    }
                    if (FS.isMountpoint(node)) {
                        throw new FS.ErrnoError(16)
                    }
                    try {
                        if (FS.trackingDelegate["willDeletePath"]) {
                            FS.trackingDelegate["willDeletePath"](path)
                        }
                    } catch (e) {
                        console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                    parent.node_ops.rmdir(parent, name);
                    FS.destroyNode(node);
                    try {
                        if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path)
                    } catch (e) {
                        console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                },
                readdir: function(path) {
                    var lookup = FS.lookupPath(path, {
                        follow: true
                    });
                    var node = lookup.node;
                    if (!node.node_ops.readdir) {
                        throw new FS.ErrnoError(20)
                    }
                    return node.node_ops.readdir(node)
                },
                unlink: function(path) {
                    var lookup = FS.lookupPath(path, {
                        parent: true
                    });
                    var parent = lookup.node;
                    var name = PATH.basename(path);
                    var node = FS.lookupNode(parent, name);
                    var err = FS.mayDelete(parent, name, false);
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    if (!parent.node_ops.unlink) {
                        throw new FS.ErrnoError(1)
                    }
                    if (FS.isMountpoint(node)) {
                        throw new FS.ErrnoError(16)
                    }
                    try {
                        if (FS.trackingDelegate["willDeletePath"]) {
                            FS.trackingDelegate["willDeletePath"](path)
                        }
                    } catch (e) {
                        console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                    parent.node_ops.unlink(parent, name);
                    FS.destroyNode(node);
                    try {
                        if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path)
                    } catch (e) {
                        console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
                    }
                },
                readlink: function(path) {
                    var lookup = FS.lookupPath(path);
                    var link = lookup.node;
                    if (!link) {
                        throw new FS.ErrnoError(2)
                    }
                    if (!link.node_ops.readlink) {
                        throw new FS.ErrnoError(22)
                    }
                    return PATH.resolve(FS.getPath(link.parent), link.node_ops.readlink(link))
                },
                stat: function(path, dontFollow) {
                    var lookup = FS.lookupPath(path, {
                        follow: !dontFollow
                    });
                    var node = lookup.node;
                    if (!node) {
                        throw new FS.ErrnoError(2)
                    }
                    if (!node.node_ops.getattr) {
                        throw new FS.ErrnoError(1)
                    }
                    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(1)
                    }
                    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(9)
                    }
                    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(1)
                    }
                    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(9)
                    }
                    FS.chown(stream.node, uid, gid)
                },
                truncate: function(path, len) {
                    if (len < 0) {
                        throw new FS.ErrnoError(22)
                    }
                    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(1)
                    }
                    if (FS.isDir(node.mode)) {
                        throw new FS.ErrnoError(21)
                    }
                    if (!FS.isFile(node.mode)) {
                        throw new FS.ErrnoError(22)
                    }
                    var err = FS.nodePermissions(node, "w");
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    node.node_ops.setattr(node, {
                        size: len,
                        timestamp: Date.now()
                    })
                },
                ftruncate: function(fd, len) {
                    var stream = FS.getStream(fd);
                    if (!stream) {
                        throw new FS.ErrnoError(9)
                    }
                    if ((stream.flags & 2097155) === 0) {
                        throw new FS.ErrnoError(22)
                    }
                    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(2)
                    }
                    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(17)
                            }
                        } else {
                            node = FS.mknod(path, mode, 0);
                            created = true
                        }
                    }
                    if (!node) {
                        throw new FS.ErrnoError(2)
                    }
                    if (FS.isChrdev(node.mode)) {
                        flags &= ~512
                    }
                    if (flags & 65536 && !FS.isDir(node.mode)) {
                        throw new FS.ErrnoError(20)
                    }
                    if (!created) {
                        var err = FS.mayOpen(node, flags);
                        if (err) {
                            throw new FS.ErrnoError(err)
                        }
                    }
                    if (flags & 512) {
                        FS.truncate(node, 0)
                    }
                    flags &= ~(128 | 512);
                    var stream = FS.createStream({
                        node: node,
                        path: FS.getPath(node),
                        flags: flags,
                        seekable: true,
                        position: 0,
                        stream_ops: node.stream_ops,
                        ungotten: [],
                        error: false
                    }, fd_start, fd_end);
                    if (stream.stream_ops.open) {
                        stream.stream_ops.open(stream)
                    }
                    if (Module["logReadFiles"] && !(flags & 1)) {
                        if (!FS.readFiles) FS.readFiles = {};
                        if (!(path in FS.readFiles)) {
                            FS.readFiles[path] = 1;
                            console.log("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) {
                        console.log("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message)
                    }
                    return stream
                },
                close: function(stream) {
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(9)
                    }
                    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(9)
                    }
                    if (!stream.seekable || !stream.stream_ops.llseek) {
                        throw new FS.ErrnoError(29)
                    }
                    if (whence != 0 && whence != 1 && whence != 2) {
                        throw new FS.ErrnoError(22)
                    }
                    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(22)
                    }
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(9)
                    }
                    if ((stream.flags & 2097155) === 1) {
                        throw new FS.ErrnoError(9)
                    }
                    if (FS.isDir(stream.node.mode)) {
                        throw new FS.ErrnoError(21)
                    }
                    if (!stream.stream_ops.read) {
                        throw new FS.ErrnoError(22)
                    }
                    var seeking = typeof position !== "undefined";
                    if (!seeking) {
                        position = stream.position
                    } else if (!stream.seekable) {
                        throw new FS.ErrnoError(29)
                    }
                    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(22)
                    }
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(9)
                    }
                    if ((stream.flags & 2097155) === 0) {
                        throw new FS.ErrnoError(9)
                    }
                    if (FS.isDir(stream.node.mode)) {
                        throw new FS.ErrnoError(21)
                    }
                    if (!stream.stream_ops.write) {
                        throw new FS.ErrnoError(22)
                    }
                    if (stream.flags & 1024) {
                        FS.llseek(stream, 0, 2)
                    }
                    var seeking = typeof position !== "undefined";
                    if (!seeking) {
                        position = stream.position
                    } else if (!stream.seekable) {
                        throw new FS.ErrnoError(29)
                    }
                    var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
                    if (!seeking) stream.position += bytesWritten;
                    try {
                        if (stream.path && FS.trackingDelegate["onWriteToFile"]) FS.trackingDelegate["onWriteToFile"](stream.path)
                    } catch (e) {
                        console.log("FS.trackingDelegate['onWriteToFile']('" + stream.path + "') threw an exception: " + e.message)
                    }
                    return bytesWritten
                },
                allocate: function(stream, offset, length) {
                    if (FS.isClosed(stream)) {
                        throw new FS.ErrnoError(9)
                    }
                    if (offset < 0 || length <= 0) {
                        throw new FS.ErrnoError(22)
                    }
                    if ((stream.flags & 2097155) === 0) {
                        throw new FS.ErrnoError(9)
                    }
                    if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
                        throw new FS.ErrnoError(19)
                    }
                    if (!stream.stream_ops.allocate) {
                        throw new FS.ErrnoError(95)
                    }
                    stream.stream_ops.allocate(stream, offset, length)
                },
                mmap: function(stream, buffer, offset, length, position, prot, flags) {
                    if ((stream.flags & 2097155) === 1) {
                        throw new FS.ErrnoError(13)
                    }
                    if (!stream.stream_ops.mmap) {
                        throw new FS.ErrnoError(19)
                    }
                    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(25)
                    }
                    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(2)
                    }
                    if (!FS.isDir(lookup.node.mode)) {
                        throw new FS.ErrnoError(20)
                    }
                    var err = FS.nodePermissions(lookup.node, "x");
                    if (err) {
                        throw new FS.ErrnoError(err)
                    }
                    FS.currentPath = lookup.path
                },
                createDefaultDirectories: function() {
                    FS.mkdir("/tmp");
                    FS.mkdir("/home");
                    FS.mkdir("/home/web_user")
                },
                createDefaultDevices: function() {
                    FS.mkdir("/dev");
                    FS.registerDevice(FS.makedev(1, 3), {
                        read: function() {
                            return 0
                        },
                        write: function(stream, buffer, offset, length, pos) {
                            return length
                        }
                    });
                    FS.mkdev("/dev/null", FS.makedev(1, 3));
                    TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
                    TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
                    FS.mkdev("/dev/tty", FS.makedev(5, 0));
                    FS.mkdev("/dev/tty1", FS.makedev(6, 0));
                    var random_device;
                    if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") {
                        var randomBuffer = new Uint8Array(1);
                        random_device = function() {
                            crypto.getRandomValues(randomBuffer);
                            return randomBuffer[0]
                        }
                    } else if (ENVIRONMENT_IS_NODE) {
                        try {
                            var crypto_module = require("crypto");
                            random_device = function() {
                                return crypto_module["randomBytes"](1)[0]
                            }
                        } catch (e) {}
                    } 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(9);
                                    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";
                        if (this.stack) Object.defineProperty(this, "stack", {
                            value: (new Error).stack,
                            writable: true
                        })
                    };
                    FS.ErrnoError.prototype = new Error;
                    FS.ErrnoError.prototype.constructor = FS.ErrnoError;
                    [2].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,
                        "NODEFS": NODEFS,
                        "WORKERFS": WORKERFS
                    }
                },
                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.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(5)
                                }
                                if (result === undefined && bytesRead === 0) {
                                    throw new FS.ErrnoError(11)
                                }
                                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(5)
                                }
                            }
                            if (length) {
                                stream.node.timestamp = Date.now()
                            }
                            return i
                        }
                    });
                    return FS.mkdev(path, mode, dev)
                },
                createLink: function(parent, name, target, canRead, canWrite) {
                    var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
                    return FS.symlink(target, path)
                },
                forceLoadFile: function(obj) {
                    if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
                    var success = true;
                    if (typeof XMLHttpRequest !== "undefined") {
                        throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")
                    } else if (Module["read"]) {
                        try {
                            obj.contents = intArrayFromString(Module["read"](obj.url), true);
                            obj.usedBytes = obj.contents.length
                        } catch (e) {
                            success = false
                        }
                    } else {
                        throw new Error("Cannot load without read() or XMLHttpRequest.")
                    }
                    if (!success) ___setErrNo(5);
                    return success
                },
                createLazyFile: function(parent, name, url, canRead, canWrite) {
                    function LazyUint8Array() {
                        this.lengthKnown = false;
                        this.chunks = []
                    }
                    LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
                        if (idx > this.length - 1 || idx < 0) {
                            return undefined
                        }
                        var chunkOffset = idx % this.chunkSize;
                        var chunkNum = idx / this.chunkSize | 0;
                        return this.getter(chunkNum)[chunkOffset]
                    };
                    LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
                        this.getter = getter
                    };
                    LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
                        var xhr = new XMLHttpRequest;
                        xhr.open("HEAD", url, false);
                        xhr.send(null);
                        if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
                        var datalength = Number(xhr.getResponseHeader("Content-length"));
                        var header;
                        var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
                        var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
                        var chunkSize = 1024 * 1024;
                        if (!hasByteServing) chunkSize = datalength;
                        var doXHR = function(from, to) {
                            if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
                            if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
                            var xhr = new XMLHttpRequest;
                            xhr.open("GET", url, false);
                            if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
                            if (typeof Uint8Array != "undefined") xhr.responseType = "arraybuffer";
                            if (xhr.overrideMimeType) {
                                xhr.overrideMimeType("text/plain; charset=x-user-defined")
                            }
                            xhr.send(null);
                            if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
                            if (xhr.response !== undefined) {
                                return new Uint8Array(xhr.response || [])
                            } else {
                                return intArrayFromString(xhr.responseText || "", true)
                            }
                        };
                        var lazyArray = this;
                        lazyArray.setDataGetter(function(chunkNum) {
                            var start = chunkNum * chunkSize;
                            var end = (chunkNum + 1) * chunkSize - 1;
                            end = Math.min(end, datalength - 1);
                            if (typeof lazyArray.chunks[chunkNum] === "undefined") {
                                lazyArray.chunks[chunkNum] = doXHR(start, end)
                            }
                            if (typeof lazyArray.chunks[chunkNum] === "undefined") throw new Error("doXHR failed!");
                            return lazyArray.chunks[chunkNum]
                        });
                        if (usesGzip || !datalength) {
                            chunkSize = datalength = 1;
                            datalength = this.getter(0).length;
                            chunkSize = datalength;
                            console.log("LazyFiles on gzip forces download of the whole file when length is accessed")
                        }
                        this._length = datalength;
                        this._chunkSize = chunkSize;
                        this.lengthKnown = true
                    };
                    if (typeof XMLHttpRequest !== "undefined") {
                        if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
                        var lazyArray = new LazyUint8Array;
                        Object.defineProperties(lazyArray, {
                            length: {
                                get: function() {
                                    if (!this.lengthKnown) {
                                        this.cacheLength()
                                    }
                                    return this._length
                                }
                            },
                            chunkSize: {
                                get: function() {
                                    if (!this.lengthKnown) {
                                        this.cacheLength()
                                    }
                                    return this._chunkSize
                                }
                            }
                        });
                        var properties = {
                            isDevice: false,
                            contents: lazyArray
                        }
                    } else {
                        var properties = {
                            isDevice: false,
                            url: url
                        }
                    }
                    var node = FS.createFile(parent, name, properties, canRead, canWrite);
                    if (properties.contents) {
                        node.contents = properties.contents
                    } else if (properties.url) {
                        node.contents = null;
                        node.url = properties.url
                    }
                    Object.defineProperties(node, {
                        usedBytes: {
                            get: function() {
                                return this.contents.length
                            }
                        }
                    });
                    var stream_ops = {};
                    var keys = Object.keys(node.stream_ops);
                    keys.forEach(function(key) {
                        var fn = node.stream_ops[key];
                        stream_ops[key] = function forceLoadLazyFile() {
                            if (!FS.forceLoadFile(node)) {
                                throw new FS.ErrnoError(5)
                            }
                            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(5)
                        }
                        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.resolve(PATH.join2(parent, name)) : parent;
                    var dep = getUniqueRunDependency("cp " + fullname);

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

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

                        function finish() {
                            if (fail == 0) onload();
                            else onerror()
                        }
                        paths.forEach(function(path) {
                            var getRequest = files.get(path);
                            getRequest.onsuccess = function getRequest_onsuccess() {
                                if (FS.analyzePath(path).exists) {
                                    FS.unlink(path)
                                }
                                FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
                                ok++;
                                if (ok + fail == total) finish()
                            };
                            getRequest.onerror = function getRequest_onerror() {
                                fail++;
                                if (ok + fail == total) finish()
                            }
                        });
                        transaction.onerror = onerror
                    };
                    openRequest.onerror = onerror
                }
            };
            var ERRNO_CODES = {
                EPERM: 1,
                ENOENT: 2,
                ESRCH: 3,
                EINTR: 4,
                EIO: 5,
                ENXIO: 6,
                E2BIG: 7,
                ENOEXEC: 8,
                EBADF: 9,
                ECHILD: 10,
                EAGAIN: 11,
                EWOULDBLOCK: 11,
                ENOMEM: 12,
                EACCES: 13,
                EFAULT: 14,
                ENOTBLK: 15,
                EBUSY: 16,
                EEXIST: 17,
                EXDEV: 18,
                ENODEV: 19,
                ENOTDIR: 20,
                EISDIR: 21,
                EINVAL: 22,
                ENFILE: 23,
                EMFILE: 24,
                ENOTTY: 25,
                ETXTBSY: 26,
                EFBIG: 27,
                ENOSPC: 28,
                ESPIPE: 29,
                EROFS: 30,
                EMLINK: 31,
                EPIPE: 32,
                EDOM: 33,
                ERANGE: 34,
                ENOMSG: 42,
                EIDRM: 43,
                ECHRNG: 44,
                EL2NSYNC: 45,
                EL3HLT: 46,
                EL3RST: 47,
                ELNRNG: 48,
                EUNATCH: 49,
                ENOCSI: 50,
                EL2HLT: 51,
                EDEADLK: 35,
                ENOLCK: 37,
                EBADE: 52,
                EBADR: 53,
                EXFULL: 54,
                ENOANO: 55,
                EBADRQC: 56,
                EBADSLT: 57,
                EDEADLOCK: 35,
                EBFONT: 59,
                ENOSTR: 60,
                ENODATA: 61,
                ETIME: 62,
                ENOSR: 63,
                ENONET: 64,
                ENOPKG: 65,
                EREMOTE: 66,
                ENOLINK: 67,
                EADV: 68,
                ESRMNT: 69,
                ECOMM: 70,
                EPROTO: 71,
                EMULTIHOP: 72,
                EDOTDOT: 73,
                EBADMSG: 74,
                ENOTUNIQ: 76,
                EBADFD: 77,
                EREMCHG: 78,
                ELIBACC: 79,
                ELIBBAD: 80,
                ELIBSCN: 81,
                ELIBMAX: 82,
                ELIBEXEC: 83,
                ENOSYS: 38,
                ENOTEMPTY: 39,
                ENAMETOOLONG: 36,
                ELOOP: 40,
                EOPNOTSUPP: 95,
                EPFNOSUPPORT: 96,
                ECONNRESET: 104,
                ENOBUFS: 105,
                EAFNOSUPPORT: 97,
                EPROTOTYPE: 91,
                ENOTSOCK: 88,
                ENOPROTOOPT: 92,
                ESHUTDOWN: 108,
                ECONNREFUSED: 111,
                EADDRINUSE: 98,
                ECONNABORTED: 103,
                ENETUNREACH: 101,
                ENETDOWN: 100,
                ETIMEDOUT: 110,
                EHOSTDOWN: 112,
                EHOSTUNREACH: 113,
                EINPROGRESS: 115,
                EALREADY: 114,
                EDESTADDRREQ: 89,
                EMSGSIZE: 90,
                EPROTONOSUPPORT: 93,
                ESOCKTNOSUPPORT: 94,
                EADDRNOTAVAIL: 99,
                ENETRESET: 102,
                EISCONN: 106,
                ENOTCONN: 107,
                ETOOMANYREFS: 109,
                EUSERS: 87,
                EDQUOT: 122,
                ESTALE: 116,
                ENOTSUP: 95,
                ENOMEDIUM: 123,
                EILSEQ: 84,
                EOVERFLOW: 75,
                ECANCELED: 125,
                ENOTRECOVERABLE: 131,
                EOWNERDEAD: 130,
                ESTRPIPE: 86
            };
            var SYSCALLS = {
                DEFAULT_POLLMASK: 5,
                mappings: {},
                umask: 511,
                calculateAt: function(dirfd, path) {
                    if (path[0] !== "/") {
                        var dir;
                        if (dirfd === -100) {
                            dir = FS.cwd()
                        } else {
                            var dirstream = FS.getStream(dirfd);
                            if (!dirstream) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
                            dir = dirstream.path
                        }
                        path = PATH.join2(dir, path)
                    }
                    return path
                },
                doStat: function(func, path, buf) {
                    try {
                        var stat = func(path)
                    } catch (e) {
                        if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
                            return -ERRNO_CODES.ENOTDIR
                        }
                        throw e
                    }
                    HEAP32[buf >> 2] = stat.dev;
                    HEAP32[buf + 4 >> 2] = 0;
                    HEAP32[buf + 8 >> 2] = stat.ino;
                    HEAP32[buf + 12 >> 2] = stat.mode;
                    HEAP32[buf + 16 >> 2] = stat.nlink;
                    HEAP32[buf + 20 >> 2] = stat.uid;
                    HEAP32[buf + 24 >> 2] = stat.gid;
                    HEAP32[buf + 28 >> 2] = stat.rdev;
                    HEAP32[buf + 32 >> 2] = 0;
                    HEAP32[buf + 36 >> 2] = stat.size;
                    HEAP32[buf + 40 >> 2] = 4096;
                    HEAP32[buf + 44 >> 2] = stat.blocks;
                    HEAP32[buf + 48 >> 2] = stat.atime.getTime() / 1e3 | 0;
                    HEAP32[buf + 52 >> 2] = 0;
                    HEAP32[buf + 56 >> 2] = stat.mtime.getTime() / 1e3 | 0;
                    HEAP32[buf + 60 >> 2] = 0;
                    HEAP32[buf + 64 >> 2] = stat.ctime.getTime() / 1e3 | 0;
                    HEAP32[buf + 68 >> 2] = 0;
                    HEAP32[buf + 72 >> 2] = stat.ino;
                    return 0
                },
                doMsync: function(addr, stream, len, flags) {
                    var buffer = new Uint8Array(HEAPU8.subarray(addr, addr + len));
                    FS.msync(stream, buffer, 0, len, flags)
                },
                doMkdir: function(path, mode) {
                    path = PATH.normalize(path);
                    if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1);
                    FS.mkdir(path, mode, 0);
                    return 0
                },
                doMknod: function(path, mode, dev) {
                    switch (mode & 61440) {
                        case 32768:
                        case 8192:
                        case 24576:
                        case 4096:
                        case 49152:
                            break;
                        default:
                            return -ERRNO_CODES.EINVAL
                    }
                    FS.mknod(path, mode, dev);
                    return 0
                },
                doReadlink: function(path, buf, bufsize) {
                    if (bufsize <= 0) return -ERRNO_CODES.EINVAL;
                    var ret = FS.readlink(path);
                    var len = Math.min(bufsize, lengthBytesUTF8(ret));
                    var endChar = HEAP8[buf + len];
                    stringToUTF8(ret, buf, bufsize + 1);
                    HEAP8[buf + len] = endChar;
                    return len
                },
                doAccess: function(path, amode) {
                    if (amode & ~7) {
                        return -ERRNO_CODES.EINVAL
                    }
                    var node;
                    var lookup = FS.lookupPath(path, {
                        follow: true
                    });
                    node = lookup.node;
                    var perms = "";
                    if (amode & 4) perms += "r";
                    if (amode & 2) perms += "w";
                    if (amode & 1) perms += "x";
                    if (perms && FS.nodePermissions(node, perms)) {
                        return -ERRNO_CODES.EACCES
                    }
                    return 0
                },
                doDup: function(path, flags, suggestFD) {
                    var suggest = FS.getStream(suggestFD);
                    if (suggest) FS.close(suggest);
                    return FS.open(path, flags, 0, suggestFD, suggestFD).fd
                },
                doReadv: function(stream, iov, iovcnt, offset) {
                    var ret = 0;
                    for (var i = 0; i < iovcnt; i++) {
                        var ptr = HEAP32[iov + i * 8 >> 2];
                        var len = HEAP32[iov + (i * 8 + 4) >> 2];
                        var curr = FS.read(stream, HEAP8, ptr, len, offset);
                        if (curr < 0) return -1;
                        ret += curr;
                        if (curr < len) break
                    }
                    return ret
                },
                doWritev: function(stream, iov, iovcnt, offset) {
                    var ret = 0;
                    for (var i = 0; i < iovcnt; i++) {
                        var ptr = HEAP32[iov + i * 8 >> 2];
                        var len = HEAP32[iov + (i * 8 + 4) >> 2];
                        var curr = FS.write(stream, HEAP8, ptr, len, offset);
                        if (curr < 0) return -1;
                        ret += curr
                    }
                    return ret
                },
                varargs: 0,
                get: function(varargs) {
                    SYSCALLS.varargs += 4;
                    var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
                    return ret
                },
                getStr: function() {
                    var ret = UTF8ToString(SYSCALLS.get());
                    return ret
                },
                getStreamFromFD: function() {
                    var stream = FS.getStream(SYSCALLS.get());
                    if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
                    return stream
                },
                getSocketFromFD: function() {
                    var socket = SOCKFS.getSocket(SYSCALLS.get());
                    if (!socket) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
                    return socket
                },
                getSocketAddress: function(allowNull) {
                    var addrp = SYSCALLS.get(),
                        addrlen = SYSCALLS.get();
                    if (allowNull && addrp === 0) return null;
                    var info = __read_sockaddr(addrp, addrlen);
                    if (info.errno) throw new FS.ErrnoError(info.errno);
                    info.addr = DNS.lookup_addr(info.addr) || info.addr;
                    return info
                },
                get64: function() {
                    var low = SYSCALLS.get(),
                        high = SYSCALLS.get();
                    return low
                },
                getZero: function() {
                    SYSCALLS.get()
                }
            };

            function ___syscall125(which, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    return 0
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___syscall140(which, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var stream = SYSCALLS.getStreamFromFD(),
                        offset_high = SYSCALLS.get(),
                        offset_low = SYSCALLS.get(),
                        result = SYSCALLS.get(),
                        whence = SYSCALLS.get();
                    var offset = offset_low;
                    FS.llseek(stream, offset, whence);
                    HEAP32[result >> 2] = stream.position;
                    if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
                    return 0
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___syscall145(which, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var stream = SYSCALLS.getStreamFromFD(),
                        iov = SYSCALLS.get(),
                        iovcnt = SYSCALLS.get();
                    return SYSCALLS.doReadv(stream, iov, iovcnt)
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___syscall146(which, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var stream = SYSCALLS.getStreamFromFD(),
                        iov = SYSCALLS.get(),
                        iovcnt = SYSCALLS.get();
                    return SYSCALLS.doWritev(stream, iov, iovcnt)
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___syscall192(which, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var addr = SYSCALLS.get(),
                        len = SYSCALLS.get(),
                        prot = SYSCALLS.get(),
                        flags = SYSCALLS.get(),
                        fd = SYSCALLS.get(),
                        off = SYSCALLS.get();
                    off <<= 12;
                    var ptr;
                    var allocated = false;
                    if (fd === -1) {
                        ptr = _memalign(PAGE_SIZE, len);
                        if (!ptr) return -ERRNO_CODES.ENOMEM;
                        _memset(ptr, 0, len);
                        allocated = true
                    } else {
                        var info = FS.getStream(fd);
                        if (!info) return -ERRNO_CODES.EBADF;
                        var res = FS.mmap(info, HEAPU8, addr, len, off, prot, flags);
                        ptr = res.ptr;
                        allocated = res.allocated
                    }
                    SYSCALLS.mappings[ptr] = {
                        malloc: ptr,
                        len: len,
                        allocated: allocated,
                        fd: fd,
                        flags: flags
                    };
                    return ptr
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

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

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

            function ___syscall221(which, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var stream = SYSCALLS.getStreamFromFD(),
                        cmd = SYSCALLS.get();
                    switch (cmd) {
                        case 0:
                            {
                                var arg = SYSCALLS.get();
                                if (arg < 0) {
                                    return -ERRNO_CODES.EINVAL
                                }
                                var newStream;newStream = FS.open(stream.path, stream.flags, 0, arg);
                                return newStream.fd
                            }
                        case 1:
                        case 2:
                            return 0;
                        case 3:
                            return stream.flags;
                        case 4:
                            {
                                var arg = SYSCALLS.get();stream.flags |= arg;
                                return 0
                            }
                        case 12:
                            {
                                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 -ERRNO_CODES.EINVAL;
                        case 9:
                            ___setErrNo(ERRNO_CODES.EINVAL);
                            return -1;
                        default:
                            {
                                return -ERRNO_CODES.EINVAL
                            }
                    }
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

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

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

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

            function ___syscall91(which, varargs) {
                SYSCALLS.varargs = varargs;
                try {
                    var addr = SYSCALLS.get(),
                        len = SYSCALLS.get();
                    var info = SYSCALLS.mappings[addr];
                    if (!info) return 0;
                    if (len === info.len) {
                        var stream = FS.getStream(info.fd);
                        SYSCALLS.doMsync(addr, stream, len, info.flags);
                        FS.munmap(stream);
                        SYSCALLS.mappings[addr] = null;
                        if (info.allocated) {
                            _free(info.malloc)
                        }
                    }
                    return 0
                } catch (e) {
                    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
                    return -e.errno
                }
            }

            function ___unlock() {}

            function _emscripten_get_heap_size() {
                return HEAP8.length
            }

            function abortOnCannotGrowMemory(requestedSize) {
                abort("OOM")
            }

            function _emscripten_resize_heap(requestedSize) {
                abortOnCannotGrowMemory(requestedSize)
            }

            function _getenv(name) {
                if (name === 0) return 0;
                name = UTF8ToString(name);
                if (!ENV.hasOwnProperty(name)) return 0;
                if (_getenv.ret) _free(_getenv.ret);
                _getenv.ret = allocateUTF8(ENV[name]);
                return _getenv.ret
            }

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

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

            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 asmGlobalArg = {};
            var asmLibraryArg = {
                "c": abort,
                "b": ___assert_fail,
                "u": ___buildEnvironment,
                "g": ___lock,
                "p": ___map_file,
                "j": ___setErrNo,
                "o": ___syscall125,
                "n": ___syscall140,
                "m": ___syscall145,
                "i": ___syscall146,
                "z": ___syscall192,
                "y": ___syscall195,
                "x": ___syscall197,
                "f": ___syscall221,
                "l": ___syscall5,
                "k": ___syscall54,
                "h": ___syscall6,
                "w": ___syscall91,
                "e": ___unlock,
                "v": _emscripten_get_heap_size,
                "t": _emscripten_memcpy_big,
                "s": _emscripten_resize_heap,
                "d": _getenv,
                "r": _sysconf,
                "q": abortOnCannotGrowMemory,
                "a": DYNAMICTOP_PTR
            };
            var asm = Module["asm"](asmGlobalArg, asmLibraryArg, buffer);
            Module["asm"] = asm;
            var ___emscripten_environ_constructor = Module["___emscripten_environ_constructor"] = function() {
                return Module["asm"]["A"].apply(null, arguments)
            };
            var ___errno_location = Module["___errno_location"] = function() {
                return Module["asm"]["B"].apply(null, arguments)
            };
            var _free = Module["_free"] = function() {
                return Module["asm"]["C"].apply(null, arguments)
            };
            var _hb_aat_layout_feature_type_get_name_id = Module["_hb_aat_layout_feature_type_get_name_id"] = function() {
                return Module["asm"]["D"].apply(null, arguments)
            };
            var _hb_aat_layout_feature_type_get_selector_infos = Module["_hb_aat_layout_feature_type_get_selector_infos"] = function() {
                return Module["asm"]["E"].apply(null, arguments)
            };
            var _hb_aat_layout_get_feature_types = Module["_hb_aat_layout_get_feature_types"] = function() {
                return Module["asm"]["F"].apply(null, arguments)
            };
            var _hb_aat_layout_has_positioning = Module["_hb_aat_layout_has_positioning"] = function() {
                return Module["asm"]["G"].apply(null, arguments)
            };
            var _hb_aat_layout_has_substitution = Module["_hb_aat_layout_has_substitution"] = function() {
                return Module["asm"]["H"].apply(null, arguments)
            };
            var _hb_aat_layout_has_tracking = Module["_hb_aat_layout_has_tracking"] = function() {
                return Module["asm"]["I"].apply(null, arguments)
            };
            var _hb_blob_copy_writable_or_fail = Module["_hb_blob_copy_writable_or_fail"] = function() {
                return Module["asm"]["J"].apply(null, arguments)
            };
            var _hb_blob_create = Module["_hb_blob_create"] = function() {
                return Module["asm"]["K"].apply(null, arguments)
            };
            var _hb_blob_create_from_file = Module["_hb_blob_create_from_file"] = function() {
                return Module["asm"]["L"].apply(null, arguments)
            };
            var _hb_blob_create_sub_blob = Module["_hb_blob_create_sub_blob"] = function() {
                return Module["asm"]["M"].apply(null, arguments)
            };
            var _hb_blob_destroy = Module["_hb_blob_destroy"] = function() {
                return Module["asm"]["N"].apply(null, arguments)
            };
            var _hb_blob_get_data = Module["_hb_blob_get_data"] = function() {
                return Module["asm"]["O"].apply(null, arguments)
            };
            var _hb_blob_get_data_writable = Module["_hb_blob_get_data_writable"] = function() {
                return Module["asm"]["P"].apply(null, arguments)
            };
            var _hb_blob_get_empty = Module["_hb_blob_get_empty"] = function() {
                return Module["asm"]["Q"].apply(null, arguments)
            };
            var _hb_blob_get_length = Module["_hb_blob_get_length"] = function() {
                return Module["asm"]["R"].apply(null, arguments)
            };
            var _hb_blob_get_user_data = Module["_hb_blob_get_user_data"] = function() {
                return Module["asm"]["S"].apply(null, arguments)
            };
            var _hb_blob_is_immutable = Module["_hb_blob_is_immutable"] = function() {
                return Module["asm"]["T"].apply(null, arguments)
            };
            var _hb_blob_make_immutable = Module["_hb_blob_make_immutable"] = function() {
                return Module["asm"]["U"].apply(null, arguments)
            };
            var _hb_blob_reference = Module["_hb_blob_reference"] = function() {
                return Module["asm"]["V"].apply(null, arguments)
            };
            var _hb_blob_set_user_data = Module["_hb_blob_set_user_data"] = function() {
                return Module["asm"]["W"].apply(null, arguments)
            };
            var _hb_buffer_add = Module["_hb_buffer_add"] = function() {
                return Module["asm"]["X"].apply(null, arguments)
            };
            var _hb_buffer_add_codepoints = Module["_hb_buffer_add_codepoints"] = function() {
                return Module["asm"]["Y"].apply(null, arguments)
            };
            var _hb_buffer_add_latin1 = Module["_hb_buffer_add_latin1"] = function() {
                return Module["asm"]["Z"].apply(null, arguments)
            };
            var _hb_buffer_add_utf16 = Module["_hb_buffer_add_utf16"] = function() {
                return Module["asm"]["_"].apply(null, arguments)
            };
            var _hb_buffer_add_utf32 = Module["_hb_buffer_add_utf32"] = function() {
                return Module["asm"]["$"].apply(null, arguments)
            };
            var _hb_buffer_add_utf8 = Module["_hb_buffer_add_utf8"] = function() {
                return Module["asm"]["aa"].apply(null, arguments)
            };
            var _hb_buffer_allocation_successful = Module["_hb_buffer_allocation_successful"] = function() {
                return Module["asm"]["ba"].apply(null, arguments)
            };
            var _hb_buffer_append = Module["_hb_buffer_append"] = function() {
                return Module["asm"]["ca"].apply(null, arguments)
            };
            var _hb_buffer_clear_contents = Module["_hb_buffer_clear_contents"] = function() {
                return Module["asm"]["da"].apply(null, arguments)
            };
            var _hb_buffer_create = Module["_hb_buffer_create"] = function() {
                return Module["asm"]["ea"].apply(null, arguments)
            };
            var _hb_buffer_deserialize_glyphs = Module["_hb_buffer_deserialize_glyphs"] = function() {
                return Module["asm"]["fa"].apply(null, arguments)
            };
            var _hb_buffer_destroy = Module["_hb_buffer_destroy"] = function() {
                return Module["asm"]["ga"].apply(null, arguments)
            };
            var _hb_buffer_diff = Module["_hb_buffer_diff"] = function() {
                return Module["asm"]["ha"].apply(null, arguments)
            };
            var _hb_buffer_get_cluster_level = Module["_hb_buffer_get_cluster_level"] = function() {
                return Module["asm"]["ia"].apply(null, arguments)
            };
            var _hb_buffer_get_content_type = Module["_hb_buffer_get_content_type"] = function() {
                return Module["asm"]["ja"].apply(null, arguments)
            };
            var _hb_buffer_get_direction = Module["_hb_buffer_get_direction"] = function() {
                return Module["asm"]["ka"].apply(null, arguments)
            };
            var _hb_buffer_get_empty = Module["_hb_buffer_get_empty"] = function() {
                return Module["asm"]["la"].apply(null, arguments)
            };
            var _hb_buffer_get_flags = Module["_hb_buffer_get_flags"] = function() {
                return Module["asm"]["ma"].apply(null, arguments)
            };
            var _hb_buffer_get_glyph_infos = Module["_hb_buffer_get_glyph_infos"] = function() {
                return Module["asm"]["na"].apply(null, arguments)
            };
            var _hb_buffer_get_glyph_positions = Module["_hb_buffer_get_glyph_positions"] = function() {
                return Module["asm"]["oa"].apply(null, arguments)
            };
            var _hb_buffer_get_invisible_glyph = Module["_hb_buffer_get_invisible_glyph"] = function() {
                return Module["asm"]["pa"].apply(null, arguments)
            };
            var _hb_buffer_get_language = Module["_hb_buffer_get_language"] = function() {
                return Module["asm"]["qa"].apply(null, arguments)
            };
            var _hb_buffer_get_length = Module["_hb_buffer_get_length"] = function() {
                return Module["asm"]["ra"].apply(null, arguments)
            };
            var _hb_buffer_get_replacement_codepoint = Module["_hb_buffer_get_replacement_codepoint"] = function() {
                return Module["asm"]["sa"].apply(null, arguments)
            };
            var _hb_buffer_get_script = Module["_hb_buffer_get_script"] = function() {
                return Module["asm"]["ta"].apply(null, arguments)
            };
            var _hb_buffer_get_segment_properties = Module["_hb_buffer_get_segment_properties"] = function() {
                return Module["asm"]["ua"].apply(null, arguments)
            };
            var _hb_buffer_get_unicode_funcs = Module["_hb_buffer_get_unicode_funcs"] = function() {
                return Module["asm"]["va"].apply(null, arguments)
            };
            var _hb_buffer_get_user_data = Module["_hb_buffer_get_user_data"] = function() {
                return Module["asm"]["wa"].apply(null, arguments)
            };
            var _hb_buffer_guess_segment_properties = Module["_hb_buffer_guess_segment_properties"] = function() {
                return Module["asm"]["xa"].apply(null, arguments)
            };
            var _hb_buffer_normalize_glyphs = Module["_hb_buffer_normalize_glyphs"] = function() {
                return Module["asm"]["ya"].apply(null, arguments)
            };
            var _hb_buffer_pre_allocate = Module["_hb_buffer_pre_allocate"] = function() {
                return Module["asm"]["za"].apply(null, arguments)
            };
            var _hb_buffer_reference = Module["_hb_buffer_reference"] = function() {
                return Module["asm"]["Aa"].apply(null, arguments)
            };
            var _hb_buffer_reset = Module["_hb_buffer_reset"] = function() {
                return Module["asm"]["Ba"].apply(null, arguments)
            };
            var _hb_buffer_reverse = Module["_hb_buffer_reverse"] = function() {
                return Module["asm"]["Ca"].apply(null, arguments)
            };
            var _hb_buffer_reverse_clusters = Module["_hb_buffer_reverse_clusters"] = function() {
                return Module["asm"]["Da"].apply(null, arguments)
            };
            var _hb_buffer_reverse_range = Module["_hb_buffer_reverse_range"] = function() {
                return Module["asm"]["Ea"].apply(null, arguments)
            };
            var _hb_buffer_serialize_format_from_string = Module["_hb_buffer_serialize_format_from_string"] = function() {
                return Module["asm"]["Fa"].apply(null, arguments)
            };
            var _hb_buffer_serialize_format_to_string = Module["_hb_buffer_serialize_format_to_string"] = function() {
                return Module["asm"]["Ga"].apply(null, arguments)
            };
            var _hb_buffer_serialize_glyphs = Module["_hb_buffer_serialize_glyphs"] = function() {
                return Module["asm"]["Ha"].apply(null, arguments)
            };
            var _hb_buffer_serialize_list_formats = Module["_hb_buffer_serialize_list_formats"] = function() {
                return Module["asm"]["Ia"].apply(null, arguments)
            };
            var _hb_buffer_set_cluster_level = Module["_hb_buffer_set_cluster_level"] = function() {
                return Module["asm"]["Ja"].apply(null, arguments)
            };
            var _hb_buffer_set_content_type = Module["_hb_buffer_set_content_type"] = function() {
                return Module["asm"]["Ka"].apply(null, arguments)
            };
            var _hb_buffer_set_direction = Module["_hb_buffer_set_direction"] = function() {
                return Module["asm"]["La"].apply(null, arguments)
            };
            var _hb_buffer_set_flags = Module["_hb_buffer_set_flags"] = function() {
                return Module["asm"]["Ma"].apply(null, arguments)
            };
            var _hb_buffer_set_invisible_glyph = Module["_hb_buffer_set_invisible_glyph"] = function() {
                return Module["asm"]["Na"].apply(null, arguments)
            };
            var _hb_buffer_set_language = Module["_hb_buffer_set_language"] = function() {
                return Module["asm"]["Oa"].apply(null, arguments)
            };
            var _hb_buffer_set_length = Module["_hb_buffer_set_length"] = function() {
                return Module["asm"]["Pa"].apply(null, arguments)
            };
            var _hb_buffer_set_message_func = Module["_hb_buffer_set_message_func"] = function() {
                return Module["asm"]["Qa"].apply(null, arguments)
            };
            var _hb_buffer_set_replacement_codepoint = Module["_hb_buffer_set_replacement_codepoint"] = function() {
                return Module["asm"]["Ra"].apply(null, arguments)
            };
            var _hb_buffer_set_script = Module["_hb_buffer_set_script"] = function() {
                return Module["asm"]["Sa"].apply(null, arguments)
            };
            var _hb_buffer_set_segment_properties = Module["_hb_buffer_set_segment_properties"] = function() {
                return Module["asm"]["Ta"].apply(null, arguments)
            };
            var _hb_buffer_set_unicode_funcs = Module["_hb_buffer_set_unicode_funcs"] = function() {
                return Module["asm"]["Ua"].apply(null, arguments)
            };
            var _hb_buffer_set_user_data = Module["_hb_buffer_set_user_data"] = function() {
                return Module["asm"]["Va"].apply(null, arguments)
            };
            var _hb_direction_from_string = Module["_hb_direction_from_string"] = function() {
                return Module["asm"]["Wa"].apply(null, arguments)
            };
            var _hb_direction_to_string = Module["_hb_direction_to_string"] = function() {
                return Module["asm"]["Xa"].apply(null, arguments)
            };
            var _hb_face_builder_add_table = Module["_hb_face_builder_add_table"] = function() {
                return Module["asm"]["Ya"].apply(null, arguments)
            };
            var _hb_face_builder_create = Module["_hb_face_builder_create"] = function() {
                return Module["asm"]["Za"].apply(null, arguments)
            };
            var _hb_face_collect_unicodes = Module["_hb_face_collect_unicodes"] = function() {
                return Module["asm"]["_a"].apply(null, arguments)
            };
            var _hb_face_collect_variation_selectors = Module["_hb_face_collect_variation_selectors"] = function() {
                return Module["asm"]["$a"].apply(null, arguments)
            };
            var _hb_face_collect_variation_unicodes = Module["_hb_face_collect_variation_unicodes"] = function() {
                return Module["asm"]["ab"].apply(null, arguments)
            };
            var _hb_face_count = Module["_hb_face_count"] = function() {
                return Module["asm"]["bb"].apply(null, arguments)
            };
            var _hb_face_create = Module["_hb_face_create"] = function() {
                return Module["asm"]["cb"].apply(null, arguments)
            };
            var _hb_face_create_for_tables = Module["_hb_face_create_for_tables"] = function() {
                return Module["asm"]["db"].apply(null, arguments)
            };
            var _hb_face_destroy = Module["_hb_face_destroy"] = function() {
                return Module["asm"]["eb"].apply(null, arguments)
            };
            var _hb_face_get_empty = Module["_hb_face_get_empty"] = function() {
                return Module["asm"]["fb"].apply(null, arguments)
            };
            var _hb_face_get_glyph_count = Module["_hb_face_get_glyph_count"] = function() {
                return Module["asm"]["gb"].apply(null, arguments)
            };
            var _hb_face_get_index = Module["_hb_face_get_index"] = function() {
                return Module["asm"]["hb"].apply(null, arguments)
            };
            var _hb_face_get_table_tags = Module["_hb_face_get_table_tags"] = function() {
                return Module["asm"]["ib"].apply(null, arguments)
            };
            var _hb_face_get_upem = Module["_hb_face_get_upem"] = function() {
                return Module["asm"]["jb"].apply(null, arguments)
            };
            var _hb_face_get_user_data = Module["_hb_face_get_user_data"] = function() {
                return Module["asm"]["kb"].apply(null, arguments)
            };
            var _hb_face_is_immutable = Module["_hb_face_is_immutable"] = function() {
                return Module["asm"]["lb"].apply(null, arguments)
            };
            var _hb_face_make_immutable = Module["_hb_face_make_immutable"] = function() {
                return Module["asm"]["mb"].apply(null, arguments)
            };
            var _hb_face_reference = Module["_hb_face_reference"] = function() {
                return Module["asm"]["nb"].apply(null, arguments)
            };
            var _hb_face_reference_blob = Module["_hb_face_reference_blob"] = function() {
                return Module["asm"]["ob"].apply(null, arguments)
            };
            var _hb_face_reference_table = Module["_hb_face_reference_table"] = function() {
                return Module["asm"]["pb"].apply(null, arguments)
            };
            var _hb_face_set_glyph_count = Module["_hb_face_set_glyph_count"] = function() {
                return Module["asm"]["qb"].apply(null, arguments)
            };
            var _hb_face_set_index = Module["_hb_face_set_index"] = function() {
                return Module["asm"]["rb"].apply(null, arguments)
            };
            var _hb_face_set_upem = Module["_hb_face_set_upem"] = function() {
                return Module["asm"]["sb"].apply(null, arguments)
            };
            var _hb_face_set_user_data = Module["_hb_face_set_user_data"] = function() {
                return Module["asm"]["tb"].apply(null, arguments)
            };
            var _hb_feature_from_string = Module["_hb_feature_from_string"] = function() {
                return Module["asm"]["ub"].apply(null, arguments)
            };
            var _hb_feature_to_string = Module["_hb_feature_to_string"] = function() {
                return Module["asm"]["vb"].apply(null, arguments)
            };
            var _hb_font_add_glyph_origin_for_direction = Module["_hb_font_add_glyph_origin_for_direction"] = function() {
                return Module["asm"]["wb"].apply(null, arguments)
            };
            var _hb_font_create = Module["_hb_font_create"] = function() {
                return Module["asm"]["xb"].apply(null, arguments)
            };
            var _hb_font_create_sub_font = Module["_hb_font_create_sub_font"] = function() {
                return Module["asm"]["yb"].apply(null, arguments)
            };
            var _hb_font_destroy = Module["_hb_font_destroy"] = function() {
                return Module["asm"]["zb"].apply(null, arguments)
            };
            var _hb_font_funcs_create = Module["_hb_font_funcs_create"] = function() {
                return Module["asm"]["Ab"].apply(null, arguments)
            };
            var _hb_font_funcs_destroy = Module["_hb_font_funcs_destroy"] = function() {
                return Module["asm"]["Bb"].apply(null, arguments)
            };
            var _hb_font_funcs_get_empty = Module["_hb_font_funcs_get_empty"] = function() {
                return Module["asm"]["Cb"].apply(null, arguments)
            };
            var _hb_font_funcs_get_user_data = Module["_hb_font_funcs_get_user_data"] = function() {
                return Module["asm"]["Db"].apply(null, arguments)
            };
            var _hb_font_funcs_is_immutable = Module["_hb_font_funcs_is_immutable"] = function() {
                return Module["asm"]["Eb"].apply(null, arguments)
            };
            var _hb_font_funcs_make_immutable = Module["_hb_font_funcs_make_immutable"] = function() {
                return Module["asm"]["Fb"].apply(null, arguments)
            };
            var _hb_font_funcs_reference = Module["_hb_font_funcs_reference"] = function() {
                return Module["asm"]["Gb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_font_h_extents_func = Module["_hb_font_funcs_set_font_h_extents_func"] = function() {
                return Module["asm"]["Hb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_font_v_extents_func = Module["_hb_font_funcs_set_font_v_extents_func"] = function() {
                return Module["asm"]["Ib"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_contour_point_func = Module["_hb_font_funcs_set_glyph_contour_point_func"] = function() {
                return Module["asm"]["Jb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_extents_func = Module["_hb_font_funcs_set_glyph_extents_func"] = function() {
                return Module["asm"]["Kb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_from_name_func = Module["_hb_font_funcs_set_glyph_from_name_func"] = function() {
                return Module["asm"]["Lb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_func = Module["_hb_font_funcs_set_glyph_func"] = function() {
                return Module["asm"]["Mb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_h_advance_func = Module["_hb_font_funcs_set_glyph_h_advance_func"] = function() {
                return Module["asm"]["Nb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_h_advances_func = Module["_hb_font_funcs_set_glyph_h_advances_func"] = function() {
                return Module["asm"]["Ob"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_h_kerning_func = Module["_hb_font_funcs_set_glyph_h_kerning_func"] = function() {
                return Module["asm"]["Pb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_h_origin_func = Module["_hb_font_funcs_set_glyph_h_origin_func"] = function() {
                return Module["asm"]["Qb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_name_func = Module["_hb_font_funcs_set_glyph_name_func"] = function() {
                return Module["asm"]["Rb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_v_advance_func = Module["_hb_font_funcs_set_glyph_v_advance_func"] = function() {
                return Module["asm"]["Sb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_v_advances_func = Module["_hb_font_funcs_set_glyph_v_advances_func"] = function() {
                return Module["asm"]["Tb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_v_kerning_func = Module["_hb_font_funcs_set_glyph_v_kerning_func"] = function() {
                return Module["asm"]["Ub"].apply(null, arguments)
            };
            var _hb_font_funcs_set_glyph_v_origin_func = Module["_hb_font_funcs_set_glyph_v_origin_func"] = function() {
                return Module["asm"]["Vb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_nominal_glyph_func = Module["_hb_font_funcs_set_nominal_glyph_func"] = function() {
                return Module["asm"]["Wb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_nominal_glyphs_func = Module["_hb_font_funcs_set_nominal_glyphs_func"] = function() {
                return Module["asm"]["Xb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_user_data = Module["_hb_font_funcs_set_user_data"] = function() {
                return Module["asm"]["Yb"].apply(null, arguments)
            };
            var _hb_font_funcs_set_variation_glyph_func = Module["_hb_font_funcs_set_variation_glyph_func"] = function() {
                return Module["asm"]["Zb"].apply(null, arguments)
            };
            var _hb_font_get_empty = Module["_hb_font_get_empty"] = function() {
                return Module["asm"]["_b"].apply(null, arguments)
            };
            var _hb_font_get_extents_for_direction = Module["_hb_font_get_extents_for_direction"] = function() {
                return Module["asm"]["$b"].apply(null, arguments)
            };
            var _hb_font_get_face = Module["_hb_font_get_face"] = function() {
                return Module["asm"]["ac"].apply(null, arguments)
            };
            var _hb_font_get_glyph = Module["_hb_font_get_glyph"] = function() {
                return Module["asm"]["bc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_advance_for_direction = Module["_hb_font_get_glyph_advance_for_direction"] = function() {
                return Module["asm"]["cc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_advances_for_direction = Module["_hb_font_get_glyph_advances_for_direction"] = function() {
                return Module["asm"]["dc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_contour_point = Module["_hb_font_get_glyph_contour_point"] = function() {
                return Module["asm"]["ec"].apply(null, arguments)
            };
            var _hb_font_get_glyph_contour_point_for_origin = Module["_hb_font_get_glyph_contour_point_for_origin"] = function() {
                return Module["asm"]["fc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_extents = Module["_hb_font_get_glyph_extents"] = function() {
                return Module["asm"]["gc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_extents_for_origin = Module["_hb_font_get_glyph_extents_for_origin"] = function() {
                return Module["asm"]["hc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_from_name = Module["_hb_font_get_glyph_from_name"] = function() {
                return Module["asm"]["ic"].apply(null, arguments)
            };
            var _hb_font_get_glyph_h_advance = Module["_hb_font_get_glyph_h_advance"] = function() {
                return Module["asm"]["jc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_h_advances = Module["_hb_font_get_glyph_h_advances"] = function() {
                return Module["asm"]["kc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_h_kerning = Module["_hb_font_get_glyph_h_kerning"] = function() {
                return Module["asm"]["lc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_h_origin = Module["_hb_font_get_glyph_h_origin"] = function() {
                return Module["asm"]["mc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_kerning_for_direction = Module["_hb_font_get_glyph_kerning_for_direction"] = function() {
                return Module["asm"]["nc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_name = Module["_hb_font_get_glyph_name"] = function() {
                return Module["asm"]["oc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_origin_for_direction = Module["_hb_font_get_glyph_origin_for_direction"] = function() {
                return Module["asm"]["pc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_v_advance = Module["_hb_font_get_glyph_v_advance"] = function() {
                return Module["asm"]["qc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_v_advances = Module["_hb_font_get_glyph_v_advances"] = function() {
                return Module["asm"]["rc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_v_kerning = Module["_hb_font_get_glyph_v_kerning"] = function() {
                return Module["asm"]["sc"].apply(null, arguments)
            };
            var _hb_font_get_glyph_v_origin = Module["_hb_font_get_glyph_v_origin"] = function() {
                return Module["asm"]["tc"].apply(null, arguments)
            };
            var _hb_font_get_h_extents = Module["_hb_font_get_h_extents"] = function() {
                return Module["asm"]["uc"].apply(null, arguments)
            };
            var _hb_font_get_nominal_glyph = Module["_hb_font_get_nominal_glyph"] = function() {
                return Module["asm"]["vc"].apply(null, arguments)
            };
            var _hb_font_get_parent = Module["_hb_font_get_parent"] = function() {
                return Module["asm"]["wc"].apply(null, arguments)
            };
            var _hb_font_get_ppem = Module["_hb_font_get_ppem"] = function() {
                return Module["asm"]["xc"].apply(null, arguments)
            };
            var _hb_font_get_ptem = Module["_hb_font_get_ptem"] = function() {
                return Module["asm"]["yc"].apply(null, arguments)
            };
            var _hb_font_get_scale = Module["_hb_font_get_scale"] = function() {
                return Module["asm"]["zc"].apply(null, arguments)
            };
            var _hb_font_get_user_data = Module["_hb_font_get_user_data"] = function() {
                return Module["asm"]["Ac"].apply(null, arguments)
            };
            var _hb_font_get_v_extents = Module["_hb_font_get_v_extents"] = function() {
                return Module["asm"]["Bc"].apply(null, arguments)
            };
            var _hb_font_get_var_coords_normalized = Module["_hb_font_get_var_coords_normalized"] = function() {
                return Module["asm"]["Cc"].apply(null, arguments)
            };
            var _hb_font_get_variation_glyph = Module["_hb_font_get_variation_glyph"] = function() {
                return Module["asm"]["Dc"].apply(null, arguments)
            };
            var _hb_font_glyph_from_string = Module["_hb_font_glyph_from_string"] = function() {
                return Module["asm"]["Ec"].apply(null, arguments)
            };
            var _hb_font_glyph_to_string = Module["_hb_font_glyph_to_string"] = function() {
                return Module["asm"]["Fc"].apply(null, arguments)
            };
            var _hb_font_is_immutable = Module["_hb_font_is_immutable"] = function() {
                return Module["asm"]["Gc"].apply(null, arguments)
            };
            var _hb_font_make_immutable = Module["_hb_font_make_immutable"] = function() {
                return Module["asm"]["Hc"].apply(null, arguments)
            };
            var _hb_font_reference = Module["_hb_font_reference"] = function() {
                return Module["asm"]["Ic"].apply(null, arguments)
            };
            var _hb_font_set_face = Module["_hb_font_set_face"] = function() {
                return Module["asm"]["Jc"].apply(null, arguments)
            };
            var _hb_font_set_funcs = Module["_hb_font_set_funcs"] = function() {
                return Module["asm"]["Kc"].apply(null, arguments)
            };
            var _hb_font_set_funcs_data = Module["_hb_font_set_funcs_data"] = function() {
                return Module["asm"]["Lc"].apply(null, arguments)
            };
            var _hb_font_set_parent = Module["_hb_font_set_parent"] = function() {
                return Module["asm"]["Mc"].apply(null, arguments)
            };
            var _hb_font_set_ppem = Module["_hb_font_set_ppem"] = function() {
                return Module["asm"]["Nc"].apply(null, arguments)
            };
            var _hb_font_set_ptem = Module["_hb_font_set_ptem"] = function() {
                return Module["asm"]["Oc"].apply(null, arguments)
            };
            var _hb_font_set_scale = Module["_hb_font_set_scale"] = function() {
                return Module["asm"]["Pc"].apply(null, arguments)
            };
            var _hb_font_set_user_data = Module["_hb_font_set_user_data"] = function() {
                return Module["asm"]["Qc"].apply(null, arguments)
            };
            var _hb_font_set_var_coords_design = Module["_hb_font_set_var_coords_design"] = function() {
                return Module["asm"]["Rc"].apply(null, arguments)
            };
            var _hb_font_set_var_coords_normalized = Module["_hb_font_set_var_coords_normalized"] = function() {
                return Module["asm"]["Sc"].apply(null, arguments)
            };
            var _hb_font_set_variations = Module["_hb_font_set_variations"] = function() {
                return Module["asm"]["Tc"].apply(null, arguments)
            };
            var _hb_font_subtract_glyph_origin_for_direction = Module["_hb_font_subtract_glyph_origin_for_direction"] = function() {
                return Module["asm"]["Uc"].apply(null, arguments)
            };
            var _hb_glyph_info_get_glyph_flags = Module["_hb_glyph_info_get_glyph_flags"] = function() {
                return Module["asm"]["Vc"].apply(null, arguments)
            };
            var _hb_language_from_string = Module["_hb_language_from_string"] = function() {
                return Module["asm"]["Wc"].apply(null, arguments)
            };
            var _hb_language_get_default = Module["_hb_language_get_default"] = function() {
                return Module["asm"]["Xc"].apply(null, arguments)
            };
            var _hb_language_to_string = Module["_hb_language_to_string"] = function() {
                return Module["asm"]["Yc"].apply(null, arguments)
            };
            var _hb_map_allocation_successful = Module["_hb_map_allocation_successful"] = function() {
                return Module["asm"]["Zc"].apply(null, arguments)
            };
            var _hb_map_clear = Module["_hb_map_clear"] = function() {
                return Module["asm"]["_c"].apply(null, arguments)
            };
            var _hb_map_create = Module["_hb_map_create"] = function() {
                return Module["asm"]["$c"].apply(null, arguments)
            };
            var _hb_map_del = Module["_hb_map_del"] = function() {
                return Module["asm"]["ad"].apply(null, arguments)
            };
            var _hb_map_destroy = Module["_hb_map_destroy"] = function() {
                return Module["asm"]["bd"].apply(null, arguments)
            };
            var _hb_map_get = Module["_hb_map_get"] = function() {
                return Module["asm"]["cd"].apply(null, arguments)
            };
            var _hb_map_get_empty = Module["_hb_map_get_empty"] = function() {
                return Module["asm"]["dd"].apply(null, arguments)
            };
            var _hb_map_get_population = Module["_hb_map_get_population"] = function() {
                return Module["asm"]["ed"].apply(null, arguments)
            };
            var _hb_map_get_user_data = Module["_hb_map_get_user_data"] = function() {
                return Module["asm"]["fd"].apply(null, arguments)
            };
            var _hb_map_has = Module["_hb_map_has"] = function() {
                return Module["asm"]["gd"].apply(null, arguments)
            };
            var _hb_map_is_empty = Module["_hb_map_is_empty"] = function() {
                return Module["asm"]["hd"].apply(null, arguments)
            };
            var _hb_map_reference = Module["_hb_map_reference"] = function() {
                return Module["asm"]["id"].apply(null, arguments)
            };
            var _hb_map_set = Module["_hb_map_set"] = function() {
                return Module["asm"]["jd"].apply(null, arguments)
            };
            var _hb_map_set_user_data = Module["_hb_map_set_user_data"] = function() {
                return Module["asm"]["kd"].apply(null, arguments)
            };
            var _hb_ot_color_glyph_get_layers = Module["_hb_ot_color_glyph_get_layers"] = function() {
                return Module["asm"]["ld"].apply(null, arguments)
            };
            var _hb_ot_color_glyph_reference_png = Module["_hb_ot_color_glyph_reference_png"] = function() {
                return Module["asm"]["md"].apply(null, arguments)
            };
            var _hb_ot_color_glyph_reference_svg = Module["_hb_ot_color_glyph_reference_svg"] = function() {
                return Module["asm"]["nd"].apply(null, arguments)
            };
            var _hb_ot_color_has_layers = Module["_hb_ot_color_has_layers"] = function() {
                return Module["asm"]["od"].apply(null, arguments)
            };
            var _hb_ot_color_has_palettes = Module["_hb_ot_color_has_palettes"] = function() {
                return Module["asm"]["pd"].apply(null, arguments)
            };
            var _hb_ot_color_has_png = Module["_hb_ot_color_has_png"] = function() {
                return Module["asm"]["qd"].apply(null, arguments)
            };
            var _hb_ot_color_has_svg = Module["_hb_ot_color_has_svg"] = function() {
                return Module["asm"]["rd"].apply(null, arguments)
            };
            var _hb_ot_color_palette_color_get_name_id = Module["_hb_ot_color_palette_color_get_name_id"] = function() {
                return Module["asm"]["sd"].apply(null, arguments)
            };
            var _hb_ot_color_palette_get_colors = Module["_hb_ot_color_palette_get_colors"] = function() {
                return Module["asm"]["td"].apply(null, arguments)
            };
            var _hb_ot_color_palette_get_count = Module["_hb_ot_color_palette_get_count"] = function() {
                return Module["asm"]["ud"].apply(null, arguments)
            };
            var _hb_ot_color_palette_get_flags = Module["_hb_ot_color_palette_get_flags"] = function() {
                return Module["asm"]["vd"].apply(null, arguments)
            };
            var _hb_ot_color_palette_get_name_id = Module["_hb_ot_color_palette_get_name_id"] = function() {
                return Module["asm"]["wd"].apply(null, arguments)
            };
            var _hb_ot_font_set_funcs = Module["_hb_ot_font_set_funcs"] = function() {
                return Module["asm"]["xd"].apply(null, arguments)
            };
            var _hb_ot_layout_collect_features = Module["_hb_ot_layout_collect_features"] = function() {
                return Module["asm"]["yd"].apply(null, arguments)
            };
            var _hb_ot_layout_collect_lookups = Module["_hb_ot_layout_collect_lookups"] = function() {
                return Module["asm"]["zd"].apply(null, arguments)
            };
            var _hb_ot_layout_feature_get_characters = Module["_hb_ot_layout_feature_get_characters"] = function() {
                return Module["asm"]["Ad"].apply(null, arguments)
            };
            var _hb_ot_layout_feature_get_lookups = Module["_hb_ot_layout_feature_get_lookups"] = function() {
                return Module["asm"]["Bd"].apply(null, arguments)
            };
            var _hb_ot_layout_feature_get_name_ids = Module["_hb_ot_layout_feature_get_name_ids"] = function() {
                return Module["asm"]["Cd"].apply(null, arguments)
            };
            var _hb_ot_layout_feature_with_variations_get_lookups = Module["_hb_ot_layout_feature_with_variations_get_lookups"] = function() {
                return Module["asm"]["Dd"].apply(null, arguments)
            };
            var _hb_ot_layout_get_attach_points = Module["_hb_ot_layout_get_attach_points"] = function() {
                return Module["asm"]["Ed"].apply(null, arguments)
            };
            var _hb_ot_layout_get_glyph_class = Module["_hb_ot_layout_get_glyph_class"] = function() {
                return Module["asm"]["Fd"].apply(null, arguments)
            };
            var _hb_ot_layout_get_glyphs_in_class = Module["_hb_ot_layout_get_glyphs_in_class"] = function() {
                return Module["asm"]["Gd"].apply(null, arguments)
            };
            var _hb_ot_layout_get_ligature_carets = Module["_hb_ot_layout_get_ligature_carets"] = function() {
                return Module["asm"]["Hd"].apply(null, arguments)
            };
            var _hb_ot_layout_get_size_params = Module["_hb_ot_layout_get_size_params"] = function() {
                return Module["asm"]["Id"].apply(null, arguments)
            };
            var _hb_ot_layout_has_glyph_classes = Module["_hb_ot_layout_has_glyph_classes"] = function() {
                return Module["asm"]["Jd"].apply(null, arguments)
            };
            var _hb_ot_layout_has_positioning = Module["_hb_ot_layout_has_positioning"] = function() {
                return Module["asm"]["Kd"].apply(null, arguments)
            };
            var _hb_ot_layout_has_substitution = Module["_hb_ot_layout_has_substitution"] = function() {
                return Module["asm"]["Ld"].apply(null, arguments)
            };
            var _hb_ot_layout_language_find_feature = Module["_hb_ot_layout_language_find_feature"] = function() {
                return Module["asm"]["Md"].apply(null, arguments)
            };
            var _hb_ot_layout_language_get_feature_indexes = Module["_hb_ot_layout_language_get_feature_indexes"] = function() {
                return Module["asm"]["Nd"].apply(null, arguments)
            };
            var _hb_ot_layout_language_get_feature_tags = Module["_hb_ot_layout_language_get_feature_tags"] = function() {
                return Module["asm"]["Od"].apply(null, arguments)
            };
            var _hb_ot_layout_language_get_required_feature = Module["_hb_ot_layout_language_get_required_feature"] = function() {
                return Module["asm"]["Pd"].apply(null, arguments)
            };
            var _hb_ot_layout_language_get_required_feature_index = Module["_hb_ot_layout_language_get_required_feature_index"] = function() {
                return Module["asm"]["Qd"].apply(null, arguments)
            };
            var _hb_ot_layout_lookup_collect_glyphs = Module["_hb_ot_layout_lookup_collect_glyphs"] = function() {
                return Module["asm"]["Rd"].apply(null, arguments)
            };
            var _hb_ot_layout_lookup_substitute_closure = Module["_hb_ot_layout_lookup_substitute_closure"] = function() {
                return Module["asm"]["Sd"].apply(null, arguments)
            };
            var _hb_ot_layout_lookup_would_substitute = Module["_hb_ot_layout_lookup_would_substitute"] = function() {
                return Module["asm"]["Td"].apply(null, arguments)
            };
            var _hb_ot_layout_lookups_substitute_closure = Module["_hb_ot_layout_lookups_substitute_closure"] = function() {
                return Module["asm"]["Ud"].apply(null, arguments)
            };
            var _hb_ot_layout_script_find_language = Module["_hb_ot_layout_script_find_language"] = function() {
                return Module["asm"]["Vd"].apply(null, arguments)
            };
            var _hb_ot_layout_script_get_language_tags = Module["_hb_ot_layout_script_get_language_tags"] = function() {
                return Module["asm"]["Wd"].apply(null, arguments)
            };
            var _hb_ot_layout_script_select_language = Module["_hb_ot_layout_script_select_language"] = function() {
                return Module["asm"]["Xd"].apply(null, arguments)
            };
            var _hb_ot_layout_table_choose_script = Module["_hb_ot_layout_table_choose_script"] = function() {
                return Module["asm"]["Yd"].apply(null, arguments)
            };
            var _hb_ot_layout_table_find_feature_variations = Module["_hb_ot_layout_table_find_feature_variations"] = function() {
                return Module["asm"]["Zd"].apply(null, arguments)
            };
            var _hb_ot_layout_table_find_script = Module["_hb_ot_layout_table_find_script"] = function() {
                return Module["asm"]["_d"].apply(null, arguments)
            };
            var _hb_ot_layout_table_get_feature_tags = Module["_hb_ot_layout_table_get_feature_tags"] = function() {
                return Module["asm"]["$d"].apply(null, arguments)
            };
            var _hb_ot_layout_table_get_lookup_count = Module["_hb_ot_layout_table_get_lookup_count"] = function() {
                return Module["asm"]["ae"].apply(null, arguments)
            };
            var _hb_ot_layout_table_get_script_tags = Module["_hb_ot_layout_table_get_script_tags"] = function() {
                return Module["asm"]["be"].apply(null, arguments)
            };
            var _hb_ot_layout_table_select_script = Module["_hb_ot_layout_table_select_script"] = function() {
                return Module["asm"]["ce"].apply(null, arguments)
            };
            var _hb_ot_math_get_constant = Module["_hb_ot_math_get_constant"] = function() {
                return Module["asm"]["de"].apply(null, arguments)
            };
            var _hb_ot_math_get_glyph_assembly = Module["_hb_ot_math_get_glyph_assembly"] = function() {
                return Module["asm"]["ee"].apply(null, arguments)
            };
            var _hb_ot_math_get_glyph_italics_correction = Module["_hb_ot_math_get_glyph_italics_correction"] = function() {
                return Module["asm"]["fe"].apply(null, arguments)
            };
            var _hb_ot_math_get_glyph_kerning = Module["_hb_ot_math_get_glyph_kerning"] = function() {
                return Module["asm"]["ge"].apply(null, arguments)
            };
            var _hb_ot_math_get_glyph_top_accent_attachment = Module["_hb_ot_math_get_glyph_top_accent_attachment"] = function() {
                return Module["asm"]["he"].apply(null, arguments)
            };
            var _hb_ot_math_get_glyph_variants = Module["_hb_ot_math_get_glyph_variants"] = function() {
                return Module["asm"]["ie"].apply(null, arguments)
            };
            var _hb_ot_math_get_min_connector_overlap = Module["_hb_ot_math_get_min_connector_overlap"] = function() {
                return Module["asm"]["je"].apply(null, arguments)
            };
            var _hb_ot_math_has_data = Module["_hb_ot_math_has_data"] = function() {
                return Module["asm"]["ke"].apply(null, arguments)
            };
            var _hb_ot_math_is_glyph_extended_shape = Module["_hb_ot_math_is_glyph_extended_shape"] = function() {
                return Module["asm"]["le"].apply(null, arguments)
            };
            var _hb_ot_name_get_utf16 = Module["_hb_ot_name_get_utf16"] = function() {
                return Module["asm"]["me"].apply(null, arguments)
            };
            var _hb_ot_name_get_utf32 = Module["_hb_ot_name_get_utf32"] = function() {
                return Module["asm"]["ne"].apply(null, arguments)
            };
            var _hb_ot_name_get_utf8 = Module["_hb_ot_name_get_utf8"] = function() {
                return Module["asm"]["oe"].apply(null, arguments)
            };
            var _hb_ot_name_list_names = Module["_hb_ot_name_list_names"] = function() {
                return Module["asm"]["pe"].apply(null, arguments)
            };
            var _hb_ot_shape_glyphs_closure = Module["_hb_ot_shape_glyphs_closure"] = function() {
                return Module["asm"]["qe"].apply(null, arguments)
            };
            var _hb_ot_shape_plan_collect_lookups = Module["_hb_ot_shape_plan_collect_lookups"] = function() {
                return Module["asm"]["re"].apply(null, arguments)
            };
            var _hb_ot_tag_from_language = Module["_hb_ot_tag_from_language"] = function() {
                return Module["asm"]["se"].apply(null, arguments)
            };
            var _hb_ot_tag_to_language = Module["_hb_ot_tag_to_language"] = function() {
                return Module["asm"]["te"].apply(null, arguments)
            };
            var _hb_ot_tag_to_script = Module["_hb_ot_tag_to_script"] = function() {
                return Module["asm"]["ue"].apply(null, arguments)
            };
            var _hb_ot_tags_from_script = Module["_hb_ot_tags_from_script"] = function() {
                return Module["asm"]["ve"].apply(null, arguments)
            };
            var _hb_ot_tags_from_script_and_language = Module["_hb_ot_tags_from_script_and_language"] = function() {
                return Module["asm"]["we"].apply(null, arguments)
            };
            var _hb_ot_tags_to_script_and_language = Module["_hb_ot_tags_to_script_and_language"] = function() {
                return Module["asm"]["xe"].apply(null, arguments)
            };
            var _hb_ot_var_find_axis = Module["_hb_ot_var_find_axis"] = function() {
                return Module["asm"]["ye"].apply(null, arguments)
            };
            var _hb_ot_var_find_axis_info = Module["_hb_ot_var_find_axis_info"] = function() {
                return Module["asm"]["ze"].apply(null, arguments)
            };
            var _hb_ot_var_get_axes = Module["_hb_ot_var_get_axes"] = function() {
                return Module["asm"]["Ae"].apply(null, arguments)
            };
            var _hb_ot_var_get_axis_count = Module["_hb_ot_var_get_axis_count"] = function() {
                return Module["asm"]["Be"].apply(null, arguments)
            };
            var _hb_ot_var_get_axis_infos = Module["_hb_ot_var_get_axis_infos"] = function() {
                return Module["asm"]["Ce"].apply(null, arguments)
            };
            var _hb_ot_var_get_named_instance_count = Module["_hb_ot_var_get_named_instance_count"] = function() {
                return Module["asm"]["De"].apply(null, arguments)
            };
            var _hb_ot_var_has_data = Module["_hb_ot_var_has_data"] = function() {
                return Module["asm"]["Ee"].apply(null, arguments)
            };
            var _hb_ot_var_named_instance_get_design_coords = Module["_hb_ot_var_named_instance_get_design_coords"] = function() {
                return Module["asm"]["Fe"].apply(null, arguments)
            };
            var _hb_ot_var_named_instance_get_postscript_name_id = Module["_hb_ot_var_named_instance_get_postscript_name_id"] = function() {
                return Module["asm"]["Ge"].apply(null, arguments)
            };
            var _hb_ot_var_named_instance_get_subfamily_name_id = Module["_hb_ot_var_named_instance_get_subfamily_name_id"] = function() {
                return Module["asm"]["He"].apply(null, arguments)
            };
            var _hb_ot_var_normalize_coords = Module["_hb_ot_var_normalize_coords"] = function() {
                return Module["asm"]["Ie"].apply(null, arguments)
            };
            var _hb_ot_var_normalize_variations = Module["_hb_ot_var_normalize_variations"] = function() {
                return Module["asm"]["Je"].apply(null, arguments)
            };
            var _hb_script_from_iso15924_tag = Module["_hb_script_from_iso15924_tag"] = function() {
                return Module["asm"]["Ke"].apply(null, arguments)
            };
            var _hb_script_from_string = Module["_hb_script_from_string"] = function() {
                return Module["asm"]["Le"].apply(null, arguments)
            };
            var _hb_script_get_horizontal_direction = Module["_hb_script_get_horizontal_direction"] = function() {
                return Module["asm"]["Me"].apply(null, arguments)
            };
            var _hb_script_to_iso15924_tag = Module["_hb_script_to_iso15924_tag"] = function() {
                return Module["asm"]["Ne"].apply(null, arguments)
            };
            var _hb_segment_properties_equal = Module["_hb_segment_properties_equal"] = function() {
                return Module["asm"]["Oe"].apply(null, arguments)
            };
            var _hb_segment_properties_hash = Module["_hb_segment_properties_hash"] = function() {
                return Module["asm"]["Pe"].apply(null, arguments)
            };
            var _hb_set_add = Module["_hb_set_add"] = function() {
                return Module["asm"]["Qe"].apply(null, arguments)
            };
            var _hb_set_add_range = Module["_hb_set_add_range"] = function() {
                return Module["asm"]["Re"].apply(null, arguments)
            };
            var _hb_set_allocation_successful = Module["_hb_set_allocation_successful"] = function() {
                return Module["asm"]["Se"].apply(null, arguments)
            };
            var _hb_set_clear = Module["_hb_set_clear"] = function() {
                return Module["asm"]["Te"].apply(null, arguments)
            };
            var _hb_set_create = Module["_hb_set_create"] = function() {
                return Module["asm"]["Ue"].apply(null, arguments)
            };
            var _hb_set_del = Module["_hb_set_del"] = function() {
                return Module["asm"]["Ve"].apply(null, arguments)
            };
            var _hb_set_del_range = Module["_hb_set_del_range"] = function() {
                return Module["asm"]["We"].apply(null, arguments)
            };
            var _hb_set_destroy = Module["_hb_set_destroy"] = function() {
                return Module["asm"]["Xe"].apply(null, arguments)
            };
            var _hb_set_get_empty = Module["_hb_set_get_empty"] = function() {
                return Module["asm"]["Ye"].apply(null, arguments)
            };
            var _hb_set_get_max = Module["_hb_set_get_max"] = function() {
                return Module["asm"]["Ze"].apply(null, arguments)
            };
            var _hb_set_get_min = Module["_hb_set_get_min"] = function() {
                return Module["asm"]["_e"].apply(null, arguments)
            };
            var _hb_set_get_population = Module["_hb_set_get_population"] = function() {
                return Module["asm"]["$e"].apply(null, arguments)
            };
            var _hb_set_get_user_data = Module["_hb_set_get_user_data"] = function() {
                return Module["asm"]["af"].apply(null, arguments)
            };
            var _hb_set_has = Module["_hb_set_has"] = function() {
                return Module["asm"]["bf"].apply(null, arguments)
            };
            var _hb_set_intersect = Module["_hb_set_intersect"] = function() {
                return Module["asm"]["cf"].apply(null, arguments)
            };
            var _hb_set_invert = Module["_hb_set_invert"] = function() {
                return Module["asm"]["df"].apply(null, arguments)
            };
            var _hb_set_is_empty = Module["_hb_set_is_empty"] = function() {
                return Module["asm"]["ef"].apply(null, arguments)
            };
            var _hb_set_is_equal = Module["_hb_set_is_equal"] = function() {
                return Module["asm"]["ff"].apply(null, arguments)
            };
            var _hb_set_is_subset = Module["_hb_set_is_subset"] = function() {
                return Module["asm"]["gf"].apply(null, arguments)
            };
            var _hb_set_next = Module["_hb_set_next"] = function() {
                return Module["asm"]["hf"].apply(null, arguments)
            };
            var _hb_set_next_range = Module["_hb_set_next_range"] = function() {
                return Module["asm"]["jf"].apply(null, arguments)
            };
            var _hb_set_previous = Module["_hb_set_previous"] = function() {
                return Module["asm"]["kf"].apply(null, arguments)
            };
            var _hb_set_previous_range = Module["_hb_set_previous_range"] = function() {
                return Module["asm"]["lf"].apply(null, arguments)
            };
            var _hb_set_reference = Module["_hb_set_reference"] = function() {
                return Module["asm"]["mf"].apply(null, arguments)
            };
            var _hb_set_set = Module["_hb_set_set"] = function() {
                return Module["asm"]["nf"].apply(null, arguments)
            };
            var _hb_set_set_user_data = Module["_hb_set_set_user_data"] = function() {
                return Module["asm"]["of"].apply(null, arguments)
            };
            var _hb_set_subtract = Module["_hb_set_subtract"] = function() {
                return Module["asm"]["pf"].apply(null, arguments)
            };
            var _hb_set_symmetric_difference = Module["_hb_set_symmetric_difference"] = function() {
                return Module["asm"]["qf"].apply(null, arguments)
            };
            var _hb_set_union = Module["_hb_set_union"] = function() {
                return Module["asm"]["rf"].apply(null, arguments)
            };
            var _hb_shape = Module["_hb_shape"] = function() {
                return Module["asm"]["sf"].apply(null, arguments)
            };
            var _hb_shape_full = Module["_hb_shape_full"] = function() {
                return Module["asm"]["tf"].apply(null, arguments)
            };
            var _hb_shape_list_shapers = Module["_hb_shape_list_shapers"] = function() {
                return Module["asm"]["uf"].apply(null, arguments)
            };
            var _hb_shape_plan_create = Module["_hb_shape_plan_create"] = function() {
                return Module["asm"]["vf"].apply(null, arguments)
            };
            var _hb_shape_plan_create2 = Module["_hb_shape_plan_create2"] = function() {
                return Module["asm"]["wf"].apply(null, arguments)
            };
            var _hb_shape_plan_create_cached = Module["_hb_shape_plan_create_cached"] = function() {
                return Module["asm"]["xf"].apply(null, arguments)
            };
            var _hb_shape_plan_create_cached2 = Module["_hb_shape_plan_create_cached2"] = function() {
                return Module["asm"]["yf"].apply(null, arguments)
            };
            var _hb_shape_plan_destroy = Module["_hb_shape_plan_destroy"] = function() {
                return Module["asm"]["zf"].apply(null, arguments)
            };
            var _hb_shape_plan_execute = Module["_hb_shape_plan_execute"] = function() {
                return Module["asm"]["Af"].apply(null, arguments)
            };
            var _hb_shape_plan_get_empty = Module["_hb_shape_plan_get_empty"] = function() {
                return Module["asm"]["Bf"].apply(null, arguments)
            };
            var _hb_shape_plan_get_shaper = Module["_hb_shape_plan_get_shaper"] = function() {
                return Module["asm"]["Cf"].apply(null, arguments)
            };
            var _hb_shape_plan_get_user_data = Module["_hb_shape_plan_get_user_data"] = function() {
                return Module["asm"]["Df"].apply(null, arguments)
            };
            var _hb_shape_plan_reference = Module["_hb_shape_plan_reference"] = function() {
                return Module["asm"]["Ef"].apply(null, arguments)
            };
            var _hb_shape_plan_set_user_data = Module["_hb_shape_plan_set_user_data"] = function() {
                return Module["asm"]["Ff"].apply(null, arguments)
            };
            var _hb_tag_from_string = Module["_hb_tag_from_string"] = function() {
                return Module["asm"]["Gf"].apply(null, arguments)
            };
            var _hb_tag_to_string = Module["_hb_tag_to_string"] = function() {
                return Module["asm"]["Hf"].apply(null, arguments)
            };
            var _hb_unicode_combining_class = Module["_hb_unicode_combining_class"] = function() {
                return Module["asm"]["If"].apply(null, arguments)
            };
            var _hb_unicode_compose = Module["_hb_unicode_compose"] = function() {
                return Module["asm"]["Jf"].apply(null, arguments)
            };
            var _hb_unicode_decompose = Module["_hb_unicode_decompose"] = function() {
                return Module["asm"]["Kf"].apply(null, arguments)
            };
            var _hb_unicode_decompose_compatibility = Module["_hb_unicode_decompose_compatibility"] = function() {
                return Module["asm"]["Lf"].apply(null, arguments)
            };
            var _hb_unicode_eastasian_width = Module["_hb_unicode_eastasian_width"] = function() {
                return Module["asm"]["Mf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_create = Module["_hb_unicode_funcs_create"] = function() {
                return Module["asm"]["Nf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_destroy = Module["_hb_unicode_funcs_destroy"] = function() {
                return Module["asm"]["Of"].apply(null, arguments)
            };
            var _hb_unicode_funcs_get_default = Module["_hb_unicode_funcs_get_default"] = function() {
                return Module["asm"]["Pf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_get_empty = Module["_hb_unicode_funcs_get_empty"] = function() {
                return Module["asm"]["Qf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_get_parent = Module["_hb_unicode_funcs_get_parent"] = function() {
                return Module["asm"]["Rf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_get_user_data = Module["_hb_unicode_funcs_get_user_data"] = function() {
                return Module["asm"]["Sf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_is_immutable = Module["_hb_unicode_funcs_is_immutable"] = function() {
                return Module["asm"]["Tf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_make_immutable = Module["_hb_unicode_funcs_make_immutable"] = function() {
                return Module["asm"]["Uf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_reference = Module["_hb_unicode_funcs_reference"] = function() {
                return Module["asm"]["Vf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_combining_class_func = Module["_hb_unicode_funcs_set_combining_class_func"] = function() {
                return Module["asm"]["Wf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_compose_func = Module["_hb_unicode_funcs_set_compose_func"] = function() {
                return Module["asm"]["Xf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_decompose_compatibility_func = Module["_hb_unicode_funcs_set_decompose_compatibility_func"] = function() {
                return Module["asm"]["Yf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_decompose_func = Module["_hb_unicode_funcs_set_decompose_func"] = function() {
                return Module["asm"]["Zf"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_eastasian_width_func = Module["_hb_unicode_funcs_set_eastasian_width_func"] = function() {
                return Module["asm"]["_f"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_general_category_func = Module["_hb_unicode_funcs_set_general_category_func"] = function() {
                return Module["asm"]["$f"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_mirroring_func = Module["_hb_unicode_funcs_set_mirroring_func"] = function() {
                return Module["asm"]["ag"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_script_func = Module["_hb_unicode_funcs_set_script_func"] = function() {
                return Module["asm"]["bg"].apply(null, arguments)
            };
            var _hb_unicode_funcs_set_user_data = Module["_hb_unicode_funcs_set_user_data"] = function() {
                return Module["asm"]["cg"].apply(null, arguments)
            };
            var _hb_unicode_general_category = Module["_hb_unicode_general_category"] = function() {
                return Module["asm"]["dg"].apply(null, arguments)
            };
            var _hb_unicode_mirroring = Module["_hb_unicode_mirroring"] = function() {
                return Module["asm"]["eg"].apply(null, arguments)
            };
            var _hb_unicode_script = Module["_hb_unicode_script"] = function() {
                return Module["asm"]["fg"].apply(null, arguments)
            };
            var _hb_variation_from_string = Module["_hb_variation_from_string"] = function() {
                return Module["asm"]["gg"].apply(null, arguments)
            };
            var _hb_variation_to_string = Module["_hb_variation_to_string"] = function() {
                return Module["asm"]["hg"].apply(null, arguments)
            };
            var _hb_version = Module["_hb_version"] = function() {
                return Module["asm"]["ig"].apply(null, arguments)
            };
            var _hb_version_atleast = Module["_hb_version_atleast"] = function() {
                return Module["asm"]["jg"].apply(null, arguments)
            };
            var _hb_version_string = Module["_hb_version_string"] = function() {
                return Module["asm"]["kg"].apply(null, arguments)
            };
            var _malloc = Module["_malloc"] = function() {
                return Module["asm"]["lg"].apply(null, arguments)
            };
            var _memalign = Module["_memalign"] = function() {
                return Module["asm"]["mg"].apply(null, arguments)
            };
            var _memset = Module["_memset"] = function() {
                return Module["asm"]["ng"].apply(null, arguments)
            };
            var stackAlloc = Module["stackAlloc"] = function() {
                return Module["asm"]["pg"].apply(null, arguments)
            };
            var dynCall_vi = Module["dynCall_vi"] = function() {
                return Module["asm"]["og"].apply(null, arguments)
            };
            Module["asm"] = asm;
            Module["then"] = function(func) {
                if (Module["calledRun"]) {
                    func(Module)
                } else {
                    var old = Module["onRuntimeInitialized"];
                    Module["onRuntimeInitialized"] = function() {
                        if (old) old();
                        func(Module)
                    }
                }
                return Module
            };

            function ExitStatus(status) {
                this.name = "ExitStatus";
                this.message = "Program terminated with exit(" + status + ")";
                this.status = status
            }
            ExitStatus.prototype = new Error;
            ExitStatus.prototype.constructor = ExitStatus;
            dependenciesFulfilled = function runCaller() {
                if (!Module["calledRun"]) run();
                if (!Module["calledRun"]) dependenciesFulfilled = runCaller
            };

            function run(args) {
                args = args || Module["arguments"];
                if (runDependencies > 0) {
                    return
                }
                preRun();
                if (runDependencies > 0) return;
                if (Module["calledRun"]) return;

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

            function abort(what) {
                if (Module["onAbort"]) {
                    Module["onAbort"](what)
                }
                if (what !== undefined) {
                    out(what);
                    err(what);
                    what = JSON.stringify(what)
                } else {
                    what = ""
                }
                ABORT = true;
                EXITSTATUS = 1;
                throw "abort(" + what + "). Build with -s ASSERTIONS=1 for more info."
            }
            Module["abort"] = abort;
            if (Module["preInit"]) {
                if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
                while (Module["preInit"].length > 0) {
                    Module["preInit"].pop()()
                }
            }
            Module["noExitRuntime"] = true;
            run();


            return Module
        }
    );
})();
if (typeof exports === 'object' && typeof module === 'object')
    module.exports = Module;
else if (typeof define === 'function' && define['amd'])
    define([], function() {
        return Module;
    });
else if (typeof exports === 'object')
    exports["Module"] = Module;