Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / wasm / quicksort.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 if (Module["ENVIRONMENT"]) {
22  if (Module["ENVIRONMENT"] === "WEB") {
23   ENVIRONMENT_IS_WEB = true;
24  } else if (Module["ENVIRONMENT"] === "WORKER") {
25   ENVIRONMENT_IS_WORKER = true;
26  } else if (Module["ENVIRONMENT"] === "NODE") {
27   ENVIRONMENT_IS_NODE = true;
28  } else if (Module["ENVIRONMENT"] === "SHELL") {
29   ENVIRONMENT_IS_SHELL = true;
30  } else {
31   throw new Error("Module['ENVIRONMENT'] value is not valid. must be one of: WEB|WORKER|NODE|SHELL.");
32  }
33 } else {
34  ENVIRONMENT_IS_WEB = typeof window === "object";
35  ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
36  ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
37  ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
38 }
39 if (ENVIRONMENT_IS_NODE) {
40  var nodeFS;
41  var nodePath;
42  Module["read"] = function shell_read(filename, binary) {
43   var ret;
44   if (!nodeFS) nodeFS = require("fs");
45   if (!nodePath) nodePath = require("path");
46   filename = nodePath["normalize"](filename);
47   ret = nodeFS["readFileSync"](filename);
48   return binary ? ret : ret.toString();
49  };
50  Module["readBinary"] = function readBinary(filename) {
51   var ret = Module["read"](filename, true);
52   if (!ret.buffer) {
53    ret = new Uint8Array(ret);
54   }
55   assert(ret.buffer);
56   return ret;
57  };
58  if (process["argv"].length > 1) {
59   Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/");
60  }
61  Module["arguments"] = process["argv"].slice(2);
62  if (typeof module !== "undefined") {
63   module["exports"] = Module;
64  }
65  process["on"]("uncaughtException", (function(ex) {
66   if (!(ex instanceof ExitStatus)) {
67    throw ex;
68   }
69  }));
70  process["on"]("unhandledRejection", (function(reason, p) {
71   process["exit"](1);
72  }));
73  Module["inspect"] = (function() {
74   return "[Emscripten Module object]";
75  });
76 } else if (ENVIRONMENT_IS_SHELL) {
77  if (typeof read != "undefined") {
78   Module["read"] = function shell_read(f) {
79    return read(f);
80   };
81  }
82  Module["readBinary"] = function readBinary(f) {
83   var data;
84   if (typeof readbuffer === "function") {
85    return new Uint8Array(readbuffer(f));
86   }
87   data = read(f, "binary");
88   assert(typeof data === "object");
89   return data;
90  };
91  if (typeof scriptArgs != "undefined") {
92   Module["arguments"] = scriptArgs;
93  } else if (typeof arguments != "undefined") {
94   Module["arguments"] = arguments;
95  }
96  if (typeof quit === "function") {
97   Module["quit"] = (function(status, toThrow) {
98    quit(status);
99   });
100  }
101 } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
102  Module["read"] = function shell_read(url) {
103   var xhr = new XMLHttpRequest;
104   xhr.open("GET", url, false);
105   xhr.send(null);
106   return xhr.responseText;
107  };
108  if (ENVIRONMENT_IS_WORKER) {
109   Module["readBinary"] = function readBinary(url) {
110    var xhr = new XMLHttpRequest;
111    xhr.open("GET", url, false);
112    xhr.responseType = "arraybuffer";
113    xhr.send(null);
114    return new Uint8Array(xhr.response);
115   };
116  }
117  Module["readAsync"] = function readAsync(url, onload, onerror) {
118   var xhr = new XMLHttpRequest;
119   xhr.open("GET", url, true);
120   xhr.responseType = "arraybuffer";
121   xhr.onload = function xhr_onload() {
122    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
123     onload(xhr.response);
124     return;
125    }
126    onerror();
127   };
128   xhr.onerror = onerror;
129   xhr.send(null);
130  };
131  Module["setWindowTitle"] = (function(title) {
132   document.title = title;
133  });
134 }
135 Module["print"] = typeof console !== "undefined" ? console.log.bind(console) : typeof print !== "undefined" ? print : null;
136 Module["printErr"] = typeof printErr !== "undefined" ? printErr : typeof console !== "undefined" && console.warn.bind(console) || Module["print"];
137 Module.print = Module["print"];
138 Module.printErr = Module["printErr"];
139 for (key in moduleOverrides) {
140  if (moduleOverrides.hasOwnProperty(key)) {
141   Module[key] = moduleOverrides[key];
142  }
143 }
144 moduleOverrides = undefined;
145 var STACK_ALIGN = 16;
146 function staticAlloc(size) {
147  assert(!staticSealed);
148  var ret = STATICTOP;
149  STATICTOP = STATICTOP + size + 15 & -16;
150  return ret;
151 }
152 function dynamicAlloc(size) {
153  assert(DYNAMICTOP_PTR);
154  var ret = HEAP32[DYNAMICTOP_PTR >> 2];
155  var end = ret + size + 15 & -16;
156  HEAP32[DYNAMICTOP_PTR >> 2] = end;
157  if (end >= TOTAL_MEMORY) {
158   var success = enlargeMemory();
159   if (!success) {
160    HEAP32[DYNAMICTOP_PTR >> 2] = ret;
161    return 0;
162   }
163  }
164  return ret;
165 }
166 function alignMemory(size, factor) {
167  if (!factor) factor = STACK_ALIGN;
168  var ret = size = Math.ceil(size / factor) * factor;
169  return ret;
170 }
171 function getNativeTypeSize(type) {
172  switch (type) {
173  case "i1":
174  case "i8":
175   return 1;
176  case "i16":
177   return 2;
178  case "i32":
179   return 4;
180  case "i64":
181   return 8;
182  case "float":
183   return 4;
184  case "double":
185   return 8;
186  default:
187   {
188    if (type[type.length - 1] === "*") {
189     return 4;
190    } else if (type[0] === "i") {
191     var bits = parseInt(type.substr(1));
192     assert(bits % 8 === 0);
193     return bits / 8;
194    } else {
195     return 0;
196    }
197   }
198  }
199 }
200 function warnOnce(text) {
201  if (!warnOnce.shown) warnOnce.shown = {};
202  if (!warnOnce.shown[text]) {
203   warnOnce.shown[text] = 1;
204   Module.printErr(text);
205  }
206 }
207 var jsCallStartIndex = 1;
208 var functionPointers = new Array(0);
209 var funcWrappers = {};
210 function dynCall(sig, ptr, args) {
211  if (args && args.length) {
212   return Module["dynCall_" + sig].apply(null, [ ptr ].concat(args));
213  } else {
214   return Module["dynCall_" + sig].call(null, ptr);
215  }
216 }
217 var GLOBAL_BASE = 1024;
218 var ABORT = 0;
219 var EXITSTATUS = 0;
220 function assert(condition, text) {
221  if (!condition) {
222   abort("Assertion failed: " + text);
223  }
224 }
225 function getCFunc(ident) {
226  var func = Module["_" + ident];
227  assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
228  return func;
229 }
230 var JSfuncs = {
231  "stackSave": (function() {
232   stackSave();
233  }),
234  "stackRestore": (function() {
235   stackRestore();
236  }),
237  "arrayToC": (function(arr) {
238   var ret = stackAlloc(arr.length);
239   writeArrayToMemory(arr, ret);
240   return ret;
241  }),
242  "stringToC": (function(str) {
243   var ret = 0;
244   if (str !== null && str !== undefined && str !== 0) {
245    var len = (str.length << 2) + 1;
246    ret = stackAlloc(len);
247    stringToUTF8(str, ret, len);
248   }
249   return ret;
250  })
251 };
252 var toC = {
253  "string": JSfuncs["stringToC"],
254  "array": JSfuncs["arrayToC"]
255 };
256 function ccall(ident, returnType, argTypes, args, opts) {
257  var func = getCFunc(ident);
258  var cArgs = [];
259  var stack = 0;
260  if (args) {
261   for (var i = 0; i < args.length; i++) {
262    var converter = toC[argTypes[i]];
263    if (converter) {
264     if (stack === 0) stack = stackSave();
265     cArgs[i] = converter(args[i]);
266    } else {
267     cArgs[i] = args[i];
268    }
269   }
270  }
271  var ret = func.apply(null, cArgs);
272  if (returnType === "string") ret = Pointer_stringify(ret); else if (returnType === "boolean") ret = Boolean(ret);
273  if (stack !== 0) {
274   stackRestore(stack);
275  }
276  return ret;
277 }
278 function setValue(ptr, value, type, noSafe) {
279  type = type || "i8";
280  if (type.charAt(type.length - 1) === "*") type = "i32";
281  switch (type) {
282  case "i1":
283   HEAP8[ptr >> 0] = value;
284   break;
285  case "i8":
286   HEAP8[ptr >> 0] = value;
287   break;
288  case "i16":
289   HEAP16[ptr >> 1] = value;
290   break;
291  case "i32":
292   HEAP32[ptr >> 2] = value;
293   break;
294  case "i64":
295   tempI64 = [ value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
296   break;
297  case "float":
298   HEAPF32[ptr >> 2] = value;
299   break;
300  case "double":
301   HEAPF64[ptr >> 3] = value;
302   break;
303  default:
304   abort("invalid type for setValue: " + type);
305  }
306 }
307 var ALLOC_STATIC = 2;
308 var ALLOC_NONE = 4;
309 function Pointer_stringify(ptr, length) {
310  if (length === 0 || !ptr) return "";
311  var hasUtf = 0;
312  var t;
313  var i = 0;
314  while (1) {
315   t = HEAPU8[ptr + i >> 0];
316   hasUtf |= t;
317   if (t == 0 && !length) break;
318   i++;
319   if (length && i == length) break;
320  }
321  if (!length) length = i;
322  var ret = "";
323  if (hasUtf < 128) {
324   var MAX_CHUNK = 1024;
325   var curr;
326   while (length > 0) {
327    curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
328    ret = ret ? ret + curr : curr;
329    ptr += MAX_CHUNK;
330    length -= MAX_CHUNK;
331   }
332   return ret;
333  }
334  return UTF8ToString(ptr);
335 }
336 var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
337 function UTF8ArrayToString(u8Array, idx) {
338  var endPtr = idx;
339  while (u8Array[endPtr]) ++endPtr;
340  if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
341   return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
342  } else {
343   var u0, u1, u2, u3, u4, u5;
344   var str = "";
345   while (1) {
346    u0 = u8Array[idx++];
347    if (!u0) return str;
348    if (!(u0 & 128)) {
349     str += String.fromCharCode(u0);
350     continue;
351    }
352    u1 = u8Array[idx++] & 63;
353    if ((u0 & 224) == 192) {
354     str += String.fromCharCode((u0 & 31) << 6 | u1);
355     continue;
356    }
357    u2 = u8Array[idx++] & 63;
358    if ((u0 & 240) == 224) {
359     u0 = (u0 & 15) << 12 | u1 << 6 | u2;
360    } else {
361     u3 = u8Array[idx++] & 63;
362     if ((u0 & 248) == 240) {
363      u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3;
364     } else {
365      u4 = u8Array[idx++] & 63;
366      if ((u0 & 252) == 248) {
367       u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4;
368      } else {
369       u5 = u8Array[idx++] & 63;
370       u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5;
371      }
372     }
373    }
374    if (u0 < 65536) {
375     str += String.fromCharCode(u0);
376    } else {
377     var ch = u0 - 65536;
378     str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
379    }
380   }
381  }
382 }
383 function UTF8ToString(ptr) {
384  return UTF8ArrayToString(HEAPU8, ptr);
385 }
386 function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
387  if (!(maxBytesToWrite > 0)) return 0;
388  var startIdx = outIdx;
389  var endIdx = outIdx + maxBytesToWrite - 1;
390  for (var i = 0; i < str.length; ++i) {
391   var u = str.charCodeAt(i);
392   if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
393   if (u <= 127) {
394    if (outIdx >= endIdx) break;
395    outU8Array[outIdx++] = u;
396   } else if (u <= 2047) {
397    if (outIdx + 1 >= endIdx) break;
398    outU8Array[outIdx++] = 192 | u >> 6;
399    outU8Array[outIdx++] = 128 | u & 63;
400   } else if (u <= 65535) {
401    if (outIdx + 2 >= endIdx) break;
402    outU8Array[outIdx++] = 224 | u >> 12;
403    outU8Array[outIdx++] = 128 | u >> 6 & 63;
404    outU8Array[outIdx++] = 128 | u & 63;
405   } else if (u <= 2097151) {
406    if (outIdx + 3 >= endIdx) break;
407    outU8Array[outIdx++] = 240 | u >> 18;
408    outU8Array[outIdx++] = 128 | u >> 12 & 63;
409    outU8Array[outIdx++] = 128 | u >> 6 & 63;
410    outU8Array[outIdx++] = 128 | u & 63;
411   } else if (u <= 67108863) {
412    if (outIdx + 4 >= endIdx) break;
413    outU8Array[outIdx++] = 248 | u >> 24;
414    outU8Array[outIdx++] = 128 | u >> 18 & 63;
415    outU8Array[outIdx++] = 128 | u >> 12 & 63;
416    outU8Array[outIdx++] = 128 | u >> 6 & 63;
417    outU8Array[outIdx++] = 128 | u & 63;
418   } else {
419    if (outIdx + 5 >= endIdx) break;
420    outU8Array[outIdx++] = 252 | u >> 30;
421    outU8Array[outIdx++] = 128 | u >> 24 & 63;
422    outU8Array[outIdx++] = 128 | u >> 18 & 63;
423    outU8Array[outIdx++] = 128 | u >> 12 & 63;
424    outU8Array[outIdx++] = 128 | u >> 6 & 63;
425    outU8Array[outIdx++] = 128 | u & 63;
426   }
427  }
428  outU8Array[outIdx] = 0;
429  return outIdx - startIdx;
430 }
431 function stringToUTF8(str, outPtr, maxBytesToWrite) {
432  return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
433 }
434 function lengthBytesUTF8(str) {
435  var len = 0;
436  for (var i = 0; i < str.length; ++i) {
437   var u = str.charCodeAt(i);
438   if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
439   if (u <= 127) {
440    ++len;
441   } else if (u <= 2047) {
442    len += 2;
443   } else if (u <= 65535) {
444    len += 3;
445   } else if (u <= 2097151) {
446    len += 4;
447   } else if (u <= 67108863) {
448    len += 5;
449   } else {
450    len += 6;
451   }
452  }
453  return len;
454 }
455 var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
456 function allocateUTF8OnStack(str) {
457  var size = lengthBytesUTF8(str) + 1;
458  var ret = stackAlloc(size);
459  stringToUTF8Array(str, HEAP8, ret, size);
460  return ret;
461 }
462 function demangle(func) {
463  return func;
464 }
465 function demangleAll(text) {
466  var regex = /__Z[\w\d_]+/g;
467  return text.replace(regex, (function(x) {
468   var y = demangle(x);
469   return x === y ? x : x + " [" + y + "]";
470  }));
471 }
472 function jsStackTrace() {
473  var err = new Error;
474  if (!err.stack) {
475   try {
476    throw new Error(0);
477   } catch (e) {
478    err = e;
479   }
480   if (!err.stack) {
481    return "(no stack trace available)";
482   }
483  }
484  return err.stack.toString();
485 }
486 var WASM_PAGE_SIZE = 65536;
487 var ASMJS_PAGE_SIZE = 16777216;
488 function alignUp(x, multiple) {
489  if (x % multiple > 0) {
490   x += multiple - x % multiple;
491  }
492  return x;
493 }
494 var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
495 function updateGlobalBuffer(buf) {
496  Module["buffer"] = buffer = buf;
497 }
498 function updateGlobalBufferViews() {
499  Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
500  Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
501  Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
502  Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
503  Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
504  Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
505  Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
506  Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer);
507 }
508 var STATIC_BASE, STATICTOP, staticSealed;
509 var STACK_BASE, STACKTOP, STACK_MAX;
510 var DYNAMIC_BASE, DYNAMICTOP_PTR;
511 STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
512 staticSealed = false;
513 function abortOnCannotGrowMemory() {
514  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 ");
515 }
516 function enlargeMemory() {
517  abortOnCannotGrowMemory();
518 }
519 var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
520 var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 67108864;
521 if (TOTAL_MEMORY < TOTAL_STACK) Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
522 if (Module["buffer"]) {
523  buffer = Module["buffer"];
524 } else {
525  if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") {
526   Module["wasmMemory"] = new WebAssembly.Memory({
527    "initial": TOTAL_MEMORY / WASM_PAGE_SIZE,
528    "maximum": TOTAL_MEMORY / WASM_PAGE_SIZE
529   });
530   buffer = Module["wasmMemory"].buffer;
531  } else {
532   buffer = new ArrayBuffer(TOTAL_MEMORY);
533  }
534  Module["buffer"] = buffer;
535 }
536 updateGlobalBufferViews();
537 function getTotalMemory() {
538  return TOTAL_MEMORY;
539 }
540 HEAP32[0] = 1668509029;
541 HEAP16[1] = 25459;
542 if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99) throw "Runtime error: expected the system to be little-endian!";
543 function callRuntimeCallbacks(callbacks) {
544  while (callbacks.length > 0) {
545   var callback = callbacks.shift();
546   if (typeof callback == "function") {
547    callback();
548    continue;
549   }
550   var func = callback.func;
551   if (typeof func === "number") {
552    if (callback.arg === undefined) {
553     Module["dynCall_v"](func);
554    } else {
555     Module["dynCall_vi"](func, callback.arg);
556    }
557   } else {
558    func(callback.arg === undefined ? null : callback.arg);
559   }
560  }
561 }
562 var __ATPRERUN__ = [];
563 var __ATINIT__ = [];
564 var __ATMAIN__ = [];
565 var __ATEXIT__ = [];
566 var __ATPOSTRUN__ = [];
567 var runtimeInitialized = false;
568 var runtimeExited = false;
569 function preRun() {
570  if (Module["preRun"]) {
571   if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
572   while (Module["preRun"].length) {
573    addOnPreRun(Module["preRun"].shift());
574   }
575  }
576  callRuntimeCallbacks(__ATPRERUN__);
577 }
578 function ensureInitRuntime() {
579  if (runtimeInitialized) return;
580  runtimeInitialized = true;
581  callRuntimeCallbacks(__ATINIT__);
582 }
583 function preMain() {
584  callRuntimeCallbacks(__ATMAIN__);
585 }
586 function exitRuntime() {
587  callRuntimeCallbacks(__ATEXIT__);
588  runtimeExited = true;
589 }
590 function postRun() {
591  if (Module["postRun"]) {
592   if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
593   while (Module["postRun"].length) {
594    addOnPostRun(Module["postRun"].shift());
595   }
596  }
597  callRuntimeCallbacks(__ATPOSTRUN__);
598 }
599 function addOnPreRun(cb) {
600  __ATPRERUN__.unshift(cb);
601 }
602 function addOnPostRun(cb) {
603  __ATPOSTRUN__.unshift(cb);
604 }
605 function writeArrayToMemory(array, buffer) {
606  HEAP8.set(array, buffer);
607 }
608 function writeAsciiToMemory(str, buffer, dontAddNull) {
609  for (var i = 0; i < str.length; ++i) {
610   HEAP8[buffer++ >> 0] = str.charCodeAt(i);
611  }
612  if (!dontAddNull) HEAP8[buffer >> 0] = 0;
613 }
614 var Math_abs = Math.abs;
615 var Math_cos = Math.cos;
616 var Math_sin = Math.sin;
617 var Math_tan = Math.tan;
618 var Math_acos = Math.acos;
619 var Math_asin = Math.asin;
620 var Math_atan = Math.atan;
621 var Math_atan2 = Math.atan2;
622 var Math_exp = Math.exp;
623 var Math_log = Math.log;
624 var Math_sqrt = Math.sqrt;
625 var Math_ceil = Math.ceil;
626 var Math_floor = Math.floor;
627 var Math_pow = Math.pow;
628 var Math_imul = Math.imul;
629 var Math_fround = Math.fround;
630 var Math_round = Math.round;
631 var Math_min = Math.min;
632 var Math_max = Math.max;
633 var Math_clz32 = Math.clz32;
634 var Math_trunc = Math.trunc;
635 var runDependencies = 0;
636 var runDependencyWatcher = null;
637 var dependenciesFulfilled = null;
638 function addRunDependency(id) {
639  runDependencies++;
640  if (Module["monitorRunDependencies"]) {
641   Module["monitorRunDependencies"](runDependencies);
642  }
643 }
644 function removeRunDependency(id) {
645  runDependencies--;
646  if (Module["monitorRunDependencies"]) {
647   Module["monitorRunDependencies"](runDependencies);
648  }
649  if (runDependencies == 0) {
650   if (runDependencyWatcher !== null) {
651    clearInterval(runDependencyWatcher);
652    runDependencyWatcher = null;
653   }
654   if (dependenciesFulfilled) {
655    var callback = dependenciesFulfilled;
656    dependenciesFulfilled = null;
657    callback();
658   }
659  }
660 }
661 Module["preloadedImages"] = {};
662 Module["preloadedAudios"] = {};
663 var dataURIPrefix = "data:application/octet-stream;base64,";
664 function isDataURI(filename) {
665  return String.prototype.startsWith ? filename.startsWith(dataURIPrefix) : filename.indexOf(dataURIPrefix) === 0;
666 }
667 function integrateWasmJS() {
668  var wasmTextFile = "quicksort.wast";
669  var wasmBinaryFile = "quicksort.wasm";
670  var asmjsCodeFile = "quicksort.temp.asm.js";
671  if (typeof Module["locateFile"] === "function") {
672   if (!isDataURI(wasmTextFile)) {
673    wasmTextFile = Module["locateFile"](wasmTextFile);
674   }
675   if (!isDataURI(wasmBinaryFile)) {
676    wasmBinaryFile = Module["locateFile"](wasmBinaryFile);
677   }
678   if (!isDataURI(asmjsCodeFile)) {
679    asmjsCodeFile = Module["locateFile"](asmjsCodeFile);
680   }
681  }
682  var wasmPageSize = 64 * 1024;
683  var info = {
684   "global": null,
685   "env": null,
686   "asm2wasm": {
687    "f64-rem": (function(x, y) {
688     return x % y;
689    }),
690    "debugger": (function() {
691     debugger;
692    })
693   },
694   "parent": Module
695  };
696  var exports = null;
697  function mergeMemory(newBuffer) {
698   var oldBuffer = Module["buffer"];
699   if (newBuffer.byteLength < oldBuffer.byteLength) {
700    Module["printErr"]("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here");
701   }
702   var oldView = new Int8Array(oldBuffer);
703   var newView = new Int8Array(newBuffer);
704   newView.set(oldView);
705   updateGlobalBuffer(newBuffer);
706   updateGlobalBufferViews();
707  }
708  function fixImports(imports) {
709   return imports;
710  }
711  function getBinary() {
712   try {
713    if (Module["wasmBinary"]) {
714     return new Uint8Array(Module["wasmBinary"]);
715    }
716     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)";
717   } catch (err) {
718    abort(err);
719   }
720  }
721  function getBinaryPromise() {
722   if (!Module["wasmBinary"] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function") {
723    return fetch(wasmBinaryFile, {
724     credentials: "same-origin"
725    }).then((function(response) {
726     if (!response["ok"]) {
727      throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
728     }
729     return response["arrayBuffer"]();
730    })).catch((function() {
731     return getBinary();
732    }));
733   }
734   return new Promise((function(resolve, reject) {
735    resolve(getBinary());
736   }));
737  }
738  function doNativeWasm(global, env, providedBuffer) {
739   if (typeof WebAssembly !== "object") {
740    Module["printErr"]("no native wasm support detected");
741    return false;
742   }
743   if (!(Module["wasmMemory"] instanceof WebAssembly.Memory)) {
744    Module["printErr"]("no native wasm Memory in use");
745    return false;
746   }
747   env["memory"] = Module["wasmMemory"];
748   info["global"] = {
749    "NaN": NaN,
750    "Infinity": Infinity
751   };
752   info["global.Math"] = Math;
753   info["env"] = env;
754   function receiveInstance(instance, module) {
755    exports = instance.exports;
756    if (exports.memory) mergeMemory(exports.memory);
757    Module["asm"] = exports;
758    Module["usingWasm"] = true;
759    removeRunDependency("wasm-instantiate");
760   }
761   addRunDependency("wasm-instantiate");
762   if (Module["instantiateWasm"]) {
763    try {
764     return Module["instantiateWasm"](info, receiveInstance);
765    } catch (e) {
766     Module["printErr"]("Module.instantiateWasm callback failed with error: " + e);
767     return false;
768    }
769   }
770   function receiveInstantiatedSource(output) {
771    receiveInstance(output["instance"], output["module"]);
772   }
773   function instantiateArrayBuffer(receiver) {
774    getBinaryPromise().then((function(binary) {
775     return WebAssembly.instantiate(binary, info);
776    })).then((...args) => {
777        reportCompileTime(benchmarkTime() - __startupStartTime);
778        return Promise.resolve(...args);
779    })
780    .then(receiver).catch((function(reason) {
781     Module["printErr"]("failed to asynchronously prepare wasm: " + reason);
782     abort(reason);
783    }));
784   }
785   if (!Module["wasmBinary"] && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
786    WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, {
787     credentials: "same-origin"
788    }), info).then(receiveInstantiatedSource).catch((function(reason) {
789     Module["printErr"]("wasm streaming compile failed: " + reason);
790     Module["printErr"]("falling back to ArrayBuffer instantiation");
791     instantiateArrayBuffer(receiveInstantiatedSource);
792    }));
793   } else {
794    instantiateArrayBuffer(receiveInstantiatedSource);
795   }
796   return {};
797  }
798  Module["asmPreload"] = Module["asm"];
799  var asmjsReallocBuffer = Module["reallocBuffer"];
800  var wasmReallocBuffer = (function(size) {
801   var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE;
802   size = alignUp(size, PAGE_MULTIPLE);
803   var old = Module["buffer"];
804   var oldSize = old.byteLength;
805   if (Module["usingWasm"]) {
806    try {
807     var result = Module["wasmMemory"].grow((size - oldSize) / wasmPageSize);
808     if (result !== (-1 | 0)) {
809      return Module["buffer"] = Module["wasmMemory"].buffer;
810     } else {
811      return null;
812     }
813    } catch (e) {
814     return null;
815    }
816   }
817  });
818  Module["reallocBuffer"] = (function(size) {
819   if (finalMethod === "asmjs") {
820    return asmjsReallocBuffer(size);
821   } else {
822    return wasmReallocBuffer(size);
823   }
824  });
825  var finalMethod = "";
826  Module["asm"] = (function(global, env, providedBuffer) {
827   env = fixImports(env);
828   if (!env["table"]) {
829    var TABLE_SIZE = Module["wasmTableSize"];
830    if (TABLE_SIZE === undefined) TABLE_SIZE = 1024;
831    var MAX_TABLE_SIZE = Module["wasmMaxTableSize"];
832    if (typeof WebAssembly === "object" && typeof WebAssembly.Table === "function") {
833     if (MAX_TABLE_SIZE !== undefined) {
834      env["table"] = new WebAssembly.Table({
835       "initial": TABLE_SIZE,
836       "maximum": MAX_TABLE_SIZE,
837       "element": "anyfunc"
838      });
839     } else {
840      env["table"] = new WebAssembly.Table({
841       "initial": TABLE_SIZE,
842       element: "anyfunc"
843      });
844     }
845    } else {
846     env["table"] = new Array(TABLE_SIZE);
847    }
848    Module["wasmTable"] = env["table"];
849   }
850   if (!env["memoryBase"]) {
851    env["memoryBase"] = Module["STATIC_BASE"];
852   }
853   if (!env["tableBase"]) {
854    env["tableBase"] = 0;
855   }
856   var exports;
857   exports = doNativeWasm(global, env, providedBuffer);
858   if (!exports) abort("no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: https://github.com/kripken/emscripten/wiki/WebAssembly#binaryen-methods");
859   return exports;
860  });
861 }
862 integrateWasmJS();
863 STATIC_BASE = GLOBAL_BASE;
864 STATICTOP = STATIC_BASE + 22720;
865 __ATINIT__.push();
866 var STATIC_BUMP = 22720;
867 Module["STATIC_BASE"] = STATIC_BASE;
868 Module["STATIC_BUMP"] = STATIC_BUMP;
869 var tempDoublePtr = STATICTOP;
870 STATICTOP += 16;
871 var SYSCALLS = {
872  varargs: 0,
873  get: (function(varargs) {
874   SYSCALLS.varargs += 4;
875   var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
876   return ret;
877  }),
878  getStr: (function() {
879   var ret = Pointer_stringify(SYSCALLS.get());
880   return ret;
881  }),
882  get64: (function() {
883   var low = SYSCALLS.get(), high = SYSCALLS.get();
884   if (low >= 0) assert(high === 0); else assert(high === -1);
885   return low;
886  }),
887  getZero: (function() {
888   assert(SYSCALLS.get() === 0);
889  })
890 };
891 function ___syscall140(which, varargs) {
892  SYSCALLS.varargs = varargs;
893  try {
894   var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get();
895   var offset = offset_low;
896   FS.llseek(stream, offset, whence);
897   HEAP32[result >> 2] = stream.position;
898   if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
899   return 0;
900  } catch (e) {
901   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
902   return -e.errno;
903  }
904 }
905 function flush_NO_FILESYSTEM() {
906  var fflush = Module["_fflush"];
907  if (fflush) fflush(0);
908  var printChar = ___syscall146.printChar;
909  if (!printChar) return;
910  var buffers = ___syscall146.buffers;
911  if (buffers[1].length) printChar(1, 10);
912  if (buffers[2].length) printChar(2, 10);
913 }
914 function ___syscall146(which, varargs) {
915  SYSCALLS.varargs = varargs;
916  try {
917   var stream = SYSCALLS.get(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get();
918   var ret = 0;
919   if (!___syscall146.buffers) {
920    ___syscall146.buffers = [ null, [], [] ];
921    ___syscall146.printChar = (function(stream, curr) {
922     var buffer = ___syscall146.buffers[stream];
923     assert(buffer);
924     if (curr === 0 || curr === 10) {
925      (stream === 1 ? Module["print"] : Module["printErr"])(UTF8ArrayToString(buffer, 0));
926      buffer.length = 0;
927     } else {
928      buffer.push(curr);
929     }
930    });
931   }
932   for (var i = 0; i < iovcnt; i++) {
933    var ptr = HEAP32[iov + i * 8 >> 2];
934    var len = HEAP32[iov + (i * 8 + 4) >> 2];
935    for (var j = 0; j < len; j++) {
936     ___syscall146.printChar(stream, HEAPU8[ptr + j]);
937    }
938    ret += len;
939   }
940   return ret;
941  } catch (e) {
942   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
943   return -e.errno;
944  }
945 }
946 function ___syscall54(which, varargs) {
947  SYSCALLS.varargs = varargs;
948  try {
949   return 0;
950  } catch (e) {
951   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
952   return -e.errno;
953  }
954 }
955 function ___syscall6(which, varargs) {
956  SYSCALLS.varargs = varargs;
957  try {
958   var stream = SYSCALLS.getStreamFromFD();
959   FS.close(stream);
960   return 0;
961  } catch (e) {
962   if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
963   return -e.errno;
964  }
965 }
966 function _emscripten_memcpy_big(dest, src, num) {
967  HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
968  return dest;
969 }
970 function ___setErrNo(value) {
971  if (Module["___errno_location"]) HEAP32[Module["___errno_location"]() >> 2] = value;
972  return value;
973 }
974 DYNAMICTOP_PTR = staticAlloc(4);
975 STACK_BASE = STACKTOP = alignMemory(STATICTOP);
976 STACK_MAX = STACK_BASE + TOTAL_STACK;
977 DYNAMIC_BASE = alignMemory(STACK_MAX);
978 HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
979 staticSealed = true;
980 var ASSERTIONS = false;
981 Module["wasmTableSize"] = 6;
982 Module["wasmMaxTableSize"] = 6;
983 function invoke_ii(index, a1) {
984  try {
985   return Module["dynCall_ii"](index, a1);
986  } catch (e) {
987   if (typeof e !== "number" && e !== "longjmp") throw e;
988   Module["setThrew"](1, 0);
989  }
990 }
991 function invoke_iiii(index, a1, a2, a3) {
992  try {
993   return Module["dynCall_iiii"](index, a1, a2, a3);
994  } catch (e) {
995   if (typeof e !== "number" && e !== "longjmp") throw e;
996   Module["setThrew"](1, 0);
997  }
998 }
999 Module.asmGlobalArg = {};
1000 Module.asmLibraryArg = {
1001  "abort": abort,
1002  "assert": assert,
1003  "enlargeMemory": enlargeMemory,
1004  "getTotalMemory": getTotalMemory,
1005  "abortOnCannotGrowMemory": abortOnCannotGrowMemory,
1006  "invoke_ii": invoke_ii,
1007  "invoke_iiii": invoke_iiii,
1008  "___setErrNo": ___setErrNo,
1009  "___syscall140": ___syscall140,
1010  "___syscall146": ___syscall146,
1011  "___syscall54": ___syscall54,
1012  "___syscall6": ___syscall6,
1013  "_emscripten_memcpy_big": _emscripten_memcpy_big,
1014  "flush_NO_FILESYSTEM": flush_NO_FILESYSTEM,
1015  "DYNAMICTOP_PTR": DYNAMICTOP_PTR,
1016  "tempDoublePtr": tempDoublePtr,
1017  "ABORT": ABORT,
1018  "STACKTOP": STACKTOP,
1019  "STACK_MAX": STACK_MAX
1020 };
1021 var asm = Module["asm"](Module.asmGlobalArg, Module.asmLibraryArg, buffer);
1022 Module["asm"] = asm;
1023 var ___errno_location = Module["___errno_location"] = (function() {
1024  return Module["asm"]["___errno_location"].apply(null, arguments);
1025 });
1026 var _free = Module["_free"] = (function() {
1027  return Module["asm"]["_free"].apply(null, arguments);
1028 });
1029 var _main = Module["_main"] = (function() {
1030  let start = benchmarkTime();
1031  let result = Module["asm"]["_main"].apply(null, arguments);
1032  reportRunTime(benchmarkTime() - start);
1033  return result;
1034 });
1035 var _malloc = Module["_malloc"] = (function() {
1036  return Module["asm"]["_malloc"].apply(null, arguments);
1037 });
1038 var _memcpy = Module["_memcpy"] = (function() {
1039  return Module["asm"]["_memcpy"].apply(null, arguments);
1040 });
1041 var _memset = Module["_memset"] = (function() {
1042  return Module["asm"]["_memset"].apply(null, arguments);
1043 });
1044 var _sbrk = Module["_sbrk"] = (function() {
1045  return Module["asm"]["_sbrk"].apply(null, arguments);
1046 });
1047 var establishStackSpace = Module["establishStackSpace"] = (function() {
1048  return Module["asm"]["establishStackSpace"].apply(null, arguments);
1049 });
1050 var getTempRet0 = Module["getTempRet0"] = (function() {
1051  return Module["asm"]["getTempRet0"].apply(null, arguments);
1052 });
1053 var runPostSets = Module["runPostSets"] = (function() {
1054  return Module["asm"]["runPostSets"].apply(null, arguments);
1055 });
1056 var setTempRet0 = Module["setTempRet0"] = (function() {
1057  return Module["asm"]["setTempRet0"].apply(null, arguments);
1058 });
1059 var setThrew = Module["setThrew"] = (function() {
1060  return Module["asm"]["setThrew"].apply(null, arguments);
1061 });
1062 var stackAlloc = Module["stackAlloc"] = (function() {
1063  return Module["asm"]["stackAlloc"].apply(null, arguments);
1064 });
1065 var stackRestore = Module["stackRestore"] = (function() {
1066  return Module["asm"]["stackRestore"].apply(null, arguments);
1067 });
1068 var stackSave = Module["stackSave"] = (function() {
1069  return Module["asm"]["stackSave"].apply(null, arguments);
1070 });
1071 var dynCall_ii = Module["dynCall_ii"] = (function() {
1072  return Module["asm"]["dynCall_ii"].apply(null, arguments);
1073 });
1074 var dynCall_iiii = Module["dynCall_iiii"] = (function() {
1075  return Module["asm"]["dynCall_iiii"].apply(null, arguments);
1076 });
1077 Module["asm"] = asm;
1078 function ExitStatus(status) {
1079  this.name = "ExitStatus";
1080  this.message = "Program terminated with exit(" + status + ")";
1081  this.status = status;
1082 }
1083 ExitStatus.prototype = new Error;
1084 ExitStatus.prototype.constructor = ExitStatus;
1085 var initialStackTop;
1086 var calledMain = false;
1087 dependenciesFulfilled = function runCaller() {
1088  if (!Module["calledRun"]) run();
1089  if (!Module["calledRun"]) dependenciesFulfilled = runCaller;
1090 };
1091 Module["callMain"] = function callMain(args) {
1092  args = args || [];
1093  ensureInitRuntime();
1094  var argc = args.length + 1;
1095  var argv = stackAlloc((argc + 1) * 4);
1096  HEAP32[argv >> 2] = allocateUTF8OnStack(Module["thisProgram"]);
1097  for (var i = 1; i < argc; i++) {
1098   HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]);
1099  }
1100  HEAP32[(argv >> 2) + argc] = 0;
1101  try {
1102   var ret = Module["_main"](argc, argv, 0);
1103   exit(ret, true);
1104  } catch (e) {
1105   if (e instanceof ExitStatus) {
1106    return;
1107   } else if (e == "SimulateInfiniteLoop") {
1108    Module["noExitRuntime"] = true;
1109    return;
1110   } else {
1111    var toLog = e;
1112    if (e && typeof e === "object" && e.stack) {
1113     toLog = [ e, e.stack ];
1114    }
1115    Module.printErr("exception thrown: " + toLog);
1116    Module["quit"](1, e);
1117   }
1118  } finally {
1119   calledMain = true;
1120  }
1121 };
1122 function run(args) {
1123  args = args || Module["arguments"];
1124  if (runDependencies > 0) {
1125   return;
1126  }
1127  preRun();
1128  if (runDependencies > 0) return;
1129  if (Module["calledRun"]) return;
1130  function doRun() {
1131   if (Module["calledRun"]) return;
1132   Module["calledRun"] = true;
1133   if (ABORT) return;
1134   ensureInitRuntime();
1135   preMain();
1136   if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
1137   if (Module["_main"] && shouldRunNow) Module["callMain"](args);
1138   postRun();
1139  }
1140  if (Module["setStatus"]) {
1141   Module["setStatus"]("Running...");
1142   setTimeout((function() {
1143    setTimeout((function() {
1144     Module["setStatus"]("");
1145    }), 1);
1146    doRun();
1147   }), 1);
1148  } else {
1149   doRun();
1150  }
1151 }
1152 Module["run"] = run;
1153 function exit(status, implicit) {
1154  if (implicit && Module["noExitRuntime"] && status === 0) {
1155   return;
1156  }
1157  if (Module["noExitRuntime"]) {} else {
1158   ABORT = true;
1159   EXITSTATUS = status;
1160   STACKTOP = initialStackTop;
1161   exitRuntime();
1162   if (Module["onExit"]) Module["onExit"](status);
1163  }
1164  if (ENVIRONMENT_IS_NODE) {
1165   process["exit"](status);
1166  }
1167  Module["quit"](status, new ExitStatus(status));
1168 }
1169 Module["exit"] = exit;
1170 function abort(what) {
1171  if (Module["onAbort"]) {
1172   Module["onAbort"](what);
1173  }
1174  if (what !== undefined) {
1175   Module.print(what);
1176   Module.printErr(what);
1177   what = JSON.stringify(what);
1178  } else {
1179   what = "";
1180  }
1181  ABORT = true;
1182  EXITSTATUS = 1;
1183  throw "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
1184 }
1185 Module["abort"] = abort;
1186 if (Module["preInit"]) {
1187  if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
1188  while (Module["preInit"].length > 0) {
1189   Module["preInit"].pop()();
1190  }
1191 }
1192 var shouldRunNow = true;
1193 if (Module["noInitialRun"]) {
1194  shouldRunNow = false;
1195 }
1196 Module["noExitRuntime"] = true;
1197 run();
1198 }