var Module;

if (!Module) Module = "__EMSCRIPTEN_PRIVATE_MODULE_EXPORT_NAME_SUBSTITUTION__";

var ENVIRONMENT_IS_NODE = typeof process === "object";

if (ENVIRONMENT_IS_NODE) {
  var fs = require("fs");
  Module["wasm"] = fs.readFileSync(__dirname + "/a.wasm");
}

function out(text) {
  console.log(text);
}

function err(text) {
  console.error(text);
}

function ready() {
  run();
}

function abort(what) {
  throw what;
}

var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;

function UTF8ArrayToString(u8Array, idx, maxBytesToRead) {
  var endIdx = idx + maxBytesToRead;
  var endPtr = idx;
  while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr;
  if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
    return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
  } else {
    var str = "";
    while (idx < endPtr) {
      var u0 = u8Array[idx++];
      if (!(u0 & 128)) {
        str += String.fromCharCode(u0);
        continue;
      }
      var u1 = u8Array[idx++] & 63;
      if ((u0 & 224) == 192) {
        str += String.fromCharCode((u0 & 31) << 6 | u1);
        continue;
      }
      var u2 = u8Array[idx++] & 63;
      if ((u0 & 240) == 224) {
        u0 = (u0 & 15) << 12 | u1 << 6 | u2;
      } else {
        u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u8Array[idx++] & 63;
      }
      if (u0 < 65536) {
        str += String.fromCharCode(u0);
      } else {
        var ch = u0 - 65536;
        str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
      }
    }
  }
  return str;
}

function UTF8ToString(ptr, maxBytesToRead) {
  return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}

var TOTAL_MEMORY = 16777216, STATIC_BASE = 1024, DYNAMICTOP_PTR = 6016;

var wasmMaximumMemory = TOTAL_MEMORY;

var wasmMemory = new WebAssembly.Memory({
  initial: TOTAL_MEMORY >> 16,
  maximum: wasmMaximumMemory >> 16
});

var buffer = wasmMemory.buffer;

var HEAP8 = new Int8Array(buffer);

var HEAP16 = new Int16Array(buffer);

var HEAP32 = new Int32Array(buffer);

var HEAPU8 = new Uint8Array(buffer);

var HEAPU16 = new Uint16Array(buffer);

var HEAPU32 = new Uint32Array(buffer);

var HEAPF32 = new Float32Array(buffer);

var HEAPF64 = new Float64Array(buffer);

HEAP32[DYNAMICTOP_PTR >> 2] = 5249152;

var SYSCALLS = {
  buffers: [ null, [], [] ],
  printChar: function(stream, curr) {
    var buffer = SYSCALLS.buffers[stream];
    if (curr === 0 || curr === 10) {
      (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
      buffer.length = 0;
    } else {
      buffer.push(curr);
    }
  },
  varargs: 0,
  get: function(varargs) {
    SYSCALLS.varargs += 4;
    var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
    return ret;
  },
  getStr: function() {
    var ret = UTF8ToString(SYSCALLS.get());
    return ret;
  },
  get64: function() {
    var low = SYSCALLS.get(), high = SYSCALLS.get();
    return low;
  },
  getZero: function() {
    SYSCALLS.get();
  }
};

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;
    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;
    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++) {
        SYSCALLS.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;
  }
}

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;
  }
}

function _emscripten_get_now() {
  abort();
}

function _emscripten_random() {
  return Math.random();
}

function _emscripten_memcpy_js(dest, src, num) {
  HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
}

if (ENVIRONMENT_IS_NODE) {
  _emscripten_get_now = function _emscripten_get_now_actual() {
    var t = process.hrtime();
    return t[0] * 1e3 + t[1] / 1e6;
  };
} else if (typeof self === "object" && self["performance"] && typeof self["performance"]["now"] === "function") {
  _emscripten_get_now = function() {
    return self["performance"]["now"]();
  };
} else if (typeof performance === "object" && typeof performance["now"] === "function") {
  _emscripten_get_now = function() {
    return performance["now"]();
  };
} else {
  _emscripten_get_now = Date.now;
}

var wasmImports = {
  b: abort,
  h: ___syscall140,
  a: ___syscall146,
  g: ___syscall54,
  f: ___syscall6,
  e: _emscripten_get_now,
  d: _emscripten_memcpy_js,
  c: _emscripten_random
};

function run() {
  var ret = _main();
}

function initRuntime(wasmExports) {
  wasmExports["i"]();
}

var env = wasmImports;

env["memory"] = wasmMemory;

env["table"] = new WebAssembly.Table({
  initial: 6,
  maximum: 6,
  element: "anyfunc"
});

env["__memory_base"] = STATIC_BASE;

env["__table_base"] = 0;

var imports = {
  env,
  global: {
    NaN,
    Infinity: Infinity
  },
  "global.Math": Math,
  asm2wasm: {
    "f64-rem": function(x, y) {
      return x % y;
    },
    debugger: function() {
      debugger;
    }
  }
};

var ___errno_location, _llvm_bswap_i32, _main, _memcpy, _memset, dynCall_ii, dynCall_iiii;

WebAssembly.instantiate(Module["wasm"], imports).then(output => {
  var wasmExports = output.instance.exports;
  ___errno_location = wasmExports["j"];
  _llvm_bswap_i32 = wasmExports["k"];
  _main = wasmExports["l"];
  _memcpy = wasmExports["m"];
  _memset = wasmExports["n"];
  dynCall_ii = wasmExports["o"];
  dynCall_iiii = wasmExports["p"];
  initRuntime(wasmExports);
  ready();
});
