Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / wasm / richards.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 dynamicAlloc(size) {
160  var ret = HEAP32[DYNAMICTOP_PTR >> 2];
161  var end = ret + size + 15 & -16;
162  HEAP32[DYNAMICTOP_PTR >> 2] = end;
163  if (end >= TOTAL_MEMORY) {
164   var success = enlargeMemory();
165   if (!success) {
166    HEAP32[DYNAMICTOP_PTR >> 2] = ret;
167    return 0;
168   }
169  }
170  return ret;
171 }
172 function alignMemory(size, factor) {
173  if (!factor) factor = STACK_ALIGN;
174  var ret = size = Math.ceil(size / factor) * factor;
175  return ret;
176 }
177 function getNativeTypeSize(type) {
178  switch (type) {
179  case "i1":
180  case "i8":
181   return 1;
182  case "i16":
183   return 2;
184  case "i32":
185   return 4;
186  case "i64":
187   return 8;
188  case "float":
189   return 4;
190  case "double":
191   return 8;
192  default:
193   {
194    if (type[type.length - 1] === "*") {
195     return 4;
196    } else if (type[0] === "i") {
197     var bits = parseInt(type.substr(1));
198     assert(bits % 8 === 0);
199     return bits / 8;
200    } else {
201     return 0;
202    }
203   }
204  }
205 }
206 function warnOnce(text) {
207  if (!warnOnce.shown) warnOnce.shown = {};
208  if (!warnOnce.shown[text]) {
209   warnOnce.shown[text] = 1;
210   err(text);
211  }
212 }
213 var asm2wasmImports = {
214  "f64-rem": (function(x, y) {
215   return x % y;
216  }),
217  "debugger": (function() {
218   debugger;
219  })
220 };
221 var jsCallStartIndex = 1;
222 var functionPointers = new Array(0);
223 var funcWrappers = {};
224 function dynCall(sig, ptr, args) {
225  if (args && args.length) {
226   return Module["dynCall_" + sig].apply(null, [ ptr ].concat(args));
227  } else {
228   return Module["dynCall_" + sig].call(null, ptr);
229  }
230 }
231 var GLOBAL_BASE = 1024;
232 var ABORT = 0;
233 var EXITSTATUS = 0;
234 function assert(condition, text) {
235  if (!condition) {
236   abort("Assertion failed: " + text);
237  }
238 }
239 function getCFunc(ident) {
240  var func = Module["_" + ident];
241  assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
242  return func;
243 }
244 var JSfuncs = {
245  "stackSave": (function() {
246   stackSave();
247  }),
248  "stackRestore": (function() {
249   stackRestore();
250  }),
251  "arrayToC": (function(arr) {
252   var ret = stackAlloc(arr.length);
253   writeArrayToMemory(arr, ret);
254   return ret;
255  }),
256  "stringToC": (function(str) {
257   var ret = 0;
258   if (str !== null && str !== undefined && str !== 0) {
259    var len = (str.length << 2) + 1;
260    ret = stackAlloc(len);
261    stringToUTF8(str, ret, len);
262   }
263   return ret;
264  })
265 };
266 var toC = {
267  "string": JSfuncs["stringToC"],
268  "array": JSfuncs["arrayToC"]
269 };
270 function ccall(ident, returnType, argTypes, args, opts) {
271  function convertReturnValue(ret) {
272   if (returnType === "string") return Pointer_stringify(ret);
273   if (returnType === "boolean") return Boolean(ret);
274   return ret;
275  }
276  var func = getCFunc(ident);
277  var cArgs = [];
278  var stack = 0;
279  if (args) {
280   for (var i = 0; i < args.length; i++) {
281    var converter = toC[argTypes[i]];
282    if (converter) {
283     if (stack === 0) stack = stackSave();
284     cArgs[i] = converter(args[i]);
285    } else {
286     cArgs[i] = args[i];
287    }
288   }
289  }
290  var ret = func.apply(null, cArgs);
291  ret = convertReturnValue(ret);
292  if (stack !== 0) stackRestore(stack);
293  return ret;
294 }
295 function setValue(ptr, value, type, noSafe) {
296  type = type || "i8";
297  if (type.charAt(type.length - 1) === "*") type = "i32";
298  switch (type) {
299  case "i1":
300   HEAP8[ptr >> 0] = value;
301   break;
302  case "i8":
303   HEAP8[ptr >> 0] = value;
304   break;
305  case "i16":
306   HEAP16[ptr >> 1] = value;
307   break;
308  case "i32":
309   HEAP32[ptr >> 2] = value;
310   break;
311  case "i64":
312   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];
313   break;
314  case "float":
315   HEAPF32[ptr >> 2] = value;
316   break;
317  case "double":
318   HEAPF64[ptr >> 3] = value;
319   break;
320  default:
321   abort("invalid type for setValue: " + type);
322  }
323 }
324 var ALLOC_STATIC = 2;
325 var ALLOC_NONE = 4;
326 function Pointer_stringify(ptr, length) {
327  if (length === 0 || !ptr) return "";
328  var hasUtf = 0;
329  var t;
330  var i = 0;
331  while (1) {
332   t = HEAPU8[ptr + i >> 0];
333   hasUtf |= t;
334   if (t == 0 && !length) break;
335   i++;
336   if (length && i == length) break;
337  }
338  if (!length) length = i;
339  var ret = "";
340  if (hasUtf < 128) {
341   var MAX_CHUNK = 1024;
342   var curr;
343   while (length > 0) {
344    curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
345    ret = ret ? ret + curr : curr;
346    ptr += MAX_CHUNK;
347    length -= MAX_CHUNK;
348   }
349   return ret;
350  }
351  return UTF8ToString(ptr);
352 }
353 var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
354 function UTF8ArrayToString(u8Array, idx) {
355  var endPtr = idx;
356  while (u8Array[endPtr]) ++endPtr;
357  if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
358   return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
359  } else {
360   var u0, u1, u2, u3, u4, u5;
361   var str = "";
362   while (1) {
363    u0 = u8Array[idx++];
364    if (!u0) return str;
365    if (!(u0 & 128)) {
366     str += String.fromCharCode(u0);
367     continue;
368    }
369    u1 = u8Array[idx++] & 63;
370    if ((u0 & 224) == 192) {
371     str += String.fromCharCode((u0 & 31) << 6 | u1);
372     continue;
373    }
374    u2 = u8Array[idx++] & 63;
375    if ((u0 & 240) == 224) {
376     u0 = (u0 & 15) << 12 | u1 << 6 | u2;
377    } else {
378     u3 = u8Array[idx++] & 63;
379     if ((u0 & 248) == 240) {
380      u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3;
381     } else {
382      u4 = u8Array[idx++] & 63;
383      if ((u0 & 252) == 248) {
384       u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4;
385      } else {
386       u5 = u8Array[idx++] & 63;
387       u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5;
388      }
389     }
390    }
391    if (u0 < 65536) {
392     str += String.fromCharCode(u0);
393    } else {
394     var ch = u0 - 65536;
395     str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
396    }
397   }
398  }
399 }
400 function UTF8ToString(ptr) {
401  return UTF8ArrayToString(HEAPU8, ptr);
402 }
403 function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
404  if (!(maxBytesToWrite > 0)) return 0;
405  var startIdx = outIdx;
406  var endIdx = outIdx + maxBytesToWrite - 1;
407  for (var i = 0; i < str.length; ++i) {
408   var u = str.charCodeAt(i);
409   if (u >= 55296 && u <= 57343) {
410    var u1 = str.charCodeAt(++i);
411    u = 65536 + ((u & 1023) << 10) | u1 & 1023;
412   }
413   if (u <= 127) {
414    if (outIdx >= endIdx) break;
415    outU8Array[outIdx++] = u;
416   } else if (u <= 2047) {
417    if (outIdx + 1 >= endIdx) break;
418    outU8Array[outIdx++] = 192 | u >> 6;
419    outU8Array[outIdx++] = 128 | u & 63;
420   } else if (u <= 65535) {
421    if (outIdx + 2 >= endIdx) break;
422    outU8Array[outIdx++] = 224 | u >> 12;
423    outU8Array[outIdx++] = 128 | u >> 6 & 63;
424    outU8Array[outIdx++] = 128 | u & 63;
425   } else if (u <= 2097151) {
426    if (outIdx + 3 >= endIdx) break;
427    outU8Array[outIdx++] = 240 | u >> 18;
428    outU8Array[outIdx++] = 128 | u >> 12 & 63;
429    outU8Array[outIdx++] = 128 | u >> 6 & 63;
430    outU8Array[outIdx++] = 128 | u & 63;
431   } else if (u <= 67108863) {
432    if (outIdx + 4 >= endIdx) break;
433    outU8Array[outIdx++] = 248 | u >> 24;
434    outU8Array[outIdx++] = 128 | u >> 18 & 63;
435    outU8Array[outIdx++] = 128 | u >> 12 & 63;
436    outU8Array[outIdx++] = 128 | u >> 6 & 63;
437    outU8Array[outIdx++] = 128 | u & 63;
438   } else {
439    if (outIdx + 5 >= endIdx) break;
440    outU8Array[outIdx++] = 252 | u >> 30;
441    outU8Array[outIdx++] = 128 | u >> 24 & 63;
442    outU8Array[outIdx++] = 128 | u >> 18 & 63;
443    outU8Array[outIdx++] = 128 | u >> 12 & 63;
444    outU8Array[outIdx++] = 128 | u >> 6 & 63;
445    outU8Array[outIdx++] = 128 | u & 63;
446   }
447  }
448  outU8Array[outIdx] = 0;
449  return outIdx - startIdx;
450 }
451 function stringToUTF8(str, outPtr, maxBytesToWrite) {
452  return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
453 }
454 function lengthBytesUTF8(str) {
455  var len = 0;
456  for (var i = 0; i < str.length; ++i) {
457   var u = str.charCodeAt(i);
458   if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
459   if (u <= 127) {
460    ++len;
461   } else if (u <= 2047) {
462    len += 2;
463   } else if (u <= 65535) {
464    len += 3;
465   } else if (u <= 2097151) {
466    len += 4;
467   } else if (u <= 67108863) {
468    len += 5;
469   } else {
470    len += 6;
471   }
472  }
473  return len;
474 }
475 var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
476 function allocateUTF8OnStack(str) {
477  var size = lengthBytesUTF8(str) + 1;
478  var ret = stackAlloc(size);
479  stringToUTF8Array(str, HEAP8, ret, size);
480  return ret;
481 }
482 function demangle(func) {
483  return func;
484 }
485 function demangleAll(text) {
486  var regex = /__Z[\w\d_]+/g;
487  return text.replace(regex, (function(x) {
488   var y = demangle(x);
489   return x === y ? x : x + " [" + y + "]";
490  }));
491 }
492 function jsStackTrace() {
493  var err = new Error;
494  if (!err.stack) {
495   try {
496    throw new Error(0);
497   } catch (e) {
498    err = e;
499   }
500   if (!err.stack) {
501    return "(no stack trace available)";
502   }
503  }
504  return err.stack.toString();
505 }
506 var WASM_PAGE_SIZE = 65536;
507 var ASMJS_PAGE_SIZE = 16777216;
508 function alignUp(x, multiple) {
509  if (x % multiple > 0) {
510   x += multiple - x % multiple;
511  }
512  return x;
513 }
514 var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
515 function updateGlobalBuffer(buf) {
516  Module["buffer"] = buffer = buf;
517 }
518 function updateGlobalBufferViews() {
519  Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
520  Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
521  Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
522  Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
523  Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
524  Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
525  Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
526  Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer);
527 }
528 var STATIC_BASE, STATICTOP, staticSealed;
529 var STACK_BASE, STACKTOP, STACK_MAX;
530 var DYNAMIC_BASE, DYNAMICTOP_PTR;
531 STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
532 staticSealed = false;
533 function abortOnCannotGrowMemory() {
534  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 ");
535 }
536 function enlargeMemory() {
537  abortOnCannotGrowMemory();
538 }
539 var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
540 var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 83886080;
541 if (TOTAL_MEMORY < TOTAL_STACK) err("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
542 if (Module["buffer"]) {
543  buffer = Module["buffer"];
544 } else {
545  if (typeof WebAssembly === "object" && typeof WebAssembly.Memory === "function") {
546   Module["wasmMemory"] = new WebAssembly.Memory({
547    "initial": TOTAL_MEMORY / WASM_PAGE_SIZE,
548    "maximum": TOTAL_MEMORY / WASM_PAGE_SIZE
549   });
550   buffer = Module["wasmMemory"].buffer;
551  } else {
552   buffer = new ArrayBuffer(TOTAL_MEMORY);
553  }
554  Module["buffer"] = buffer;
555 }
556 updateGlobalBufferViews();
557 function getTotalMemory() {
558  return TOTAL_MEMORY;
559 }
560 function callRuntimeCallbacks(callbacks) {
561  while (callbacks.length > 0) {
562   var callback = callbacks.shift();
563   if (typeof callback == "function") {
564    callback();
565    continue;
566   }
567   var func = callback.func;
568   if (typeof func === "number") {
569    if (callback.arg === undefined) {
570     Module["dynCall_v"](func);
571    } else {
572     Module["dynCall_vi"](func, callback.arg);
573    }
574   } else {
575    func(callback.arg === undefined ? null : callback.arg);
576   }
577  }
578 }
579 var __ATPRERUN__ = [];
580 var __ATINIT__ = [];
581 var __ATMAIN__ = [];
582 var __ATEXIT__ = [];
583 var __ATPOSTRUN__ = [];
584 var runtimeInitialized = false;
585 var runtimeExited = false;
586 function preRun() {
587  if (Module["preRun"]) {
588   if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
589   while (Module["preRun"].length) {
590    addOnPreRun(Module["preRun"].shift());
591   }
592  }
593  callRuntimeCallbacks(__ATPRERUN__);
594 }
595 function ensureInitRuntime() {
596  if (runtimeInitialized) return;
597  runtimeInitialized = true;
598  callRuntimeCallbacks(__ATINIT__);
599 }
600 function preMain() {
601  callRuntimeCallbacks(__ATMAIN__);
602 }
603 function exitRuntime() {
604  callRuntimeCallbacks(__ATEXIT__);
605  runtimeExited = true;
606 }
607 function postRun() {
608  if (Module["postRun"]) {
609   if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
610   while (Module["postRun"].length) {
611    addOnPostRun(Module["postRun"].shift());
612   }
613  }
614  callRuntimeCallbacks(__ATPOSTRUN__);
615 }
616 function addOnPreRun(cb) {
617  __ATPRERUN__.unshift(cb);
618 }
619 function addOnPostRun(cb) {
620  __ATPOSTRUN__.unshift(cb);
621 }
622 function writeArrayToMemory(array, buffer) {
623  HEAP8.set(array, buffer);
624 }
625 function writeAsciiToMemory(str, buffer, dontAddNull) {
626  for (var i = 0; i < str.length; ++i) {
627   HEAP8[buffer++ >> 0] = str.charCodeAt(i);
628  }
629  if (!dontAddNull) HEAP8[buffer >> 0] = 0;
630 }
631 var Math_abs = Math.abs;
632 var Math_ceil = Math.ceil;
633 var Math_floor = Math.floor;
634 var Math_min = Math.min;
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 = "richards.wast";
669  var wasmBinaryFile = "richards.wasm";
670  var asmjsCodeFile = "richards.temp.asm.js";
671  if (!isDataURI(wasmTextFile)) {
672   wasmTextFile = locateFile(wasmTextFile);
673  }
674  if (!isDataURI(wasmBinaryFile)) {
675   wasmBinaryFile = locateFile(wasmBinaryFile);
676  }
677  if (!isDataURI(asmjsCodeFile)) {
678   asmjsCodeFile = locateFile(asmjsCodeFile);
679  }
680  var wasmPageSize = 64 * 1024;
681  var info = {
682   "global": null,
683   "env": null,
684   "asm2wasm": asm2wasmImports,
685   "parent": Module
686  };
687  var exports = null;
688  function mergeMemory(newBuffer) {
689   var oldBuffer = Module["buffer"];
690   if (newBuffer.byteLength < oldBuffer.byteLength) {
691    err("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here");
692   }
693   var oldView = new Int8Array(oldBuffer);
694   var newView = new Int8Array(newBuffer);
695   newView.set(oldView);
696   updateGlobalBuffer(newBuffer);
697   updateGlobalBufferViews();
698  }
699  function fixImports(imports) {
700   return imports;
701  }
702  function getBinary() {
703   try {
704    if (Module["wasmBinary"]) {
705     return new Uint8Array(Module["wasmBinary"]);
706    }
707    if (Module["readBinary"]) {
708     return Module["readBinary"](wasmBinaryFile);
709    } else {
710     throw "both async and sync fetching of the wasm failed";
711    }
712   } catch (err) {
713    abort(err);
714   }
715  }
716  function getBinaryPromise() {
717   if (!Module["wasmBinary"] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function") {
718    return fetch(wasmBinaryFile, {
719     credentials: "same-origin"
720    }).then((function(response) {
721     if (!response["ok"]) {
722      throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
723     }
724     return response["arrayBuffer"]();
725    })).catch((function() {
726     return getBinary();
727    }));
728   }
729   return new Promise((function(resolve, reject) {
730    resolve(getBinary());
731   }));
732  }
733  function doNativeWasm(global, env, providedBuffer) {
734   if (typeof WebAssembly !== "object") {
735    err("no native wasm support detected");
736    return false;
737   }
738   if (!(Module["wasmMemory"] instanceof WebAssembly.Memory)) {
739    err("no native wasm Memory in use");
740    return false;
741   }
742   env["memory"] = Module["wasmMemory"];
743   info["global"] = {
744    "NaN": NaN,
745    "Infinity": Infinity
746   };
747   info["global.Math"] = Math;
748   info["env"] = env;
749   function receiveInstance(instance, module) {
750    exports = instance.exports;
751    if (exports.memory) mergeMemory(exports.memory);
752    Module["asm"] = exports;
753    Module["usingWasm"] = true;
754    removeRunDependency("wasm-instantiate");
755   }
756   addRunDependency("wasm-instantiate");
757   if (Module["instantiateWasm"]) {
758    try {
759     return Module["instantiateWasm"](info, receiveInstance);
760    } catch (e) {
761     err("Module.instantiateWasm callback failed with error: " + e);
762     return false;
763    }
764   }
765   function receiveInstantiatedSource(output) {
766    receiveInstance(output["instance"], output["module"]);
767   }
768   function instantiateArrayBuffer(receiver) {
769    getBinaryPromise().then((function(binary) {
770     return WebAssembly.instantiate(binary, info);
771    }))
772    .then((...args) => {
773        reportCompileTime(benchmarkTime() - __startupStartTime);
774        return Promise.resolve(...args);
775    })
776    .then(receiver).catch((function(reason) {
777     err("failed to asynchronously prepare wasm: " + reason);
778     abort(reason);
779    }));
780   }
781   if (!Module["wasmBinary"] && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
782    WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, {
783     credentials: "same-origin"
784    }), info).then(receiveInstantiatedSource).catch((function(reason) {
785     err("wasm streaming compile failed: " + reason);
786     err("falling back to ArrayBuffer instantiation");
787     instantiateArrayBuffer(receiveInstantiatedSource);
788    }));
789   } else {
790    instantiateArrayBuffer(receiveInstantiatedSource);
791   }
792   return {};
793  }
794  Module["asmPreload"] = Module["asm"];
795  var asmjsReallocBuffer = Module["reallocBuffer"];
796  var wasmReallocBuffer = (function(size) {
797   var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE;
798   size = alignUp(size, PAGE_MULTIPLE);
799   var old = Module["buffer"];
800   var oldSize = old.byteLength;
801   if (Module["usingWasm"]) {
802    try {
803     var result = Module["wasmMemory"].grow((size - oldSize) / wasmPageSize);
804     if (result !== (-1 | 0)) {
805      return Module["buffer"] = Module["wasmMemory"].buffer;
806     } else {
807      return null;
808     }
809    } catch (e) {
810     return null;
811    }
812   }
813  });
814  Module["reallocBuffer"] = (function(size) {
815   if (finalMethod === "asmjs") {
816    return asmjsReallocBuffer(size);
817   } else {
818    return wasmReallocBuffer(size);
819   }
820  });
821  var finalMethod = "";
822  Module["asm"] = (function(global, env, providedBuffer) {
823   env = fixImports(env);
824   if (!env["table"]) {
825    var TABLE_SIZE = Module["wasmTableSize"];
826    if (TABLE_SIZE === undefined) TABLE_SIZE = 1024;
827    var MAX_TABLE_SIZE = Module["wasmMaxTableSize"];
828    if (typeof WebAssembly === "object" && typeof WebAssembly.Table === "function") {
829     if (MAX_TABLE_SIZE !== undefined) {
830      env["table"] = new WebAssembly.Table({
831       "initial": TABLE_SIZE,
832       "maximum": MAX_TABLE_SIZE,
833       "element": "anyfunc"
834      });
835     } else {
836      env["table"] = new WebAssembly.Table({
837       "initial": TABLE_SIZE,
838       element: "anyfunc"
839      });
840     }
841    } else {
842     env["table"] = new Array(TABLE_SIZE);
843    }
844    Module["wasmTable"] = env["table"];
845   }
846   if (!env["memoryBase"]) {
847    env["memoryBase"] = Module["STATIC_BASE"];
848   }
849   if (!env["tableBase"]) {
850    env["tableBase"] = 0;
851   }
852   var exports;
853   exports = doNativeWasm(global, env, providedBuffer);
854   assert(exports, "no binaryen method succeeded.");
855   return exports;
856  });
857 }
858 integrateWasmJS();
859 var ASM_CONSTS = [ (function() {
860  runRichards();
861 }) ];
862 function _emscripten_asm_const_i(code) {
863  return ASM_CONSTS[code]();
864 }
865 STATIC_BASE = GLOBAL_BASE;
866 STATICTOP = STATIC_BASE + 1664;
867 __ATINIT__.push();
868 var STATIC_BUMP = 1664;
869 Module["STATIC_BASE"] = STATIC_BASE;
870 Module["STATIC_BUMP"] = STATIC_BUMP;
871 var tempDoublePtr = STATICTOP;
872 STATICTOP += 16;
873 function _emscripten_memcpy_big(dest, src, num) {
874  HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
875  return dest;
876 }
877 function ___setErrNo(value) {
878  if (Module["___errno_location"]) HEAP32[Module["___errno_location"]() >> 2] = value;
879  return value;
880 }
881 DYNAMICTOP_PTR = staticAlloc(4);
882 STACK_BASE = STACKTOP = alignMemory(STATICTOP);
883 STACK_MAX = STACK_BASE + TOTAL_STACK;
884 DYNAMIC_BASE = alignMemory(STACK_MAX);
885 HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
886 staticSealed = true;
887 var ASSERTIONS = false;
888 Module["wasmTableSize"] = 8;
889 Module["wasmMaxTableSize"] = 8;
890 function invoke_ii(index, a1) {
891  var sp = stackSave();
892  try {
893   return Module["dynCall_ii"](index, a1);
894  } catch (e) {
895   stackRestore(sp);
896   if (typeof e !== "number" && e !== "longjmp") throw e;
897   Module["setThrew"](1, 0);
898  }
899 }
900 Module.asmGlobalArg = {};
901 Module.asmLibraryArg = {
902  "abort": abort,
903  "assert": assert,
904  "enlargeMemory": enlargeMemory,
905  "getTotalMemory": getTotalMemory,
906  "abortOnCannotGrowMemory": abortOnCannotGrowMemory,
907  "invoke_ii": invoke_ii,
908  "___setErrNo": ___setErrNo,
909  "_emscripten_asm_const_i": _emscripten_asm_const_i,
910  "_emscripten_memcpy_big": _emscripten_memcpy_big,
911  "DYNAMICTOP_PTR": DYNAMICTOP_PTR,
912  "tempDoublePtr": tempDoublePtr,
913  "ABORT": ABORT,
914  "STACKTOP": STACKTOP,
915  "STACK_MAX": STACK_MAX
916 };
917 var asm = Module["asm"](Module.asmGlobalArg, Module.asmLibraryArg, buffer);
918 Module["asm"] = asm;
919 var ___errno_location = Module["___errno_location"] = (function() {
920  return Module["asm"]["___errno_location"].apply(null, arguments);
921 });
922 var _free = Module["_free"] = (function() {
923  return Module["asm"]["_free"].apply(null, arguments);
924 });
925 var _getHoldcount = Module["_getHoldcount"] = (function() {
926  return Module["asm"]["_getHoldcount"].apply(null, arguments);
927 });
928 var _getQpktcount = Module["_getQpktcount"] = (function() {
929  return Module["asm"]["_getQpktcount"].apply(null, arguments);
930 });
931 var _main = Module["_main"] = (function() {
932  let start = benchmarkTime();
933  let ret = Module["asm"]["_main"].apply(null, arguments);
934  reportRunTime(benchmarkTime() - start);
935  return ret;
936 });
937 var _malloc = Module["_malloc"] = (function() {
938  return Module["asm"]["_malloc"].apply(null, arguments);
939 });
940 var _memcpy = Module["_memcpy"] = (function() {
941  return Module["asm"]["_memcpy"].apply(null, arguments);
942 });
943 var _memset = Module["_memset"] = (function() {
944  return Module["asm"]["_memset"].apply(null, arguments);
945 });
946 var _sbrk = Module["_sbrk"] = (function() {
947  return Module["asm"]["_sbrk"].apply(null, arguments);
948 });
949 var _scheduleIter = Module["_scheduleIter"] = (function() {
950  return Module["asm"]["_scheduleIter"].apply(null, arguments);
951 });
952 var _setup = Module["_setup"] = (function() {
953  return Module["asm"]["_setup"].apply(null, arguments);
954 });
955 var establishStackSpace = Module["establishStackSpace"] = (function() {
956  return Module["asm"]["establishStackSpace"].apply(null, arguments);
957 });
958 var getTempRet0 = Module["getTempRet0"] = (function() {
959  return Module["asm"]["getTempRet0"].apply(null, arguments);
960 });
961 var runPostSets = Module["runPostSets"] = (function() {
962  return Module["asm"]["runPostSets"].apply(null, arguments);
963 });
964 var setTempRet0 = Module["setTempRet0"] = (function() {
965  return Module["asm"]["setTempRet0"].apply(null, arguments);
966 });
967 var setThrew = Module["setThrew"] = (function() {
968  return Module["asm"]["setThrew"].apply(null, arguments);
969 });
970 var stackAlloc = Module["stackAlloc"] = (function() {
971  return Module["asm"]["stackAlloc"].apply(null, arguments);
972 });
973 var stackRestore = Module["stackRestore"] = (function() {
974  return Module["asm"]["stackRestore"].apply(null, arguments);
975 });
976 var stackSave = Module["stackSave"] = (function() {
977  return Module["asm"]["stackSave"].apply(null, arguments);
978 });
979 var dynCall_ii = Module["dynCall_ii"] = (function() {
980  return Module["asm"]["dynCall_ii"].apply(null, arguments);
981 });
982 Module["asm"] = asm;
983 function ExitStatus(status) {
984  this.name = "ExitStatus";
985  this.message = "Program terminated with exit(" + status + ")";
986  this.status = status;
987 }
988 ExitStatus.prototype = new Error;
989 ExitStatus.prototype.constructor = ExitStatus;
990 var initialStackTop;
991 var calledMain = false;
992 dependenciesFulfilled = function runCaller() {
993  if (!Module["calledRun"]) run();
994  if (!Module["calledRun"]) dependenciesFulfilled = runCaller;
995 };
996 Module["callMain"] = function callMain(args) {
997  args = args || [];
998  ensureInitRuntime();
999  var argc = args.length + 1;
1000  var argv = stackAlloc((argc + 1) * 4);
1001  HEAP32[argv >> 2] = allocateUTF8OnStack(Module["thisProgram"]);
1002  for (var i = 1; i < argc; i++) {
1003   HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]);
1004  }
1005  HEAP32[(argv >> 2) + argc] = 0;
1006  try {
1007   var ret = Module["_main"](argc, argv, 0);
1008   exit(ret, true);
1009  } catch (e) {
1010   if (e instanceof ExitStatus) {
1011    return;
1012   } else if (e == "SimulateInfiniteLoop") {
1013    Module["noExitRuntime"] = true;
1014    return;
1015   } else {
1016    var toLog = e;
1017    if (e && typeof e === "object" && e.stack) {
1018     toLog = [ e, e.stack ];
1019    }
1020    err("exception thrown: " + toLog);
1021    Module["quit"](1, e);
1022   }
1023  } finally {
1024   calledMain = true;
1025  }
1026 };
1027 function run(args) {
1028  args = args || Module["arguments"];
1029  if (runDependencies > 0) {
1030   return;
1031  }
1032  preRun();
1033  if (runDependencies > 0) return;
1034  if (Module["calledRun"]) return;
1035  function doRun() {
1036   if (Module["calledRun"]) return;
1037   Module["calledRun"] = true;
1038   if (ABORT) return;
1039   ensureInitRuntime();
1040   preMain();
1041   if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
1042   if (Module["_main"] && shouldRunNow) Module["callMain"](args);
1043   postRun();
1044  }
1045  if (Module["setStatus"]) {
1046   Module["setStatus"]("Running...");
1047   setTimeout((function() {
1048    setTimeout((function() {
1049     Module["setStatus"]("");
1050    }), 1);
1051    doRun();
1052   }), 1);
1053  } else {
1054   doRun();
1055  }
1056 }
1057 Module["run"] = run;
1058 function exit(status, implicit) {
1059  if (implicit && Module["noExitRuntime"] && status === 0) {
1060   return;
1061  }
1062  if (Module["noExitRuntime"]) {} else {
1063   ABORT = true;
1064   EXITSTATUS = status;
1065   STACKTOP = initialStackTop;
1066   exitRuntime();
1067   if (Module["onExit"]) Module["onExit"](status);
1068  }
1069  Module["quit"](status, new ExitStatus(status));
1070 }
1071 function abort(what) {
1072  if (Module["onAbort"]) {
1073   Module["onAbort"](what);
1074  }
1075  if (what !== undefined) {
1076   out(what);
1077   err(what);
1078   what = JSON.stringify(what);
1079  } else {
1080   what = "";
1081  }
1082  ABORT = true;
1083  EXITSTATUS = 1;
1084  throw "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
1085 }
1086 Module["abort"] = abort;
1087 if (Module["preInit"]) {
1088  if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
1089  while (Module["preInit"].length > 0) {
1090   Module["preInit"].pop()();
1091  }
1092 }
1093 var shouldRunNow = true;
1094 if (Module["noInitialRun"]) {
1095  shouldRunNow = false;
1096 }
1097 Module["noExitRuntime"] = true;
1098 run();
1099 }
1100
1101 function runRichards() {
1102     function scheduleIter() {
1103         return Module._scheduleIter();
1104     }
1105
1106     for (let i = 0; i < 4; ++i) {
1107         Module._setup();
1108         while (scheduleIter()) { }
1109         if (Module._getQpktcount() !== 2326410 || Module._getHoldcount() !== 930563)
1110             throw new Error("Bad richards result!");
1111     }
1112 }
1113