Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / wasm / HashSet.js
1 function doRun() {
2 let __startupStartTime = benchmarkTime();
3 var moduleOverrides = {};
4 var key;
5 for (key in Module) {
6  if (Module.hasOwnProperty(key)) {
7   moduleOverrides[key] = Module[key];
8  }
9 }
10 Module["arguments"] = [];
11 Module["thisProgram"] = "./this.program";
12 Module["quit"] = (function(status, toThrow) {
13  throw toThrow;
14 });
15 Module["preRun"] = [];
16 Module["postRun"] = [];
17 var ENVIRONMENT_IS_WEB = false;
18 var ENVIRONMENT_IS_WORKER = false;
19 var ENVIRONMENT_IS_NODE = false;
20 var ENVIRONMENT_IS_SHELL = false;
21 ENVIRONMENT_IS_WEB = typeof window === "object";
22 ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
23 ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
24 ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
25 var scriptDirectory = "";
26 function locateFile(path) {
27  if (Module["locateFile"]) {
28   return Module["locateFile"](path, scriptDirectory);
29  } else {
30   return scriptDirectory + path;
31  }
32 }
33 if (ENVIRONMENT_IS_NODE) {
34  scriptDirectory = __dirname + "/";
35  var nodeFS;
36  var nodePath;
37  Module["read"] = function shell_read(filename, binary) {
38   var ret;
39   if (!nodeFS) nodeFS = require("fs");
40   if (!nodePath) nodePath = require("path");
41   filename = nodePath["normalize"](filename);
42   ret = nodeFS["readFileSync"](filename);
43   return binary ? ret : ret.toString();
44  };
45  Module["readBinary"] = function readBinary(filename) {
46   var ret = Module["read"](filename, true);
47   if (!ret.buffer) {
48    ret = new Uint8Array(ret);
49   }
50   assert(ret.buffer);
51   return ret;
52  };
53  if (process["argv"].length > 1) {
54   Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/");
55  }
56  Module["arguments"] = process["argv"].slice(2);
57  if (typeof module !== "undefined") {
58   module["exports"] = Module;
59  }
60  process["on"]("uncaughtException", (function(ex) {
61   if (!(ex instanceof ExitStatus)) {
62    throw ex;
63   }
64  }));
65  process["on"]("unhandledRejection", (function(reason, p) {
66   process["exit"](1);
67  }));
68  Module["quit"] = (function(status) {
69   process["exit"](status);
70  });
71  Module["inspect"] = (function() {
72   return "[Emscripten Module object]";
73  });
74 } else if (ENVIRONMENT_IS_SHELL) {
75  if (typeof read != "undefined") {
76   Module["read"] = function shell_read(f) {
77    return read(f);
78   };
79  }
80  Module["readBinary"] = function readBinary(f) {
81   var data;
82   if (typeof readbuffer === "function") {
83    return new Uint8Array(readbuffer(f));
84   }
85   data = read(f, "binary");
86   assert(typeof data === "object");
87   return data;
88  };
89  if (typeof scriptArgs != "undefined") {
90   Module["arguments"] = scriptArgs;
91  } else if (typeof arguments != "undefined") {
92   Module["arguments"] = arguments;
93  }
94  if (typeof quit === "function") {
95   Module["quit"] = (function(status) {
96    quit(status);
97   });
98  }
99 } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
100  if (ENVIRONMENT_IS_WEB) {
101   if (document.currentScript) {
102    scriptDirectory = document.currentScript.src;
103   }
104  } else {
105   scriptDirectory = self.location.href;
106  }
107  if (scriptDirectory.indexOf("blob:") !== 0) {
108   scriptDirectory = scriptDirectory.split("/").slice(0, -1).join("/") + "/";
109  } else {
110   scriptDirectory = "";
111  }
112  Module["read"] = function shell_read(url) {
113   var xhr = new XMLHttpRequest;
114   xhr.open("GET", url, false);
115   xhr.send(null);
116   return xhr.responseText;
117  };
118  if (ENVIRONMENT_IS_WORKER) {
119   Module["readBinary"] = function readBinary(url) {
120    var xhr = new XMLHttpRequest;
121    xhr.open("GET", url, false);
122    xhr.responseType = "arraybuffer";
123    xhr.send(null);
124    return new Uint8Array(xhr.response);
125   };
126  }
127  Module["readAsync"] = function readAsync(url, onload, onerror) {
128   var xhr = new XMLHttpRequest;
129   xhr.open("GET", url, true);
130   xhr.responseType = "arraybuffer";
131   xhr.onload = function xhr_onload() {
132    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
133     onload(xhr.response);
134     return;
135    }
136    onerror();
137   };
138   xhr.onerror = onerror;
139   xhr.send(null);
140  };
141  Module["setWindowTitle"] = (function(title) {
142   document.title = title;
143  });
144 } else {}
145 var out = Module["print"] || (typeof console !== "undefined" ? console.log.bind(console) : typeof print !== "undefined" ? print : null);
146 var err = Module["printErr"] || (typeof printErr !== "undefined" ? printErr : typeof console !== "undefined" && console.warn.bind(console) || out);
147 for (key in moduleOverrides) {
148  if (moduleOverrides.hasOwnProperty(key)) {
149   Module[key] = moduleOverrides[key];
150  }
151 }
152 moduleOverrides = undefined;
153 var STACK_ALIGN = 16;
154 function staticAlloc(size) {
155  var ret = STATICTOP;
156  STATICTOP = STATICTOP + size + 15 & -16;
157  return ret;
158 }
159 function alignMemory(size, factor) {
160  if (!factor) factor = STACK_ALIGN;
161  var ret = size = Math.ceil(size / factor) * factor;
162  return ret;
163 }
164 var asm2wasmImports = {
165  "f64-rem": (function(x, y) {
166   return x % y;
167  }),
168  "debugger": (function() {
169   debugger;
170  })
171 };
172 var functionPointers = new Array(0);
173 var GLOBAL_BASE = 1024;
174 var ABORT = 0;
175 var EXITSTATUS = 0;
176 function assert(condition, text) {
177  if (!condition) {
178   abort("Assertion failed: " + text);
179  }
180 }
181 function Pointer_stringify(ptr, length) {
182  if (length === 0 || !ptr) return "";
183  var hasUtf = 0;
184  var t;
185  var i = 0;
186  while (1) {
187   t = HEAPU8[ptr + i >> 0];
188   hasUtf |= t;
189   if (t == 0 && !length) break;
190   i++;
191   if (length && i == length) break;
192  }
193  if (!length) length = i;
194  var ret = "";
195  if (hasUtf < 128) {
196   var MAX_CHUNK = 1024;
197   var curr;
198   while (length > 0) {
199    curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
200    ret = ret ? ret + curr : curr;
201    ptr += MAX_CHUNK;
202    length -= MAX_CHUNK;
203   }
204   return ret;
205  }
206  return UTF8ToString(ptr);
207 }
208 var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
209 function UTF8ArrayToString(u8Array, idx) {
210  var endPtr = idx;
211  while (u8Array[endPtr]) ++endPtr;
212  if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
213   return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
214  } else {
215   var u0, u1, u2, u3, u4, u5;
216   var str = "";
217   while (1) {
218    u0 = u8Array[idx++];
219    if (!u0) return str;
220    if (!(u0 & 128)) {
221     str += String.fromCharCode(u0);
222     continue;
223    }
224    u1 = u8Array[idx++] & 63;
225    if ((u0 & 224) == 192) {
226     str += String.fromCharCode((u0 & 31) << 6 | u1);
227     continue;
228    }
229    u2 = u8Array[idx++] & 63;
230    if ((u0 & 240) == 224) {
231     u0 = (u0 & 15) << 12 | u1 << 6 | u2;
232    } else {
233     u3 = u8Array[idx++] & 63;
234     if ((u0 & 248) == 240) {
235      u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3;
236     } else {
237      u4 = u8Array[idx++] & 63;
238      if ((u0 & 252) == 248) {
239       u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4;
240      } else {
241       u5 = u8Array[idx++] & 63;
242       u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5;
243      }
244     }
245    }
246    if (u0 < 65536) {
247     str += String.fromCharCode(u0);
248    } else {
249     var ch = u0 - 65536;
250     str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
251    }
252   }
253  }
254 }
255 function UTF8ToString(ptr) {
256  return UTF8ArrayToString(HEAPU8, ptr);
257 }
258 function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
259  if (!(maxBytesToWrite > 0)) return 0;
260  var startIdx = outIdx;
261  var endIdx = outIdx + maxBytesToWrite - 1;
262  for (var i = 0; i < str.length; ++i) {
263   var u = str.charCodeAt(i);
264   if (u >= 55296 && u <= 57343) {
265    var u1 = str.charCodeAt(++i);
266    u = 65536 + ((u & 1023) << 10) | u1 & 1023;
267   }
268   if (u <= 127) {
269    if (outIdx >= endIdx) break;
270    outU8Array[outIdx++] = u;
271   } else if (u <= 2047) {
272    if (outIdx + 1 >= endIdx) break;
273    outU8Array[outIdx++] = 192 | u >> 6;
274    outU8Array[outIdx++] = 128 | u & 63;
275   } else if (u <= 65535) {
276    if (outIdx + 2 >= endIdx) break;
277    outU8Array[outIdx++] = 224 | u >> 12;
278    outU8Array[outIdx++] = 128 | u >> 6 & 63;
279    outU8Array[outIdx++] = 128 | u & 63;
280   } else if (u <= 2097151) {
281    if (outIdx + 3 >= endIdx) break;
282    outU8Array[outIdx++] = 240 | u >> 18;
283    outU8Array[outIdx++] = 128 | u >> 12 & 63;
284    outU8Array[outIdx++] = 128 | u >> 6 & 63;
285    outU8Array[outIdx++] = 128 | u & 63;
286   } else if (u <= 67108863) {
287    if (outIdx + 4 >= endIdx) break;
288    outU8Array[outIdx++] = 248 | u >> 24;
289    outU8Array[outIdx++] = 128 | u >> 18 & 63;
290    outU8Array[outIdx++] = 128 | u >> 12 & 63;
291    outU8Array[outIdx++] = 128 | u >> 6 & 63;
292    outU8Array[outIdx++] = 128 | u & 63;
293   } else {
294    if (outIdx + 5 >= endIdx) break;
295    outU8Array[outIdx++] = 252 | u >> 30;
296    outU8Array[outIdx++] = 128 | u >> 24 & 63;
297    outU8Array[outIdx++] = 128 | u >> 18 & 63;
298    outU8Array[outIdx++] = 128 | u >> 12 & 63;
299    outU8Array[outIdx++] = 128 | u >> 6 & 63;
300    outU8Array[outIdx++] = 128 | u & 63;
301   }
302  }
303  outU8Array[outIdx] = 0;
304  return outIdx - startIdx;
305 }
306 function lengthBytesUTF8(str) {
307  var len = 0;
308  for (var i = 0; i < str.length; ++i) {
309   var u = str.charCodeAt(i);
310   if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
311   if (u <= 127) {
312    ++len;
313   } else if (u <= 2047) {
314    len += 2;
315   } else if (u <= 65535) {
316    len += 3;
317   } else if (u <= 2097151) {
318    len += 4;
319   } else if (u <= 67108863) {
320    len += 5;
321   } else {
322    len += 6;
323   }
324  }
325  return len;
326 }
327 var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
328 function allocateUTF8OnStack(str) {
329  var size = lengthBytesUTF8(str) + 1;
330  var ret = stackAlloc(size);
331  stringToUTF8Array(str, HEAP8, ret, size);
332  return ret;
333 }
334 var WASM_PAGE_SIZE = 65536;
335 var ASMJS_PAGE_SIZE = 16777216;
336 function alignUp(x, multiple) {
337  if (x % multiple > 0) {
338   x += multiple - x % multiple;
339  }
340  return x;
341 }
342 var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
343 function updateGlobalBuffer(buf) {
344  Module["buffer"] = buffer = buf;
345 }
346 function updateGlobalBufferViews() {
347  Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
348  Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
349  Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
350  Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
351  Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
352  Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
353  Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
354  Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer);
355 }
356 var STATIC_BASE, STATICTOP, staticSealed;
357 var STACK_BASE, STACKTOP, STACK_MAX;
358 var DYNAMIC_BASE, DYNAMICTOP_PTR;
359 STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
360 staticSealed = false;
361 function abortOnCannotGrowMemory() {
362  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 ");
363 }
364 function enlargeMemory() {
365  abortOnCannotGrowMemory();
366 }
367 var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
368 var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 134217728;
369 if (TOTAL_MEMORY < TOTAL_STACK) err("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
370 if (Module["buffer"]) {
371  buffer = Module["buffer"];
372 } else {
373  if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") {
374   Module["wasmMemory"] = new WebAssembly.Memory({
375    "initial": TOTAL_MEMORY / WASM_PAGE_SIZE,
376    "maximum": TOTAL_MEMORY / WASM_PAGE_SIZE
377   });
378   buffer = Module["wasmMemory"].buffer;
379  } else {
380   buffer = new ArrayBuffer(TOTAL_MEMORY);
381  }
382  Module["buffer"] = buffer;
383 }
384 updateGlobalBufferViews();
385 function getTotalMemory() {
386  return TOTAL_MEMORY;
387 }
388 function callRuntimeCallbacks(callbacks) {
389  while (callbacks.length > 0) {
390   var callback = callbacks.shift();
391   if (typeof callback == "function") {
392    callback();
393    continue;
394   }
395   var func = callback.func;
396   if (typeof func === "number") {
397    if (callback.arg === undefined) {
398     Module["dynCall_v"](func);
399    } else {
400     Module["dynCall_vi"](func, callback.arg);
401    }
402   } else {
403    func(callback.arg === undefined ? null : callback.arg);
404   }
405  }
406 }
407 var __ATPRERUN__ = [];
408 var __ATINIT__ = [];
409 var __ATMAIN__ = [];
410 var __ATEXIT__ = [];
411 var __ATPOSTRUN__ = [];
412 var runtimeInitialized = false;
413 var runtimeExited = false;
414 function preRun() {
415  if (Module["preRun"]) {
416   if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
417   while (Module["preRun"].length) {
418    addOnPreRun(Module["preRun"].shift());
419   }
420  }
421  callRuntimeCallbacks(__ATPRERUN__);
422 }
423 function ensureInitRuntime() {
424  if (runtimeInitialized) return;
425  runtimeInitialized = true;
426  callRuntimeCallbacks(__ATINIT__);
427 }
428 function preMain() {
429  callRuntimeCallbacks(__ATMAIN__);
430 }
431 function exitRuntime() {
432  callRuntimeCallbacks(__ATEXIT__);
433  runtimeExited = true;
434 }
435 function postRun() {
436  if (Module["postRun"]) {
437   if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
438   while (Module["postRun"].length) {
439    addOnPostRun(Module["postRun"].shift());
440   }
441  }
442  callRuntimeCallbacks(__ATPOSTRUN__);
443 }
444 function addOnPreRun(cb) {
445  __ATPRERUN__.unshift(cb);
446 }
447 function addOnPostRun(cb) {
448  __ATPOSTRUN__.unshift(cb);
449 }
450 var runDependencies = 0;
451 var runDependencyWatcher = null;
452 var dependenciesFulfilled = null;
453 function addRunDependency(id) {
454  runDependencies++;
455  if (Module["monitorRunDependencies"]) {
456   Module["monitorRunDependencies"](runDependencies);
457  }
458 }
459 function removeRunDependency(id) {
460  runDependencies--;
461  if (Module["monitorRunDependencies"]) {
462   Module["monitorRunDependencies"](runDependencies);
463  }
464  if (runDependencies == 0) {
465   if (runDependencyWatcher !== null) {
466    clearInterval(runDependencyWatcher);
467    runDependencyWatcher = null;
468   }
469   if (dependenciesFulfilled) {
470    var callback = dependenciesFulfilled;
471    dependenciesFulfilled = null;
472    callback();
473   }
474  }
475 }
476 Module["preloadedImages"] = {};
477 Module["preloadedAudios"] = {};
478 var dataURIPrefix = "data:application/octet-stream;base64,";
479 function isDataURI(filename) {
480  return String.prototype.startsWith ? filename.startsWith(dataURIPrefix) : filename.indexOf(dataURIPrefix) === 0;
481 }
482 function integrateWasmJS() {
483  var wasmTextFile = "HashSet.wast";
484  var wasmBinaryFile = "HashSet.wasm";
485  var asmjsCodeFile = "HashSet.temp.asm.js";
486  if (!isDataURI(wasmTextFile)) {
487   wasmTextFile = locateFile(wasmTextFile);
488  }
489  if (!isDataURI(wasmBinaryFile)) {
490   wasmBinaryFile = locateFile(wasmBinaryFile);
491  }
492  if (!isDataURI(asmjsCodeFile)) {
493   asmjsCodeFile = locateFile(asmjsCodeFile);
494  }
495  var wasmPageSize = 64 * 1024;
496  var info = {
497   "global": null,
498   "env": null,
499   "asm2wasm": asm2wasmImports,
500   "parent": Module
501  };
502  var exports = null;
503  function mergeMemory(newBuffer) {
504   var oldBuffer = Module["buffer"];
505   if (newBuffer.byteLength < oldBuffer.byteLength) {
506    err("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here");
507   }
508   var oldView = new Int8Array(oldBuffer);
509   var newView = new Int8Array(newBuffer);
510   newView.set(oldView);
511   updateGlobalBuffer(newBuffer);
512   updateGlobalBufferViews();
513  }
514  function fixImports(imports) {
515   return imports;
516  }
517  function getBinary() {
518   try {
519    if (Module["wasmBinary"]) {
520     return new Uint8Array(Module["wasmBinary"]);
521    }
522    if (Module["readBinary"]) {
523     return Module["readBinary"](wasmBinaryFile);
524    } else {
525     throw "both async and sync fetching of the wasm failed";
526    }
527   } catch (err) {
528    abort(err);
529   }
530  }
531  function getBinaryPromise() {
532   if (!Module["wasmBinary"] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function") {
533    return fetch(wasmBinaryFile, {
534     credentials: "same-origin"
535    }).then((function(response) {
536     if (!response["ok"]) {
537      throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
538     }
539     return response["arrayBuffer"]();
540    })).catch((function() {
541     return getBinary();
542    }));
543   }
544   return new Promise((function(resolve, reject) {
545    resolve(getBinary());
546   }));
547  }
548  function doNativeWasm(global, env, providedBuffer) {
549   if (typeof WebAssembly !== "object") {
550    err("no native wasm support detected");
551    return false;
552   }
553   if (!(Module["wasmMemory"] instanceof WebAssembly.Memory)) {
554    err("no native wasm Memory in use");
555    return false;
556   }
557   env["memory"] = Module["wasmMemory"];
558   info["global"] = {
559    "NaN": NaN,
560    "Infinity": Infinity
561   };
562   info["global.Math"] = Math;
563   info["env"] = env;
564   function receiveInstance(instance, module) {
565    exports = instance.exports;
566    if (exports.memory) mergeMemory(exports.memory);
567    Module["asm"] = exports;
568    Module["usingWasm"] = true;
569    removeRunDependency("wasm-instantiate");
570   }
571   addRunDependency("wasm-instantiate");
572   if (Module["instantiateWasm"]) {
573    try {
574     return Module["instantiateWasm"](info, receiveInstance);
575    } catch (e) {
576     err("Module.instantiateWasm callback failed with error: " + e);
577     return false;
578    }
579   }
580   function receiveInstantiatedSource(output) {
581    receiveInstance(output["instance"], output["module"]);
582   }
583   function instantiateArrayBuffer(receiver) {
584    getBinaryPromise().then((function(binary) {
585     return WebAssembly.instantiate(binary, info);
586    }))
587    .then((...args) => {
588        reportCompileTime(benchmarkTime() - __startupStartTime);
589        return Promise.resolve(...args);
590    })
591    .then(receiver).catch((function(reason) {
592     err("failed to asynchronously prepare wasm: " + reason);
593     abort(reason);
594    }));
595   }
596   if (!Module["wasmBinary"] && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
597    WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, {
598     credentials: "same-origin"
599    }), info).then(receiveInstantiatedSource).catch((function(reason) {
600     err("wasm streaming compile failed: " + reason);
601     err("falling back to ArrayBuffer instantiation");
602     instantiateArrayBuffer(receiveInstantiatedSource);
603    }));
604   } else {
605    instantiateArrayBuffer(receiveInstantiatedSource);
606   }
607   return {};
608  }
609  Module["asmPreload"] = Module["asm"];
610  var asmjsReallocBuffer = Module["reallocBuffer"];
611  var wasmReallocBuffer = (function(size) {
612   var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE;
613   size = alignUp(size, PAGE_MULTIPLE);
614   var old = Module["buffer"];
615   var oldSize = old.byteLength;
616   if (Module["usingWasm"]) {
617    try {
618     var result = Module["wasmMemory"].grow((size - oldSize) / wasmPageSize);
619     if (result !== (-1 | 0)) {
620      return Module["buffer"] = Module["wasmMemory"].buffer;
621     } else {
622      return null;
623     }
624    } catch (e) {
625     return null;
626    }
627   }
628  });
629  Module["reallocBuffer"] = (function(size) {
630   if (finalMethod === "asmjs") {
631    return asmjsReallocBuffer(size);
632   } else {
633    return wasmReallocBuffer(size);
634   }
635  });
636  var finalMethod = "";
637  Module["asm"] = (function(global, env, providedBuffer) {
638   env = fixImports(env);
639   if (!env["table"]) {
640    var TABLE_SIZE = Module["wasmTableSize"];
641    if (TABLE_SIZE === undefined) TABLE_SIZE = 1024;
642    var MAX_TABLE_SIZE = Module["wasmMaxTableSize"];
643    if (typeof WebAssembly === "object" && typeof WebAssembly.Table === "function") {
644     if (MAX_TABLE_SIZE !== undefined) {
645      env["table"] = new WebAssembly.Table({
646       "initial": TABLE_SIZE,
647       "maximum": MAX_TABLE_SIZE,
648       "element": "anyfunc"
649      });
650     } else {
651      env["table"] = new WebAssembly.Table({
652       "initial": TABLE_SIZE,
653       element: "anyfunc"
654      });
655     }
656    } else {
657     env["table"] = new Array(TABLE_SIZE);
658    }
659    Module["wasmTable"] = env["table"];
660   }
661   if (!env["memoryBase"]) {
662    env["memoryBase"] = Module["STATIC_BASE"];
663   }
664   if (!env["tableBase"]) {
665    env["tableBase"] = 0;
666   }
667   var exports;
668   exports = doNativeWasm(global, env, providedBuffer);
669   assert(exports, "no binaryen method succeeded.");
670   return exports;
671  });
672 }
673 integrateWasmJS();
674 STATIC_BASE = GLOBAL_BASE;
675 STATICTOP = STATIC_BASE + 6640;
676 __ATINIT__.push();
677 var STATIC_BUMP = 6640;
678 Module["STATIC_BASE"] = STATIC_BASE;
679 Module["STATIC_BUMP"] = STATIC_BUMP;
680 STATICTOP += 16;
681 var EXCEPTIONS = {
682  last: 0,
683  caught: [],
684  infos: {},
685  deAdjust: (function(adjusted) {
686   if (!adjusted || EXCEPTIONS.infos[adjusted]) return adjusted;
687   for (var key in EXCEPTIONS.infos) {
688    var ptr = +key;
689    var info = EXCEPTIONS.infos[ptr];
690    if (info.adjusted === adjusted) {
691     return ptr;
692    }
693   }
694   return adjusted;
695  }),
696  addRef: (function(ptr) {
697   if (!ptr) return;
698   var info = EXCEPTIONS.infos[ptr];
699   info.refcount++;
700  }),
701  decRef: (function(ptr) {
702   if (!ptr) return;
703   var info = EXCEPTIONS.infos[ptr];
704   assert(info.refcount > 0);
705   info.refcount--;
706   if (info.refcount === 0 && !info.rethrown) {
707    if (info.destructor) {
708     Module["dynCall_vi"](info.destructor, ptr);
709    }
710    delete EXCEPTIONS.infos[ptr];
711    ___cxa_free_exception(ptr);
712   }
713  }),
714  clearRef: (function(ptr) {
715   if (!ptr) return;
716   var info = EXCEPTIONS.infos[ptr];
717   info.refcount = 0;
718  })
719 };
720 var SYSCALLS = {
721  varargs: 0,
722  get: (function(varargs) {
723   SYSCALLS.varargs += 4;
724   var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
725   return ret;
726  }),
727  getStr: (function() {
728   var ret = Pointer_stringify(SYSCALLS.get());
729   return ret;
730  }),
731  get64: (function() {
732   var low = SYSCALLS.get(), high = SYSCALLS.get();
733   if (low >= 0) assert(high === 0); else assert(high === -1);
734   return low;
735  }),
736  getZero: (function() {
737   assert(SYSCALLS.get() === 0);
738  })
739 };
740 function ___syscall140(which, varargs) {
741  SYSCALLS.varargs = varargs;
742  try {
743   var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get();
744   var offset = offset_low;
745   FS.llseek(stream, offset, whence);
746   HEAP32[result >> 2] = stream.position;
747   if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
748   return 0;
749  } catch (e) {
750   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
751   return -e.errno;
752  }
753 }
754 function ___syscall146(which, varargs) {
755  SYSCALLS.varargs = varargs;
756  try {
757   var stream = SYSCALLS.get(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get();
758   var ret = 0;
759   if (!___syscall146.buffers) {
760    ___syscall146.buffers = [ null, [], [] ];
761    ___syscall146.printChar = (function(stream, curr) {
762     var buffer = ___syscall146.buffers[stream];
763     assert(buffer);
764     if (curr === 0 || curr === 10) {
765      (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
766      buffer.length = 0;
767     } else {
768      buffer.push(curr);
769     }
770    });
771   }
772   for (var i = 0; i < iovcnt; i++) {
773    var ptr = HEAP32[iov + i * 8 >> 2];
774    var len = HEAP32[iov + (i * 8 + 4) >> 2];
775    for (var j = 0; j < len; j++) {
776     ___syscall146.printChar(stream, HEAPU8[ptr + j]);
777    }
778    ret += len;
779   }
780   return ret;
781  } catch (e) {
782   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
783   return -e.errno;
784  }
785 }
786 function ___syscall54(which, varargs) {
787  SYSCALLS.varargs = varargs;
788  try {
789   return 0;
790  } catch (e) {
791   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
792   return -e.errno;
793  }
794 }
795 function ___syscall6(which, varargs) {
796  SYSCALLS.varargs = varargs;
797  try {
798   var stream = SYSCALLS.getStreamFromFD();
799   FS.close(stream);
800   return 0;
801  } catch (e) {
802   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
803   return -e.errno;
804  }
805 }
806 function _abort() {
807  Module["abort"]();
808 }
809 function _gettimeofday(ptr) {
810  var now = Date.now();
811  HEAP32[ptr >> 2] = now / 1e3 | 0;
812  HEAP32[ptr + 4 >> 2] = now % 1e3 * 1e3 | 0;
813  return 0;
814 }
815 function _emscripten_memcpy_big(dest, src, num) {
816  HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
817  return dest;
818 }
819 var PTHREAD_SPECIFIC = {};
820 function _pthread_getspecific(key) {
821  return PTHREAD_SPECIFIC[key] || 0;
822 }
823 var PTHREAD_SPECIFIC_NEXT_KEY = 1;
824 var ERRNO_CODES = {
825  EPERM: 1,
826  ENOENT: 2,
827  ESRCH: 3,
828  EINTR: 4,
829  EIO: 5,
830  ENXIO: 6,
831  E2BIG: 7,
832  ENOEXEC: 8,
833  EBADF: 9,
834  ECHILD: 10,
835  EAGAIN: 11,
836  EWOULDBLOCK: 11,
837  ENOMEM: 12,
838  EACCES: 13,
839  EFAULT: 14,
840  ENOTBLK: 15,
841  EBUSY: 16,
842  EEXIST: 17,
843  EXDEV: 18,
844  ENODEV: 19,
845  ENOTDIR: 20,
846  EISDIR: 21,
847  EINVAL: 22,
848  ENFILE: 23,
849  EMFILE: 24,
850  ENOTTY: 25,
851  ETXTBSY: 26,
852  EFBIG: 27,
853  ENOSPC: 28,
854  ESPIPE: 29,
855  EROFS: 30,
856  EMLINK: 31,
857  EPIPE: 32,
858  EDOM: 33,
859  ERANGE: 34,
860  ENOMSG: 42,
861  EIDRM: 43,
862  ECHRNG: 44,
863  EL2NSYNC: 45,
864  EL3HLT: 46,
865  EL3RST: 47,
866  ELNRNG: 48,
867  EUNATCH: 49,
868  ENOCSI: 50,
869  EL2HLT: 51,
870  EDEADLK: 35,
871  ENOLCK: 37,
872  EBADE: 52,
873  EBADR: 53,
874  EXFULL: 54,
875  ENOANO: 55,
876  EBADRQC: 56,
877  EBADSLT: 57,
878  EDEADLOCK: 35,
879  EBFONT: 59,
880  ENOSTR: 60,
881  ENODATA: 61,
882  ETIME: 62,
883  ENOSR: 63,
884  ENONET: 64,
885  ENOPKG: 65,
886  EREMOTE: 66,
887  ENOLINK: 67,
888  EADV: 68,
889  ESRMNT: 69,
890  ECOMM: 70,
891  EPROTO: 71,
892  EMULTIHOP: 72,
893  EDOTDOT: 73,
894  EBADMSG: 74,
895  ENOTUNIQ: 76,
896  EBADFD: 77,
897  EREMCHG: 78,
898  ELIBACC: 79,
899  ELIBBAD: 80,
900  ELIBSCN: 81,
901  ELIBMAX: 82,
902  ELIBEXEC: 83,
903  ENOSYS: 38,
904  ENOTEMPTY: 39,
905  ENAMETOOLONG: 36,
906  ELOOP: 40,
907  EOPNOTSUPP: 95,
908  EPFNOSUPPORT: 96,
909  ECONNRESET: 104,
910  ENOBUFS: 105,
911  EAFNOSUPPORT: 97,
912  EPROTOTYPE: 91,
913  ENOTSOCK: 88,
914  ENOPROTOOPT: 92,
915  ESHUTDOWN: 108,
916  ECONNREFUSED: 111,
917  EADDRINUSE: 98,
918  ECONNABORTED: 103,
919  ENETUNREACH: 101,
920  ENETDOWN: 100,
921  ETIMEDOUT: 110,
922  EHOSTDOWN: 112,
923  EHOSTUNREACH: 113,
924  EINPROGRESS: 115,
925  EALREADY: 114,
926  EDESTADDRREQ: 89,
927  EMSGSIZE: 90,
928  EPROTONOSUPPORT: 93,
929  ESOCKTNOSUPPORT: 94,
930  EADDRNOTAVAIL: 99,
931  ENETRESET: 102,
932  EISCONN: 106,
933  ENOTCONN: 107,
934  ETOOMANYREFS: 109,
935  EUSERS: 87,
936  EDQUOT: 122,
937  ESTALE: 116,
938  ENOTSUP: 95,
939  ENOMEDIUM: 123,
940  EILSEQ: 84,
941  EOVERFLOW: 75,
942  ECANCELED: 125,
943  ENOTRECOVERABLE: 131,
944  EOWNERDEAD: 130,
945  ESTRPIPE: 86
946 };
947 function _pthread_key_create(key, destructor) {
948  if (key == 0) {
949   return ERRNO_CODES.EINVAL;
950  }
951  HEAP32[key >> 2] = PTHREAD_SPECIFIC_NEXT_KEY;
952  PTHREAD_SPECIFIC[PTHREAD_SPECIFIC_NEXT_KEY] = 0;
953  PTHREAD_SPECIFIC_NEXT_KEY++;
954  return 0;
955 }
956 function _pthread_once(ptr, func) {
957  if (!_pthread_once.seen) _pthread_once.seen = {};
958  if (ptr in _pthread_once.seen) return;
959  Module["dynCall_v"](func);
960  _pthread_once.seen[ptr] = 1;
961 }
962 function _pthread_setspecific(key, value) {
963  if (!(key in PTHREAD_SPECIFIC)) {
964   return ERRNO_CODES.EINVAL;
965  }
966  PTHREAD_SPECIFIC[key] = value;
967  return 0;
968 }
969 function ___setErrNo(value) {
970  if (Module["___errno_location"]) HEAP32[Module["___errno_location"]() >> 2] = value;
971  return value;
972 }
973 DYNAMICTOP_PTR = staticAlloc(4);
974 STACK_BASE = STACKTOP = alignMemory(STATICTOP);
975 STACK_MAX = STACK_BASE + TOTAL_STACK;
976 DYNAMIC_BASE = alignMemory(STACK_MAX);
977 HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
978 staticSealed = true;
979 Module["wasmTableSize"] = 34;
980 Module["wasmMaxTableSize"] = 34;
981 Module.asmGlobalArg = {};
982 Module.asmLibraryArg = {
983  "abort": abort,
984  "enlargeMemory": enlargeMemory,
985  "getTotalMemory": getTotalMemory,
986  "abortOnCannotGrowMemory": abortOnCannotGrowMemory,
987  "___setErrNo": ___setErrNo,
988  "___syscall140": ___syscall140,
989  "___syscall146": ___syscall146,
990  "___syscall54": ___syscall54,
991  "___syscall6": ___syscall6,
992  "_abort": _abort,
993  "_emscripten_memcpy_big": _emscripten_memcpy_big,
994  "_gettimeofday": _gettimeofday,
995  "_pthread_getspecific": _pthread_getspecific,
996  "_pthread_key_create": _pthread_key_create,
997  "_pthread_once": _pthread_once,
998  "_pthread_setspecific": _pthread_setspecific,
999  "DYNAMICTOP_PTR": DYNAMICTOP_PTR,
1000  "STACKTOP": STACKTOP
1001 };
1002 var asm = Module["asm"](Module.asmGlobalArg, Module.asmLibraryArg, buffer);
1003 Module["asm"] = asm;
1004 var ___errno_location = Module["___errno_location"] = (function() {
1005  return Module["asm"]["___errno_location"].apply(null, arguments);
1006 });
1007 var _main = Module["_main"] = (function() {
1008  let start = benchmarkTime();
1009  let ret = Module["asm"]["_main"].apply(null, arguments);
1010  reportRunTime(benchmarkTime() - start);
1011  return ret;
1012 });
1013 var stackAlloc = Module["stackAlloc"] = (function() {
1014  return Module["asm"]["stackAlloc"].apply(null, arguments);
1015 });
1016 var dynCall_v = Module["dynCall_v"] = (function() {
1017  return Module["asm"]["dynCall_v"].apply(null, arguments);
1018 });
1019 var dynCall_vi = Module["dynCall_vi"] = (function() {
1020  return Module["asm"]["dynCall_vi"].apply(null, arguments);
1021 });
1022 Module["asm"] = asm;
1023 function ExitStatus(status) {
1024  this.name = "ExitStatus";
1025  this.message = "Program terminated with exit(" + status + ")";
1026  this.status = status;
1027 }
1028 ExitStatus.prototype = new Error;
1029 ExitStatus.prototype.constructor = ExitStatus;
1030 var initialStackTop;
1031 var calledMain = false;
1032 dependenciesFulfilled = function runCaller() {
1033  if (!Module["calledRun"]) run();
1034  if (!Module["calledRun"]) dependenciesFulfilled = runCaller;
1035 };
1036 Module["callMain"] = function callMain(args) {
1037  args = args || [];
1038  ensureInitRuntime();
1039  var argc = args.length + 1;
1040  var argv = stackAlloc((argc + 1) * 4);
1041  HEAP32[argv >> 2] = allocateUTF8OnStack(Module["thisProgram"]);
1042  for (var i = 1; i < argc; i++) {
1043   HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]);
1044  }
1045  HEAP32[(argv >> 2) + argc] = 0;
1046  try {
1047   var ret = Module["_main"](argc, argv, 0);
1048   exit(ret, true);
1049  } catch (e) {
1050   if (e instanceof ExitStatus) {
1051    return;
1052   } else if (e == "SimulateInfiniteLoop") {
1053    Module["noExitRuntime"] = true;
1054    return;
1055   } else {
1056    var toLog = e;
1057    if (e && typeof e === "object" && e.stack) {
1058     toLog = [ e, e.stack ];
1059    }
1060    err("exception thrown: " + toLog);
1061    Module["quit"](1, e);
1062   }
1063  } finally {
1064   calledMain = true;
1065  }
1066 };
1067 function run(args) {
1068  args = args || Module["arguments"];
1069  if (runDependencies > 0) {
1070   return;
1071  }
1072  preRun();
1073  if (runDependencies > 0) return;
1074  if (Module["calledRun"]) return;
1075  function doRun() {
1076   if (Module["calledRun"]) return;
1077   Module["calledRun"] = true;
1078   if (ABORT) return;
1079   ensureInitRuntime();
1080   preMain();
1081   if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
1082   if (Module["_main"] && shouldRunNow) Module["callMain"](args);
1083   postRun();
1084  }
1085  if (Module["setStatus"]) {
1086   Module["setStatus"]("Running...");
1087   setTimeout((function() {
1088    setTimeout((function() {
1089     Module["setStatus"]("");
1090    }), 1);
1091    doRun();
1092   }), 1);
1093  } else {
1094   doRun();
1095  }
1096 }
1097 Module["run"] = run;
1098 function exit(status, implicit) {
1099  if (implicit && Module["noExitRuntime"] && status === 0) {
1100   return;
1101  }
1102  if (Module["noExitRuntime"]) {} else {
1103   ABORT = true;
1104   EXITSTATUS = status;
1105   STACKTOP = initialStackTop;
1106   exitRuntime();
1107   if (Module["onExit"]) Module["onExit"](status);
1108  }
1109  Module["quit"](status, new ExitStatus(status));
1110 }
1111 function abort(what) {
1112  if (Module["onAbort"]) {
1113   Module["onAbort"](what);
1114  }
1115  if (what !== undefined) {
1116   out(what);
1117   err(what);
1118   what = JSON.stringify(what);
1119  } else {
1120   what = "";
1121  }
1122  ABORT = true;
1123  EXITSTATUS = 1;
1124  throw "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
1125 }
1126 Module["abort"] = abort;
1127 if (Module["preInit"]) {
1128  if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
1129  while (Module["preInit"].length > 0) {
1130   Module["preInit"].pop()();
1131  }
1132 }
1133 var shouldRunNow = true;
1134 if (Module["noInitialRun"]) {
1135  shouldRunNow = false;
1136 }
1137 Module["noExitRuntime"] = true;
1138 run();
1139 }