text: function integrateWasmJS(Module) {
   var method = Module["wasmJSMethod"] || Module["wasmJSMethod"] || "native-wasm" || "native-wasm,interpret-s-expr";
   var wasmTextFile = Module["wasmTextFile"] || "hello-binaryen.wast";
   var wasmBinaryFile = Module["wasmBinaryFile"] || "hello-binaryen.wasm";
   var asmjsCodeFile = Module["asmjsCodeFile"] || "hello-binaryen.asm.js";
   var wasmPageSize = 64 * 1024;
   var asm2wasmImports = {
    "f64-rem": (function(x, y) {
     return x % y;
    }),
    "f64-to-int": (function(x) {
     return x | 0;
    }),
    "i32s-div": (function(x, y) {
     return (x | 0) / (y | 0) | 0;
    }),
    "i32u-div": (function(x, y) {
     return (x >>> 0) / (y >>> 0) >>> 0;
    }),
    "i32s-rem": (function(x, y) {
     return (x | 0) % (y | 0) | 0;
    }),
    "i32u-rem": (function(x, y) {
     return (x >>> 0) % (y >>> 0) >>> 0;
    }),
    "debugger": (function() {
     debugger;
    })
   };
   var info = {
    "global": null,
    "env": null,
    "asm2wasm": asm2wasmImports,
    "parent": Module
   };
   var exports = null;
   function lookupImport(mod, base) {
    var lookup = info;
    if (mod.indexOf(".") < 0) {
     lookup = (lookup || {})[mod];
    } else {
     var parts = mod.split(".");
     lookup = (lookup || {})[parts[0]];
     lookup = (lookup || {})[parts[1]];
    }
    if (base) {
     lookup = (lookup || {})[base];
    }
    if (lookup === undefined) {
     abort("bad lookupImport to (" + mod + ")." + base);
    }
    return lookup;
   }
   function mergeMemory(newBuffer) {
    var oldBuffer = Module["buffer"];
    if (newBuffer.byteLength < oldBuffer.byteLength) {
     Module["printErr"]("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here");
    }
    var oldView = new Int8Array(oldBuffer);
    var newView = new Int8Array(newBuffer);
    if (0) {
     oldView.set(newView.subarray(STATIC_BASE, STATIC_BASE + STATIC_BUMP), STATIC_BASE);
    }
    newView.set(oldView);
    updateGlobalBuffer(newBuffer);
    updateGlobalBufferViews();
    Module["reallocBuffer"] = (function(size) {
     size = Math.ceil(size / wasmPageSize) * wasmPageSize;
     var old = Module["buffer"];
     exports["__growWasmMemory"](size / wasmPageSize);
     return Module["buffer"] !== old ? Module["buffer"] : null;
    });
   }
   var WasmTypes = {
    none: 0,
    i32: 1,
    i64: 2,
    f32: 3,
    f64: 4
   };
   function applyMappedGlobals(globalsFileBase) {
    var mappedGlobals = JSON.parse(Module["read"](globalsFileBase + ".mappedGlobals"));
    for (var name in mappedGlobals) {
     var global = mappedGlobals[name];
     if (!global.import) continue;
     var value = lookupImport(global.module, global.base);
     var address = global.address;
     switch (global.type) {
     case WasmTypes.i32:
      Module["HEAP32"][address >> 2] = value;
      break;
     case WasmTypes.f32:
      Module["HEAPF32"][address >> 2] = value;
      break;
     case WasmTypes.f64:
      Module["HEAPF64"][address >> 3] = value;
      break;
     default:
      abort();
     }
    }
   }
   function fixImports(imports) {
    if (!0) return imports;
    var ret = {};
    for (var i in imports) {
     var fixed = i;
     if (fixed[0] == "_") fixed = fixed.substr(1);
     ret[fixed] = imports[i];
    }
    return ret;
   }
   function getBinary() {
    var binary;
    if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
     binary = Module["wasmBinary"];
     assert(binary, "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)");
     binary = new Uint8Array(binary);
    } else {
     binary = Module["readBinary"](wasmBinaryFile);
    }
    return binary;
   }
   function doJustAsm(global, env, providedBuffer) {
    if (typeof Module["asm"] !== "function" || Module["asm"] === methodHandler) {
     if (!Module["asmPreload"]) {
      eval(Module["read"](asmjsCodeFile));
     } else {
      Module["asm"] = Module["asmPreload"];
     }
    }
    if (typeof Module["asm"] !== "function") {
     Module["printErr"]("asm evalling did not set the module properly");
     return false;
    }
    return Module["asm"](global, env, providedBuffer);
   }
   function doNativeWasm(global, env, providedBuffer) {
    if (typeof Wasm !== "object") {
     Module["printErr"]("no native wasm support detected");
     return false;
    }
    info["global"] = {
     "NaN": NaN,
     "Infinity": Infinity
    };
    info["global.Math"] = global.Math;
    info["env"] = env;
    var instance;
    try {
     instance = Wasm["instantiateModule"](getBinary(), info);
    } catch (e) {
     Module["printErr"]("failed to compile wasm module: " + e);
     return false;
    }
    exports = instance.exports;
    mergeMemory(exports.memory);
    applyMappedGlobals(wasmBinaryFile);
    Module["usingWasm"] = true;
    return exports;
   }
   function doWasmPolyfill(global, env, providedBuffer, method) {
    if (typeof WasmJS !== "function") {
     Module["printErr"]("WasmJS not detected - polyfill not bundled?");
     return false;
    }
    var wasmJS = WasmJS({});
    wasmJS["outside"] = Module;
    wasmJS["info"] = info;
    wasmJS["lookupImport"] = lookupImport;
    assert(providedBuffer === Module["buffer"]);
    info.global = global;
    info.env = env;
    wasmJS["providedTotalMemory"] = Module["buffer"].byteLength;
    var code;
    if (method === "interpret-binary") {
     code = getBinary();
    } else {
     code = Module["read"](method == "interpret-asm2wasm" ? asmjsCodeFile : wasmTextFile);
    }
    var temp;
    if (method == "interpret-asm2wasm") {
     temp = wasmJS["_malloc"](code.length + 1);
     wasmJS["writeAsciiToMemory"](code, temp);
     wasmJS["_load_asm2wasm"](temp);
    } else if (method === "interpret-s-expr") {
     temp = wasmJS["_malloc"](code.length + 1);
     wasmJS["writeAsciiToMemory"](code, temp);
     wasmJS["_load_s_expr2wasm"](temp);
    } else if (method === "interpret-binary") {
     temp = wasmJS["_malloc"](code.length);
     wasmJS["HEAPU8"].set(code, temp);
     wasmJS["_load_binary2wasm"](temp, code.length);
    } else {
     throw "what? " + method;
    }
    wasmJS["_free"](temp);
    wasmJS["_instantiate"](temp);
    if (Module["newBuffer"]) {
     mergeMemory(Module["newBuffer"]);
     Module["newBuffer"] = null;
    }
    if (method == "interpret-s-expr") {
     applyMappedGlobals(wasmTextFile);
    } else if (method == "interpret-binary") {
     applyMappedGlobals(wasmBinaryFile);
    }
    exports = wasmJS["asmExports"];
    return exports;
   }
   Module["asmPreload"] = Module["asm"];
   Module["asm"] = (function(global, env, providedBuffer) {
    global = fixImports(global);
    env = fixImports(env);
    var exports;
    var methods = method.split(",");
    for (var i = 0; i < methods.length; i++) {
     var curr = methods[i];
     Module["printErr"]("trying binaryen method: " + curr);
     if (curr === "native-wasm") {
      if (exports = doNativeWasm(global, env, providedBuffer)) break;
     } else if (curr === "asmjs") {
      if (exports = doJustAsm(global, env, providedBuffer)) break;
     } else if (curr === "interpret-asm2wasm" || curr === "interpret-s-expr" || curr === "interpret-binary") {
      if (exports = doWasmPolyfill(global, env, providedBuffer, curr)) break;
     } else {
      throw "bad method: " + curr;
     }
    }
    if (!exports) throw "no binaryen method succeeded";
    Module["printErr"]("binaryen method succeeded.");
    return exports;
   });
   var methodHandler = Module["asm"];
  }
  var Module;
  if (!Module) Module = (typeof main !== "undefined" ? main : null) || {};
  var moduleOverrides = {};
  for (var key in Module) {
   if (Module.hasOwnProperty(key)) {
    moduleOverrides[key] = Module[key];
   }
  }
  var ENVIRONMENT_IS_WEB = false;
  var ENVIRONMENT_IS_WORKER = false;
  var ENVIRONMENT_IS_NODE = false;
  var ENVIRONMENT_IS_SHELL = false;
  if (Module["ENVIRONMENT"]) {
   if (Module["ENVIRONMENT"] === "WEB") {
    ENVIRONMENT_IS_WEB = true;
   } else if (Module["ENVIRONMENT"] === "WORKER") {
    ENVIRONMENT_IS_WORKER = true;
   } else if (Module["ENVIRONMENT"] === "NODE") {
    ENVIRONMENT_IS_NODE = true;
   } else if (Module["ENVIRONMENT"] === "SHELL") {
    ENVIRONMENT_IS_SHELL = true;
   } else {
    throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.");
   }
  } else {
   ENVIRONMENT_IS_WEB = typeof window === "object";
   ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
   ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
   ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
  }
  if (ENVIRONMENT_IS_NODE) {
   if (!Module["print"]) Module["print"] = console.log;
   if (!Module["printErr"]) Module["printErr"] = console.warn;
   var nodeFS;
   var nodePath;
   Module["read"] = function read(filename, binary) {
    if (!nodeFS) nodeFS = require("fs");
    if (!nodePath) nodePath = require("path");
    filename = nodePath["normalize"](filename);
    var ret = nodeFS["readFileSync"](filename);
    return binary ? ret : ret.toString();
   };
   Module["readBinary"] = function readBinary(filename) {
    var ret = Module["read"](filename, true);
    if (!ret.buffer) {
     ret = new Uint8Array(ret);
    }
    assert(ret.buffer);
    return ret;
   };
   Module["load"] = function load(f) {
    globalEval(read(f));
   };
   if (!Module["thisProgram"]) {
    if (process["argv"].length > 1) {
     Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/");
    } else {
     Module["thisProgram"] = "unknown-program";
    }
   }
   Module["arguments"] = process["argv"].slice(2);
   if (typeof module !== "undefined") {
    module["exports"] = Module;
   }
   process["on"]("uncaughtException", (function(ex) {
    if (!(ex instanceof ExitStatus)) {
     throw ex;
    }
   }));
   Module["inspect"] = (function() {
    return "[Emscripten Module object]";
   });
  } else if (ENVIRONMENT_IS_SHELL) {
   if (!Module["print"]) Module["print"] = print;
   if (typeof printErr != "undefined") Module["printErr"] = printErr;
   if (typeof read != "undefined") {
    Module["read"] = read;
   } else {
    Module["read"] = function read() {
     throw "no read() available (jsc?)";
    };
   }
   Module["readBinary"] = function readBinary(f) {
    if (typeof readbuffer === "function") {
     return new Uint8Array(readbuffer(f));
    }
    var data = read(f, "binary");
    assert(typeof data === "object");
    return data;
   };
   if (typeof scriptArgs != "undefined") {
    Module["arguments"] = scriptArgs;
   } else if (typeof arguments != "undefined") {
    Module["arguments"] = arguments;
   }
  } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
   Module["read"] = function read(url) {
    var xhr = new XMLHttpRequest;
    xhr.open("GET", url, false);
    xhr.send(null);
    return xhr.responseText;
   };
   Module["readAsync"] = function readAsync(url, onload, onerror) {
    var xhr = new XMLHttpRequest;
    xhr.open("GET", url, true);
    xhr.responseType = "arraybuffer";
    xhr.onload = function xhr_onload() {
     if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
      onload(xhr.response);
     } else {
      onerror();
     }
    };
    xhr.onerror = onerror;
    xhr.send(null);
   };
   if (typeof arguments != "undefined") {
    Module["arguments"] = arguments;
   }
   if (typeof console !== "undefined") {
    if (!Module["print"]) Module["print"] = function print(x) {
     console.log(x);
    };
    if (!Module["printErr"]) Module["printErr"] = function printErr(x) {
     console.warn(x);
    };
   } else {
    var TRY_USE_DUMP = false;
    if (!Module["print"]) Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? (function(x) {
     dump(x);
    }) : (function(x) {});
   }
   if (ENVIRONMENT_IS_WORKER) {
    Module["load"] = importScripts;
   }
   if (typeof Module["setWindowTitle"] === "undefined") {
    Module["setWindowTitle"] = (function(title) {
     document.title = title;
    });
   }
  } else {
   throw "Unknown runtime environment. Where are we?";
  }
  function globalEval(x) {
   eval.call(null, x);
  }
  if (!Module["load"] && Module["read"]) {
   Module["load"] = function load(f) {
    globalEval(Module["read"](f));
   };
  }
  if (!Module["print"]) {
   Module["print"] = (function() {});
  }
  if (!Module["printErr"]) {
   Module["printErr"] = Module["print"];
  }
  if (!Module["arguments"]) {
   Module["arguments"] = [];
  }
  if (!Module["thisProgram"]) {
   Module["thisProgram"] = "./this.program";
  }
  Module.print = Module["print"];
  Module.printErr = Module["printErr"];
  Module["preRun"] = [];
  Module["postRun"] = [];
  for (var key in moduleOverrides) {
   if (moduleOverrides.hasOwnProperty(key)) {
    Module[key] = moduleOverrides[key];
   }
  }
  moduleOverrides = undefined;
  integrateWasmJS(Module);
  var Runtime = {
   setTempRet0: (function(value) {
    tempRet0 = value;
   }),
   getTempRet0: (function() {
    return tempRet0;
   }),
   stackSave: (function() {
    return STACKTOP;
   }),
   stackRestore: (function(stackTop) {
    STACKTOP = stackTop;
   }),
   getNativeTypeSize: (function(type) {
    switch (type) {
    case "i1":
    case "i8":
     return 1;
    case "i16":
     return 2;
    case "i32":
     return 4;
    case "i64":
     return 8;
    case "float":
     return 4;
    case "double":
     return 8;
    default:
     {
      if (type[type.length - 1] === "*") {
       return Runtime.QUANTUM_SIZE;
      } else if (type[0] === "i") {
       var bits = parseInt(type.substr(1));
       assert(bits % 8 === 0);
       return bits / 8;
      } else {
       return 0;
      }
     }
    }
   }),
   getNativeFieldSize: (function(type) {
    return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
   }),
   STACK_ALIGN: 16,
   prepVararg: (function(ptr, type) {
    if (type === "double" || type === "i64") {
     if (ptr & 7) {
      assert((ptr & 7) === 4);
      ptr += 4;
     }
    } else {
     assert((ptr & 3) === 0);
    }
    return ptr;
   }),
   getAlignSize: (function(type, size, vararg) {
    if (!vararg && (type == "i64" || type == "double")) return 8;
    if (!type) return Math.min(size, 8);
    return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
   }),
   dynCall: (function(sig, ptr, args) {
    if (args && args.length) {
     return Module["dynCall_" + sig].apply(null, [ ptr ].concat(args));
    } else {
     return Module["dynCall_" + sig].call(null, ptr);
    }
   }),
   functionPointers: [],
   addFunction: (function(func) {
    for (var i = 0; i < Runtime.functionPointers.length; i++) {
     if (!Runtime.functionPointers[i]) {
      Runtime.functionPointers[i] = func;
      return 2 * (1 + i);
     }
    }
    throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.";
   }),
   removeFunction: (function(index) {
    Runtime.functionPointers[(index - 2) / 2] = null;
   }),
   warnOnce: (function(text) {
    if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
    if (!Runtime.warnOnce.shown[text]) {
     Runtime.warnOnce.shown[text] = 1;
     Module.printErr(text);
    }
   }),
   funcWrappers: {},
   getFuncWrapper: (function(func, sig) {
    assert(sig);
    if (!Runtime.funcWrappers[sig]) {
     Runtime.funcWrappers[sig] = {};
    }
    var sigCache = Runtime.funcWrappers[sig];
    if (!sigCache[func]) {
     if (sig.length === 1) {
      sigCache[func] = function dynCall_wrapper() {
       return Runtime.dynCall(sig, func);
      };
     } else if (sig.length === 2) {
      sigCache[func] = function dynCall_wrapper(arg) {
       return Runtime.dynCall(sig, func, [ arg ]);
      };
     } else {
      sigCache[func] = function dynCall_wrapper() {
       return Runtime.dynCall(sig, func, Array.prototype.slice.call(arguments));
      };
     }
    }
    return sigCache[func];
   }),
   getCompilerSetting: (function(name) {
    throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work";
   }),
   stackAlloc: (function(size) {
    var ret = STACKTOP;
    STACKTOP = STACKTOP + size | 0;
    STACKTOP = STACKTOP + 15 & -16;
    return ret;
   }),
   staticAlloc: (function(size) {
    var ret = STATICTOP;
    STATICTOP = STATICTOP + size | 0;
    STATICTOP = STATICTOP + 15 & -16;
    return ret;
   }),
   dynamicAlloc: (function(size) {
    var ret = DYNAMICTOP;
    DYNAMICTOP = DYNAMICTOP + size | 0;
    DYNAMICTOP = DYNAMICTOP + 15 & -16;
    if (DYNAMICTOP >= TOTAL_MEMORY) {
     var success = enlargeMemory();
     if (!success) {
      DYNAMICTOP = ret;
      return 0;
     }
    }
    return ret;
   }),
   alignMemory: (function(size, quantum) {
    var ret = size = Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16);
    return ret;
   }),
   makeBigInt: (function(low, high, unsigned) {
    var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * +4294967296 : +(low >>> 0) + +(high | 0) * +4294967296;
    return ret;
   }),
   GLOBAL_BASE: 1024,
   QUANTUM_SIZE: 4,
   __dummy__: 0
  };
  Module["Runtime"] = Runtime;
  var ABORT = false;
  var EXITSTATUS = 0;
  function assert(condition, text) {
   if (!condition) {
    abort("Assertion failed: " + text);
   }
  }
  function getCFunc(ident) {
   var func = Module["_" + ident];
   if (!func) {
    try {
     func = eval("_" + ident);
    } catch (e) {}
   }
   assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
   return func;
  }
  var cwrap, ccall;
  ((function() {
   var JSfuncs = {
    "stackSave": (function() {
     Runtime.stackSave();
    }),
    "stackRestore": (function() {
     Runtime.stackRestore();
    }),
    "arrayToC": (function(arr) {
     var ret = Runtime.stackAlloc(arr.length);
     writeArrayToMemory(arr, ret);
     return ret;
    }),
    "stringToC": (function(str) {
     var ret = 0;
     if (str !== null && str !== undefined && str !== 0) {
      ret = Runtime.stackAlloc((str.length << 2) + 1);
      writeStringToMemory(str, ret);
     }
     return ret;
    })
   };
   var toC = {
    "string": JSfuncs["stringToC"],
    "array": JSfuncs["arrayToC"]
   };
   ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
    var func = getCFunc(ident);
    var cArgs = [];
    var stack = 0;
    if (args) {
     for (var i = 0; i < args.length; i++) {
      var converter = toC[argTypes[i]];
      if (converter) {
       if (stack === 0) stack = Runtime.stackSave();
       cArgs[i] = converter(args[i]);
      } else {
       cArgs[i] = args[i];
      }
     }
    }
    var ret = func.apply(null, cArgs);
    if (returnType === "string") ret = Pointer_stringify(ret);
    if (stack !== 0) {
     if (opts && opts.async) {
      EmterpreterAsync.asyncFinalizers.push((function() {
       Runtime.stackRestore(stack);
      }));
      return;
     }
     Runtime.stackRestore(stack);
    }
    return ret;
   };
   var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
   function parseJSFunc(jsfunc) {
    var parsed = jsfunc.toString().match(sourceRegex).slice(1);
    return {
     arguments: parsed[0],
     body: parsed[1],
     returnValue: parsed[2]
    };
   }
   var JSsource = null;
   function ensureJSsource() {
    if (!JSsource) {
     JSsource = {};
     for (var fun in JSfuncs) {
      if (JSfuncs.hasOwnProperty(fun)) {
       JSsource[fun] = parseJSFunc(JSfuncs[fun]);
      }
     }
    }
   }
   cwrap = function cwrap(ident, returnType, argTypes) {
    argTypes = argTypes || [];
    var cfunc = getCFunc(ident);
    var numericArgs = argTypes.every((function(type) {
     return type === "number";
    }));
    var numericRet = returnType !== "string";
    if (numericRet && numericArgs) {
     return cfunc;
    }
    var argNames = argTypes.map((function(x, i) {
     return "$" + i;
    }));
    var funcstr = "(function(" + argNames.join(",") + ") {";
    var nargs = argTypes.length;
    if (!numericArgs) {
     ensureJSsource();
     funcstr += "var stack = " + JSsource["stackSave"].body + ";";
     for (var i = 0; i < nargs; i++) {
      var arg = argNames[i], type = argTypes[i];
      if (type === "number") continue;
      var convertCode = JSsource[type + "ToC"];
      funcstr += "var " + convertCode.arguments + " = " + arg + ";";
      funcstr += convertCode.body + ";";
      funcstr += arg + "=(" + convertCode.returnValue + ");";
     }
    }
    var cfuncname = parseJSFunc((function() {
     return cfunc;
    })).returnValue;
    funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
    if (!numericRet) {
     var strgfy = parseJSFunc((function() {
      return Pointer_stringify;
     })).returnValue;
     funcstr += "ret = " + strgfy + "(ret);";
    }
    if (!numericArgs) {
     ensureJSsource();
     funcstr += JSsource["stackRestore"].body.replace("()", "(stack)") + ";";
    }
    funcstr += "return ret})";
    return eval(funcstr);
   };
  }))();
  Module["ccall"] = ccall;
  Module["cwrap"] = cwrap;
  function setValue(ptr, value, type, noSafe) {
   type = type || "i8";
   if (type.charAt(type.length - 1) === "*") type = "i32";
   switch (type) {
   case "i1":
    HEAP8[ptr >> 0] = value;
    break;
   case "i8":
    HEAP8[ptr >> 0] = value;
    break;
   case "i16":
    HEAP16[ptr >> 1] = value;
    break;
   case "i32":
    HEAP32[ptr >> 2] = value;
    break;
   case "i64":
    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];
    break;
   case "float":
    HEAPF32[ptr >> 2] = value;
    break;
   case "double":
    HEAPF64[ptr >> 3] = value;
    break;
   default:
    abort("invalid type for setValue: " + type);
   }
  }
  Module["setValue"] = setValue;
  function getValue(ptr, type, noSafe) {
   type = type || "i8";
   if (type.charAt(type.length - 1) === "*") type = "i32";
   switch (type) {
   case "i1":
    return HEAP8[ptr >> 0];
   case "i8":
    return HEAP8[ptr >> 0];
   case "i16":
    return HEAP16[ptr >> 1];
   case "i32":
    return HEAP32[ptr >> 2];
   case "i64":
    return HEAP32[ptr >> 2];
   case "float":
    return HEAPF32[ptr >> 2];
   case "double":
    return HEAPF64[ptr >> 3];
   default:
    abort("invalid type for setValue: " + type);
   }
   return null;
  }
  Module["getValue"] = getValue;
  var ALLOC_NORMAL = 0;
  var ALLOC_STACK = 1;
  var ALLOC_STATIC = 2;
  var ALLOC_DYNAMIC = 3;
  var ALLOC_NONE = 4;
  Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
  Module["ALLOC_STACK"] = ALLOC_STACK;
  Module["ALLOC_STATIC"] = ALLOC_STATIC;
  Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
  Module["ALLOC_NONE"] = ALLOC_NONE;
  function allocate(slab, types, allocator, ptr) {
   var zeroinit, size;
   if (typeof slab === "number") {
    zeroinit = true;
    size = slab;
   } else {
    zeroinit = false;
    size = slab.length;
   }
   var singleType = typeof types === "string" ? types : null;
   var ret;
   if (allocator == ALLOC_NONE) {
    ret = ptr;
   } else {
    ret = [ typeof _malloc === "function" ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc ][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
   }
   if (zeroinit) {
    var ptr = ret, stop;
    assert((ret & 3) == 0);
    stop = ret + (size & ~3);
    for (; ptr < stop; ptr += 4) {
     HEAP32[ptr >> 2] = 0;
    }
    stop = ret + size;
    while (ptr < stop) {
     HEAP8[ptr++ >> 0] = 0;
    }
    return ret;
   }
   if (singleType === "i8") {
    if (slab.subarray || slab.slice) {
     HEAPU8.set(slab, ret);
    } else {
     HEAPU8.set(new Uint8Array(slab), ret);
    }
    return ret;
   }
   var i = 0, type, typeSize, previousType;
   while (i < size) {
    var curr = slab[i];
    if (typeof curr === "function") {
     curr = Runtime.getFunctionIndex(curr);
    }
    type = singleType || types[i];
    if (type === 0) {
     i++;
     continue;
    }
    if (type == "i64") type = "i32";
    setValue(ret + i, curr, type);
    if (previousType !== type) {
     typeSize = Runtime.getNativeTypeSize(type);
     previousType = type;
    }
    i += typeSize;
   }
   return ret;
  }
  Module["allocate"] = allocate;
  function getMemory(size) {
   if (!staticSealed) return Runtime.staticAlloc(size);
   if (typeof _sbrk !== "undefined" && !_sbrk.called || !runtimeInitialized) return Runtime.dynamicAlloc(size);
   return _malloc(size);
  }
  Module["getMemory"] = getMemory;
  function Pointer_stringify(ptr, length) {
   if (length === 0 || !ptr) return "";
   var hasUtf = 0;
   var t;
   var i = 0;
   while (1) {
    t = HEAPU8[ptr + i >> 0];
    hasUtf |= t;
    if (t == 0 && !length) break;
    i++;
    if (length && i == length) break;
   }
   if (!length) length = i;
   var ret = "";
   if (hasUtf < 128) {
    var MAX_CHUNK = 1024;
    var curr;
    while (length > 0) {
     curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
     ret = ret ? ret + curr : curr;
     ptr += MAX_CHUNK;
     length -= MAX_CHUNK;
    }
    return ret;
   }
   return Module["UTF8ToString"](ptr);
  }
  Module["Pointer_stringify"] = Pointer_stringify;
  function AsciiToString(ptr) {
   var str = "";
   while (1) {
    var ch = HEAP8[ptr++ >> 0];
    if (!ch) return str;
    str += String.fromCharCode(ch);
   }
  }
  Module["AsciiToString"] = AsciiToString;
  function stringToAscii(str, outPtr) {
   return writeAsciiToMemory(str, outPtr, false);
  }
  Module["stringToAscii"] = stringToAscii;
  var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
  function UTF8ArrayToString(u8Array, idx) {
   var endPtr = idx;
   while (u8Array[endPtr]) ++endPtr;
   if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
    return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
   } else {
    var u0, u1, u2, u3, u4, u5;
    var str = "";
    while (1) {
     u0 = u8Array[idx++];
     if (!u0) return str;
     if (!(u0 & 128)) {
      str += String.fromCharCode(u0);
      continue;
     }
     u1 = u8Array[idx++] & 63;
     if ((u0 & 224) == 192) {
      str += String.fromCharCode((u0 & 31) << 6 | u1);
      continue;
     }
     u2 = u8Array[idx++] & 63;
     if ((u0 & 240) == 224) {
      u0 = (u0 & 15) << 12 | u1 << 6 | u2;
     } else {
      u3 = u8Array[idx++] & 63;
      if ((u0 & 248) == 240) {
       u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3;
      } else {
       u4 = u8Array[idx++] & 63;
       if ((u0 & 252) == 248) {
        u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4;
       } else {
        u5 = u8Array[idx++] & 63;
        u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5;
       }
      }
     }
     if (u0 < 65536) {
      str += String.fromCharCode(u0);
     } else {
      var ch = u0 - 65536;
      str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
     }
    }
   }
  }
  Module["UTF8ArrayToString"] = UTF8ArrayToString;
  function UTF8ToString(ptr) {
   return UTF8ArrayToString(HEAPU8, ptr);
  }
  Module["UTF8ToString"] = UTF8ToString;
  function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
   if (!(maxBytesToWrite > 0)) return 0;
   var startIdx = outIdx;
   var endIdx = outIdx + maxBytesToWrite - 1;
   for (var i = 0; i < str.length; ++i) {
    var u = str.charCodeAt(i);
    if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
    if (u <= 127) {
     if (outIdx >= endIdx) break;
     outU8Array[outIdx++] = u;
    } else if (u <= 2047) {
     if (outIdx + 1 >= endIdx) break;
     outU8Array[outIdx++] = 192 | u >> 6;
     outU8Array[outIdx++] = 128 | u & 63;
    } else if (u <= 65535) {
     if (outIdx + 2 >= endIdx) break;
     outU8Array[outIdx++] = 224 | u >> 12;
     outU8Array[outIdx++] = 128 | u >> 6 & 63;
     outU8Array[outIdx++] = 128 | u & 63;
    } else if (u <= 2097151) {
     if (outIdx + 3 >= endIdx) break;
     outU8Array[outIdx++] = 240 | u >> 18;
     outU8Array[outIdx++] = 128 | u >> 12 & 63;
     outU8Array[outIdx++] = 128 | u >> 6 & 63;
     outU8Array[outIdx++] = 128 | u & 63;
    } else if (u <= 67108863) {
     if (outIdx + 4 >= endIdx) break;
     outU8Array[outIdx++] = 248 | u >> 24;
     outU8Array[outIdx++] = 128 | u >> 18 & 63;
     outU8Array[outIdx++] = 128 | u >> 12 & 63;
     outU8Array[outIdx++] = 128 | u >> 6 & 63;
     outU8Array[outIdx++] = 128 | u & 63;
    } else {
     if (outIdx + 5 >= endIdx) break;
     outU8Array[outIdx++] = 252 | u >> 30;
     outU8Array[outIdx++] = 128 | u >> 24 & 63;
     outU8Array[outIdx++] = 128 | u >> 18 & 63;
     outU8Array[outIdx++] = 128 | u >> 12 & 63;
     outU8Array[outIdx++] = 128 | u >> 6 & 63;
     outU8Array[outIdx++] = 128 | u & 63;
    }
   }
   outU8Array[outIdx] = 0;
   return outIdx - startIdx;
  }
  Module["stringToUTF8Array"] = stringToUTF8Array;
  function stringToUTF8(str, outPtr, maxBytesToWrite) {
   return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
  }
  Module["stringToUTF8"] = stringToUTF8;
  function lengthBytesUTF8(str) {
   var len = 0;
   for (var i = 0; i < str.length; ++i) {
    var u = str.charCodeAt(i);
    if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
    if (u <= 127) {
     ++len;
    } else if (u <= 2047) {
     len += 2;
    } else if (u <= 65535) {
     len += 3;
    } else if (u <= 2097151) {
     len += 4;
    } else if (u <= 67108863) {
     len += 5;
    } else {
     len += 6;
    }
   }
   return len;
  }
  Module["lengthBytesUTF8"] = lengthBytesUTF8;
  var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
  function demangle(func) {
   var hasLibcxxabi = !!Module["___cxa_demangle"];
   if (hasLibcxxabi) {
    try {
     var buf = _malloc(func.length);
     writeStringToMemory(func.substr(1), buf);
     var status = _malloc(4);
     var ret = Module["___cxa_demangle"](buf, 0, 0, status);
     if (getValue(status, "i32") === 0 && ret) {
      return Pointer_stringify(ret);
     }
    } catch (e) {} finally {
     if (buf) _free(buf);
     if (status) _free(status);
     if (ret) _free(ret);
    }
    return func;
   }
   Runtime.warnOnce("warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling");
   return func;
  }
  function demangleAll(text) {
   return text.replace(/__Z[\w\d_]+/g, (function(x) {
    var y = demangle(x);
    return x === y ? x : x + " [" + y + "]";
   }));
  }
  function jsStackTrace() {
   var err = new Error;
   if (!err.stack) {
    try {
     throw new Error(0);
    } catch (e) {
     err = e;
    }
    if (!err.stack) {
     return "(no stack trace available)";
    }
   }
   return err.stack.toString();
  }
  function stackTrace() {
   var js = jsStackTrace();
   if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
   return demangleAll(js);
  }
  Module["stackTrace"] = stackTrace;
  function alignMemoryPage(x) {
   if (x % 4096 > 0) {
    x += 4096 - x % 4096;
   }
   return x;
  }
  var HEAP;
  var buffer;
  var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
  function updateGlobalBuffer(buf) {
   Module["buffer"] = buffer = buf;
  }
  function updateGlobalBufferViews() {
   Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
   Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
   Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
   Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
   Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
   Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
   Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
   Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer);
  }
  var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false;
  var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0;
  var DYNAMIC_BASE = 0, DYNAMICTOP = 0;
  function abortOnCannotGrowMemory() {
   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 adjusts the size at runtime but prevents some optimizations, (3) set Module.TOTAL_MEMORY to a higher value before the program runs, or if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 ");
  }
  function enlargeMemory() {
   abortOnCannotGrowMemory();
  }
  var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
  var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 16777216;
  var totalMemory = 64 * 1024;
  while (totalMemory < TOTAL_MEMORY || totalMemory < 2 * TOTAL_STACK) {
   if (totalMemory < 16 * 1024 * 1024) {
    totalMemory *= 2;
   } else {
    totalMemory += 16 * 1024 * 1024;
   }
  }
  if (totalMemory !== TOTAL_MEMORY) {
   TOTAL_MEMORY = totalMemory;
  }
  if (Module["buffer"]) {
   buffer = Module["buffer"];
  } else {
   buffer = new ArrayBuffer(TOTAL_MEMORY);
  }
  updateGlobalBufferViews();
  HEAP32[0] = 1668509029;
  HEAP16[1] = 25459;
  if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99) throw "Runtime error: expected the system to be little-endian!";
  Module["HEAP"] = HEAP;
  Module["buffer"] = buffer;
  Module["HEAP8"] = HEAP8;
  Module["HEAP16"] = HEAP16;
  Module["HEAP32"] = HEAP32;
  Module["HEAPU8"] = HEAPU8;
  Module["HEAPU16"] = HEAPU16;
  Module["HEAPU32"] = HEAPU32;
  Module["HEAPF32"] = HEAPF32;
  Module["HEAPF64"] = HEAPF64;
  function callRuntimeCallbacks(callbacks) {
   while (callbacks.length > 0) {
    var callback = callbacks.shift();
    if (typeof callback == "function") {
     callback();
     continue;
    }
    var func = callback.func;
    if (typeof func === "number") {
     if (callback.arg === undefined) {
      Runtime.dynCall("v", func);
     } else {
      Runtime.dynCall("vi", func, [ callback.arg ]);
     }
    } else {
     func(callback.arg === undefined ? null : callback.arg);
    }
   }
  }
  var __ATPRERUN__ = [];
  var __ATINIT__ = [];
  var __ATMAIN__ = [];
  var __ATEXIT__ = [];
  var __ATPOSTRUN__ = [];
  var runtimeInitialized = false;
  var runtimeExited = false;
  function preRun() {
   if (Module["preRun"]) {
    if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
    while (Module["preRun"].length) {
     addOnPreRun(Module["preRun"].shift());
    }
   }
   callRuntimeCallbacks(__ATPRERUN__);
  }
  function ensureInitRuntime() {
   if (runtimeInitialized) return;
   runtimeInitialized = true;
   callRuntimeCallbacks(__ATINIT__);
  }
  function preMain() {
   callRuntimeCallbacks(__ATMAIN__);
  }
  function exitRuntime() {
   callRuntimeCallbacks(__ATEXIT__);
   runtimeExited = true;
  }
  function postRun() {
   if (Module["postRun"]) {
    if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
    while (Module["postRun"].length) {
     addOnPostRun(Module["postRun"].shift());
    }
   }
   callRuntimeCallbacks(__ATPOSTRUN__);
  }
  function addOnPreRun(cb) {
   __ATPRERUN__.unshift(cb);
  }
  Module["addOnPreRun"] = addOnPreRun;
  function addOnInit(cb) {
   __ATINIT__.unshift(cb);
  }
  Module["addOnInit"] = addOnInit;
  function addOnPreMain(cb) {
   __ATMAIN__.unshift(cb);
  }
  Module["addOnPreMain"] = addOnPreMain;
  function addOnExit(cb) {
   __ATEXIT__.unshift(cb);
  }
  Module["addOnExit"] = addOnExit;
  function addOnPostRun(cb) {
   __ATPOSTRUN__.unshift(cb);
  }
  Module["addOnPostRun"] = addOnPostRun;
  function intArrayFromString(stringy, dontAddNull, length) {
   var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
   var u8array = new Array(len);
   var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
   if (dontAddNull) u8array.length = numBytesWritten;
   return u8array;
  }
  Module["intArrayFromString"] = intArrayFromString;
  function intArrayToString(array) {
   var ret = [];
   for (var i = 0; i < array.length; i++) {
    var chr = array[i];
    if (chr > 255) {
     chr &= 255;
    }
    ret.push(String.fromCharCode(chr));
   }
   return ret.join("");
  }
  Module["intArrayToString"] = intArrayToString;
  function writeStringToMemory(string, buffer, dontAddNull) {
   var array = intArrayFromString(string, dontAddNull);
   var i = 0;
   while (i < array.length) {
    var chr = array[i];
    HEAP8[buffer + i >> 0] = chr;
    i = i + 1;
   }
  }
  Module["writeStringToMemory"] = writeStringToMemory;
  function writeArrayToMemory(array, buffer) {
   for (var i = 0; i < array.length; i++) {
    HEAP8[buffer++ >> 0] = array[i];
   }
  }
  Module["writeArrayToMemory"] = writeArrayToMemory;
  function writeAsciiToMemory(str, buffer, dontAddNull) {
   for (var i = 0; i < str.length; ++i) {
    HEAP8[buffer++ >> 0] = str.charCodeAt(i);
   }
   if (!dontAddNull) HEAP8[buffer >> 0] = 0;
  }
  Module["writeAsciiToMemory"] = writeAsciiToMemory;
  if (!Math["imul"] || Math["imul"](4294967295, 5) !== -5) Math["imul"] = function imul(a, b) {
   var ah = a >>> 16;
   var al = a & 65535;
   var bh = b >>> 16;
   var bl = b & 65535;
   return al * bl + (ah * bl + al * bh << 16) | 0;
  };
  Math.imul = Math["imul"];
  if (!Math["clz32"]) Math["clz32"] = (function(x) {
   x = x >>> 0;
   for (var i = 0; i < 32; i++) {
    if (x & 1 << 31 - i) return i;
   }
   return 32;
  });
  Math.clz32 = Math["clz32"];
  if (!Math["trunc"]) Math["trunc"] = (function(x) {
   return x < 0 ? Math.ceil(x) : Math.floor(x);
  });
  Math.trunc = Math["trunc"];
  var Math_abs = Math.abs;
  var Math_cos = Math.cos;
  var Math_sin = Math.sin;
  var Math_tan = Math.tan;
  var Math_acos = Math.acos;
  var Math_asin = Math.asin;
  var Math_atan = Math.atan;
  var Math_atan2 = Math.atan2;
  var Math_exp = Math.exp;
  var Math_log = Math.log;
  var Math_sqrt = Math.sqrt;
  var Math_ceil = Math.ceil;
  var Math_floor = Math.floor;
  var Math_pow = Math.pow;
  var Math_imul = Math.imul;
  var Math_fround = Math.fround;
  var Math_min = Math.min;
  var Math_clz32 = Math.clz32;
  var Math_trunc = Math.trunc;
  var runDependencies = 0;
  var runDependencyWatcher = null;
  var dependenciesFulfilled = null;
  function addRunDependency(id) {
   runDependencies++;
   if (Module["monitorRunDependencies"]) {
    Module["monitorRunDependencies"](runDependencies);
   }
  }
  Module["addRunDependency"] = addRunDependency;
  function removeRunDependency(id) {
   runDependencies--;
   if (Module["monitorRunDependencies"]) {
    Module["monitorRunDependencies"](runDependencies);
   }
   if (runDependencies == 0) {
    if (runDependencyWatcher !== null) {
     clearInterval(runDependencyWatcher);
     runDependencyWatcher = null;
    }
    if (dependenciesFulfilled) {
     var callback = dependenciesFulfilled;
     dependenciesFulfilled = null;
     callback();
    }
   }
  }
  Module["removeRunDependency"] = removeRunDependency;
  Module["preloadedImages"] = {};
  Module["preloadedAudios"] = {};
  var memoryInitializer = null;
  var ASM_CONSTS = [];
  STATIC_BASE = 1024;
  STATICTOP = STATIC_BASE + 5168;
  __ATINIT__.push();
  memoryInitializer = "hello-binaryen.html.mem";
  var STATIC_BUMP = 5168;
  var tempDoublePtr = STATICTOP;
  STATICTOP += 16;
  Module["_i64Subtract"] = _i64Subtract;
  Module["_i64Add"] = _i64Add;
  Module["_memset"] = _memset;
  function _pthread_cleanup_push(routine, arg) {
   __ATEXIT__.push((function() {
    Runtime.dynCall("vi", routine, [ arg ]);
   }));
   _pthread_cleanup_push.level = __ATEXIT__.length;
  }
  Module["_bitshift64Lshr"] = _bitshift64Lshr;
  Module["_bitshift64Shl"] = _bitshift64Shl;
  function _pthread_cleanup_pop() {
   assert(_pthread_cleanup_push.level == __ATEXIT__.length, "cannot pop if something else added meanwhile!");
   __ATEXIT__.pop();
   _pthread_cleanup_push.level = __ATEXIT__.length;
  }
  function _abort() {
   Module["abort"]();
  }
  function ___lock() {}
  function ___unlock() {}
  var SYSCALLS = {
   varargs: 0,
   get: (function(varargs) {
    SYSCALLS.varargs += 4;
    var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
    return ret;
   }),
   getStr: (function() {
    var ret = Pointer_stringify(SYSCALLS.get());
    return ret;
   }),
   get64: (function() {
    var low = SYSCALLS.get(), high = SYSCALLS.get();
    if (low >= 0) assert(high === 0); else assert(high === -1);
    return low;
   }),
   getZero: (function() {
    assert(SYSCALLS.get() === 0);
   })
  };
  function ___syscall6(which, varargs) {
   SYSCALLS.varargs = varargs;
   try {
    var stream = SYSCALLS.getStreamFromFD();
    FS.close(stream);
    return 0;
   } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return -e.errno;
   }
  }
  var cttz_i8 = allocate([ 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 ], "i8", ALLOC_STATIC);
  function _llvm_cttz_i32(x) {
   x = x | 0;
   var ret = 0;
   ret = HEAP8[cttz_i8 + (x & 255) >> 0] | 0;
   if ((ret | 0) < 8) return ret | 0;
   ret = HEAP8[cttz_i8 + (x >> 8 & 255) >> 0] | 0;
   if ((ret | 0) < 8) return ret + 8 | 0;
   ret = HEAP8[cttz_i8 + (x >> 16 & 255) >> 0] | 0;
   if ((ret | 0) < 8) return ret + 16 | 0;
   return (HEAP8[cttz_i8 + (x >>> 24) >> 0] | 0) + 24 | 0;
  }
  Module["___udivmoddi4"] = ___udivmoddi4;
  Module["___udivdi3"] = ___udivdi3;
  function _sbrk(bytes) {
   var self = _sbrk;
   if (!self.called) {
    DYNAMICTOP = alignMemoryPage(DYNAMICTOP);
    self.called = true;
    assert(Runtime.dynamicAlloc);
    self.alloc = Runtime.dynamicAlloc;
    Runtime.dynamicAlloc = (function() {
     abort("cannot dynamically allocate, sbrk now has control");
    });
   }
   var ret = DYNAMICTOP;
   if (bytes != 0) {
    var success = self.alloc(bytes);
    if (!success) return -1 >>> 0;
   }
   return ret;
  }
  Module["___uremdi3"] = ___uremdi3;
  function _emscripten_memcpy_big(dest, src, num) {
   HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
   return dest;
  }
  Module["_memcpy"] = _memcpy;
  Module["_pthread_self"] = _pthread_self;
  function ___syscall140(which, varargs) {
   SYSCALLS.varargs = varargs;
   try {
    var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get();
    var offset = offset_low;
    assert(offset_high === 0);
    FS.llseek(stream, offset, whence);
    HEAP32[result >> 2] = stream.position;
    if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
    return 0;
   } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return -e.errno;
   }
  }
  function ___syscall146(which, varargs) {
   SYSCALLS.varargs = varargs;
   try {
    var stream = SYSCALLS.get(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get();
    var ret = 0;
    if (!___syscall146.buffer) {
     ___syscall146.buffers = [ null, [], [] ];
     ___syscall146.printChar = (function(stream, curr) {
      var buffer = ___syscall146.buffers[stream];
      assert(buffer);
      if (curr === 0 || curr === 10) {
       (stream === 1 ? Module["print"] : Module["printErr"])(UTF8ArrayToString(buffer, 0));
       buffer.length = 0;
      } else {
       buffer.push(curr);
      }
     });
    }
    for (var i = 0; i < iovcnt; i++) {
     var ptr = HEAP32[iov + i * 8 >> 2];
     var len = HEAP32[iov + (i * 8 + 4) >> 2];
     for (var j = 0; j < len; j++) {
      ___syscall146.printChar(stream, HEAPU8[ptr + j]);
     }
     ret += len;
    }
    return ret;
   } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return -e.errno;
   }
  }
  function ___syscall54(which, varargs) {
   SYSCALLS.varargs = varargs;
   try {
    return 0;
   } catch (e) {
    if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
    return -e.errno;
   }
  }
  __ATEXIT__.push((function() {
   var fflush = Module["_fflush"];
   if (fflush) fflush(0);
   var printChar = ___syscall146.printChar;
   if (!printChar) return;
   var buffers = ___syscall146.buffers;
   if (buffers[1].length) printChar(1, 10);
   if (buffers[2].length) printChar(2, 10);
  }));
  STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
  staticSealed = true;
  STACK_MAX = STACK_BASE + TOTAL_STACK;
  DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
  function invoke_ii(index, a1) {
   try {
    return Module["dynCall_ii"](index, a1);
   } catch (e) {
    if (typeof e !== "number" && e !== "longjmp") throw e;
    asm["setThrew"](1, 0);
   }
  }
  function invoke_iiii(index, a1, a2, a3) {
   try {
    return Module["dynCall_iiii"](index, a1, a2, a3);
   } catch (e) {
    if (typeof e !== "number" && e !== "longjmp") throw e;
    asm["setThrew"](1, 0);
   }
  }
  function invoke_vi(index, a1) {
   try {
    Module["dynCall_vi"](index, a1);
   } catch (e) {
    if (typeof e !== "number" && e !== "longjmp") throw e;
    asm["setThrew"](1, 0);
   }
  }
  Module.asmGlobalArg = {
   "Math": Math,
   "Int8Array": Int8Array,
   "Int16Array": Int16Array,
   "Int32Array": Int32Array,
   "Uint8Array": Uint8Array,
   "Uint16Array": Uint16Array,
   "Uint32Array": Uint32Array,
   "Float32Array": Float32Array,
   "Float64Array": Float64Array,
   "NaN": NaN,
   "Infinity": Infinity
  };
  Module.asmLibraryArg = {
   "abort": abort,
   "assert": assert,
   "invoke_ii": invoke_ii,
   "invoke_iiii": invoke_iiii,
   "invoke_vi": invoke_vi,
   "_pthread_cleanup_pop": _pthread_cleanup_pop,
   "_abort": _abort,
   "___lock": ___lock,
   "___syscall6": ___syscall6,
   "_pthread_cleanup_push": _pthread_cleanup_push,
   "_llvm_cttz_i32": _llvm_cttz_i32,
   "_sbrk": _sbrk,
   "___syscall140": ___syscall140,
   "_emscripten_memcpy_big": _emscripten_memcpy_big,
   "___syscall54": ___syscall54,
   "___unlock": ___unlock,
   "___syscall146": ___syscall146,
   "STACKTOP": STACKTOP,
   "STACK_MAX": STACK_MAX,
   "tempDoublePtr": tempDoublePtr,
   "ABORT": ABORT,
   "cttz_i8": cttz_i8
  };
  // EMSCRIPTEN_START_ASM
  
  var asm =Module["asm"]// EMSCRIPTEN_END_ASM
  (Module.asmGlobalArg, Module.asmLibraryArg, buffer);
  var _i64Subtract = Module["_i64Subtract"] = asm["_i64Subtract"];
  var _free = Module["_free"] = asm["_free"];
  var _main = Module["_main"] = asm["_main"];
  var _i64Add = Module["_i64Add"] = asm["_i64Add"];
  var runPostSets = Module["runPostSets"] = asm["runPostSets"];
  var ___udivmoddi4 = Module["___udivmoddi4"] = asm["___udivmoddi4"];
  var _pthread_self = Module["_pthread_self"] = asm["_pthread_self"];
  var _memset = Module["_memset"] = asm["_memset"];
  var ___udivdi3 = Module["___udivdi3"] = asm["___udivdi3"];
  var _malloc = Module["_malloc"] = asm["_malloc"];
  var _memcpy = Module["_memcpy"] = asm["_memcpy"];
  var _bitshift64Lshr = Module["_bitshift64Lshr"] = asm["_bitshift64Lshr"];
  var _fflush = Module["_fflush"] = asm["_fflush"];
  var ___uremdi3 = Module["___uremdi3"] = asm["___uremdi3"];
  var ___errno_location = Module["___errno_location"] = asm["___errno_location"];
  var _bitshift64Shl = Module["_bitshift64Shl"] = asm["_bitshift64Shl"];
  var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
  var dynCall_iiii = Module["dynCall_iiii"] = asm["dynCall_iiii"];
  var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
  Runtime.stackAlloc = asm["stackAlloc"];
  Runtime.stackSave = asm["stackSave"];
  Runtime.stackRestore = asm["stackRestore"];
  Runtime.establishStackSpace = asm["establishStackSpace"];
  Runtime.setTempRet0 = asm["setTempRet0"];
  Runtime.getTempRet0 = asm["getTempRet0"];
  if (memoryInitializer) {
   if (typeof Module["locateFile"] === "function") {
    memoryInitializer = Module["locateFile"](memoryInitializer);
   } else if (Module["memoryInitializerPrefixURL"]) {
    memoryInitializer = Module["memoryInitializerPrefixURL"] + memoryInitializer;
   }
   if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
    var data = Module["readBinary"](memoryInitializer);
    HEAPU8.set(data, Runtime.GLOBAL_BASE);
   } else {
    addRunDependency("memory initializer");
    var applyMemoryInitializer = (function(data) {
     if (data.byteLength) data = new Uint8Array(data);
     HEAPU8.set(data, Runtime.GLOBAL_BASE);
     if (Module["memoryInitializerRequest"]) delete Module["memoryInitializerRequest"].response;
     removeRunDependency("memory initializer");
    });
    function doBrowserLoad() {
     Module["readAsync"](memoryInitializer, applyMemoryInitializer, (function() {
      throw "could not load memory initializer " + memoryInitializer;
     }));
    }
    if (Module["memoryInitializerRequest"]) {
     function useRequest() {
      var request = Module["memoryInitializerRequest"];
      if (request.status !== 200 && request.status !== 0) {
       console.warn("a problem seems to have happened with Module.memoryInitializerRequest, status: " + request.status + ", retrying " + memoryInitializer);
       doBrowserLoad();
       return;
      }
      applyMemoryInitializer(request.response);
     }
     if (Module["memoryInitializerRequest"].response) {
      setTimeout(useRequest, 0);
     } else {
      Module["memoryInitializerRequest"].addEventListener("load", useRequest);
     }
    } else {
     doBrowserLoad();
    }
   }
  }
  function ExitStatus(status) {
   this.name = "ExitStatus";
   this.message = "Program terminated with exit(" + status + ")";
   this.status = status;
  }
  ExitStatus.prototype = new Error;
  ExitStatus.prototype.constructor = ExitStatus;
  var initialStackTop;
  var preloadStartTime = null;
  var calledMain = false;
  dependenciesFulfilled = function runCaller() {
   if (!Module["calledRun"]) run();
   if (!Module["calledRun"]) dependenciesFulfilled = runCaller;
  };
  Module["callMain"] = Module.callMain = function callMain(args) {
   args = args || [];
   ensureInitRuntime();
   var argc = args.length + 1;
   function pad() {
    for (var i = 0; i < 4 - 1; i++) {
     argv.push(0);
    }
   }
   var argv = [ allocate(intArrayFromString(Module["thisProgram"]), "i8", ALLOC_NORMAL) ];
   pad();
   for (var i = 0; i < argc - 1; i = i + 1) {
    argv.push(allocate(intArrayFromString(args[i]), "i8", ALLOC_NORMAL));
    pad();
   }
   argv.push(0);
   argv = allocate(argv, "i32", ALLOC_NORMAL);
   try {
    var ret = Module["_main"](argc, argv, 0);
    exit(ret, true);
   } catch (e) {
    if (e instanceof ExitStatus) {
     return;
    } else if (e == "SimulateInfiniteLoop") {
     Module["noExitRuntime"] = true;
     return;
    } else {
     if (e && typeof e === "object" && e.stack) Module.printErr("exception thrown: " + [ e, e.stack ]);
     throw e;
    }
   } finally {
    calledMain = true;
   }
  };
  function run(args) {
   args = args || Module["arguments"];
   if (preloadStartTime === null) preloadStartTime = Date.now();
   if (runDependencies > 0) {
    return;
   }
   preRun();
   if (runDependencies > 0) return;
   if (Module["calledRun"]) return;
   function doRun() {
    if (Module["calledRun"]) return;
    Module["calledRun"] = true;
    if (ABORT) return;
    ensureInitRuntime();
    preMain();
    if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
    if (Module["_main"] && shouldRunNow) Module["callMain"](args);
    postRun();
   }
   if (Module["setStatus"]) {
    Module["setStatus"]("Running...");
    setTimeout((function() {
     setTimeout((function() {
      Module["setStatus"]("");
     }), 1);
     doRun();
    }), 1);
   } else {
    doRun();
   }
  }
  Module["run"] = Module.run = run;
  function exit(status, implicit) {
   if (implicit && Module["noExitRuntime"]) {
    return;
   }
   if (Module["noExitRuntime"]) {} else {
    ABORT = true;
    EXITSTATUS = status;
    STACKTOP = initialStackTop;
    exitRuntime();
    if (Module["onExit"]) Module["onExit"](status);
   }
   if (ENVIRONMENT_IS_NODE) {
    process["exit"](status);
   } else if (ENVIRONMENT_IS_SHELL && typeof quit === "function") {
    quit(status);
   }
   throw new ExitStatus(status);
  }
  Module["exit"] = Module.exit = exit;
  var abortDecorators = [];
  function abort(what) {
   if (what !== undefined) {
    Module.print(what);
    Module.printErr(what);
    what = JSON.stringify(what);
   } else {
    what = "";
   }
   ABORT = true;
   EXITSTATUS = 1;
   var extra = "\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.";
   var output = "abort(" + what + ") at " + stackTrace() + extra;
   if (abortDecorators) {
    abortDecorators.forEach((function(decorator) {
     output = decorator(output, what);
    }));
   }
   throw output;
  }
  Module["abort"] = Module.abort = abort;
  if (Module["preInit"]) {
   if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
   while (Module["preInit"].length > 0) {
    Module["preInit"].pop()();
   }
  }
  var shouldRunNow = true;
  if (Module["noInitialRun"]) {
   shouldRunNow = false;
  }
  run();
  
  
  
  
  