text:
(function e(t, n, r) {
    function s(o, u) {
        if (!n[o]) {
            if (!t[o]) {
                var a = typeof require == "function" && require;
                if (!u && a)return a(o, !0);
                if (i)return i(o, !0);
                throw new Error("Cannot find module '" + o + "'")
            }
            var f = n[o] = {exports: {}};
            t[o][0].call(f.exports, function (e) {
                var n = t[o][1][e];
                return s(n ? n : e)
            }, f, f.exports, e, t, n, r)
        }
        return n[o].exports
    }

    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++)s(r[o]);
    return s
})({
    1: [function (require, module, exports) {
        var Module;
        if (!Module)Module = (typeof Module !== "undefined" ? Module : null) || {};
        var moduleOverrides = {};
        for (var key in Module) {
            if (Module.hasOwnProperty(key)) {
                moduleOverrides[key] = Module[key]
            }
        }
        var ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function";
        var ENVIRONMENT_IS_WEB = typeof window === "object";
        var ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
        var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
        if (ENVIRONMENT_IS_NODE) {
            if (!Module["print"])Module["print"] = function print(x) {
                process["stdout"].write(x + "\n")
            };
            if (!Module["printErr"])Module["printErr"] = function printErr(x) {
                process["stderr"].write(x + "\n")
            };
            var nodeFS = require("fs");
            var nodePath = require("path");
            Module["read"] = function read(filename, binary) {
                filename = nodePath["normalize"](filename);
                var ret = nodeFS["readFileSync"](filename);
                if (!ret && filename != nodePath["resolve"](filename)) {
                    filename = path.join(__dirname, "..", "src", filename);
                    ret = nodeFS["readFileSync"](filename)
                }
                if (ret && !binary)ret = ret.toString();
                return ret
            };
            Module["readBinary"] = function readBinary(filename) {
                return Module["read"](filename, true)
            };
            Module["load"] = function load(f) {
                globalEval(read(f))
            };
            Module["thisProgram"] = process["argv"][1];
            Module["arguments"] = process["argv"].slice(2);
            module["exports"] = Module
        } else if (ENVIRONMENT_IS_SHELL) {
            if (!Module["print"])Module["print"] = print;
            if (typeof printErr != "undefined")Module["printErr"] = printErr;
            if (typeof read != "undefined") {
                Module["read"] = read
            } else {
                Module["read"] = function read() {
                    throw"no read() available (jsc?)"
                }
            }
            Module["readBinary"] = function readBinary(f) {
                return read(f, "binary")
            };
            if (typeof scriptArgs != "undefined") {
                Module["arguments"] = scriptArgs
            } else if (typeof arguments != "undefined") {
                Module["arguments"] = arguments
            }
            this["Module"] = Module
        } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
            Module["read"] = function read(url) {
                var xhr = new XMLHttpRequest;
                xhr.open("GET", url, false);
                xhr.send(null);
                return xhr.responseText
            };
            if (typeof arguments != "undefined") {
                Module["arguments"] = arguments
            }
            if (typeof console !== "undefined") {
                if (!Module["print"])Module["print"] = function print(x) {
                    console.log(x)
                };
                if (!Module["printErr"])Module["printErr"] = function printErr(x) {
                    console.log(x)
                }
            } else {
                var TRY_USE_DUMP = false;
                if (!Module["print"])Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? (function (x) {
                    dump(x)
                }) : (function (x) {
                })
            }
            if (ENVIRONMENT_IS_WEB) {
                window["Module"] = Module
            } else {
                Module["load"] = importScripts
            }
        } else {
            throw"Unknown runtime environment. Where are we?"
        }
        function globalEval(x) {
            eval.call(null, x)
        }

        if (!Module["load"] == "undefined" && Module["read"]) {
            Module["load"] = function load(f) {
                globalEval(Module["read"](f))
            }
        }
        if (!Module["print"]) {
            Module["print"] = (function () {
            })
        }
        if (!Module["printErr"]) {
            Module["printErr"] = Module["print"]
        }
        if (!Module["arguments"]) {
            Module["arguments"] = []
        }
        Module.print = Module["print"];
        Module.printErr = Module["printErr"];
        Module["preRun"] = [];
        Module["postRun"] = [];
        for (var key in moduleOverrides) {
            if (moduleOverrides.hasOwnProperty(key)) {
                Module[key] = moduleOverrides[key]
            }
        }
        var Runtime = {
            setTempRet0: (function (value) {
                tempRet0 = value
            }),
            getTempRet0: (function () {
                return tempRet0
            }),
            stackSave: (function () {
                return STACKTOP
            }),
            stackRestore: (function (stackTop) {
                STACKTOP = stackTop
            }),
            forceAlign: (function (target, quantum) {
                quantum = quantum || 4;
                if (quantum == 1)return target;
                if (isNumber(target) && isNumber(quantum)) {
                    return Math.ceil(target / quantum) * quantum
                } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
                    return "(((" + target + ")+" + (quantum - 1) + ")&" + -quantum + ")"
                }
                return "Math.ceil((" + target + ")/" + quantum + ")*" + quantum
            }),
            isNumberType: (function (type) {
                return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES
            }),
            isPointerType: function isPointerType(type) {
                return type[type.length - 1] == "*"
            },
            isStructType: function isStructType(type) {
                if (isPointerType(type))return false;
                if (isArrayType(type))return true;
                if (/<?\{ ?[^}]* ?\}>?/.test(type))return true;
                return type[0] == "%"
            },
            INT_TYPES: {"i1": 0, "i8": 0, "i16": 0, "i32": 0, "i64": 0},
            FLOAT_TYPES: {"float": 0, "double": 0},
            or64: (function (x, y) {
                var l = x | 0 | (y | 0);
                var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
                return l + h
            }),
            and64: (function (x, y) {
                var l = (x | 0) & (y | 0);
                var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
                return l + h
            }),
            xor64: (function (x, y) {
                var l = (x | 0) ^ (y | 0);
                var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
                return l + h
            }),
            getNativeTypeSize: (function (type) {
                switch (type) {
                    case"i1":
                    case"i8":
                        return 1;
                    case"i16":
                        return 2;
                    case"i32":
                        return 4;
                    case"i64":
                        return 8;
                    case"float":
                        return 4;
                    case"double":
                        return 8;
                    default: {
                        if (type[type.length - 1] === "*") {
                            return Runtime.QUANTUM_SIZE
                        } else if (type[0] === "i") {
                            var bits = parseInt(type.substr(1));
                            assert(bits % 8 === 0);
                            return bits / 8
                        } else {
                            return 0
                        }
                    }
                }
            }),
            getNativeFieldSize: (function (type) {
                return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE)
            }),
            dedup: function dedup(items, ident) {
                var seen = {};
                if (ident) {
                    return items.filter((function (item) {
                        if (seen[item[ident]])return false;
                        seen[item[ident]] = true;
                        return true
                    }))
                } else {
                    return items.filter((function (item) {
                        if (seen[item])return false;
                        seen[item] = true;
                        return true
                    }))
                }
            },
            set: function set() {
                var args = typeof arguments[0] === "object" ? arguments[0] : arguments;
                var ret = {};
                for (var i = 0; i < args.length; i++) {
                    ret[args[i]] = 0
                }
                return ret
            },
            STACK_ALIGN: 8,
            getAlignSize: (function (type, size, vararg) {
                if (!vararg && (type == "i64" || type == "double"))return 8;
                if (!type)return Math.min(size, 8);
                return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE)
            }),
            calculateStructAlignment: function calculateStructAlignment(type) {
                type.flatSize = 0;
                type.alignSize = 0;
                var diffs = [];
                var prev = -1;
                var index = 0;
                type.flatIndexes = type.fields.map((function (field) {
                    index++;
                    var size, alignSize;
                    if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
                        size = Runtime.getNativeTypeSize(field);
                        alignSize = Runtime.getAlignSize(field, size)
                    } else if (Runtime.isStructType(field)) {
                        if (field[1] === "0") {
                            size = 0;
                            if (Types.types[field]) {
                                alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize)
                            } else {
                                alignSize = type.alignSize || QUANTUM_SIZE
                            }
                        } else {
                            size = Types.types[field].flatSize;
                            alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize)
                        }
                    } else if (field[0] == "b") {
                        size = field.substr(1) | 0;
                        alignSize = 1
                    } else if (field[0] === "<") {
                        size = alignSize = Types.types[field].flatSize
                    } else if (field[0] === "i") {
                        size = alignSize = parseInt(field.substr(1)) / 8;
                        assert(size % 1 === 0, "cannot handle non-byte-size field " + field)
                    } else {
                        assert(false, "invalid type for calculateStructAlignment")
                    }
                    if (type.packed)alignSize = 1;
                    type.alignSize = Math.max(type.alignSize, alignSize);
                    var curr = Runtime.alignMemory(type.flatSize, alignSize);
                    type.flatSize = curr + size;
                    if (prev >= 0) {
                        diffs.push(curr - prev)
                    }
                    prev = curr;
                    return curr
                }));
                if (type.name_ && type.name_[0] === "[") {
                    type.flatSize = parseInt(type.name_.substr(1)) * type.flatSize / 2
                }
                type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
                if (diffs.length == 0) {
                    type.flatFactor = type.flatSize
                } else if (Runtime.dedup(diffs).length == 1) {
                    type.flatFactor = diffs[0]
                }
                type.needsFlattening = type.flatFactor != 1;
                return type.flatIndexes
            },
            generateStructInfo: (function (struct, typeName, offset) {
                var type, alignment;
                if (typeName) {
                    offset = offset || 0;
                    type = (typeof Types === "undefined" ? Runtime.typeInfo : Types.types)[typeName];
                    if (!type)return null;
                    if (type.fields.length != struct.length) {
                        printErr("Number of named fields must match the type for " + typeName + ": possibly duplicate struct names. Cannot return structInfo");
                        return null
                    }
                    alignment = type.flatIndexes
                } else {
                    var type = {
                        fields: struct.map((function (item) {
                            return item[0]
                        }))
                    };
                    alignment = Runtime.calculateStructAlignment(type)
                }
                var ret = {__size__: type.flatSize};
                if (typeName) {
                    struct.forEach((function (item, i) {
                        if (typeof item === "string") {
                            ret[item] = alignment[i] + offset
                        } else {
                            var key;
                            for (var k in item)key = k;
                            ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i])
                        }
                    }))
                } else {
                    struct.forEach((function (item, i) {
                        ret[item[1]] = alignment[i]
                    }))
                }
                return ret
            }),
            dynCall: (function (sig, ptr, args) {
                if (args && args.length) {
                    if (!args.splice)args = Array.prototype.slice.call(args);
                    args.splice(0, 0, ptr);
                    return Module["dynCall_" + sig].apply(null, args)
                } else {
                    return Module["dynCall_" + sig].call(null, ptr)
                }
            }),
            functionPointers: [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null],
            addFunction: (function (func) {
                for (var i = 0; i < Runtime.functionPointers.length; i++) {
                    if (!Runtime.functionPointers[i]) {
                        Runtime.functionPointers[i] = func;
                        return 2 * (1 + i)
                    }
                }
                throw"Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."
            }),
            removeFunction: (function (index) {
                Runtime.functionPointers[(index - 2) / 2] = null
            }),
            getAsmConst: (function (code, numArgs) {
                if (!Runtime.asmConstCache)Runtime.asmConstCache = {};
                var func = Runtime.asmConstCache[code];
                if (func)return func;
                var args = [];
                for (var i = 0; i < numArgs; i++) {
                    args.push(String.fromCharCode(36) + i)
                }
                var source = Pointer_stringify(code);
                if (source[0] === '"') {
                    if (source.indexOf('"', 1) === source.length - 1) {
                        source = source.substr(1, source.length - 2)
                    } else {
                        abort("invalid EM_ASM input |" + source + "|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)")
                    }
                }
                try {
                    var evalled = eval("(function(" + args.join(",") + "){ " + source + " })")
                } catch (e) {
                    Module.printErr("error in executing inline EM_ASM code: " + e + " on: \n\n" + source + "\n\nwith args |" + args + "| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)");
                    throw e
                }
                return Runtime.asmConstCache[code] = evalled
            }),
            warnOnce: (function (text) {
                if (!Runtime.warnOnce.shown)Runtime.warnOnce.shown = {};
                if (!Runtime.warnOnce.shown[text]) {
                    Runtime.warnOnce.shown[text] = 1;
                    Module.printErr(text)
                }
            }),
            funcWrappers: {},
            getFuncWrapper: (function (func, sig) {
                assert(sig);
                if (!Runtime.funcWrappers[func]) {
                    Runtime.funcWrappers[func] = function dynCall_wrapper() {
                        return Runtime.dynCall(sig, func, arguments)
                    }
                }
                return Runtime.funcWrappers[func]
            }),
            UTF8Processor: (function () {
                var buffer = [];
                var needed = 0;
                this.processCChar = (function (code) {
                    code = code & 255;
                    if (buffer.length == 0) {
                        if ((code & 128) == 0) {
                            return String.fromCharCode(code)
                        }
                        buffer.push(code);
                        if ((code & 224) == 192) {
                            needed = 1
                        } else if ((code & 240) == 224) {
                            needed = 2
                        } else {
                            needed = 3
                        }
                        return ""
                    }
                    if (needed) {
                        buffer.push(code);
                        needed--;
                        if (needed > 0)return ""
                    }
                    var c1 = buffer[0];
                    var c2 = buffer[1];
                    var c3 = buffer[2];
                    var c4 = buffer[3];
                    var ret;
                    if (buffer.length == 2) {
                        ret = String.fromCharCode((c1 & 31) << 6 | c2 & 63)
                    } else if (buffer.length == 3) {
                        ret = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63)
                    } else {
                        var codePoint = (c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63;
                        ret = String.fromCharCode(Math.floor((codePoint - 65536) / 1024) + 55296, (codePoint - 65536) % 1024 + 56320)
                    }
                    buffer.length = 0;
                    return ret
                });
                this.processJSString = function processJSString(string) {
                    string = unescape(encodeURIComponent(string));
                    var ret = [];
                    for (var i = 0; i < string.length; i++) {
                        ret.push(string.charCodeAt(i))
                    }
                    return ret
                }
            }),
            getCompilerSetting: (function (name) {
                throw"You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work"
            }),
            stackAlloc: (function (size) {
                var ret = STACKTOP;
                STACKTOP = STACKTOP + size | 0;
                STACKTOP = STACKTOP + 7 & -8;
                return ret
            }),
            staticAlloc: (function (size) {
                var ret = STATICTOP;
                STATICTOP = STATICTOP + size | 0;
                STATICTOP = STATICTOP + 7 & -8;
                return ret
            }),
            dynamicAlloc: (function (size) {
                var ret = DYNAMICTOP;
                DYNAMICTOP = DYNAMICTOP + size | 0;
                DYNAMICTOP = DYNAMICTOP + 7 & -8;
                if (DYNAMICTOP >= TOTAL_MEMORY)enlargeMemory();
                return ret
            }),
            alignMemory: (function (size, quantum) {
                var ret = size = Math.ceil(size / (quantum ? quantum : 8)) * (quantum ? quantum : 8);
                return ret
            }),
            makeBigInt: (function (low, high, unsigned) {
                var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * +4294967296 : +(low >>> 0) + +(high | 0) * +4294967296;
                return ret
            }),
            GLOBAL_BASE: 8,
            QUANTUM_SIZE: 4,
            __dummy__: 0
        };
        Module["Runtime"] = Runtime;
        function jsCall() {
            var args = Array.prototype.slice.call(arguments);
            return Runtime.functionPointers[args[0]].apply(null, args.slice(1))
        }

        var __THREW__ = 0;
        var ABORT = false;
        var EXITSTATUS = 0;
        var undef = 0;
        var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
        var tempI64, tempI64b;
        var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;

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

        var globalScope = this;

        function getCFunc(ident) {
            var func = Module["_" + ident];
            if (!func) {
                try {
                    func = eval("_" + ident)
                } catch (e) {
                }
            }
            assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
            return func
        }

        var cwrap, ccall;
        ((function () {
            var stack = 0;
            var JSfuncs = {
                "stackSave": (function () {
                    stack = Runtime.stackSave()
                }), "stackRestore": (function () {
                    Runtime.stackRestore(stack)
                }), "arrayToC": (function (arr) {
                    var ret = Runtime.stackAlloc(arr.length);
                    writeArrayToMemory(arr, ret);
                    return ret
                }), "stringToC": (function (str) {
                    var ret = 0;
                    if (str !== null && str !== undefined && str !== 0) {
                        ret = Runtime.stackAlloc(str.length + 1);
                        writeStringToMemory(str, ret)
                    }
                    return ret
                })
            };
            var toC = {"string": JSfuncs["stringToC"], "array": JSfuncs["arrayToC"]};
            ccall = function ccallFunc(ident, returnType, argTypes, args) {
                var func = getCFunc(ident);
                var cArgs = [];
                if (args) {
                    for (var i = 0; i < args.length; i++) {
                        var converter = toC[argTypes[i]];
                        if (converter) {
                            if (stack === 0)stack = Runtime.stackSave();
                            cArgs[i] = converter(args[i])
                        } else {
                            cArgs[i] = args[i]
                        }
                    }
                }
                var ret = func.apply(null, cArgs);
                if (returnType === "string")ret = Pointer_stringify(ret);
                if (stack !== 0)JSfuncs["stackRestore"]();
                return ret
            };
            var sourceRegex = /^function\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;

            function parseJSFunc(jsfunc) {
                var parsed = jsfunc.toString().match(sourceRegex).slice(1);
                return {arguments: parsed[0], body: parsed[1], returnValue: parsed[2]}
            }

            var JSsource = {};
            for (var fun in JSfuncs) {
                if (JSfuncs.hasOwnProperty(fun)) {
                    JSsource[fun] = parseJSFunc(JSfuncs[fun])
                }
            }
            cwrap = function cwrap(ident, returnType, argTypes) {
                var cfunc = getCFunc(ident);
                var numericArgs = argTypes.every((function (type) {
                    return type === "number"
                }));
                var numericRet = returnType !== "string";
                if (numericRet && numericArgs) {
                    return cfunc
                }
                var argNames = argTypes.map((function (x, i) {
                    return "$" + i
                }));
                var funcstr = "(function(" + argNames.join(",") + ") {";
                var nargs = argTypes.length;
                if (!numericArgs) {
                    funcstr += JSsource["stackSave"].body + ";";
                    for (var i = 0; i < nargs; i++) {
                        var arg = argNames[i], type = argTypes[i];
                        if (type === "number")continue;
                        var convertCode = JSsource[type + "ToC"];
                        funcstr += "var " + convertCode.arguments + " = " + arg + ";";
                        funcstr += convertCode.body + ";";
                        funcstr += arg + "=" + convertCode.returnValue + ";"
                    }
                }
                var cfuncname = parseJSFunc((function () {
                    return cfunc
                })).returnValue;
                funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
                if (!numericRet) {
                    var strgfy = parseJSFunc((function () {
                        return Pointer_stringify
                    })).returnValue;
                    funcstr += "ret = " + strgfy + "(ret);"
                }
                if (!numericArgs) {
                    funcstr += JSsource["stackRestore"].body + ";"
                }
                funcstr += "return ret})";
                return eval(funcstr)
            }
        }))();
        Module["cwrap"] = cwrap;
        Module["ccall"] = ccall;
        function setValue(ptr, value, type, noSafe) {
            type = type || "i8";
            if (type.charAt(type.length - 1) === "*")type = "i32";
            switch (type) {
                case"i1":
                    HEAP8[ptr >> 0] = value;
                    break;
                case"i8":
                    HEAP8[ptr >> 0] = value;
                    break;
                case"i16":
                    HEAP16[ptr >> 1] = value;
                    break;
                case"i32":
                    HEAP32[ptr >> 2] = value;
                    break;
                case"i64":
                    tempI64 = [value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= +1 ? tempDouble > +0 ? (Math_min(+Math_floor(tempDouble / +4294967296), +4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / +4294967296) >>> 0 : 0)], HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
                    break;
                case"float":
                    HEAPF32[ptr >> 2] = value;
                    break;
                case"double":
                    HEAPF64[ptr >> 3] = value;
                    break;
                default:
                    abort("invalid type for setValue: " + type)
            }
        }

        Module["setValue"] = setValue;
        function getValue(ptr, type, noSafe) {
            type = type || "i8";
            if (type.charAt(type.length - 1) === "*")type = "i32";
            switch (type) {
                case"i1":
                    return HEAP8[ptr >> 0];
                case"i8":
                    return HEAP8[ptr >> 0];
                case"i16":
                    return HEAP16[ptr >> 1];
                case"i32":
                    return HEAP32[ptr >> 2];
                case"i64":
                    return HEAP32[ptr >> 2];
                case"float":
                    return HEAPF32[ptr >> 2];
                case"double":
                    return HEAPF64[ptr >> 3];
                default:
                    abort("invalid type for setValue: " + type)
            }
            return null
        }

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

        Module["allocate"] = allocate;
        function Pointer_stringify(ptr, length) {
            var hasUtf = false;
            var t;
            var i = 0;
            while (1) {
                t = HEAPU8[ptr + i >> 0];
                if (t >= 128)hasUtf = true; else if (t == 0 && !length)break;
                i++;
                if (length && i == length)break
            }
            if (!length)length = i;
            var ret = "";
            if (!hasUtf) {
                var MAX_CHUNK = 1024;
                var curr;
                while (length > 0) {
                    curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
                    ret = ret ? ret + curr : curr;
                    ptr += MAX_CHUNK;
                    length -= MAX_CHUNK
                }
                return ret
            }
            var utf8 = new Runtime.UTF8Processor;
            for (i = 0; i < length; i++) {
                t = HEAPU8[ptr + i >> 0];
                ret += utf8.processCChar(t)
            }
            return ret
        }

        Module["Pointer_stringify"] = Pointer_stringify;
        function UTF16ToString(ptr) {
            var i = 0;
            var str = "";
            while (1) {
                var codeUnit = HEAP16[ptr + i * 2 >> 1];
                if (codeUnit == 0)return str;
                ++i;
                str += String.fromCharCode(codeUnit)
            }
        }

        Module["UTF16ToString"] = UTF16ToString;
        function stringToUTF16(str, outPtr) {
            for (var i = 0; i < str.length; ++i) {
                var codeUnit = str.charCodeAt(i);
                HEAP16[outPtr + i * 2 >> 1] = codeUnit
            }
            HEAP16[outPtr + str.length * 2 >> 1] = 0
        }

        Module["stringToUTF16"] = stringToUTF16;
        function UTF32ToString(ptr) {
            var i = 0;
            var str = "";
            while (1) {
                var utf32 = HEAP32[ptr + i * 4 >> 2];
                if (utf32 == 0)return str;
                ++i;
                if (utf32 >= 65536) {
                    var ch = utf32 - 65536;
                    str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
                } else {
                    str += String.fromCharCode(utf32)
                }
            }
        }

        Module["UTF32ToString"] = UTF32ToString;
        function stringToUTF32(str, outPtr) {
            var iChar = 0;
            for (var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
                var codeUnit = str.charCodeAt(iCodeUnit);
                if (codeUnit >= 55296 && codeUnit <= 57343) {
                    var trailSurrogate = str.charCodeAt(++iCodeUnit);
                    codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023
                }
                HEAP32[outPtr + iChar * 4 >> 2] = codeUnit;
                ++iChar
            }
            HEAP32[outPtr + iChar * 4 >> 2] = 0
        }

        Module["stringToUTF32"] = stringToUTF32;
        function demangle(func) {
            var i = 3;
            var basicTypes = {
                "v": "void",
                "b": "bool",
                "c": "char",
                "s": "short",
                "i": "int",
                "l": "long",
                "f": "float",
                "d": "double",
                "w": "wchar_t",
                "a": "signed char",
                "h": "unsigned char",
                "t": "unsigned short",
                "j": "unsigned int",
                "m": "unsigned long",
                "x": "long long",
                "y": "unsigned long long",
                "z": "..."
            };
            var subs = [];
            var first = true;

            function dump(x) {
                if (x)Module.print(x);
                Module.print(func);
                var pre = "";
                for (var a = 0; a < i; a++)pre += " ";
                Module.print(pre + "^")
            }

            function parseNested() {
                i++;
                if (func[i] === "K")i++;
                var parts = [];
                while (func[i] !== "E") {
                    if (func[i] === "S") {
                        i++;
                        var next = func.indexOf("_", i);
                        var num = func.substring(i, next) || 0;
                        parts.push(subs[num] || "?");
                        i = next + 1;
                        continue
                    }
                    if (func[i] === "C") {
                        parts.push(parts[parts.length - 1]);
                        i += 2;
                        continue
                    }
                    var size = parseInt(func.substr(i));
                    var pre = size.toString().length;
                    if (!size || !pre) {
                        i--;
                        break
                    }
                    var curr = func.substr(i + pre, size);
                    parts.push(curr);
                    subs.push(curr);
                    i += pre + size
                }
                i++;
                return parts
            }

            function parse(rawList, limit, allowVoid) {
                limit = limit || Infinity;
                var ret = "", list = [];

                function flushList() {
                    return "(" + list.join(", ") + ")"
                }

                var name;
                if (func[i] === "N") {
                    name = parseNested().join("::");
                    limit--;
                    if (limit === 0)return rawList ? [name] : name
                } else {
                    if (func[i] === "K" || first && func[i] === "L")i++;
                    var size = parseInt(func.substr(i));
                    if (size) {
                        var pre = size.toString().length;
                        name = func.substr(i + pre, size);
                        i += pre + size
                    }
                }
                first = false;
                if (func[i] === "I") {
                    i++;
                    var iList = parse(true);
                    var iRet = parse(true, 1, true);
                    ret += iRet[0] + " " + name + "<" + iList.join(", ") + ">"
                } else {
                    ret = name
                }
                paramLoop:while (i < func.length && limit-- > 0) {
                    var c = func[i++];
                    if (c in basicTypes) {
                        list.push(basicTypes[c])
                    } else {
                        switch (c) {
                            case"P":
                                list.push(parse(true, 1, true)[0] + "*");
                                break;
                            case"R":
                                list.push(parse(true, 1, true)[0] + "&");
                                break;
                            case"L": {
                                i++;
                                var end = func.indexOf("E", i);
                                var size = end - i;
                                list.push(func.substr(i, size));
                                i += size + 2;
                                break
                            }
                                ;
                            case"A": {
                                var size = parseInt(func.substr(i));
                                i += size.toString().length;
                                if (func[i] !== "_")throw"?";
                                i++;
                                list.push(parse(true, 1, true)[0] + " [" + size + "]");
                                break
                            }
                                ;
                            case"E":
                                break paramLoop;
                            default:
                                ret += "?" + c;
                                break paramLoop
                        }
                    }
                }
                if (!allowVoid && list.length === 1 && list[0] === "void")list = [];
                if (rawList) {
                    if (ret) {
                        list.push(ret + "?")
                    }
                    return list
                } else {
                    return ret + flushList()
                }
            }

            try {
                if (func == "Object._main" || func == "_main") {
                    return "main()"
                }
                if (typeof func === "number")func = Pointer_stringify(func);
                if (func[0] !== "_")return func;
                if (func[1] !== "_")return func;
                if (func[2] !== "Z")return func;
                switch (func[3]) {
                    case"n":
                        return "operator new()";
                    case"d":
                        return "operator delete()"
                }
                return parse()
            } catch (e) {
                return func
            }
        }

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

        function stackTrace() {
            var stack = (new Error).stack;
            return stack ? demangleAll(stack) : "(no stack trace available)"
        }

        var PAGE_SIZE = 4096;

        function alignMemoryPage(x) {
            return x + 4095 & -4096
        }

        var HEAP;
        var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
        var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false;
        var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0;
        var DYNAMIC_BASE = 0, DYNAMICTOP = 0;

        function enlargeMemory() {
            abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value " + TOTAL_MEMORY + ", (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.")
        }

        var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
        var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 16777216;
        var FAST_MEMORY = Module["FAST_MEMORY"] || 2097152;
        var totalMemory = 4096;
        while (totalMemory < TOTAL_MEMORY || totalMemory < 2 * TOTAL_STACK) {
            if (totalMemory < 16 * 1024 * 1024) {
                totalMemory *= 2
            } else {
                totalMemory += 16 * 1024 * 1024
            }
        }
        if (totalMemory !== TOTAL_MEMORY) {
            Module.printErr("increasing TOTAL_MEMORY to " + totalMemory + " to be more reasonable");
            TOTAL_MEMORY = totalMemory
        }
        assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && !!(new Int32Array(1))["subarray"] && !!(new Int32Array(1))["set"], "JS engine does not provide full typed array support");
        var buffer = new ArrayBuffer(TOTAL_MEMORY);
        HEAP8 = new Int8Array(buffer);
        HEAP16 = new Int16Array(buffer);
        HEAP32 = new Int32Array(buffer);
        HEAPU8 = new Uint8Array(buffer);
        HEAPU16 = new Uint16Array(buffer);
        HEAPU32 = new Uint32Array(buffer);
        HEAPF32 = new Float32Array(buffer);
        HEAPF64 = new Float64Array(buffer);
        HEAP32[0] = 255;
        assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, "Typed arrays 2 must be run on a little-endian system");
        Module["HEAP"] = HEAP;
        Module["HEAP8"] = HEAP8;
        Module["HEAP16"] = HEAP16;
        Module["HEAP32"] = HEAP32;
        Module["HEAPU8"] = HEAPU8;
        Module["HEAPU16"] = HEAPU16;
        Module["HEAPU32"] = HEAPU32;
        Module["HEAPF32"] = HEAPF32;
        Module["HEAPF64"] = HEAPF64;
        function callRuntimeCallbacks(callbacks) {
            while (callbacks.length > 0) {
                var callback = callbacks.shift();
                if (typeof callback == "function") {
                    callback();
                    continue
                }
                var func = callback.func;
                if (typeof func === "number") {
                    if (callback.arg === undefined) {
                        Runtime.dynCall("v", func)
                    } else {
                        Runtime.dynCall("vi", func, [callback.arg])
                    }
                } else {
                    func(callback.arg === undefined ? null : callback.arg)
                }
            }
        }

        var __ATPRERUN__ = [];
        var __ATINIT__ = [];
        var __ATMAIN__ = [];
        var __ATEXIT__ = [];
        var __ATPOSTRUN__ = [];
        var runtimeInitialized = false;

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

        function ensureInitRuntime() {
            if (runtimeInitialized)return;
            runtimeInitialized = true;
            callRuntimeCallbacks(__ATINIT__)
        }

        function preMain() {
            callRuntimeCallbacks(__ATMAIN__)
        }

        function exitRuntime() {
            callRuntimeCallbacks(__ATEXIT__);
            runtimeInitialized = false
        }

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

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

        Module["addOnPreRun"] = Module.addOnPreRun = addOnPreRun;
        function addOnInit(cb) {
            __ATINIT__.unshift(cb)
        }

        Module["addOnInit"] = Module.addOnInit = addOnInit;
        function addOnPreMain(cb) {
            __ATMAIN__.unshift(cb)
        }

        Module["addOnPreMain"] = Module.addOnPreMain = addOnPreMain;
        function addOnExit(cb) {
            __ATEXIT__.unshift(cb)
        }

        Module["addOnExit"] = Module.addOnExit = addOnExit;
        function addOnPostRun(cb) {
            __ATPOSTRUN__.unshift(cb)
        }

        Module["addOnPostRun"] = Module.addOnPostRun = addOnPostRun;
        function intArrayFromString(stringy, dontAddNull, length) {
            var ret = (new Runtime.UTF8Processor).processJSString(stringy);
            if (length) {
                ret.length = length
            }
            if (!dontAddNull) {
                ret.push(0)
            }
            return ret
        }

        Module["intArrayFromString"] = intArrayFromString;
        function intArrayToString(array) {
            var ret = [];
            for (var i = 0; i < array.length; i++) {
                var chr = array[i];
                if (chr > 255) {
                    chr &= 255
                }
                ret.push(String.fromCharCode(chr))
            }
            return ret.join("")
        }

        Module["intArrayToString"] = intArrayToString;
        function writeStringToMemory(string, buffer, dontAddNull) {
            var array = intArrayFromString(string, dontAddNull);
            var i = 0;
            while (i < array.length) {
                var chr = array[i];
                HEAP8[buffer + i >> 0] = chr;
                i = i + 1
            }
        }

        Module["writeStringToMemory"] = writeStringToMemory;
        function writeArrayToMemory(array, buffer) {
            for (var i = 0; i < array.length; i++) {
                HEAP8[buffer + i >> 0] = array[i]
            }
        }

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

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

        function reSign(value, bits, ignore) {
            if (value <= 0) {
                return value
            }
            var half = bits <= 32 ? Math.abs(1 << bits - 1) : Math.pow(2, bits - 1);
            if (value >= half && (bits <= 32 || value > half)) {
                value = -2 * half + value
            }
            return value
        }

        if (!Math["imul"] || Math["imul"](4294967295, 5) !== -5)Math["imul"] = function imul(a, b) {
            var ah = a >>> 16;
            var al = a & 65535;
            var bh = b >>> 16;
            var bl = b & 65535;
            return al * bl + (ah * bl + al * bh << 16) | 0
        };
        Math.imul = Math["imul"];
        var Math_abs = Math.abs;
        var Math_cos = Math.cos;
        var Math_sin = Math.sin;
        var Math_tan = Math.tan;
        var Math_acos = Math.acos;
        var Math_asin = Math.asin;
        var Math_atan = Math.atan;
        var Math_atan2 = Math.atan2;
        var Math_exp = Math.exp;
        var Math_log = Math.log;
        var Math_sqrt = Math.sqrt;
        var Math_ceil = Math.ceil;
        var Math_floor = Math.floor;
        var Math_pow = Math.pow;
        var Math_imul = Math.imul;
        var Math_fround = Math.fround;
        var Math_min = Math.min;
        var runDependencies = 0;
        var runDependencyWatcher = null;
        var dependenciesFulfilled = null;

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

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

        Module["removeRunDependency"] = removeRunDependency;
        Module["preloadedImages"] = {};
        Module["preloadedAudios"] = {};
        var memoryInitializer = null;
        STATIC_BASE = 8;
        STATICTOP = STATIC_BASE + Runtime.alignMemory(1739);
        __ATINIT__.push();
        allocate([0, 0, 0, 0, 183, 29, 193, 4, 110, 59, 130, 9, 217, 38, 67, 13, 220, 118, 4, 19, 107, 107, 197, 23, 178, 77, 134, 26, 5, 80, 71, 30, 184, 237, 8, 38, 15, 240, 201, 34, 214, 214, 138, 47, 97, 203, 75, 43, 100, 155, 12, 53, 211, 134, 205, 49, 10, 160, 142, 60, 189, 189, 79, 56, 112, 219, 17, 76, 199, 198, 208, 72, 30, 224, 147, 69, 169, 253, 82, 65, 172, 173, 21, 95, 27, 176, 212, 91, 194, 150, 151, 86, 117, 139, 86, 82, 200, 54, 25, 106, 127, 43, 216, 110, 166, 13, 155, 99, 17, 16, 90, 103, 20, 64, 29, 121, 163, 93, 220, 125, 122, 123, 159, 112, 205, 102, 94, 116, 224, 182, 35, 152, 87, 171, 226, 156, 142, 141, 161, 145, 57, 144, 96, 149, 60, 192, 39, 139, 139, 221, 230, 143, 82, 251, 165, 130, 229, 230, 100, 134, 88, 91, 43, 190, 239, 70, 234, 186, 54, 96, 169, 183, 129, 125, 104, 179, 132, 45, 47, 173, 51, 48, 238, 169, 234, 22, 173, 164, 93, 11, 108, 160, 144, 109, 50, 212, 39, 112, 243, 208, 254, 86, 176, 221, 73, 75, 113, 217, 76, 27, 54, 199, 251, 6, 247, 195, 34, 32, 180, 206, 149, 61, 117, 202, 40, 128, 58, 242, 159, 157, 251, 246, 70, 187, 184, 251, 241, 166, 121, 255, 244, 246, 62, 225, 67, 235, 255, 229, 154, 205, 188, 232, 45, 208, 125, 236, 119, 112, 134, 52, 192, 109, 71, 48, 25, 75, 4, 61, 174, 86, 197, 57, 171, 6, 130, 39, 28, 27, 67, 35, 197, 61, 0, 46, 114, 32, 193, 42, 207, 157, 142, 18, 120, 128, 79, 22, 161, 166, 12, 27, 22, 187, 205, 31, 19, 235, 138, 1, 164, 246, 75, 5, 125, 208, 8, 8, 202, 205, 201, 12, 7, 171, 151, 120, 176, 182, 86, 124, 105, 144, 21, 113, 222, 141, 212, 117, 219, 221, 147, 107, 108, 192, 82, 111, 181, 230, 17, 98, 2, 251, 208, 102, 191, 70, 159, 94, 8, 91, 94, 90, 209, 125, 29, 87, 102, 96, 220, 83, 99, 48, 155, 77, 212, 45, 90, 73, 13, 11, 25, 68, 186, 22, 216, 64, 151, 198, 165, 172, 32, 219, 100, 168, 249, 253, 39, 165, 78, 224, 230, 161, 75, 176, 161, 191, 252, 173, 96, 187, 37, 139, 35, 182, 146, 150, 226, 178, 47, 43, 173, 138, 152, 54, 108, 142, 65, 16, 47, 131, 246, 13, 238, 135, 243, 93, 169, 153, 68, 64, 104, 157, 157, 102, 43, 144, 42, 123, 234, 148, 231, 29, 180, 224, 80, 0, 117, 228, 137, 38, 54, 233, 62, 59, 247, 237, 59, 107, 176, 243, 140, 118, 113, 247, 85, 80, 50, 250, 226, 77, 243, 254, 95, 240, 188, 198, 232, 237, 125, 194, 49, 203, 62, 207, 134, 214, 255, 203, 131, 134, 184, 213, 52, 155, 121, 209, 237, 189, 58, 220, 90, 160, 251, 216, 238, 224, 12, 105, 89, 253, 205, 109, 128, 219, 142, 96, 55, 198, 79, 100, 50, 150, 8, 122, 133, 139, 201, 126, 92, 173, 138, 115, 235, 176, 75, 119, 86, 13, 4, 79, 225, 16, 197, 75, 56, 54, 134, 70, 143, 43, 71, 66, 138, 123, 0, 92, 61, 102, 193, 88, 228, 64, 130, 85, 83, 93, 67, 81, 158, 59, 29, 37, 41, 38, 220, 33, 240, 0, 159, 44, 71, 29, 94, 40, 66, 77, 25, 54, 245, 80, 216, 50, 44, 118, 155, 63, 155, 107, 90, 59, 38, 214, 21, 3, 145, 203, 212, 7, 72, 237, 151, 10, 255, 240, 86, 14, 250, 160, 17, 16, 77, 189, 208, 20, 148, 155, 147, 25, 35, 134, 82, 29, 14, 86, 47, 241, 185, 75, 238, 245, 96, 109, 173, 248, 215, 112, 108, 252, 210, 32, 43, 226, 101, 61, 234, 230, 188, 27, 169, 235, 11, 6, 104, 239, 182, 187, 39, 215, 1, 166, 230, 211, 216, 128, 165, 222, 111, 157, 100, 218, 106, 205, 35, 196, 221, 208, 226, 192, 4, 246, 161, 205, 179, 235, 96, 201, 126, 141, 62, 189, 201, 144, 255, 185, 16, 182, 188, 180, 167, 171, 125, 176, 162, 251, 58, 174, 21, 230, 251, 170, 204, 192, 184, 167, 123, 221, 121, 163, 198, 96, 54, 155, 113, 125, 247, 159, 168, 91, 180, 146, 31, 70, 117, 150, 26, 22, 50, 136, 173, 11, 243, 140, 116, 45, 176, 129, 195, 48, 113, 133, 153, 144, 138, 93, 46, 141, 75, 89, 247, 171, 8, 84, 64, 182, 201, 80, 69, 230, 142, 78, 242, 251, 79, 74, 43, 221, 12, 71, 156, 192, 205, 67, 33, 125, 130, 123, 150, 96, 67, 127, 79, 70, 0, 114, 248, 91, 193, 118, 253, 11, 134, 104, 74, 22, 71, 108, 147, 48, 4, 97, 36, 45, 197, 101, 233, 75, 155, 17, 94, 86, 90, 21, 135, 112, 25, 24, 48, 109, 216, 28, 53, 61, 159, 2, 130, 32, 94, 6, 91, 6, 29, 11, 236, 27, 220, 15, 81, 166, 147, 55, 230, 187, 82, 51, 63, 157, 17, 62, 136, 128, 208, 58, 141, 208, 151, 36, 58, 205, 86, 32, 227, 235, 21, 45, 84, 246, 212, 41, 121, 38, 169, 197, 206, 59, 104, 193, 23, 29, 43, 204, 160, 0, 234, 200, 165, 80, 173, 214, 18, 77, 108, 210, 203, 107, 47, 223, 124, 118, 238, 219, 193, 203, 161, 227, 118, 214, 96, 231, 175, 240, 35, 234, 24, 237, 226, 238, 29, 189, 165, 240, 170, 160, 100, 244, 115, 134, 39, 249, 196, 155, 230, 253, 9, 253, 184, 137, 190, 224, 121, 141, 103, 198, 58, 128, 208, 219, 251, 132, 213, 139, 188, 154, 98, 150, 125, 158, 187, 176, 62, 147, 12, 173, 255, 151, 177, 16, 176, 175, 6, 13, 113, 171, 223, 43, 50, 166, 104, 54, 243, 162, 109, 102, 180, 188, 218, 123, 117, 184, 3, 93, 54, 181, 180, 64, 247, 177, 79, 103, 103, 83, 0, 0, 0, 0, 33, 111, 103, 103, 95, 115, 121, 110, 99, 95, 105, 110, 105, 116, 40, 38, 111, 103, 103, 45, 62, 115, 116, 97, 116, 101, 41, 0, 0, 0, 0, 0, 115, 114, 99, 47, 111, 103, 103, 46, 99, 0, 0, 0, 0, 0, 0, 0, 65, 86, 79, 103, 103, 73, 110, 105, 116, 0, 0, 0, 0, 0, 0, 0, 33, 111, 103, 103, 95, 115, 121, 110, 99, 95, 119, 114, 111, 116, 101, 40, 38, 111, 103, 103, 45, 62, 115, 116, 97, 116, 101, 44, 32, 98, 117, 102, 108, 101, 110, 41, 0, 0, 0, 0, 65, 86, 79, 103, 103, 82, 101, 97, 100, 0, 0, 0, 0, 0, 0, 0, 33, 111, 103, 103, 95, 115, 116, 114, 101, 97, 109, 95, 105, 110, 105, 116, 40, 38, 111, 103, 103, 45, 62, 115, 116, 114, 101, 97, 109, 44, 32, 115, 101, 114, 105, 97, 108, 41, 0, 0, 33, 111, 103, 103, 95, 115, 116, 114, 101, 97, 109, 95, 112, 97, 103, 101, 105, 110, 40, 38, 111, 103, 103, 45, 62, 115, 116, 114, 101, 97, 109, 44, 32, 38, 111, 103, 103, 45, 62, 112, 97, 103, 101, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
        var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
        assert(tempDoublePtr % 8 == 0);
        function copyTempFloat(ptr) {
            HEAP8[tempDoublePtr] = HEAP8[ptr];
            HEAP8[tempDoublePtr + 1] = HEAP8[ptr + 1];
            HEAP8[tempDoublePtr + 2] = HEAP8[ptr + 2];
            HEAP8[tempDoublePtr + 3] = HEAP8[ptr + 3]
        }

        function copyTempDouble(ptr) {
            HEAP8[tempDoublePtr] = HEAP8[ptr];
            HEAP8[tempDoublePtr + 1] = HEAP8[ptr + 1];
            HEAP8[tempDoublePtr + 2] = HEAP8[ptr + 2];
            HEAP8[tempDoublePtr + 3] = HEAP8[ptr + 3];
            HEAP8[tempDoublePtr + 4] = HEAP8[ptr + 4];
            HEAP8[tempDoublePtr + 5] = HEAP8[ptr + 5];
            HEAP8[tempDoublePtr + 6] = HEAP8[ptr + 6];
            HEAP8[tempDoublePtr + 7] = HEAP8[ptr + 7]
        }

        Module["_i64Add"] = _i64Add;
        function _sbrk(bytes) {
            var self = _sbrk;
            if (!self.called) {
                DYNAMICTOP = alignMemoryPage(DYNAMICTOP);
                self.called = true;
                assert(Runtime.dynamicAlloc);
                self.alloc = Runtime.dynamicAlloc;
                Runtime.dynamicAlloc = (function () {
                    abort("cannot dynamically allocate, sbrk now has control")
                })
            }
            var ret = DYNAMICTOP;
            if (bytes != 0)self.alloc(bytes);
            return ret
        }

        var ___errno_state = 0;

        function ___setErrNo(value) {
            HEAP32[___errno_state >> 2] = value;
            return value
        }

        var ERRNO_CODES = {
            EPERM: 1,
            ENOENT: 2,
            ESRCH: 3,
            EINTR: 4,
            EIO: 5,
            ENXIO: 6,
            E2BIG: 7,
            ENOEXEC: 8,
            EBADF: 9,
            ECHILD: 10,
            EAGAIN: 11,
            EWOULDBLOCK: 11,
            ENOMEM: 12,
            EACCES: 13,
            EFAULT: 14,
            ENOTBLK: 15,
            EBUSY: 16,
            EEXIST: 17,
            EXDEV: 18,
            ENODEV: 19,
            ENOTDIR: 20,
            EISDIR: 21,
            EINVAL: 22,
            ENFILE: 23,
            EMFILE: 24,
            ENOTTY: 25,
            ETXTBSY: 26,
            EFBIG: 27,
            ENOSPC: 28,
            ESPIPE: 29,
            EROFS: 30,
            EMLINK: 31,
            EPIPE: 32,
            EDOM: 33,
            ERANGE: 34,
            ENOMSG: 42,
            EIDRM: 43,
            ECHRNG: 44,
            EL2NSYNC: 45,
            EL3HLT: 46,
            EL3RST: 47,
            ELNRNG: 48,
            EUNATCH: 49,
            ENOCSI: 50,
            EL2HLT: 51,
            EDEADLK: 35,
            ENOLCK: 37,
            EBADE: 52,
            EBADR: 53,
            EXFULL: 54,
            ENOANO: 55,
            EBADRQC: 56,
            EBADSLT: 57,
            EDEADLOCK: 35,
            EBFONT: 59,
            ENOSTR: 60,
            ENODATA: 61,
            ETIME: 62,
            ENOSR: 63,
            ENONET: 64,
            ENOPKG: 65,
            EREMOTE: 66,
            ENOLINK: 67,
            EADV: 68,
            ESRMNT: 69,
            ECOMM: 70,
            EPROTO: 71,
            EMULTIHOP: 72,
            EDOTDOT: 73,
            EBADMSG: 74,
            ENOTUNIQ: 76,
            EBADFD: 77,
            EREMCHG: 78,
            ELIBACC: 79,
            ELIBBAD: 80,
            ELIBSCN: 81,
            ELIBMAX: 82,
            ELIBEXEC: 83,
            ENOSYS: 38,
            ENOTEMPTY: 39,
            ENAMETOOLONG: 36,
            ELOOP: 40,
            EOPNOTSUPP: 95,
            EPFNOSUPPORT: 96,
            ECONNRESET: 104,
            ENOBUFS: 105,
            EAFNOSUPPORT: 97,
            EPROTOTYPE: 91,
            ENOTSOCK: 88,
            ENOPROTOOPT: 92,
            ESHUTDOWN: 108,
            ECONNREFUSED: 111,
            EADDRINUSE: 98,
            ECONNABORTED: 103,
            ENETUNREACH: 101,
            ENETDOWN: 100,
            ETIMEDOUT: 110,
            EHOSTDOWN: 112,
            EHOSTUNREACH: 113,
            EINPROGRESS: 115,
            EALREADY: 114,
            EDESTADDRREQ: 89,
            EMSGSIZE: 90,
            EPROTONOSUPPORT: 93,
            ESOCKTNOSUPPORT: 94,
            EADDRNOTAVAIL: 99,
            ENETRESET: 102,
            EISCONN: 106,
            ENOTCONN: 107,
            ETOOMANYREFS: 109,
            EUSERS: 87,
            EDQUOT: 122,
            ESTALE: 116,
            ENOTSUP: 95,
            ENOMEDIUM: 123,
            EILSEQ: 84,
            EOVERFLOW: 75,
            ECANCELED: 125,
            ENOTRECOVERABLE: 131,
            EOWNERDEAD: 130,
            ESTRPIPE: 86
        };

        function _sysconf(name) {
            switch (name) {
                case 30:
                    return 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 79:
                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 27:
                case 246:
                case 127:
                case 128:
                case 23:
                case 24:
                case 160:
                case 161:
                case 181:
                case 182:
                case 242:
                case 183:
                case 184:
                case 243:
                case 244:
                case 245:
                case 165:
                case 178:
                case 179:
                case 49:
                case 50:
                case 168:
                case 169:
                case 175:
                case 170:
                case 171:
                case 172:
                case 97:
                case 76:
                case 32:
                case 173:
                case 35:
                    return -1;
                case 176:
                case 177:
                case 7:
                case 155:
                case 8:
                case 157:
                case 125:
                case 126:
                case 92:
                case 93:
                case 129:
                case 130:
                case 131:
                case 94:
                case 91:
                    return 1;
                case 74:
                case 60:
                case 69:
                case 70:
                case 4:
                    return 1024;
                case 31:
                case 42:
                case 72:
                    return 32;
                case 87:
                case 26:
                case 33:
                    return 2147483647;
                case 34:
                case 1:
                    return 47839;
                case 38:
                case 36:
                    return 99;
                case 43:
                case 37:
                    return 2048;
                case 0:
                    return 2097152;
                case 3:
                    return 65536;
                case 28:
                    return 32768;
                case 44:
                    return 32767;
                case 75:
                    return 16384;
                case 39:
                    return 1e3;
                case 89:
                    return 700;
                case 71:
                    return 256;
                case 40:
                    return 255;
                case 2:
                    return 100;
                case 180:
                    return 64;
                case 25:
                    return 20;
                case 5:
                    return 16;
                case 6:
                    return 6;
                case 73:
                    return 4;
                case 84: {
                    if (typeof navigator === "object")return navigator["hardwareConcurrency"] || 1;
                    return 1
                }
            }
            ___setErrNo(ERRNO_CODES.EINVAL);
            return -1
        }

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

        Module["_memcpy"] = _memcpy;
        Module["_memmove"] = _memmove;
        Module["_memset"] = _memset;
        function ___errno_location() {
            return ___errno_state
        }

        Module["_bitshift64Shl"] = _bitshift64Shl;
        function _abort() {
            Module["abort"]()
        }

        var ERRNO_MESSAGES = {
            0: "Success",
            1: "Not super-user",
            2: "No such file or directory",
            3: "No such process",
            4: "Interrupted system call",
            5: "I/O error",
            6: "No such device or address",
            7: "Arg list too long",
            8: "Exec format error",
            9: "Bad file number",
            10: "No children",
            11: "No more processes",
            12: "Not enough core",
            13: "Permission denied",
            14: "Bad address",
            15: "Block device required",
            16: "Mount device busy",
            17: "File exists",
            18: "Cross-device link",
            19: "No such device",
            20: "Not a directory",
            21: "Is a directory",
            22: "Invalid argument",
            23: "Too many open files in system",
            24: "Too many open files",
            25: "Not a typewriter",
            26: "Text file busy",
            27: "File too large",
            28: "No space left on device",
            29: "Illegal seek",
            30: "Read only file system",
            31: "Too many links",
            32: "Broken pipe",
            33: "Math arg out of domain of func",
            34: "Math result not representable",
            35: "File locking deadlock error",
            36: "File or path name too long",
            37: "No record locks available",
            38: "Function not implemented",
            39: "Directory not empty",
            40: "Too many symbolic links",
            42: "No message of desired type",
            43: "Identifier removed",
            44: "Channel number out of range",
            45: "Level 2 not synchronized",
            46: "Level 3 halted",
            47: "Level 3 reset",
            48: "Link number out of range",
            49: "Protocol driver not attached",
            50: "No CSI structure available",
            51: "Level 2 halted",
            52: "Invalid exchange",
            53: "Invalid request descriptor",
            54: "Exchange full",
            55: "No anode",
            56: "Invalid request code",
            57: "Invalid slot",
            59: "Bad font file fmt",
            60: "Device not a stream",
            61: "No data (for no delay io)",
            62: "Timer expired",
            63: "Out of streams resources",
            64: "Machine is not on the network",
            65: "Package not installed",
            66: "The object is remote",
            67: "The link has been severed",
            68: "Advertise error",
            69: "Srmount error",
            70: "Communication error on send",
            71: "Protocol error",
            72: "Multihop attempted",
            73: "Cross mount point (not really error)",
            74: "Trying to read unreadable message",
            75: "Value too large for defined data type",
            76: "Given log. name not unique",
            77: "f.d. invalid for this operation",
            78: "Remote address changed",
            79: "Can   access a needed shared lib",
            80: "Accessing a corrupted shared lib",
            81: ".lib section in a.out corrupted",
            82: "Attempting to link in too many libs",
            83: "Attempting to exec a shared library",
            84: "Illegal byte sequence",
            86: "Streams pipe error",
            87: "Too many users",
            88: "Socket operation on non-socket",
            89: "Destination address required",
            90: "Message too long",
            91: "Protocol wrong type for socket",
            92: "Protocol not available",
            93: "Unknown protocol",
            94: "Socket type not supported",
            95: "Not supported",
            96: "Protocol family not supported",
            97: "Address family not supported by protocol family",
            98: "Address already in use",
            99: "Address not available",
            100: "Network interface is not configured",
            101: "Network is unreachable",
            102: "Connection reset by network",
            103: "Connection aborted",
            104: "Connection reset by peer",
            105: "No buffer space available",
            106: "Socket is already connected",
            107: "Socket is not connected",
            108: "Can't send after socket shutdown",
            109: "Too many references",
            110: "Connection timed out",
            111: "Connection refused",
            112: "Host is down",
            113: "Host is unreachable",
            114: "Socket already connected",
            115: "Connection already in progress",
            116: "Stale file handle",
            122: "Quota exceeded",
            123: "No medium (in tape drive)",
            125: "Operation canceled",
            130: "Previous owner died",
            131: "State not recoverable"
        };
        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) {
                    if (stream.tty.output.length) {
                        stream.tty.ops.put_char(stream.tty, 10)
                    }
                }), read: (function (stream, buffer, offset, length, pos) {
                    if (!stream.tty || !stream.tty.ops.get_char) {
                        throw new FS.ErrnoError(ERRNO_CODES.ENXIO)
                    }
                    var bytesRead = 0;
                    for (var i = 0; i < length; i++) {
                        var result;
                        try {
                            result = stream.tty.ops.get_char(stream.tty)
                        } catch (e) {
                            throw new FS.ErrnoError(ERRNO_CODES.EIO)
                        }
                        if (result === undefined && bytesRead === 0) {
                            throw new FS.ErrnoError(ERRNO_CODES.EAGAIN)
                        }
                        if (result === null || result === undefined)break;
                        bytesRead++;
                        buffer[offset + i] = result
                    }
                    if (bytesRead) {
                        stream.node.timestamp = Date.now()
                    }
                    return bytesRead
                }), write: (function (stream, buffer, offset, length, pos) {
                    if (!stream.tty || !stream.tty.ops.put_char) {
                        throw new FS.ErrnoError(ERRNO_CODES.ENXIO)
                    }
                    for (var i = 0; i < length; i++) {
                        try {
                            stream.tty.ops.put_char(stream.tty, buffer[offset + i])
                        } catch (e) {
                            throw new FS.ErrnoError(ERRNO_CODES.EIO)
                        }
                    }
                    if (length) {
                        stream.node.timestamp = Date.now()
                    }
                    return i
                })
            }, default_tty_ops: {
                get_char: (function (tty) {
                    if (!tty.input.length) {
                        var result = null;
                        if (ENVIRONMENT_IS_NODE) {
                            result = process["stdin"]["read"]();
                            if (!result) {
                                if (process["stdin"]["_readableState"] && process["stdin"]["_readableState"]["ended"]) {
                                    return null
                                }
                                return undefined
                            }
                        } else if (typeof window != "undefined" && typeof window.prompt == "function") {
                            result = window.prompt("Input: ");
                            if (result !== null) {
                                result += "\n"
                            }
                        } else if (typeof readline == "function") {
                            result = readline();
                            if (result !== null) {
                                result += "\n"
                            }
                        }
                        if (!result) {
                            return null
                        }
                        tty.input = intArrayFromString(result, true)
                    }
                    return tty.input.shift()
                }), put_char: (function (tty, val) {
                    if (val === null || val === 10) {
                        Module["print"](tty.output.join(""));
                        tty.output = []
                    } else {
                        tty.output.push(TTY.utf8.processCChar(val))
                    }
                })
            }, default_tty1_ops: {
                put_char: (function (tty, val) {
                    if (val === null || val === 10) {
                        Module["printErr"](tty.output.join(""));
                        tty.output = []
                    } else {
                        tty.output.push(TTY.utf8.processCChar(val))
                    }
                })
            }
        };
        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
                            }
                        },
                        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 && node.contents.subarray)return node.contents.subarray(0, node.usedBytes);
                return new Uint8Array(node.contents)
            }), expandFileStorage: (function (node, newCapacity) {
                if (node.contents && node.contents.subarray && newCapacity > node.contents.length) {
                    node.contents = MEMFS.getFileDataAsRegularArray(node);
                    node.usedBytes = node.contents.length
                }
                if (!node.contents || node.contents.subarray) {
                    var prevCapacity = node.contents ? node.contents.buffer.byteLength : 0;
                    if (prevCapacity >= newCapacity)return;
                    var CAPACITY_DOUBLING_MAX = 1024 * 1024;
                    newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) | 0);
                    if (prevCapacity != 0)newCapacity = Math.max(newCapacity, 256);
                    var oldContents = node.contents;
                    node.contents = new Uint8Array(newCapacity);
                    if (node.usedBytes > 0)node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
                    return
                }
                if (!node.contents && newCapacity > 0)node.contents = [];
                while (node.contents.length < newCapacity)node.contents.push(0)
            }), resizeFileStorage: (function (node, newSize) {
                if (node.usedBytes == newSize)return;
                if (newSize == 0) {
                    node.contents = null;
                    node.usedBytes = 0;
                    return
                }
                if (!node.contents || node.contents.subarray) {
                    var oldContents = node.contents;
                    node.contents = new Uint8Array(new ArrayBuffer(newSize));
                    node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
                    node.usedBytes = newSize;
                    return
                }
                if (!node.contents)node.contents = [];
                if (node.contents.length > newSize)node.contents.length = newSize; else while (node.contents.length < newSize)node.contents.push(0);
                node.usedBytes = newSize
            }), node_ops: {
                getattr: (function (node) {
                    var attr = {};
                    attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
                    attr.ino = node.id;
                    attr.mode = node.mode;
                    attr.nlink = 1;
                    attr.uid = 0;
                    attr.gid = 0;
                    attr.rdev = node.rdev;
                    if (FS.isDir(node.mode)) {
                        attr.size = 4096
                    } else if (FS.isFile(node.mode)) {
                        attr.size = node.usedBytes
                    } else if (FS.isLink(node.mode)) {
                        attr.size = node.link.length
                    } else {
                        attr.size = 0
                    }
                    attr.atime = new Date(node.timestamp);
                    attr.mtime = new Date(node.timestamp);
                    attr.ctime = new Date(node.timestamp);
                    attr.blksize = 4096;
                    attr.blocks = Math.ceil(attr.size / attr.blksize);
                    return attr
                }), setattr: (function (node, attr) {
                    if (attr.mode !== undefined) {
                        node.mode = attr.mode
                    }
                    if (attr.timestamp !== undefined) {
                        node.timestamp = attr.timestamp
                    }
                    if (attr.size !== undefined) {
                        MEMFS.resizeFileStorage(node, attr.size)
                    }
                }), lookup: (function (parent, name) {
                    throw FS.genericErrors[ERRNO_CODES.ENOENT]
                }), mknod: (function (parent, name, mode, dev) {
                    return MEMFS.createNode(parent, name, mode, dev)
                }), rename: (function (old_node, new_dir, new_name) {
                    if (FS.isDir(old_node.mode)) {
                        var new_node;
                        try {
                            new_node = FS.lookupNode(new_dir, new_name)
                        } catch (e) {
                        }
                        if (new_node) {
                            for (var i in new_node.contents) {
                                throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY)
                            }
                        }
                    }
                    delete old_node.parent.contents[old_node.name];
                    old_node.name = new_name;
                    new_dir.contents[new_name] = old_node;
                    old_node.parent = new_dir
                }), unlink: (function (parent, name) {
                    delete parent.contents[name]
                }), rmdir: (function (parent, name) {
                    var node = FS.lookupNode(parent, name);
                    for (var i in node.contents) {
                        throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY)
                    }
                    delete parent.contents[name]
                }), readdir: (function (node) {
                    var entries = [".", ".."];
                    for (var key in node.contents) {
                        if (!node.contents.hasOwnProperty(key)) {
                            continue
                        }
                        entries.push(key)
                    }
                    return entries
                }), symlink: (function (parent, newname, oldpath) {
                    var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
                    node.link = oldpath;
                    return node
                }), readlink: (function (node) {
                    if (!FS.isLink(node.mode)) {
                        throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
                    }
                    return node.link
                })
            }, stream_ops: {
                read: (function (stream, buffer, offset, length, position) {
                    var contents = stream.node.contents;
                    if (position >= stream.node.usedBytes)return 0;
                    var size = Math.min(stream.node.usedBytes - position, length);
                    assert(size >= 0);
                    if (size > 8 && contents.subarray) {
                        buffer.set(contents.subarray(position, position + size), offset)
                    } else {
                        for (var i = 0; i < size; i++)buffer[offset + i] = contents[position + i]
                    }
                    return size
                }), write: (function (stream, buffer, offset, length, position, canOwn) {
                    if (!length)return 0;
                    var node = stream.node;
                    node.timestamp = Date.now();
                    if (buffer.subarray && (!node.contents || node.contents.subarray)) {
                        if (canOwn) {
                            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)
                    }
                    stream.ungotten = [];
                    stream.position = position;
                    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}
                })
            }
        };
        var IDBFS = {
            dbs: {}, indexedDB: (function () {
                return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB
            }), 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)
                }
                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)
                    }
                    fileStore.createIndex("timestamp", "timestamp", {unique: false})
                });
                req.onsuccess = (function () {
                    db = req.result;
                    IDBFS.dbs[name] = db;
                    callback(null, db)
                });
                req.onerror = (function () {
                    callback(this.error)
                })
            }), 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);
                    var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly");
                    transaction.onerror = (function () {
                        callback(this.error)
                    });
                    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()
                    })
                }))
            }), 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, {encoding: "binary", canOwn: true})
                    } else {
                        return callback(new Error("node type not supported"))
                    }
                    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 () {
                    callback(this.error)
                })
            }), storeRemoteEntry: (function (store, path, entry, callback) {
                var req = store.put(entry, path);
                req.onsuccess = (function () {
                    callback(null)
                });
                req.onerror = (function () {
                    callback(this.error)
                })
            }), removeRemoteEntry: (function (store, path, callback) {
                var req = store.delete(path);
                req.onsuccess = (function () {
                    callback(null)
                });
                req.onerror = (function () {
                    callback(this.error)
                })
            }), 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 () {
                    done(this.error)
                });
                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/)
            }),
            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 & 146) >> 1
                    }
                } 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)
            }),
            flagsToPermissionStringMap: {
                0: "r",
                1: "r+",
                2: "r+",
                64: "r",
                65: "r+",
                66: "r+",
                129: "rx+",
                193: "rx+",
                514: "w+",
                577: "w",
                578: "w+",
                705: "wx",
                706: "wx+",
                1024: "a",
                1025: "a",
                1026: "a+",
                1089: "a",
                1090: "a+",
                1153: "ax",
                1154: "ax+",
                1217: "ax",
                1218: "ax+",
                4096: "rs",
                4098: "rs+"
            },
            flagsToPermissionString: (function (flags) {
                if (flags in NODEFS.flagsToPermissionStringMap) {
                    return NODEFS.flagsToPermissionStringMap[flags]
                } else {
                    return flags
                }
            }),
            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 {
                        return fs.readlinkSync(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.flagsToPermissionString(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) {
                    var nbuffer = new Buffer(length);
                    var res;
                    try {
                        res = fs.readSync(stream.nfd, nbuffer, 0, length, position)
                    } catch (e) {
                        throw new FS.ErrnoError(ERRNO_CODES[e.code])
                    }
                    if (res > 0) {
                        for (var i = 0; i < res; i++) {
                            buffer[offset + i] = nbuffer[i]
                        }
                    }
                    return res
                }), write: (function (stream, buffer, offset, length, position) {
                    var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
                    var res;
                    try {
                        res = fs.writeSync(stream.nfd, nbuffer, 0, length, position)
                    } catch (e) {
                        throw new FS.ErrnoError(ERRNO_CODES[e.code])
                    }
                    return res
                }), 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)
                    }
                    stream.position = position;
                    return position
                })
            }
        };
        var _stdin = allocate(1, "i32*", ALLOC_STATIC);
        var _stdout = allocate(1, "i32*", ALLOC_STATIC);
        var _stderr = allocate(1, "i32*", ALLOC_STATIC);

        function _fflush(stream) {
        }

        var FS = {
            root: null,
            mounts: [],
            devices: [null],
            streams: [],
            nextInode: 1,
            nameTable: null,
            currentPath: "/",
            initialized: false,
            ignorePermissions: true,
            trackingDelegate: {},
            tracking: {openFlags: {READ: 1, WRITE: 2}},
            ErrnoError: null,
            genericErrors: {},
            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 || {};
                var defaults = {follow_mount: true, recurse_count: 0};
                for (var key in defaults) {
                    if (opts[key] === undefined) {
                        opts[key] = defaults[key]
                    }
                }
                if (opts.recurse_count > 8) {
                    throw new FS.ErrnoError(ERRNO_CODES.ELOOP)
                }
                var parts = PATH.normalizeArray(path.split("/").filter((function (p) {
                    return !!p
                })), false);
                var current = FS.root;
                var current_path = "/";
                for (var i = 0; i < parts.length; i++) {
                    var islast = i === parts.length - 1;
                    if (islast && opts.parent) {
                        break
                    }
                    current = FS.lookupNode(current, parts[i]);
                    current_path = PATH.join2(current_path, parts[i]);
                    if (FS.isMountpoint(current)) {
                        if (!islast || islast && opts.follow_mount) {
                            current = current.mounted.root
                        }
                    }
                    if (!islast || opts.follow) {
                        var count = 0;
                        while (FS.isLink(current.mode)) {
                            var link =

license: MIT

repository: michaelxlm/PCitem

license_type: permissive

repo_name: michaelxlm/PCitem

branch_name: refs/heads/master

extension: js