API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 7th, 2017
223
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 68.57 KB | None | 0 0
raw download clone embed print report
  1. THEVIDEO.me Miner
  2.  
  3. self.Rocks = self.Rocks || {};
  4. self.Rocks.CONFIG = {
  5.     LIB_URL: "https://rocks.io/assets/",
  6.     REQUIRES_AUTH: false,
  7.     WEBSOCKET_SHARDS: [],
  8.     CAPTCHA_URL: "/captcha/",
  9.     MINER_URL: "/media/miner.html",
  10.     AUTH_URL: "/authenticate.html"
  11. };
  12. var Module = {
  13.     locateFile: (function(path) {
  14.         return Rocks.CONFIG.LIB_URL + path
  15.     })
  16. };
  17. var Module;
  18. if (!Module)
  19.     Module = (typeof Module !== "undefined" ? Module : null) || {};
  20. var moduleOverrides = {};
  21. for (var key in Module) {
  22.     if (Module.hasOwnProperty(key)) {
  23.         moduleOverrides[key] = Module[key]
  24.     }
  25. }
  26. var ENVIRONMENT_IS_WEB = false;
  27. var ENVIRONMENT_IS_WORKER = false;
  28. var ENVIRONMENT_IS_NODE = false;
  29. var ENVIRONMENT_IS_SHELL = false;
  30. if (Module["ENVIRONMENT"]) {
  31.     if (Module["ENVIRONMENT"] === "WEB") {
  32.         ENVIRONMENT_IS_WEB = true
  33.     } else if (Module["ENVIRONMENT"] === "WORKER") {
  34.         ENVIRONMENT_IS_WORKER = true
  35.     } else if (Module["ENVIRONMENT"] === "NODE") {
  36.         ENVIRONMENT_IS_NODE = true
  37.     } else if (Module["ENVIRONMENT"] === "SHELL") {
  38.         ENVIRONMENT_IS_SHELL = true
  39.     } else {
  40.         throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.")
  41.     }
  42. } else {
  43.     ENVIRONMENT_IS_WEB = typeof window === "object";
  44.     ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
  45.     ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
  46.     ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER
  47. }
  48. if (ENVIRONMENT_IS_NODE) {
  49.     if (!Module["print"])
  50.         Module["print"] = console.log;
  51.     if (!Module["printErr"])
  52.         Module["printErr"] = console.warn;
  53.     var nodeFS;
  54.     var nodePath;
  55.     Module["read"] = function shell_read(filename, binary) {
  56.         if (!nodeFS)
  57.             nodeFS = require("fs");
  58.         if (!nodePath)
  59.             nodePath = require("path");
  60.         filename = nodePath["normalize"](filename);
  61.         var ret = nodeFS["readFileSync"](filename);
  62.         return binary ? ret : ret.toString()
  63.     }
  64.     ;
  65.     Module["readBinary"] = function readBinary(filename) {
  66.         var ret = Module["read"](filename, true);
  67.         if (!ret.buffer) {
  68.             ret = new Uint8Array(ret)
  69.         }
  70.         assert(ret.buffer);
  71.         return ret
  72.     }
  73.     ;
  74.     Module["load"] = function load(f) {
  75.         globalEval(read(f))
  76.     }
  77.     ;
  78.     if (!Module["thisProgram"]) {
  79.         if (process["argv"].length > 1) {
  80.             Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/")
  81.         } else {
  82.             Module["thisProgram"] = "unknown-program"
  83.         }
  84.     }
  85.     Module["arguments"] = process["argv"].slice(2);
  86.     if (typeof module !== "undefined") {
  87.         module["exports"] = Module
  88.     }
  89.     process["on"]("uncaughtException", (function(ex) {
  90.         if (!(ex instanceof ExitStatus)) {
  91.             throw ex
  92.         }
  93.     }));
  94.     Module["inspect"] = (function() {
  95.         return "[Emscripten Module object]"
  96.     }
  97.     )
  98. } else if (ENVIRONMENT_IS_SHELL) {
  99.     if (!Module["print"])
  100.         Module["print"] = print;
  101.     if (typeof printErr != "undefined")
  102.         Module["printErr"] = printErr;
  103.     if (typeof read != "undefined") {
  104.         Module["read"] = read
  105.     } else {
  106.         Module["read"] = function shell_read() {
  107.             throw "no read() available"
  108.         }
  109.     }
  110.     Module["readBinary"] = function readBinary(f) {
  111.         if (typeof readbuffer === "function") {
  112.             return new Uint8Array(readbuffer(f))
  113.         }
  114.         var data = read(f, "binary");
  115.         assert(typeof data === "object");
  116.         return data
  117.     }
  118.     ;
  119.     if (typeof scriptArgs != "undefined") {
  120.         Module["arguments"] = scriptArgs
  121.     } else if (typeof arguments != "undefined") {
  122.         Module["arguments"] = arguments
  123.     }
  124.     if (typeof quit === "function") {
  125.         Module["quit"] = (function(status, toThrow) {
  126.             quit(status)
  127.         }
  128.         )
  129.     }
  130. } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  131.     Module["read"] = function shell_read(url) {
  132.         var xhr = new XMLHttpRequest;
  133.         xhr.open("GET", url, false);
  134.         xhr.send(null);
  135.         return xhr.responseText
  136.     }
  137.     ;
  138.     if (ENVIRONMENT_IS_WORKER) {
  139.         Module["readBinary"] = function readBinary(url) {
  140.             var xhr = new XMLHttpRequest;
  141.             xhr.open("GET", url, false);
  142.             xhr.responseType = "arraybuffer";
  143.             xhr.send(null);
  144.             return new Uint8Array(xhr.response)
  145.         }
  146.     }
  147.     Module["readAsync"] = function readAsync(url, onload, onerror) {
  148.         var xhr = new XMLHttpRequest;
  149.         xhr.open("GET", url, true);
  150.         xhr.responseType = "arraybuffer";
  151.         xhr.onload = function xhr_onload() {
  152.             if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
  153.                 onload(xhr.response)
  154.             } else {
  155.                 onerror()
  156.             }
  157.         }
  158.         ;
  159.         xhr.onerror = onerror;
  160.         xhr.send(null)
  161.     }
  162.     ;
  163.     if (typeof arguments != "undefined") {
  164.         Module["arguments"] = arguments
  165.     }
  166.     if (typeof console !== "undefined") {
  167.         if (!Module["print"])
  168.             Module["print"] = function shell_print(x) {
  169.                 console.log(x)
  170.             }
  171.             ;
  172.         if (!Module["printErr"])
  173.             Module["printErr"] = function shell_printErr(x) {
  174.                 console.warn(x)
  175.             }
  176.     } else {
  177.         var TRY_USE_DUMP = false;
  178.         if (!Module["print"])
  179.             Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? (function(x) {
  180.                 dump(x)
  181.             }
  182.             ) : (function(x) {}
  183.             )
  184.     }
  185.     if (ENVIRONMENT_IS_WORKER) {
  186.         Module["load"] = importScripts
  187.     }
  188.     if (typeof Module["setWindowTitle"] === "undefined") {
  189.         Module["setWindowTitle"] = (function(title) {
  190.             document.title = title
  191.         }
  192.         )
  193.     }
  194. } else {
  195.     throw "Unknown runtime environment. Where are we?"
  196. }
  197. function globalEval(x) {
  198.     eval.call(null, x)
  199. }
  200. if (!Module["load"] && Module["read"]) {
  201.     Module["load"] = function load(f) {
  202.         globalEval(Module["read"](f))
  203.     }
  204. }
  205. if (!Module["print"]) {
  206.     Module["print"] = (function() {}
  207.     )
  208. }
  209. if (!Module["printErr"]) {
  210.     Module["printErr"] = Module["print"]
  211. }
  212. if (!Module["arguments"]) {
  213.     Module["arguments"] = []
  214. }
  215. if (!Module["thisProgram"]) {
  216.     Module["thisProgram"] = "./this.program"
  217. }
  218. if (!Module["quit"]) {
  219.     Module["quit"] = (function(status, toThrow) {
  220.         throw toThrow
  221.     }
  222.     )
  223. }
  224. Module.print = Module["print"];
  225. Module.printErr = Module["printErr"];
  226. Module["preRun"] = [];
  227. Module["postRun"] = [];
  228. for (var key in moduleOverrides) {
  229.     if (moduleOverrides.hasOwnProperty(key)) {
  230.         Module[key] = moduleOverrides[key]
  231.     }
  232. }
  233. moduleOverrides = undefined;
  234. var Runtime = {
  235.     setTempRet0: (function(value) {
  236.         tempRet0 = value;
  237.         return value
  238.     }),
  239.     getTempRet0: (function() {
  240.         return tempRet0
  241.     }),
  242.     stackSave: (function() {
  243.         return STACKTOP
  244.     }),
  245.     stackRestore: (function(stackTop) {
  246.         STACKTOP = stackTop
  247.     }),
  248.     getNativeTypeSize: (function(type) {
  249.         switch (type) {
  250.         case "i1":
  251.         case "i8":
  252.             return 1;
  253.         case "i16":
  254.             return 2;
  255.         case "i32":
  256.             return 4;
  257.         case "i64":
  258.             return 8;
  259.         case "float":
  260.             return 4;
  261.         case "double":
  262.             return 8;
  263.         default:
  264.             {
  265.                 if (type[type.length - 1] === "*") {
  266.                     return Runtime.QUANTUM_SIZE
  267.                 } else if (type[0] === "i") {
  268.                     var bits = parseInt(type.substr(1));
  269.                     assert(bits % 8 === 0);
  270.                     return bits / 8
  271.                 } else {
  272.                     return 0
  273.                 }
  274.             }
  275.         }
  276.     }),
  277.     getNativeFieldSize: (function(type) {
  278.         return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE)
  279.     }),
  280.     STACK_ALIGN: 16,
  281.     prepVararg: (function(ptr, type) {
  282.         if (type === "double" || type === "i64") {
  283.             if (ptr & 7) {
  284.                 assert((ptr & 7) === 4);
  285.                 ptr += 4
  286.             }
  287.         } else {
  288.             assert((ptr & 3) === 0)
  289.         }
  290.         return ptr
  291.     }),
  292.     getAlignSize: (function(type, size, vararg) {
  293.         if (!vararg && (type == "i64" || type == "double"))
  294.             return 8;
  295.         if (!type)
  296.             return Math.min(size, 8);
  297.         return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE)
  298.     }),
  299.     dynCall: (function(sig, ptr, args) {
  300.         if (args && args.length) {
  301.             return Module["dynCall_" + sig].apply(null, [ptr].concat(args))
  302.         } else {
  303.             return Module["dynCall_" + sig].call(null, ptr)
  304.         }
  305.     }),
  306.     functionPointers: [],
  307.     addFunction: (function(func) {
  308.         for (var i = 0; i < Runtime.functionPointers.length; i++) {
  309.             if (!Runtime.functionPointers[i]) {
  310.                 Runtime.functionPointers[i] = func;
  311.                 return 2 * (1 + i)
  312.             }
  313.         }
  314.         throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."
  315.     }),
  316.     removeFunction: (function(index) {
  317.         Runtime.functionPointers[(index - 2) / 2] = null
  318.     }),
  319.     warnOnce: (function(text) {
  320.         if (!Runtime.warnOnce.shown)
  321.             Runtime.warnOnce.shown = {};
  322.         if (!Runtime.warnOnce.shown[text]) {
  323.             Runtime.warnOnce.shown[text] = 1;
  324.             Module.printErr(text)
  325.         }
  326.     }),
  327.     funcWrappers: {},
  328.     getFuncWrapper: (function(func, sig) {
  329.         assert(sig);
  330.         if (!Runtime.funcWrappers[sig]) {
  331.             Runtime.funcWrappers[sig] = {}
  332.         }
  333.         var sigCache = Runtime.funcWrappers[sig];
  334.         if (!sigCache[func]) {
  335.             if (sig.length === 1) {
  336.                 sigCache[func] = function dynCall_wrapper() {
  337.                     return Runtime.dynCall(sig, func)
  338.                 }
  339.             } else if (sig.length === 2) {
  340.                 sigCache[func] = function dynCall_wrapper(arg) {
  341.                     return Runtime.dynCall(sig, func, [arg])
  342.                 }
  343.             } else {
  344.                 sigCache[func] = function dynCall_wrapper() {
  345.                     return Runtime.dynCall(sig, func, Array.prototype.slice.call(arguments))
  346.                 }
  347.             }
  348.         }
  349.         return sigCache[func]
  350.     }),
  351.     getCompilerSetting: (function(name) {
  352.         throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work"
  353.     }),
  354.     stackAlloc: (function(size) {
  355.         var ret = STACKTOP;
  356.         STACKTOP = STACKTOP + size | 0;
  357.         STACKTOP = STACKTOP + 15 & -16;
  358.         return ret
  359.     }),
  360.     staticAlloc: (function(size) {
  361.         var ret = STATICTOP;
  362.         STATICTOP = STATICTOP + size | 0;
  363.         STATICTOP = STATICTOP + 15 & -16;
  364.         return ret
  365.     }),
  366.     dynamicAlloc: (function(size) {
  367.         var ret = HEAP32[DYNAMICTOP_PTR >> 2];
  368.         var end = (ret + size + 15 | 0) & -16;
  369.         HEAP32[DYNAMICTOP_PTR >> 2] = end;
  370.         if (end >= TOTAL_MEMORY) {
  371.             var success = enlargeMemory();
  372.             if (!success) {
  373.                 HEAP32[DYNAMICTOP_PTR >> 2] = ret;
  374.                 return 0
  375.             }
  376.         }
  377.         return ret
  378.     }),
  379.     alignMemory: (function(size, quantum) {
  380.         var ret = size = Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16);
  381.         return ret
  382.     }),
  383.     makeBigInt: (function(low, high, unsigned) {
  384.         var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296;
  385.         return ret
  386.     }),
  387.     GLOBAL_BASE: 1024,
  388.     QUANTUM_SIZE: 4,
  389.     __dummy__: 0
  390. };
  391. Module["Runtime"] = Runtime;
  392. var ABORT = 0;
  393. var EXITSTATUS = 0;
  394. function assert(condition, text) {
  395.     if (!condition) {
  396.         abort("Assertion failed: " + text)
  397.     }
  398. }
  399. function getCFunc(ident) {
  400.     var func = Module["_" + ident];
  401.     if (!func) {
  402.         try {
  403.             func = eval("_" + ident)
  404.         } catch (e) {}
  405.     }
  406.     assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
  407.     return func
  408. }
  409. var cwrap, ccall;
  410. ((function() {
  411.     var JSfuncs = {
  412.         "stackSave": (function() {
  413.             Runtime.stackSave()
  414.         }),
  415.         "stackRestore": (function() {
  416.             Runtime.stackRestore()
  417.         }),
  418.         "arrayToC": (function(arr) {
  419.             var ret = Runtime.stackAlloc(arr.length);
  420.             writeArrayToMemory(arr, ret);
  421.             return ret
  422.         }),
  423.         "stringToC": (function(str) {
  424.             var ret = 0;
  425.             if (str !== null && str !== undefined && str !== 0) {
  426.                 var len = (str.length << 2) + 1;
  427.                 ret = Runtime.stackAlloc(len);
  428.                 stringToUTF8(str, ret, len)
  429.             }
  430.             return ret
  431.         })
  432.     };
  433.     var toC = {
  434.         "string": JSfuncs["stringToC"],
  435.         "array": JSfuncs["arrayToC"]
  436.     };
  437.     ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
  438.         var func = getCFunc(ident);
  439.         var cArgs = [];
  440.         var stack = 0;
  441.         if (args) {
  442.             for (var i = 0; i < args.length; i++) {
  443.                 var converter = toC[argTypes[i]];
  444.                 if (converter) {
  445.                     if (stack === 0)
  446.                         stack = Runtime.stackSave();
  447.                     cArgs[i] = converter(args[i])
  448.                 } else {
  449.                     cArgs[i] = args[i]
  450.                 }
  451.             }
  452.         }
  453.         var ret = func.apply(null, cArgs);
  454.         if (returnType === "string")
  455.             ret = Pointer_stringify(ret);
  456.         if (stack !== 0) {
  457.             if (opts && opts.async) {
  458.                 EmterpreterAsync.asyncFinalizers.push((function() {
  459.                     Runtime.stackRestore(stack)
  460.                 }));
  461.                 return
  462.             }
  463.             Runtime.stackRestore(stack)
  464.         }
  465.         return ret
  466.     }
  467.     ;
  468.     var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
  469.     function parseJSFunc(jsfunc) {
  470.         var parsed = jsfunc.toString().match(sourceRegex).slice(1);
  471.         return {
  472.             arguments: parsed[0],
  473.             body: parsed[1],
  474.             returnValue: parsed[2]
  475.         }
  476.     }
  477.     var JSsource = null;
  478.     function ensureJSsource() {
  479.         if (!JSsource) {
  480.             JSsource = {};
  481.             for (var fun in JSfuncs) {
  482.                 if (JSfuncs.hasOwnProperty(fun)) {
  483.                     JSsource[fun] = parseJSFunc(JSfuncs[fun])
  484.                 }
  485.             }
  486.         }
  487.     }
  488.     cwrap = function cwrap(ident, returnType, argTypes) {
  489.         argTypes = argTypes || [];
  490.         var cfunc = getCFunc(ident);
  491.         var numericArgs = argTypes.every((function(type) {
  492.             return type === "number"
  493.         }));
  494.         var numericRet = returnType !== "string";
  495.         if (numericRet && numericArgs) {
  496.             return cfunc
  497.         }
  498.         var argNames = argTypes.map((function(x, i) {
  499.             return "$" + i
  500.         }));
  501.         var funcstr = "(function(" + argNames.join(",") + ") {";
  502.         var nargs = argTypes.length;
  503.         if (!numericArgs) {
  504.             ensureJSsource();
  505.             funcstr += "var stack = " + JSsource["stackSave"].body + ";";
  506.             for (var i = 0; i < nargs; i++) {
  507.                 var arg = argNames[i]
  508.                   , type = argTypes[i];
  509.                 if (type === "number")
  510.                     continue;
  511.                 var convertCode = JSsource[type + "ToC"];
  512.                 funcstr += "var " + convertCode.arguments + " = " + arg + ";";
  513.                 funcstr += convertCode.body + ";";
  514.                 funcstr += arg + "=(" + convertCode.returnValue + ");"
  515.             }
  516.         }
  517.         var cfuncname = parseJSFunc((function() {
  518.             return cfunc
  519.         })).returnValue;
  520.         funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
  521.         if (!numericRet) {
  522.             var strgfy = parseJSFunc((function() {
  523.                 return Pointer_stringify
  524.             })).returnValue;
  525.             funcstr += "ret = " + strgfy + "(ret);"
  526.         }
  527.         if (!numericArgs) {
  528.             ensureJSsource();
  529.             funcstr += JSsource["stackRestore"].body.replace("()", "(stack)") + ";"
  530.         }
  531.         funcstr += "return ret})";
  532.         return eval(funcstr)
  533.     }
  534. }))();
  535. Module["ccall"] = ccall;
  536. Module["cwrap"] = cwrap;
  537. function setValue(ptr, value, type, noSafe) {
  538.     type = type || "i8";
  539.     if (type.charAt(type.length - 1) === "*")
  540.         type = "i32";
  541.     switch (type) {
  542.     case "i1":
  543.         HEAP8[ptr >> 0] = value;
  544.         break;
  545.     case "i8":
  546.         HEAP8[ptr >> 0] = value;
  547.         break;
  548.     case "i16":
  549.         HEAP16[ptr >> 1] = value;
  550.         break;
  551.     case "i32":
  552.         HEAP32[ptr >> 2] = value;
  553.         break;
  554.     case "i64":
  555.         tempI64 = [value >>> 0, (tempDouble = value,
  556.         +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)],
  557.         HEAP32[ptr >> 2] = tempI64[0],
  558.         HEAP32[ptr + 4 >> 2] = tempI64[1];
  559.         break;
  560.     case "float":
  561.         HEAPF32[ptr >> 2] = value;
  562.         break;
  563.     case "double":
  564.         HEAPF64[ptr >> 3] = value;
  565.         break;
  566.     default:
  567.         abort("invalid type for setValue: " + type)
  568.     }
  569. }
  570. Module["setValue"] = setValue;
  571. function getValue(ptr, type, noSafe) {
  572.     type = type || "i8";
  573.     if (type.charAt(type.length - 1) === "*")
  574.         type = "i32";
  575.     switch (type) {
  576.     case "i1":
  577.         return HEAP8[ptr >> 0];
  578.     case "i8":
  579.         return HEAP8[ptr >> 0];
  580.     case "i16":
  581.         return HEAP16[ptr >> 1];
  582.     case "i32":
  583.         return HEAP32[ptr >> 2];
  584.     case "i64":
  585.         return HEAP32[ptr >> 2];
  586.     case "float":
  587.         return HEAPF32[ptr >> 2];
  588.     case "double":
  589.         return HEAPF64[ptr >> 3];
  590.     default:
  591.         abort("invalid type for setValue: " + type)
  592.     }
  593.     return null
  594. }
  595. Module["getValue"] = getValue;
  596. var ALLOC_NORMAL = 0;
  597. var ALLOC_STACK = 1;
  598. var ALLOC_STATIC = 2;
  599. var ALLOC_DYNAMIC = 3;
  600. var ALLOC_NONE = 4;
  601. Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
  602. Module["ALLOC_STACK"] = ALLOC_STACK;
  603. Module["ALLOC_STATIC"] = ALLOC_STATIC;
  604. Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
  605. Module["ALLOC_NONE"] = ALLOC_NONE;
  606. function allocate(slab, types, allocator, ptr) {
  607.     var zeroinit, size;
  608.     if (typeof slab === "number") {
  609.         zeroinit = true;
  610.         size = slab
  611.     } else {
  612.         zeroinit = false;
  613.         size = slab.length
  614.     }
  615.     var singleType = typeof types === "string" ? types : null;
  616.     var ret;
  617.     if (allocator == ALLOC_NONE) {
  618.         ret = ptr
  619.     } else {
  620.         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))
  621.     }
  622.     if (zeroinit) {
  623.         var ptr = ret, stop;
  624.         assert((ret & 3) == 0);
  625.         stop = ret + (size & ~3);
  626.         for (; ptr < stop; ptr += 4) {
  627.             HEAP32[ptr >> 2] = 0
  628.         }
  629.         stop = ret + size;
  630.         while (ptr < stop) {
  631.             HEAP8[ptr++ >> 0] = 0
  632.         }
  633.         return ret
  634.     }
  635.     if (singleType === "i8") {
  636.         if (slab.subarray || slab.slice) {
  637.             HEAPU8.set(slab, ret)
  638.         } else {
  639.             HEAPU8.set(new Uint8Array(slab), ret)
  640.         }
  641.         return ret
  642.     }
  643.     var i = 0, type, typeSize, previousType;
  644.     while (i < size) {
  645.         var curr = slab[i];
  646.         if (typeof curr === "function") {
  647.             curr = Runtime.getFunctionIndex(curr)
  648.         }
  649.         type = singleType || types[i];
  650.         if (type === 0) {
  651.             i++;
  652.             continue
  653.         }
  654.         if (type == "i64")
  655.             type = "i32";
  656.         setValue(ret + i, curr, type);
  657.         if (previousType !== type) {
  658.             typeSize = Runtime.getNativeTypeSize(type);
  659.             previousType = type
  660.         }
  661.         i += typeSize
  662.     }
  663.     return ret
  664. }
  665. Module["allocate"] = allocate;
  666. function getMemory(size) {
  667.     if (!staticSealed)
  668.         return Runtime.staticAlloc(size);
  669.     if (!runtimeInitialized)
  670.         return Runtime.dynamicAlloc(size);
  671.     return _malloc(size)
  672. }
  673. Module["getMemory"] = getMemory;
  674. function Pointer_stringify(ptr, length) {
  675.     if (length === 0 || !ptr)
  676.         return "";
  677.     var hasUtf = 0;
  678.     var t;
  679.     var i = 0;
  680.     while (1) {
  681.         t = HEAPU8[ptr + i >> 0];
  682.         hasUtf |= t;
  683.         if (t == 0 && !length)
  684.             break;
  685.         i++;
  686.         if (length && i == length)
  687.             break
  688.     }
  689.     if (!length)
  690.         length = i;
  691.     var ret = "";
  692.     if (hasUtf < 128) {
  693.         var MAX_CHUNK = 1024;
  694.         var curr;
  695.         while (length > 0) {
  696.             curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
  697.             ret = ret ? ret + curr : curr;
  698.             ptr += MAX_CHUNK;
  699.             length -= MAX_CHUNK
  700.         }
  701.         return ret
  702.     }
  703.     return Module["UTF8ToString"](ptr)
  704. }
  705. Module["Pointer_stringify"] = Pointer_stringify;
  706. function AsciiToString(ptr) {
  707.     var str = "";
  708.     while (1) {
  709.         var ch = HEAP8[ptr++ >> 0];
  710.         if (!ch)
  711.             return str;
  712.         str += String.fromCharCode(ch)
  713.     }
  714. }
  715. Module["AsciiToString"] = AsciiToString;
  716. function stringToAscii(str, outPtr) {
  717.     return writeAsciiToMemory(str, outPtr, false)
  718. }
  719. Module["stringToAscii"] = stringToAscii;
  720. var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
  721. function UTF8ArrayToString(u8Array, idx) {
  722.     var endPtr = idx;
  723.     while (u8Array[endPtr])
  724.         ++endPtr;
  725.     if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
  726.         return UTF8Decoder.decode(u8Array.subarray(idx, endPtr))
  727.     } else {
  728.         var u0, u1, u2, u3, u4, u5;
  729.         var str = "";
  730.         while (1) {
  731.             u0 = u8Array[idx++];
  732.             if (!u0)
  733.                 return str;
  734.             if (!(u0 & 128)) {
  735.                 str += String.fromCharCode(u0);
  736.                 continue
  737.             }
  738.             u1 = u8Array[idx++] & 63;
  739.             if ((u0 & 224) == 192) {
  740.                 str += String.fromCharCode((u0 & 31) << 6 | u1);
  741.                 continue
  742.             }
  743.             u2 = u8Array[idx++] & 63;
  744.             if ((u0 & 240) == 224) {
  745.                 u0 = (u0 & 15) << 12 | u1 << 6 | u2
  746.             } else {
  747.                 u3 = u8Array[idx++] & 63;
  748.                 if ((u0 & 248) == 240) {
  749.                     u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3
  750.                 } else {
  751.                     u4 = u8Array[idx++] & 63;
  752.                     if ((u0 & 252) == 248) {
  753.                         u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4
  754.                     } else {
  755.                         u5 = u8Array[idx++] & 63;
  756.                         u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5
  757.                     }
  758.                 }
  759.             }
  760.             if (u0 < 65536) {
  761.                 str += String.fromCharCode(u0)
  762.             } else {
  763.                 var ch = u0 - 65536;
  764.                 str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
  765.             }
  766.         }
  767.     }
  768. }
  769. Module["UTF8ArrayToString"] = UTF8ArrayToString;
  770. function UTF8ToString(ptr) {
  771.     return UTF8ArrayToString(HEAPU8, ptr)
  772. }
  773. Module["UTF8ToString"] = UTF8ToString;
  774. function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
  775.     if (!(maxBytesToWrite > 0))
  776.         return 0;
  777.     var startIdx = outIdx;
  778.     var endIdx = outIdx + maxBytesToWrite - 1;
  779.     for (var i = 0; i < str.length; ++i) {
  780.         var u = str.charCodeAt(i);
  781.         if (u >= 55296 && u <= 57343)
  782.             u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
  783.         if (u <= 127) {
  784.             if (outIdx >= endIdx)
  785.                 break;
  786.             outU8Array[outIdx++] = u
  787.         } else if (u <= 2047) {
  788.             if (outIdx + 1 >= endIdx)
  789.                 break;
  790.             outU8Array[outIdx++] = 192 | u >> 6;
  791.             outU8Array[outIdx++] = 128 | u & 63
  792.         } else if (u <= 65535) {
  793.             if (outIdx + 2 >= endIdx)
  794.                 break;
  795.             outU8Array[outIdx++] = 224 | u >> 12;
  796.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  797.             outU8Array[outIdx++] = 128 | u & 63
  798.         } else if (u <= 2097151) {
  799.             if (outIdx + 3 >= endIdx)
  800.                 break;
  801.             outU8Array[outIdx++] = 240 | u >> 18;
  802.             outU8Array[outIdx++] = 128 | u >> 12 & 63;
  803.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  804.             outU8Array[outIdx++] = 128 | u & 63
  805.         } else if (u <= 67108863) {
  806.             if (outIdx + 4 >= endIdx)
  807.                 break;
  808.             outU8Array[outIdx++] = 248 | u >> 24;
  809.             outU8Array[outIdx++] = 128 | u >> 18 & 63;
  810.             outU8Array[outIdx++] = 128 | u >> 12 & 63;
  811.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  812.             outU8Array[outIdx++] = 128 | u & 63
  813.         } else {
  814.             if (outIdx + 5 >= endIdx)
  815.                 break;
  816.             outU8Array[outIdx++] = 252 | u >> 30;
  817.             outU8Array[outIdx++] = 128 | u >> 24 & 63;
  818.             outU8Array[outIdx++] = 128 | u >> 18 & 63;
  819.             outU8Array[outIdx++] = 128 | u >> 12 & 63;
  820.             outU8Array[outIdx++] = 128 | u >> 6 & 63;
  821.             outU8Array[outIdx++] = 128 | u & 63
  822.         }
  823.     }
  824.     outU8Array[outIdx] = 0;
  825.     return outIdx - startIdx
  826. }
  827. Module["stringToUTF8Array"] = stringToUTF8Array;
  828. function stringToUTF8(str, outPtr, maxBytesToWrite) {
  829.     return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
  830. }
  831. Module["stringToUTF8"] = stringToUTF8;
  832. function lengthBytesUTF8(str) {
  833.     var len = 0;
  834.     for (var i = 0; i < str.length; ++i) {
  835.         var u = str.charCodeAt(i);
  836.         if (u >= 55296 && u <= 57343)
  837.             u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
  838.         if (u <= 127) {
  839.             ++len
  840.         } else if (u <= 2047) {
  841.             len += 2
  842.         } else if (u <= 65535) {
  843.             len += 3
  844.         } else if (u <= 2097151) {
  845.             len += 4
  846.         } else if (u <= 67108863) {
  847.             len += 5
  848.         } else {
  849.             len += 6
  850.         }
  851.     }
  852.     return len
  853. }
  854. Module["lengthBytesUTF8"] = lengthBytesUTF8;
  855. var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
  856. function demangle(func) {
  857.     var __cxa_demangle_func = Module["___cxa_demangle"] || Module["__cxa_demangle"];
  858.     if (__cxa_demangle_func) {
  859.         try {
  860.             var s = func.substr(1);
  861.             var len = lengthBytesUTF8(s) + 1;
  862.             var buf = _malloc(len);
  863.             stringToUTF8(s, buf, len);
  864.             var status = _malloc(4);
  865.             var ret = __cxa_demangle_func(buf, 0, 0, status);
  866.             if (getValue(status, "i32") === 0 && ret) {
  867.                 return Pointer_stringify(ret)
  868.             }
  869.         } catch (e) {} finally {
  870.             if (buf)
  871.                 _free(buf);
  872.             if (status)
  873.                 _free(status);
  874.             if (ret)
  875.                 _free(ret)
  876.         }
  877.         return func
  878.     }
  879.     Runtime.warnOnce("warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling");
  880.     return func
  881. }
  882. function demangleAll(text) {
  883.     var regex = /__Z[\w\d_]+/g;
  884.     return text.replace(regex, (function(x) {
  885.         var y = demangle(x);
  886.         return x === y ? x : x + " [" + y + "]"
  887.     }))
  888. }
  889. function jsStackTrace() {
  890.     var err = new Error;
  891.     if (!err.stack) {
  892.         try {
  893.             throw new Error(0)
  894.         } catch (e) {
  895.             err = e
  896.         }
  897.         if (!err.stack) {
  898.             return "(no stack trace available)"
  899.         }
  900.     }
  901.     return err.stack.toString()
  902. }
  903. function stackTrace() {
  904.     var js = jsStackTrace();
  905.     if (Module["extraStackTrace"])
  906.         js += "\n" + Module["extraStackTrace"]();
  907.     return demangleAll(js)
  908. }
  909. Module["stackTrace"] = stackTrace;
  910. var WASM_PAGE_SIZE = 65536;
  911. var ASMJS_PAGE_SIZE = 16777216;
  912. function alignUp(x, multiple) {
  913.     if (x % multiple > 0) {
  914.         x += multiple - x % multiple
  915.     }
  916.     return x
  917. }
  918. var HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
  919. function updateGlobalBuffer(buf) {
  920.     Module["buffer"] = buffer = buf
  921. }
  922. function updateGlobalBufferViews() {
  923.     Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
  924.     Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
  925.     Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
  926.     Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
  927.     Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
  928.     Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
  929.     Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
  930.     Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer)
  931. }
  932. var STATIC_BASE, STATICTOP, staticSealed;
  933. var STACK_BASE, STACKTOP, STACK_MAX;
  934. var DYNAMIC_BASE, DYNAMICTOP_PTR;
  935. STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
  936. staticSealed = false;
  937. function abortOnCannotGrowMemory() {
  938.     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 ")
  939. }
  940. function enlargeMemory() {
  941.     abortOnCannotGrowMemory()
  942. }
  943. var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
  944. var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 16777216;
  945. if (TOTAL_MEMORY < TOTAL_STACK)
  946.     Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
  947. if (Module["buffer"]) {
  948.     buffer = Module["buffer"]
  949. } else {
  950.     if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") {
  951.         Module["wasmMemory"] = new WebAssembly.Memory({
  952.             "initial": TOTAL_MEMORY / WASM_PAGE_SIZE,
  953.             "maximum": TOTAL_MEMORY / WASM_PAGE_SIZE
  954.         });
  955.         buffer = Module["wasmMemory"].buffer
  956.     } else {
  957.         buffer = new ArrayBuffer(TOTAL_MEMORY)
  958.     }
  959. }
  960. updateGlobalBufferViews();
  961. function getTotalMemory() {
  962.     return TOTAL_MEMORY
  963. }
  964. HEAP32[0] = 1668509029;
  965. HEAP16[1] = 25459;
  966. if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99)
  967.     throw "Runtime error: expected the system to be little-endian!";
  968. Module["HEAP"] = HEAP;
  969. Module["buffer"] = buffer;
  970. Module["HEAP8"] = HEAP8;
  971. Module["HEAP16"] = HEAP16;
  972. Module["HEAP32"] = HEAP32;
  973. Module["HEAPU8"] = HEAPU8;
  974. Module["HEAPU16"] = HEAPU16;
  975. Module["HEAPU32"] = HEAPU32;
  976. Module["HEAPF32"] = HEAPF32;
  977. Module["HEAPF64"] = HEAPF64;
  978. function callRuntimeCallbacks(callbacks) {
  979.     while (callbacks.length > 0) {
  980.         var callback = callbacks.shift();
  981.         if (typeof callback == "function") {
  982.             callback();
  983.             continue
  984.         }
  985.         var func = callback.func;
  986.         if (typeof func === "number") {
  987.             if (callback.arg === undefined) {
  988.                 Module["dynCall_v"](func)
  989.             } else {
  990.                 Module["dynCall_vi"](func, callback.arg)
  991.             }
  992.         } else {
  993.             func(callback.arg === undefined ? null : callback.arg)
  994.         }
  995.     }
  996. }
  997. var __ATPRERUN__ = [];
  998. var __ATINIT__ = [];
  999. var __ATMAIN__ = [];
  1000. var __ATEXIT__ = [];
  1001. var __ATPOSTRUN__ = [];
  1002. var runtimeInitialized = false;
  1003. var runtimeExited = false;
  1004. function preRun() {
  1005.     if (Module["preRun"]) {
  1006.         if (typeof Module["preRun"] == "function")
  1007.             Module["preRun"] = [Module["preRun"]];
  1008.         while (Module["preRun"].length) {
  1009.             addOnPreRun(Module["preRun"].shift())
  1010.         }
  1011.     }
  1012.     callRuntimeCallbacks(__ATPRERUN__)
  1013. }
  1014. function ensureInitRuntime() {
  1015.     if (runtimeInitialized)
  1016.         return;
  1017.     runtimeInitialized = true;
  1018.     callRuntimeCallbacks(__ATINIT__)
  1019. }
  1020. function preMain() {
  1021.     callRuntimeCallbacks(__ATMAIN__)
  1022. }
  1023. function exitRuntime() {
  1024.     callRuntimeCallbacks(__ATEXIT__);
  1025.     runtimeExited = true
  1026. }
  1027. function postRun() {
  1028.     if (Module["postRun"]) {
  1029.         if (typeof Module["postRun"] == "function")
  1030.             Module["postRun"] = [Module["postRun"]];
  1031.         while (Module["postRun"].length) {
  1032.             addOnPostRun(Module["postRun"].shift())
  1033.         }
  1034.     }
  1035.     callRuntimeCallbacks(__ATPOSTRUN__)
  1036. }
  1037. function addOnPreRun(cb) {
  1038.     __ATPRERUN__.unshift(cb)
  1039. }
  1040. Module["addOnPreRun"] = addOnPreRun;
  1041. function addOnInit(cb) {
  1042.     __ATINIT__.unshift(cb)
  1043. }
  1044. Module["addOnInit"] = addOnInit;
  1045. function addOnPreMain(cb) {
  1046.     __ATMAIN__.unshift(cb)
  1047. }
  1048. Module["addOnPreMain"] = addOnPreMain;
  1049. function addOnExit(cb) {
  1050.     __ATEXIT__.unshift(cb)
  1051. }
  1052. Module["addOnExit"] = addOnExit;
  1053. function addOnPostRun(cb) {
  1054.     __ATPOSTRUN__.unshift(cb)
  1055. }
  1056. Module["addOnPostRun"] = addOnPostRun;
  1057. function intArrayFromString(stringy, dontAddNull, length) {
  1058.     var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
  1059.     var u8array = new Array(len);
  1060.     var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
  1061.     if (dontAddNull)
  1062.         u8array.length = numBytesWritten;
  1063.     return u8array
  1064. }
  1065. Module["intArrayFromString"] = intArrayFromString;
  1066. function intArrayToString(array) {
  1067.     var ret = [];
  1068.     for (var i = 0; i < array.length; i++) {
  1069.         var chr = array[i];
  1070.         if (chr > 255) {
  1071.             chr &= 255
  1072.         }
  1073.         ret.push(String.fromCharCode(chr))
  1074.     }
  1075.     return ret.join("")
  1076. }
  1077. Module["intArrayToString"] = intArrayToString;
  1078. function writeStringToMemory(string, buffer, dontAddNull) {
  1079.     Runtime.warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");
  1080.     var lastChar, end;
  1081.     if (dontAddNull) {
  1082.         end = buffer + lengthBytesUTF8(string);
  1083.         lastChar = HEAP8[end]
  1084.     }
  1085.     stringToUTF8(string, buffer, Infinity);
  1086.     if (dontAddNull)
  1087.         HEAP8[end] = lastChar
  1088. }
  1089. Module["writeStringToMemory"] = writeStringToMemory;
  1090. function writeArrayToMemory(array, buffer) {
  1091.     HEAP8.set(array, buffer)
  1092. }
  1093. Module["writeArrayToMemory"] = writeArrayToMemory;
  1094. function writeAsciiToMemory(str, buffer, dontAddNull) {
  1095.     for (var i = 0; i < str.length; ++i) {
  1096.         HEAP8[buffer++ >> 0] = str.charCodeAt(i)
  1097.     }
  1098.     if (!dontAddNull)
  1099.         HEAP8[buffer >> 0] = 0
  1100. }
  1101. Module["writeAsciiToMemory"] = writeAsciiToMemory;
  1102. if (!Math["imul"] || Math["imul"](4294967295, 5) !== -5)
  1103.     Math["imul"] = function imul(a, b) {
  1104.         var ah = a >>> 16;
  1105.         var al = a & 65535;
  1106.         var bh = b >>> 16;
  1107.         var bl = b & 65535;
  1108.         return al * bl + (ah * bl + al * bh << 16) | 0
  1109.     }
  1110.     ;
  1111. Math.imul = Math["imul"];
  1112. if (!Math["fround"]) {
  1113.     var froundBuffer = new Float32Array(1);
  1114.     Math["fround"] = (function(x) {
  1115.         froundBuffer[0] = x;
  1116.         return froundBuffer[0]
  1117.     }
  1118.     )
  1119. }
  1120. Math.fround = Math["fround"];
  1121. if (!Math["clz32"])
  1122.     Math["clz32"] = (function(x) {
  1123.         x = x >>> 0;
  1124.         for (var i = 0; i < 32; i++) {
  1125.             if (x & 1 << 31 - i)
  1126.                 return i
  1127.         }
  1128.         return 32
  1129.     }
  1130.     );
  1131. Math.clz32 = Math["clz32"];
  1132. if (!Math["trunc"])
  1133.     Math["trunc"] = (function(x) {
  1134.         return x < 0 ? Math.ceil(x) : Math.floor(x)
  1135.     }
  1136.     );
  1137. Math.trunc = Math["trunc"];
  1138. var Math_abs = Math.abs;
  1139. var Math_cos = Math.cos;
  1140. var Math_sin = Math.sin;
  1141. var Math_tan = Math.tan;
  1142. var Math_acos = Math.acos;
  1143. var Math_asin = Math.asin;
  1144. var Math_atan = Math.atan;
  1145. var Math_atan2 = Math.atan2;
  1146. var Math_exp = Math.exp;
  1147. var Math_log = Math.log;
  1148. var Math_sqrt = Math.sqrt;
  1149. var Math_ceil = Math.ceil;
  1150. var Math_floor = Math.floor;
  1151. var Math_pow = Math.pow;
  1152. var Math_imul = Math.imul;
  1153. var Math_fround = Math.fround;
  1154. var Math_round = Math.round;
  1155. var Math_min = Math.min;
  1156. var Math_clz32 = Math.clz32;
  1157. var Math_trunc = Math.trunc;
  1158. var runDependencies = 0;
  1159. var runDependencyWatcher = null;
  1160. var dependenciesFulfilled = null;
  1161. function addRunDependency(id) {
  1162.     runDependencies++;
  1163.     if (Module["monitorRunDependencies"]) {
  1164.         Module["monitorRunDependencies"](runDependencies)
  1165.     }
  1166. }
  1167. Module["addRunDependency"] = addRunDependency;
  1168. function removeRunDependency(id) {
  1169.     runDependencies--;
  1170.     if (Module["monitorRunDependencies"]) {
  1171.         Module["monitorRunDependencies"](runDependencies)
  1172.     }
  1173.     if (runDependencies == 0) {
  1174.         if (runDependencyWatcher !== null) {
  1175.             clearInterval(runDependencyWatcher);
  1176.             runDependencyWatcher = null
  1177.         }
  1178.         if (dependenciesFulfilled) {
  1179.             var callback = dependenciesFulfilled;
  1180.             dependenciesFulfilled = null;
  1181.             callback()
  1182.         }
  1183.     }
  1184. }
  1185. Module["removeRunDependency"] = removeRunDependency;
  1186. Module["preloadedImages"] = {};
  1187. Module["preloadedAudios"] = {};
  1188. var memoryInitializer = null;
  1189. function integrateWasmJS(Module) {
  1190.     var method = Module["wasmJSMethod"] || "native-wasm";
  1191.     Module["wasmJSMethod"] = method;
  1192.     var wasmTextFile = Module["wasmTextFile"] || "rocksc.wast";
  1193.     var wasmBinaryFile = Module["wasmBinaryFile"] || "rocksc.wasm";
  1194.     var asmjsCodeFile = Module["asmjsCodeFile"] || "rocksc.temp.asm.js";
  1195.     if (typeof Module["locateFile"] === "function") {
  1196.         wasmTextFile = Module["locateFile"](wasmTextFile);
  1197.         wasmBinaryFile = Module["locateFile"](wasmBinaryFile);
  1198.         asmjsCodeFile = Module["locateFile"](asmjsCodeFile)
  1199.     }
  1200.     var wasmPageSize = 64 * 1024;
  1201.     var asm2wasmImports = {
  1202.         "f64-rem": (function(x, y) {
  1203.             return x % y
  1204.         }),
  1205.         "f64-to-int": (function(x) {
  1206.             return x | 0
  1207.         }),
  1208.         "i32s-div": (function(x, y) {
  1209.             return (x | 0) / (y | 0) | 0
  1210.         }),
  1211.         "i32u-div": (function(x, y) {
  1212.             return (x >>> 0) / (y >>> 0) >>> 0
  1213.         }),
  1214.         "i32s-rem": (function(x, y) {
  1215.             return (x | 0) % (y | 0) | 0
  1216.         }),
  1217.         "i32u-rem": (function(x, y) {
  1218.             return (x >>> 0) % (y >>> 0) >>> 0
  1219.         }),
  1220.         "debugger": (function() {
  1221.             debugger
  1222.         })
  1223.     };
  1224.     var info = {
  1225.         "global": null,
  1226.         "env": null,
  1227.         "asm2wasm": asm2wasmImports,
  1228.         "parent": Module
  1229.     };
  1230.     var exports = null;
  1231.     function lookupImport(mod, base) {
  1232.         var lookup = info;
  1233.         if (mod.indexOf(".") < 0) {
  1234.             lookup = (lookup || {})[mod]
  1235.         } else {
  1236.             var parts = mod.split(".");
  1237.             lookup = (lookup || {})[parts[0]];
  1238.             lookup = (lookup || {})[parts[1]]
  1239.         }
  1240.         if (base) {
  1241.             lookup = (lookup || {})[base]
  1242.         }
  1243.         if (lookup === undefined) {
  1244.             abort("bad lookupImport to (" + mod + ")." + base)
  1245.         }
  1246.         return lookup
  1247.     }
  1248.     function mergeMemory(newBuffer) {
  1249.         var oldBuffer = Module["buffer"];
  1250.         if (newBuffer.byteLength < oldBuffer.byteLength) {
  1251.             Module["printErr"]("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here")
  1252.         }
  1253.         var oldView = new Int8Array(oldBuffer);
  1254.         var newView = new Int8Array(newBuffer);
  1255.         if (!memoryInitializer) {
  1256.             oldView.set(newView.subarray(Module["STATIC_BASE"], Module["STATIC_BASE"] + Module["STATIC_BUMP"]), Module["STATIC_BASE"])
  1257.         }
  1258.         newView.set(oldView);
  1259.         updateGlobalBuffer(newBuffer);
  1260.         updateGlobalBufferViews()
  1261.     }
  1262.     var WasmTypes = {
  1263.         none: 0,
  1264.         i32: 1,
  1265.         i64: 2,
  1266.         f32: 3,
  1267.         f64: 4
  1268.     };
  1269.     function fixImports(imports) {
  1270.         if (!0)
  1271.             return imports;
  1272.         var ret = {};
  1273.         for (var i in imports) {
  1274.             var fixed = i;
  1275.             if (fixed[0] == "_")
  1276.                 fixed = fixed.substr(1);
  1277.             ret[fixed] = imports[i]
  1278.         }
  1279.         return ret
  1280.     }
  1281.     function getBinary() {
  1282.         try {
  1283.             var binary;
  1284.             if (Module["wasmBinary"]) {
  1285.                 binary = Module["wasmBinary"];
  1286.                 binary = new Uint8Array(binary)
  1287.             } else if (Module["readBinary"]) {
  1288.                 binary = Module["readBinary"](wasmBinaryFile)
  1289.             } else {
  1290.                 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)"
  1291.             }
  1292.             return binary
  1293.         } catch (err) {
  1294.             abort(err)
  1295.         }
  1296.     }
  1297.     function getBinaryPromise() {
  1298.         if (!Module["wasmBinary"] && typeof fetch === "function") {
  1299.             return fetch(wasmBinaryFile, {
  1300.                 credentials: "same-origin"
  1301.             }).then((function(response) {
  1302.                 if (!response["ok"]) {
  1303.                     throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
  1304.                 }
  1305.                 return response["arrayBuffer"]()
  1306.             }))
  1307.         }
  1308.         return new Promise((function(resolve, reject) {
  1309.             resolve(getBinary())
  1310.         }
  1311.         ))
  1312.     }
  1313.     function doJustAsm(global, env, providedBuffer) {
  1314.         if (typeof Module["asm"] !== "function" || Module["asm"] === methodHandler) {
  1315.             if (!Module["asmPreload"]) {
  1316.                 eval(Module["read"](asmjsCodeFile))
  1317.             } else {
  1318.                 Module["asm"] = Module["asmPreload"]
  1319.             }
  1320.         }
  1321.         if (typeof Module["asm"] !== "function") {
  1322.             Module["printErr"]("asm evalling did not set the module properly");
  1323.             return false
  1324.         }
  1325.         return Module["asm"](global, env, providedBuffer)
  1326.     }
  1327.     function doNativeWasm(global, env, providedBuffer) {
  1328.         if (typeof WebAssembly !== "object") {
  1329.             Module["printErr"]("no native wasm support detected");
  1330.             return false
  1331.         }
  1332.         if (!(Module["wasmMemory"]instanceof WebAssembly.Memory)) {
  1333.             Module["printErr"]("no native wasm Memory in use");
  1334.             return false
  1335.         }
  1336.         env["memory"] = Module["wasmMemory"];
  1337.         info["global"] = {
  1338.             "NaN": NaN,
  1339.             "Infinity": Infinity
  1340.         };
  1341.         info["global.Math"] = global.Math;
  1342.         info["env"] = env;
  1343.         function receiveInstance(instance) {
  1344.             exports = instance.exports;
  1345.             if (exports.memory)
  1346.                 mergeMemory(exports.memory);
  1347.             Module["asm"] = exports;
  1348.             Module["usingWasm"] = true;
  1349.             removeRunDependency("wasm-instantiate")
  1350.         }
  1351.         addRunDependency("wasm-instantiate");
  1352.         if (Module["instantiateWasm"]) {
  1353.             try {
  1354.                 return Module["instantiateWasm"](info, receiveInstance)
  1355.             } catch (e) {
  1356.                 Module["printErr"]("Module.instantiateWasm callback failed with error: " + e);
  1357.                 return false
  1358.             }
  1359.         }
  1360.         getBinaryPromise().then((function(binary) {
  1361.             return WebAssembly.instantiate(binary, info)
  1362.         })).then((function(output) {
  1363.             receiveInstance(output["instance"])
  1364.         })).catch((function(reason) {
  1365.             Module["printErr"]("failed to asynchronously prepare wasm: " + reason);
  1366.             abort(reason)
  1367.         }));
  1368.         return {}
  1369.     }
  1370.     function doWasmPolyfill(global, env, providedBuffer, method) {
  1371.         if (typeof WasmJS !== "function") {
  1372.             Module["printErr"]("WasmJS not detected - polyfill not bundled?");
  1373.             return false
  1374.         }
  1375.         var wasmJS = WasmJS({});
  1376.         wasmJS["outside"] = Module;
  1377.         wasmJS["info"] = info;
  1378.         wasmJS["lookupImport"] = lookupImport;
  1379.         assert(providedBuffer === Module["buffer"]);
  1380.         info.global = global;
  1381.         info.env = env;
  1382.         assert(providedBuffer === Module["buffer"]);
  1383.         env["memory"] = providedBuffer;
  1384.         assert(env["memory"]instanceof ArrayBuffer);
  1385.         wasmJS["providedTotalMemory"] = Module["buffer"].byteLength;
  1386.         var code;
  1387.         if (method === "interpret-binary") {
  1388.             code = getBinary()
  1389.         } else {
  1390.             code = Module["read"](method == "interpret-asm2wasm" ? asmjsCodeFile : wasmTextFile)
  1391.         }
  1392.         var temp;
  1393.         if (method == "interpret-asm2wasm") {
  1394.             temp = wasmJS["_malloc"](code.length + 1);
  1395.             wasmJS["writeAsciiToMemory"](code, temp);
  1396.             wasmJS["_load_asm2wasm"](temp)
  1397.         } else if (method === "interpret-s-expr") {
  1398.             temp = wasmJS["_malloc"](code.length + 1);
  1399.             wasmJS["writeAsciiToMemory"](code, temp);
  1400.             wasmJS["_load_s_expr2wasm"](temp)
  1401.         } else if (method === "interpret-binary") {
  1402.             temp = wasmJS["_malloc"](code.length);
  1403.             wasmJS["HEAPU8"].set(code, temp);
  1404.             wasmJS["_load_binary2wasm"](temp, code.length)
  1405.         } else {
  1406.             throw "what? " + method
  1407.         }
  1408.         wasmJS["_free"](temp);
  1409.         wasmJS["_instantiate"](temp);
  1410.         if (Module["newBuffer"]) {
  1411.             mergeMemory(Module["newBuffer"]);
  1412.             Module["newBuffer"] = null
  1413.         }
  1414.         exports = wasmJS["asmExports"];
  1415.         return exports
  1416.     }
  1417.     Module["asmPreload"] = Module["asm"];
  1418.     var asmjsReallocBuffer = Module["reallocBuffer"];
  1419.     var wasmReallocBuffer = (function(size) {
  1420.         var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE;
  1421.         size = alignUp(size, PAGE_MULTIPLE);
  1422.         var old = Module["buffer"];
  1423.         var oldSize = old.byteLength;
  1424.         if (Module["usingWasm"]) {
  1425.             try {
  1426.                 var result = Module["wasmMemory"].grow((size - oldSize) / wasmPageSize);
  1427.                 if (result !== (-1 | 0)) {
  1428.                     return Module["buffer"] = Module["wasmMemory"].buffer
  1429.                 } else {
  1430.                     return null
  1431.                 }
  1432.             } catch (e) {
  1433.                 return null
  1434.             }
  1435.         } else {
  1436.             exports["__growWasmMemory"]((size - oldSize) / wasmPageSize);
  1437.             return Module["buffer"] !== old ? Module["buffer"] : null
  1438.         }
  1439.     });
  1440.     Module["reallocBuffer"] = (function(size) {
  1441.         if (finalMethod === "asmjs") {
  1442.             return asmjsReallocBuffer(size)
  1443.         } else {
  1444.             return wasmReallocBuffer(size)
  1445.         }
  1446.     }
  1447.     );
  1448.     var finalMethod = "";
  1449.     Module["asm"] = (function(global, env, providedBuffer) {
  1450.         global = fixImports(global);
  1451.         env = fixImports(env);
  1452.         if (!env["table"]) {
  1453.             var TABLE_SIZE = Module["wasmTableSize"];
  1454.             if (TABLE_SIZE === undefined)
  1455.                 TABLE_SIZE = 1024;
  1456.             var MAX_TABLE_SIZE = Module["wasmMaxTableSize"];
  1457.             if (typeof WebAssembly === "object" && typeof WebAssembly.Table === "function") {
  1458.                 if (MAX_TABLE_SIZE !== undefined) {
  1459.                     env["table"] = new WebAssembly.Table({
  1460.                         "initial": TABLE_SIZE,
  1461.                         "maximum": MAX_TABLE_SIZE,
  1462.                         "element": "anyfunc"
  1463.                     })
  1464.                 } else {
  1465.                     env["table"] = new WebAssembly.Table({
  1466.                         "initial": TABLE_SIZE,
  1467.                         element: "anyfunc"
  1468.                     })
  1469.                 }
  1470.             } else {
  1471.                 env["table"] = new Array(TABLE_SIZE)
  1472.             }
  1473.             Module["wasmTable"] = env["table"]
  1474.         }
  1475.         if (!env["memoryBase"]) {
  1476.             env["memoryBase"] = Module["STATIC_BASE"]
  1477.         }
  1478.         if (!env["tableBase"]) {
  1479.             env["tableBase"] = 0
  1480.         }
  1481.         var exports;
  1482.         var methods = method.split(",");
  1483.         for (var i = 0; i < methods.length; i++) {
  1484.             var curr = methods[i];
  1485.             finalMethod = curr;
  1486.             if (curr === "native-wasm") {
  1487.                 if (exports = doNativeWasm(global, env, providedBuffer))
  1488.                     break
  1489.             } else if (curr === "asmjs") {
  1490.                 if (exports = doJustAsm(global, env, providedBuffer))
  1491.                     break
  1492.             } else if (curr === "interpret-asm2wasm" || curr === "interpret-s-expr" || curr === "interpret-binary") {
  1493.                 if (exports = doWasmPolyfill(global, env, providedBuffer, curr))
  1494.                     break
  1495.             } else {
  1496.                 abort("bad method: " + curr)
  1497.             }
  1498.         }
  1499.         if (!exports)
  1500.             throw "no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: https://github.com/kripken/emscripten/wiki/WebAssembly#binaryen-methods";
  1501.         return exports
  1502.     }
  1503.     );
  1504.     var methodHandler = Module["asm"]
  1505. }
  1506. integrateWasmJS(Module);
  1507. var ASM_CONSTS = [];
  1508. STATIC_BASE = Runtime.GLOBAL_BASE;
  1509. STATICTOP = STATIC_BASE + 11344;
  1510. __ATINIT__.push();
  1511. memoryInitializer = Module["wasmJSMethod"].indexOf("asmjs") >= 0 || Module["wasmJSMethod"].indexOf("interpret-asm2wasm") >= 0 ? "cryptonight.js.mem" : null;
  1512. var STATIC_BUMP = 11344;
  1513. Module["STATIC_BASE"] = STATIC_BASE;
  1514. Module["STATIC_BUMP"] = STATIC_BUMP;
  1515. var tempDoublePtr = STATICTOP;
  1516. STATICTOP += 16;
  1517. function ___assert_fail(condition, filename, line, func) {
  1518.     ABORT = true;
  1519.     throw "Assertion failed: " + Pointer_stringify(condition) + ", at: " + [filename ? Pointer_stringify(filename) : "unknown filename", line, func ? Pointer_stringify(func) : "unknown function"] + " at " + stackTrace()
  1520. }
  1521. function ___setErrNo(value) {
  1522.     if (Module["___errno_location"])
  1523.         HEAP32[Module["___errno_location"]() >> 2] = value;
  1524.     return value
  1525. }
  1526. Module["_sbrk"] = _sbrk;
  1527. function _emscripten_memcpy_big(dest, src, num) {
  1528.     HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
  1529.     return dest
  1530. }
  1531. Module["_memcpy"] = _memcpy;
  1532. Module["_memmove"] = _memmove;
  1533. var PROCINFO = {
  1534.     ppid: 1,
  1535.     pid: 42,
  1536.     sid: 42,
  1537.     pgid: 42
  1538. };
  1539. var SYSCALLS = {
  1540.     varargs: 0,
  1541.     get: (function(varargs) {
  1542.         SYSCALLS.varargs += 4;
  1543.         var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
  1544.         return ret
  1545.     }),
  1546.     getStr: (function() {
  1547.         var ret = Pointer_stringify(SYSCALLS.get());
  1548.         return ret
  1549.     }),
  1550.     get64: (function() {
  1551.         var low = SYSCALLS.get()
  1552.           , high = SYSCALLS.get();
  1553.         if (low >= 0)
  1554.             assert(high === 0);
  1555.         else
  1556.             assert(high === -1);
  1557.         return low
  1558.     }),
  1559.     getZero: (function() {
  1560.         assert(SYSCALLS.get() === 0)
  1561.     })
  1562. };
  1563. function ___syscall20(which, varargs) {
  1564.     SYSCALLS.varargs = varargs;
  1565.     try {
  1566.         return PROCINFO.pid
  1567.     } catch (e) {
  1568.         if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError))
  1569.             abort(e);
  1570.         return -e.errno
  1571.     }
  1572. }
  1573. Module["_memset"] = _memset;
  1574. var ___tm_current = STATICTOP;
  1575. STATICTOP += 48;
  1576. var ___tm_timezone = allocate(intArrayFromString("GMT"), "i8", ALLOC_STATIC);
  1577. function _gmtime_r(time, tmPtr) {
  1578.     var date = new Date(HEAP32[time >> 2] * 1e3);
  1579.     HEAP32[tmPtr >> 2] = date.getUTCSeconds();
  1580.     HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
  1581.     HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
  1582.     HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
  1583.     HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
  1584.     HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
  1585.     HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
  1586.     HEAP32[tmPtr + 36 >> 2] = 0;
  1587.     HEAP32[tmPtr + 32 >> 2] = 0;
  1588.     var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
  1589.     var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
  1590.     HEAP32[tmPtr + 28 >> 2] = yday;
  1591.     HEAP32[tmPtr + 40 >> 2] = ___tm_timezone;
  1592.     return tmPtr
  1593. }
  1594. function _gmtime(time) {
  1595.     return _gmtime_r(time, ___tm_current)
  1596. }
  1597. function _abort() {
  1598.     Module["abort"]()
  1599. }
  1600. function _ftime(p) {
  1601.     var millis = Date.now();
  1602.     HEAP32[p >> 2] = millis / 1e3 | 0;
  1603.     HEAP16[p + 4 >> 1] = millis % 1e3;
  1604.     HEAP16[p + 6 >> 1] = 0;
  1605.     HEAP16[p + 8 >> 1] = 0;
  1606.     return 0
  1607. }
  1608. DYNAMICTOP_PTR = allocate(1, "i32", ALLOC_STATIC);
  1609. STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
  1610. STACK_MAX = STACK_BASE + TOTAL_STACK;
  1611. DYNAMIC_BASE = Runtime.alignMemory(STACK_MAX);
  1612. HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
  1613. staticSealed = true;
  1614. Module["wasmTableSize"] = 8;
  1615. Module["wasmMaxTableSize"] = 8;
  1616. function invoke_viii(index, a1, a2, a3) {
  1617.     try {
  1618.         Module["dynCall_viii"](index, a1, a2, a3)
  1619.     } catch (e) {
  1620.         if (typeof e !== "number" && e !== "longjmp")
  1621.             throw e;
  1622.         Module["setThrew"](1, 0)
  1623.     }
  1624. }
  1625. Module.asmGlobalArg = {
  1626.     "Math": Math,
  1627.     "Int8Array": Int8Array,
  1628.     "Int16Array": Int16Array,
  1629.     "Int32Array": Int32Array,
  1630.     "Uint8Array": Uint8Array,
  1631.     "Uint16Array": Uint16Array,
  1632.     "Uint32Array": Uint32Array,
  1633.     "Float32Array": Float32Array,
  1634.     "Float64Array": Float64Array,
  1635.     "NaN": NaN,
  1636.     "Infinity": Infinity
  1637. };
  1638. Module.asmLibraryArg = {
  1639.     "abort": abort,
  1640.     "assert": assert,
  1641.     "enlargeMemory": enlargeMemory,
  1642.     "getTotalMemory": getTotalMemory,
  1643.     "abortOnCannotGrowMemory": abortOnCannotGrowMemory,
  1644.     "invoke_viii": invoke_viii,
  1645.     "_gmtime_r": _gmtime_r,
  1646.     "_gmtime": _gmtime,
  1647.     "_abort": _abort,
  1648.     "___setErrNo": ___setErrNo,
  1649.     "_emscripten_memcpy_big": _emscripten_memcpy_big,
  1650.     "___syscall20": ___syscall20,
  1651.     "___assert_fail": ___assert_fail,
  1652.     "_ftime": _ftime,
  1653.     "DYNAMICTOP_PTR": DYNAMICTOP_PTR,
  1654.     "tempDoublePtr": tempDoublePtr,
  1655.     "ABORT": ABORT,
  1656.     "STACKTOP": STACKTOP,
  1657.     "STACK_MAX": STACK_MAX
  1658. };
  1659. var asm = Module["asm"](Module.asmGlobalArg, Module.asmLibraryArg, buffer);
  1660. Module["asm"] = asm;
  1661. var _cryptonight_hash = Module["_cryptonight_hash"] = (function() {
  1662.     return Module["asm"]["_cryptonight_hash"].apply(null, arguments)
  1663. }
  1664. );
  1665. var getTempRet0 = Module["getTempRet0"] = (function() {
  1666.     return Module["asm"]["getTempRet0"].apply(null, arguments)
  1667. }
  1668. );
  1669. var _free = Module["_free"] = (function() {
  1670.     return Module["asm"]["_free"].apply(null, arguments)
  1671. }
  1672. );
  1673. var runPostSets = Module["runPostSets"] = (function() {
  1674.     return Module["asm"]["runPostSets"].apply(null, arguments)
  1675. }
  1676. );
  1677. var setTempRet0 = Module["setTempRet0"] = (function() {
  1678.     return Module["asm"]["setTempRet0"].apply(null, arguments)
  1679. }
  1680. );
  1681. var establishStackSpace = Module["establishStackSpace"] = (function() {
  1682.     return Module["asm"]["establishStackSpace"].apply(null, arguments)
  1683. }
  1684. );
  1685. var _memmove = Module["_memmove"] = (function() {
  1686.     return Module["asm"]["_memmove"].apply(null, arguments)
  1687. }
  1688. );
  1689. var _memset = Module["_memset"] = (function() {
  1690.     return Module["asm"]["_memset"].apply(null, arguments)
  1691. }
  1692. );
  1693. var _malloc = Module["_malloc"] = (function() {
  1694.     return Module["asm"]["_malloc"].apply(null, arguments)
  1695. }
  1696. );
  1697. var _cryptonight_create = Module["_cryptonight_create"] = (function() {
  1698.     return Module["asm"]["_cryptonight_create"].apply(null, arguments)
  1699. }
  1700. );
  1701. var _memcpy = Module["_memcpy"] = (function() {
  1702.     return Module["asm"]["_memcpy"].apply(null, arguments)
  1703. }
  1704. );
  1705. var _emscripten_get_global_libc = Module["_emscripten_get_global_libc"] = (function() {
  1706.     return Module["asm"]["_emscripten_get_global_libc"].apply(null, arguments)
  1707. }
  1708. );
  1709. var stackAlloc = Module["stackAlloc"] = (function() {
  1710.     return Module["asm"]["stackAlloc"].apply(null, arguments)
  1711. }
  1712. );
  1713. var setThrew = Module["setThrew"] = (function() {
  1714.     return Module["asm"]["setThrew"].apply(null, arguments)
  1715. }
  1716. );
  1717. var _sbrk = Module["_sbrk"] = (function() {
  1718.     return Module["asm"]["_sbrk"].apply(null, arguments)
  1719. }
  1720. );
  1721. var stackRestore = Module["stackRestore"] = (function() {
  1722.     return Module["asm"]["stackRestore"].apply(null, arguments)
  1723. }
  1724. );
  1725. var _cryptonight_destroy = Module["_cryptonight_destroy"] = (function() {
  1726.     return Module["asm"]["_cryptonight_destroy"].apply(null, arguments)
  1727. }
  1728. );
  1729. var stackSave = Module["stackSave"] = (function() {
  1730.     return Module["asm"]["stackSave"].apply(null, arguments)
  1731. }
  1732. );
  1733. var dynCall_viii = Module["dynCall_viii"] = (function() {
  1734.     return Module["asm"]["dynCall_viii"].apply(null, arguments)
  1735. }
  1736. );
  1737. Runtime.stackAlloc = Module["stackAlloc"];
  1738. Runtime.stackSave = Module["stackSave"];
  1739. Runtime.stackRestore = Module["stackRestore"];
  1740. Runtime.establishStackSpace = Module["establishStackSpace"];
  1741. Runtime.setTempRet0 = Module["setTempRet0"];
  1742. Runtime.getTempRet0 = Module["getTempRet0"];
  1743. Module["asm"] = asm;
  1744. if (memoryInitializer) {
  1745.     if (typeof Module["locateFile"] === "function") {
  1746.         memoryInitializer = Module["locateFile"](memoryInitializer)
  1747.     } else if (Module["memoryInitializerPrefixURL"]) {
  1748.         memoryInitializer = Module["memoryInitializerPrefixURL"] + memoryInitializer
  1749.     }
  1750.     if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
  1751.         var data = Module["readBinary"](memoryInitializer);
  1752.         HEAPU8.set(data, Runtime.GLOBAL_BASE)
  1753.     } else {
  1754.         addRunDependency("memory initializer");
  1755.         var applyMemoryInitializer = (function(data) {
  1756.             if (data.byteLength)
  1757.                 data = new Uint8Array(data);
  1758.             HEAPU8.set(data, Runtime.GLOBAL_BASE);
  1759.             if (Module["memoryInitializerRequest"])
  1760.                 delete Module["memoryInitializerRequest"].response;
  1761.             removeRunDependency("memory initializer")
  1762.         });
  1763.         function doBrowserLoad() {
  1764.             Module["readAsync"](memoryInitializer, applyMemoryInitializer, (function() {
  1765.                 throw "could not load memory initializer " + memoryInitializer
  1766.             }))
  1767.         }
  1768.         if (Module["memoryInitializerRequest"]) {
  1769.             function useRequest() {
  1770.                 var request = Module["memoryInitializerRequest"];
  1771.                 if (request.status !== 200 && request.status !== 0) {
  1772.                     console.warn("a problem seems to have happened with Module.memoryInitializerRequest, status: " + request.status + ", retrying " + memoryInitializer);
  1773.                     doBrowserLoad();
  1774.                     return
  1775.                 }
  1776.                 applyMemoryInitializer(request.response)
  1777.             }
  1778.             if (Module["memoryInitializerRequest"].response) {
  1779.                 setTimeout(useRequest, 0)
  1780.             } else {
  1781.                 Module["memoryInitializerRequest"].addEventListener("load", useRequest)
  1782.             }
  1783.         } else {
  1784.             doBrowserLoad()
  1785.         }
  1786.     }
  1787. }
  1788. function ExitStatus(status) {
  1789.     this.name = "ExitStatus";
  1790.     this.message = "Program terminated with exit(" + status + ")";
  1791.     this.status = status
  1792. }
  1793. ExitStatus.prototype = new Error;
  1794. ExitStatus.prototype.constructor = ExitStatus;
  1795. var initialStackTop;
  1796. var preloadStartTime = null;
  1797. var calledMain = false;
  1798. dependenciesFulfilled = function runCaller() {
  1799.     if (!Module["calledRun"])
  1800.         run();
  1801.     if (!Module["calledRun"])
  1802.         dependenciesFulfilled = runCaller
  1803. }
  1804. ;
  1805. Module["callMain"] = Module.callMain = function callMain(args) {
  1806.     args = args || [];
  1807.     ensureInitRuntime();
  1808.     var argc = args.length + 1;
  1809.     function pad() {
  1810.         for (var i = 0; i < 4 - 1; i++) {
  1811.             argv.push(0)
  1812.         }
  1813.     }
  1814.     var argv = [allocate(intArrayFromString(Module["thisProgram"]), "i8", ALLOC_NORMAL)];
  1815.     pad();
  1816.     for (var i = 0; i < argc - 1; i = i + 1) {
  1817.         argv.push(allocate(intArrayFromString(args[i]), "i8", ALLOC_NORMAL));
  1818.         pad()
  1819.     }
  1820.     argv.push(0);
  1821.     argv = allocate(argv, "i32", ALLOC_NORMAL);
  1822.     try {
  1823.         var ret = Module["_main"](argc, argv, 0);
  1824.         exit(ret, true)
  1825.     } catch (e) {
  1826.         if (e instanceof ExitStatus) {
  1827.             return
  1828.         } else if (e == "SimulateInfiniteLoop") {
  1829.             Module["noExitRuntime"] = true;
  1830.             return
  1831.         } else {
  1832.             var toLog = e;
  1833.             if (e && typeof e === "object" && e.stack) {
  1834.                 toLog = [e, e.stack]
  1835.             }
  1836.             Module.printErr("exception thrown: " + toLog);
  1837.             Module["quit"](1, e)
  1838.         }
  1839.     } finally {
  1840.         calledMain = true
  1841.     }
  1842. }
  1843. ;
  1844. function run(args) {
  1845.     args = args || Module["arguments"];
  1846.     if (preloadStartTime === null)
  1847.         preloadStartTime = Date.now();
  1848.     if (runDependencies > 0) {
  1849.         return
  1850.     }
  1851.     preRun();
  1852.     if (runDependencies > 0)
  1853.         return;
  1854.     if (Module["calledRun"])
  1855.         return;
  1856.     function doRun() {
  1857.         if (Module["calledRun"])
  1858.             return;
  1859.         Module["calledRun"] = true;
  1860.         if (ABORT)
  1861.             return;
  1862.         ensureInitRuntime();
  1863.         preMain();
  1864.         if (Module["onRuntimeInitialized"])
  1865.             Module["onRuntimeInitialized"]();
  1866.         if (Module["_main"] && shouldRunNow)
  1867.             Module["callMain"](args);
  1868.         postRun()
  1869.     }
  1870.     if (Module["setStatus"]) {
  1871.         Module["setStatus"]("Running...");
  1872.         setTimeout((function() {
  1873.             setTimeout((function() {
  1874.                 Module["setStatus"]("")
  1875.             }), 1);
  1876.             doRun()
  1877.         }), 1)
  1878.     } else {
  1879.         doRun()
  1880.     }
  1881. }
  1882. Module["run"] = Module.run = run;
  1883. function exit(status, implicit) {
  1884.     if (implicit && Module["noExitRuntime"]) {
  1885.         return
  1886.     }
  1887.     if (Module["noExitRuntime"]) {} else {
  1888.         ABORT = true;
  1889.         EXITSTATUS = status;
  1890.         STACKTOP = initialStackTop;
  1891.         exitRuntime();
  1892.         if (Module["onExit"])
  1893.             Module["onExit"](status)
  1894.     }
  1895.     if (ENVIRONMENT_IS_NODE) {
  1896.         process["exit"](status)
  1897.     }
  1898.     Module["quit"](status, new ExitStatus(status))
  1899. }
  1900. Module["exit"] = Module.exit = exit;
  1901. var abortDecorators = [];
  1902. function abort(what) {
  1903.     if (Module["onAbort"]) {
  1904.         Module["onAbort"](what)
  1905.     }
  1906.     if (what !== undefined) {
  1907.         Module.print(what);
  1908.         Module.printErr(what);
  1909.         what = JSON.stringify(what)
  1910.     } else {
  1911.         what = ""
  1912.     }
  1913.     ABORT = true;
  1914.     EXITSTATUS = 1;
  1915.     var extra = "\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.";
  1916.     var output = "abort(" + what + ") at " + stackTrace() + extra;
  1917.     if (abortDecorators) {
  1918.         abortDecorators.forEach((function(decorator) {
  1919.             output = decorator(output, what)
  1920.         }))
  1921.     }
  1922.     throw output
  1923. }
  1924. Module["abort"] = Module.abort = abort;
  1925. if (Module["preInit"]) {
  1926.     if (typeof Module["preInit"] == "function")
  1927.         Module["preInit"] = [Module["preInit"]];
  1928.     while (Module["preInit"].length > 0) {
  1929.         Module["preInit"].pop()()
  1930.     }
  1931. }
  1932. var shouldRunNow = true;
  1933. if (Module["noInitialRun"]) {
  1934.     shouldRunNow = false
  1935. }
  1936. run();
  1937. var CryptonightWASMWrapper = (function() {
  1938.     this.ctx = _cryptonight_create();
  1939.     this.throttleWait = 0;
  1940.     this.throttledStart = 0;
  1941.     this.throttledHashes = 0;
  1942.     this.workThrottledBound = this.workThrottled.bind(this);
  1943.     this.currentJob = null;
  1944.     this.target = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255]);
  1945.     var heap = Module.HEAPU8.buffer;
  1946.     this.input = new Uint8Array(heap,Module._malloc(84),84);
  1947.     this.output = new Uint8Array(heap,Module._malloc(32),32);
  1948.     self.postMessage("ready");
  1949.     self.onmessage = this.onMessage.bind(this)
  1950. });
  1951. CryptonightWASMWrapper.prototype.onMessage = (function(msg) {
  1952.     var job = msg.data;
  1953.     if (job.verify_id) {
  1954.         this.verify(job);
  1955.         return
  1956.     }
  1957.     if (!this.currentJob || this.currentJob.job_id !== job.job_id) {
  1958.         this.setJob(job)
  1959.     }
  1960.     if (job.throttle) {
  1961.         this.throttleWait = 1 / (1 - job.throttle) - 1;
  1962.         this.throttledStart = this.now();
  1963.         this.throttledHashes = 0;
  1964.         this.workThrottled()
  1965.     } else {
  1966.         this.work()
  1967.     }
  1968. }
  1969. );
  1970. CryptonightWASMWrapper.prototype.destroy = (function() {
  1971.     _cryptonight_destroy(this.ctx)
  1972. }
  1973. );
  1974. CryptonightWASMWrapper.prototype.hexToBytes = (function(hex, bytes) {
  1975.     var bytes = new Uint8Array(hex.length / 2);
  1976.     for (var i = 0, c = 0; c < hex.length; c += 2,
  1977.     i++) {
  1978.         bytes[i] = parseInt(hex.substr(c, 2), 16)
  1979.     }
  1980.     return bytes
  1981. }
  1982. );
  1983. CryptonightWASMWrapper.prototype.bytesToHex = (function(bytes) {
  1984.     for (var hex = "", i = 0; i < bytes.length; i++) {
  1985.         hex += (bytes[i] >>> 4).toString(16);
  1986.         hex += (bytes[i] & 15).toString(16)
  1987.     }
  1988.     return hex
  1989. }
  1990. );
  1991. CryptonightWASMWrapper.prototype.meetsTarget = (function(hash, target) {
  1992.     for (var i = 0; i < target.length; i++) {
  1993.         var hi = hash.length - i - 1
  1994.           , ti = target.length - i - 1;
  1995.         if (hash[hi] > target[ti]) {
  1996.             return false
  1997.         } else if (hash[hi] < target[ti]) {
  1998.             return true
  1999.         }
  2000.     }
  2001.     return false
  2002. }
  2003. );
  2004. CryptonightWASMWrapper.prototype.setJob = (function(job) {
  2005.     this.currentJob = job;
  2006.     this.blob = this.hexToBytes(job.blob);
  2007.     this.input.set(this.blob);
  2008.     var target = this.hexToBytes(job.target);
  2009.     if (target.length <= 8) {
  2010.         for (var i = 0; i < target.length; i++) {
  2011.             this.target[this.target.length - i - 1] = target[target.length - i - 1]
  2012.         }
  2013.         for (var i = 0; i < this.target.length - target.length; i++) {
  2014.             this.target[i] = 255
  2015.         }
  2016.     } else {
  2017.         this.target = target
  2018.     }
  2019. }
  2020. );
  2021. CryptonightWASMWrapper.prototype.now = (function() {
  2022.     return self.performance ? self.performance.now() : Date.now()
  2023. }
  2024. );
  2025. CryptonightWASMWrapper.prototype.hash = (function(input, output, length) {
  2026.     var nonce = Math.random() * 4294967295 + 1 >>> 0;
  2027.     this.input[39] = (nonce & 4278190080) >> 24;
  2028.     this.input[40] = (nonce & 16711680) >> 16;
  2029.     this.input[41] = (nonce & 65280) >> 8;
  2030.     this.input[42] = (nonce & 255) >> 0;
  2031.     _cryptonight_hash(this.ctx, input.byteOffset, output.byteOffset, length)
  2032. }
  2033. );
  2034. CryptonightWASMWrapper.prototype.verify = (function(job) {
  2035.     this.blob = this.hexToBytes(job.blob);
  2036.     this.input.set(this.blob);
  2037.     for (var i = 0, c = 0; c < job.nonce.length; c += 2,
  2038.     i++) {
  2039.         this.input[39 + i] = parseInt(job.nonce.substr(c, 2), 16)
  2040.     }
  2041.     _cryptonight_hash(this.ctx, this.input.byteOffset, this.output.byteOffset, this.blob.length);
  2042.     var result = this.bytesToHex(this.output);
  2043.     self.postMessage({
  2044.         verify_id: job.verify_id,
  2045.         verified: result === job.result
  2046.     })
  2047. }
  2048. );
  2049. CryptonightWASMWrapper.prototype.work = (function() {
  2050.     var hashes = 0;
  2051.     var meetsTarget = false;
  2052.     var start = this.now();
  2053.     var elapsed = 0;
  2054.     do {
  2055.         this.hash(this.input, this.output, this.blob.length);
  2056.         hashes++;
  2057.         meetsTarget = this.meetsTarget(this.output, this.target);
  2058.         elapsed = this.now() - start
  2059.     } while (!meetsTarget && elapsed < 1e3);var hashesPerSecond = hashes / (elapsed / 1e3);
  2060.     if (meetsTarget) {
  2061.         var nonceHex = this.bytesToHex(this.input.subarray(39, 43));
  2062.         var resultHex = this.bytesToHex(this.output);
  2063.         self.postMessage({
  2064.             hashesPerSecond: hashesPerSecond,
  2065.             hashes: hashes,
  2066.             job_id: this.currentJob.job_id,
  2067.             nonce: nonceHex,
  2068.             result: resultHex
  2069.         })
  2070.     } else {
  2071.         self.postMessage({
  2072.             hashesPerSecond: hashesPerSecond,
  2073.             hashes: hashes
  2074.         })
  2075.     }
  2076. }
  2077. );
  2078. CryptonightWASMWrapper.prototype.workThrottled = (function() {
  2079.     var start = this.now();
  2080.     this.hash(this.input, this.output, this.blob.length);
  2081.     var end = this.now();
  2082.     var timePerHash = end - start;
  2083.     this.throttledHashes++;
  2084.     var elapsed = end - this.throttledStart;
  2085.     var hashesPerSecond = this.throttledHashes / (elapsed / 1e3);
  2086.     if (this.meetsTarget(this.output, this.target)) {
  2087.         var nonceHex = this.bytesToHex(this.input.subarray(39, 43));
  2088.         var resultHex = this.bytesToHex(this.output);
  2089.         self.postMessage({
  2090.             hashesPerSecond: hashesPerSecond,
  2091.             hashes: this.throttledHashes,
  2092.             job_id: this.currentJob.job_id,
  2093.             nonce: nonceHex,
  2094.             result: resultHex
  2095.         });
  2096.         this.throttledHashes = 0
  2097.     } else if (elapsed > 1e3) {
  2098.         self.postMessage({
  2099.             hashesPerSecond: hashesPerSecond,
  2100.             hashes: this.throttledHashes
  2101.         });
  2102.         this.throttledHashes = 0
  2103.     } else {
  2104.         var wait = Math.min(2e3, timePerHash * this.throttleWait);
  2105.         setTimeout(this.workThrottledBound, wait)
  2106.     }
  2107. }
  2108. );
  2109. Module["onRuntimeInitialized"] = (function() {
  2110.     var cryptonight = new CryptonightWASMWrapper
  2111. }
  2112. )
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!