c2iec

// The Module object: Our interface to the outside world. We import

// and export values on it. There are various ways Module can be used:

// 1. Not defined. We create it here

// 2. A function parameter, function(Module) { ..generated code.. }

// 3. pre-run appended it, var Module = {}; ..generated code..

// 4. External script tag defines var Module.

// We need to check if Module already exists (e.g. case 3 above).

// Substitution will be replaced with actual code on later stage of the build,

// this way Closure Compiler will not mangle it (e.g. case 4. above).

// Note that if you want to run closure, and also to use Module

// after the generated code, you will need to define   var Module = {};

// before the code. Then that object will be used in the code, and you

// can continue to use Module afterwards as well.

var Module = typeof Module !== 'undefined' ? Module : {};

// --pre-jses are emitted after the Module integration code, so that they can

// refer to Module (if they choose; they can also define Module)

// {{PRE_JSES}}

// Sometimes an existing Module object exists with properties

// meant to overwrite the default module functionality. Here

// we collect those properties and reapply _after_ we configure

// the current environment's defaults to avoid having to be so

// defensive during initialization.

var moduleOverrides = {};

var key;

for (key in Module) {

  if (Module.hasOwnProperty(key)) {

    moduleOverrides[key] = Module[key];

  }

}

var arguments_ = [];

var thisProgram = './this.program';

var quit_ = function(status, toThrow) {

  throw toThrow;

};

// Determine the runtime environment we are in. You can customize this by

// setting the ENVIRONMENT setting at compile time (see settings.js).

var ENVIRONMENT_IS_WEB = false;

var ENVIRONMENT_IS_WORKER = false;

var ENVIRONMENT_IS_NODE = false;

var ENVIRONMENT_IS_SHELL = false;

ENVIRONMENT_IS_WEB = typeof window === 'object';

ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';

// N.b. Electron.js environment is simultaneously a NODE-environment, but

// also a web environment.

ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string';

ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

if (Module['ENVIRONMENT']) {

  throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)');

}

// `/` should be present at the end if `scriptDirectory` is not empty

var scriptDirectory = '';

function locateFile(path) {

  if (Module['locateFile']) {

    return Module['locateFile'](path, scriptDirectory);

  }

  return scriptDirectory + path;

}

// Hooks that are implemented differently in different runtime environments.

var read_,

    readAsync,

    readBinary,

    setWindowTitle;

var nodeFS;

var nodePath;

if (ENVIRONMENT_IS_NODE) {

  if (ENVIRONMENT_IS_WORKER) {

    scriptDirectory = require('path').dirname(scriptDirectory) + '/';

  } else {

    scriptDirectory = __dirname + '/';

  }

  read_ = function shell_read(filename, binary) {

    if (!nodeFS) nodeFS = require('fs');

    if (!nodePath) nodePath = require('path');

    filename = nodePath['normalize'](filename);

    return nodeFS['readFileSync'](filename, binary ? null : 'utf8');

  };

  readBinary = function readBinary(filename) {

    var ret = read_(filename, true);

    if (!ret.buffer) {

      ret = new Uint8Array(ret);

    }

    assert(ret.buffer);

    return ret;

  };

  if (process['argv'].length > 1) {

    thisProgram = process['argv'][1].replace(/\\/g, '/');

  }

  arguments_ = process['argv'].slice(2);

  if (typeof module !== 'undefined') {

    module['exports'] = Module;

  }

  process['on']('uncaughtException', function(ex) {

    // suppress ExitStatus exceptions from showing an error

    if (!(ex instanceof ExitStatus)) {

      throw ex;

    }

  });

  process['on']('unhandledRejection', abort);

  quit_ = function(status) {

    process['exit'](status);

  };

  Module['inspect'] = function () { return '[Emscripten Module object]'; };

} else

if (ENVIRONMENT_IS_SHELL) {

  if (typeof read != 'undefined') {

    read_ = function shell_read(f) {

      return read(f);

    };

  }

  readBinary = function readBinary(f) {

    var data;

    if (typeof readbuffer === 'function') {

      return new Uint8Array(readbuffer(f));

    }

    data = read(f, 'binary');

    assert(typeof data === 'object');

    return data;

  };

  if (typeof scriptArgs != 'undefined') {

    arguments_ = scriptArgs;

  } else if (typeof arguments != 'undefined') {

    arguments_ = arguments;

  }

  if (typeof quit === 'function') {

    quit_ = function(status) {

      quit(status);

    };

  }

  if (typeof print !== 'undefined') {

    // Prefer to use print/printErr where they exist, as they usually work better.

    if (typeof console === 'undefined') console = /** @type{!Console} */({});

    console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);

    console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr !== 'undefined' ? printErr : print);

  }

} else

// Note that this includes Node.js workers when relevant (pthreads is enabled).

// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and

// ENVIRONMENT_IS_NODE.

if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {

  if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled

    scriptDirectory = self.location.href;

  } else if (document.currentScript) { // web

    scriptDirectory = document.currentScript.src;

  }

  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.

  // otherwise, slice off the final part of the url to find the script directory.

  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,

  // and scriptDirectory will correctly be replaced with an empty string.

  if (scriptDirectory.indexOf('blob:') !== 0) {

    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1);

  } else {

    scriptDirectory = '';

  }

  // Differentiate the Web Worker from the Node Worker case, as reading must

  // be done differently.

  {

  read_ = function shell_read(url) {

      var xhr = new XMLHttpRequest();

      xhr.open('GET', url, false);

      xhr.send(null);

      return xhr.responseText;

  };

  if (ENVIRONMENT_IS_WORKER) {

    readBinary = function readBinary(url) {

        var xhr = new XMLHttpRequest();

        xhr.open('GET', url, false);

        xhr.responseType = 'arraybuffer';

        xhr.send(null);

        return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));

    };

  }

  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)) { // file URLs can return 0

        onload(xhr.response);

        return;

      }

      onerror();

    };

    xhr.onerror = onerror;

    xhr.send(null);

  };

  }

  setWindowTitle = function(title) { document.title = title };

} else

{

  throw new Error('environment detection error');

}

// Set up the out() and err() hooks, which are how we can print to stdout or

// stderr, respectively.

var out = Module['print'] || console.log.bind(console);

var err = Module['printErr'] || console.warn.bind(console);

// Merge back in the overrides

for (key in moduleOverrides) {

  if (moduleOverrides.hasOwnProperty(key)) {

    Module[key] = moduleOverrides[key];

  }

}

// Free the object hierarchy contained in the overrides, this lets the GC

// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.

moduleOverrides = null;

// Emit code to handle expected values on the Module object. This applies Module.x

// to the proper local x. This has two benefits: first, we only emit it if it is

// expected to arrive, and second, by using a local everywhere else that can be

// minified.

if (Module['arguments']) arguments_ = Module['arguments'];if (!Object.getOwnPropertyDescriptor(Module, 'arguments')) Object.defineProperty(Module, 'arguments', { configurable: true, get: function() { abort('Module.arguments has been replaced with plain arguments_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

if (Module['thisProgram']) thisProgram = Module['thisProgram'];if (!Object.getOwnPropertyDescriptor(Module, 'thisProgram')) Object.defineProperty(Module, 'thisProgram', { configurable: true, get: function() { abort('Module.thisProgram has been replaced with plain thisProgram (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

if (Module['quit']) quit_ = Module['quit'];if (!Object.getOwnPropertyDescriptor(Module, 'quit')) Object.defineProperty(Module, 'quit', { configurable: true, get: function() { abort('Module.quit has been replaced with plain quit_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message

// Assertions on removed incoming Module JS APIs.

assert(typeof Module['memoryInitializerPrefixURL'] === 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');

assert(typeof Module['pthreadMainPrefixURL'] === 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');

assert(typeof Module['cdInitializerPrefixURL'] === 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');

assert(typeof Module['filePackagePrefixURL'] === 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');

assert(typeof Module['read'] === 'undefined', 'Module.read option was removed (modify read_ in JS)');

assert(typeof Module['readAsync'] === 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');

assert(typeof Module['readBinary'] === 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');

assert(typeof Module['setWindowTitle'] === 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)');

assert(typeof Module['TOTAL_MEMORY'] === 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');

if (!Object.getOwnPropertyDescriptor(Module, 'read')) Object.defineProperty(Module, 'read', { configurable: true, get: function() { abort('Module.read has been replaced with plain read_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

if (!Object.getOwnPropertyDescriptor(Module, 'readAsync')) Object.defineProperty(Module, 'readAsync', { configurable: true, get: function() { abort('Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

if (!Object.getOwnPropertyDescriptor(Module, 'readBinary')) Object.defineProperty(Module, 'readBinary', { configurable: true, get: function() { abort('Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

if (!Object.getOwnPropertyDescriptor(Module, 'setWindowTitle')) Object.defineProperty(Module, 'setWindowTitle', { configurable: true, get: function() { abort('Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';

var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';

var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';

var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';

// {{PREAMBLE_ADDITIONS}}

var STACK_ALIGN = 16;

function dynamicAlloc(size) {

  assert(DYNAMICTOP_PTR);

  var ret = HEAP32[DYNAMICTOP_PTR>>2];

  var end = (ret + size + 15) & -16;

  assert(end <= HEAP8.length, 'failure to dynamicAlloc - memory growth etc. is not supported there, call malloc/sbrk directly');

  HEAP32[DYNAMICTOP_PTR>>2] = end;

  return ret;

}

function alignMemory(size, factor) {

  if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default

  return Math.ceil(size / factor) * factor;

}

function getNativeTypeSize(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 4; // A pointer

      } else if (type[0] === 'i') {

        var bits = Number(type.substr(1));

        assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type);

        return bits / 8;

      } else {

        return 0;

      }

    }

  }

}

function warnOnce(text) {

  if (!warnOnce.shown) warnOnce.shown = {};

  if (!warnOnce.shown[text]) {

    warnOnce.shown[text] = 1;

    err(text);

  }

}

// Wraps a JS function as a wasm function with a given signature.

function convertJsFunctionToWasm(func, sig) {

  // If the type reflection proposal is available, use the new

  // "WebAssembly.Function" constructor.

  // Otherwise, construct a minimal wasm module importing the JS function and

  // re-exporting it.

  if (typeof WebAssembly.Function === "function") {

    var typeNames = {

      'i': 'i32',

      'j': 'i64',

      'f': 'f32',

      'd': 'f64'

    };

    var type = {

      parameters: [],

      results: sig[0] == 'v' ? [] : [typeNames[sig[0]]]

    };

    for (var i = 1; i < sig.length; ++i) {

      type.parameters.push(typeNames[sig[i]]);

    }

    return new WebAssembly.Function(type, func);

  }

  // The module is static, with the exception of the type section, which is

  // generated based on the signature passed in.

  var typeSection = [

    0x01, // id: section,

    0x00, // length: 0 (placeholder)

    0x01, // count: 1

    0x60, // form: func

  ];

  var sigRet = sig.slice(0, 1);

  var sigParam = sig.slice(1);

  var typeCodes = {

    'i': 0x7f, // i32

    'j': 0x7e, // i64

    'f': 0x7d, // f32

    'd': 0x7c, // f64

  };

  // Parameters, length + signatures

  typeSection.push(sigParam.length);

  for (var i = 0; i < sigParam.length; ++i) {

    typeSection.push(typeCodes[sigParam[i]]);

  }

  // Return values, length + signatures

  // With no multi-return in MVP, either 0 (void) or 1 (anything else)

  if (sigRet == 'v') {

    typeSection.push(0x00);

  } else {

    typeSection = typeSection.concat([0x01, typeCodes[sigRet]]);

  }

  // Write the overall length of the type section back into the section header

  // (excepting the 2 bytes for the section id and length)

  typeSection[1] = typeSection.length - 2;

  // Rest of the module is static

  var bytes = new Uint8Array([

    0x00, 0x61, 0x73, 0x6d, // magic ("\0asm")

    0x01, 0x00, 0x00, 0x00, // version: 1

  ].concat(typeSection, [

    0x02, 0x07, // import section

      // (import "e" "f" (func 0 (type 0)))

      0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00,

    0x07, 0x05, // export section

      // (export "f" (func 0 (type 0)))

      0x01, 0x01, 0x66, 0x00, 0x00,

  ]));

   // We can compile this wasm module synchronously because it is very small.

  // This accepts an import (at "e.f"), that it reroutes to an export (at "f")

  var module = new WebAssembly.Module(bytes);

  var instance = new WebAssembly.Instance(module, {

    'e': {

      'f': func

    }

  });

  var wrappedFunc = instance.exports['f'];

  return wrappedFunc;

}

var freeTableIndexes = [];

// Weak map of functions in the table to their indexes, created on first use.

var functionsInTableMap;

// Add a wasm function to the table.

function addFunctionWasm(func, sig) {

  var table = wasmTable;

  // Check if the function is already in the table, to ensure each function

  // gets a unique index. First, create the map if this is the first use.

  if (!functionsInTableMap) {

    functionsInTableMap = new WeakMap();

    for (var i = 0; i < table.length; i++) {

      var item = table.get(i);

      // Ignore null values.

      if (item) {

        functionsInTableMap.set(item, i);

      }

    }

  }

  if (functionsInTableMap.has(func)) {

    return functionsInTableMap.get(func);

  }

  // It's not in the table, add it now.

  var ret;

  // Reuse a free index if there is one, otherwise grow.

  if (freeTableIndexes.length) {

    ret = freeTableIndexes.pop();

  } else {

    ret = table.length;

    // Grow the table

    try {

      table.grow(1);

    } catch (err) {

      if (!(err instanceof RangeError)) {

        throw err;

      }

      throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.';

    }

  }

  // Set the new value.

  try {

    // Attempting to call this with JS function will cause of table.set() to fail

    table.set(ret, func);

  } catch (err) {

    if (!(err instanceof TypeError)) {

      throw err;

    }

    assert(typeof sig !== 'undefined', 'Missing signature argument to addFunction');

    var wrapped = convertJsFunctionToWasm(func, sig);

    table.set(ret, wrapped);

  }

  functionsInTableMap.set(func, ret);

  return ret;

}

function removeFunctionWasm(index) {

  functionsInTableMap.delete(wasmTable.get(index));

  freeTableIndexes.push(index);

}

// 'sig' parameter is required for the llvm backend but only when func is not

// already a WebAssembly function.

function addFunction(func, sig) {

  assert(typeof func !== 'undefined');

  return addFunctionWasm(func, sig);

}

function removeFunction(index) {

  removeFunctionWasm(index);

}

var funcWrappers = {};

function getFuncWrapper(func, sig) {

  if (!func) return; // on null pointer, return undefined

  assert(sig);

  if (!funcWrappers[sig]) {

    funcWrappers[sig] = {};

  }

  var sigCache = funcWrappers[sig];

  if (!sigCache[func]) {

    // optimize away arguments usage in common cases

    if (sig.length === 1) {

      sigCache[func] = function dynCall_wrapper() {

        return dynCall(sig, func);

      };

    } else if (sig.length === 2) {

      sigCache[func] = function dynCall_wrapper(arg) {

        return dynCall(sig, func, [arg]);

      };

    } else {

      // general case

      sigCache[func] = function dynCall_wrapper() {

        return dynCall(sig, func, Array.prototype.slice.call(arguments));

      };

    }

  }

  return sigCache[func];

}

function makeBigInt(low, high, unsigned) {

  return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0));

}

/** @param {Array=} args */

function dynCall(sig, ptr, args) {

  if (args && args.length) {

    // j (64-bit integer) must be passed in as two numbers [low 32, high 32].

    assert(args.length === sig.substring(1).replace(/j/g, '--').length);

    assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\'');

    return Module['dynCall_' + sig].apply(null, [ptr].concat(args));

  } else {

    assert(sig.length == 1);

    assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\'');

    return Module['dynCall_' + sig].call(null, ptr);

  }

}

var tempRet0 = 0;

var setTempRet0 = function(value) {

  tempRet0 = value;

};

var getTempRet0 = function() {

  return tempRet0;

};

function getCompilerSetting(name) {

  throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for getCompilerSetting or emscripten_get_compiler_setting to work';

}

// The address globals begin at. Very low in memory, for code size and optimization opportunities.

// Above 0 is static memory, starting with globals.

// Then the stack.

// Then 'dynamic' memory for sbrk.

var GLOBAL_BASE = 1024;

// === Preamble library stuff ===

// Documentation for the public APIs defined in this file must be updated in:

//    site/source/docs/api_reference/preamble.js.rst

// A prebuilt local version of the documentation is available at:

//    site/build/text/docs/api_reference/preamble.js.txt

// You can also build docs locally as HTML or other formats in site/

// An online HTML version (which may be of a different version of Emscripten)

//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html

var wasmBinary;if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];if (!Object.getOwnPropertyDescriptor(Module, 'wasmBinary')) Object.defineProperty(Module, 'wasmBinary', { configurable: true, get: function() { abort('Module.wasmBinary has been replaced with plain wasmBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime'];if (!Object.getOwnPropertyDescriptor(Module, 'noExitRuntime')) Object.defineProperty(Module, 'noExitRuntime', { configurable: true, get: function() { abort('Module.noExitRuntime has been replaced with plain noExitRuntime (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') } });

if (typeof WebAssembly !== 'object') {

  abort('No WebAssembly support found. Build with -s WASM=0 to target JavaScript instead.');

}

// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.

// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)

/** @param {number} ptr

    @param {number} value

    @param {string} type

    @param {number|boolean=} noSafe */

function setValue(ptr, value, type, noSafe) {

  type = type || 'i8';

  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit

    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.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>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);

    }

}

/** @param {number} ptr

    @param {string} type

    @param {number|boolean=} noSafe */

function getValue(ptr, type, noSafe) {

  type = type || 'i8';

  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit

    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 getValue: ' + type);

    }

  return null;

}

// Wasm globals

var wasmMemory;

// In fastcomp asm.js, we don't need a wasm Table at all.

// In the wasm backend, we polyfill the WebAssembly object,

// so this creates a (non-native-wasm) table for us.

var wasmTable = new WebAssembly.Table({

  'initial': 10,

  'maximum': 10 + 0,

  'element': 'anyfunc'

});

//========================================

// Runtime essentials

//========================================

// whether we are quitting the application. no code should run after this.

// set in exit() and abort()

var ABORT = false;

// set by exit() and abort().  Passed to 'onExit' handler.

// NOTE: This is also used as the process return code code in shell environments

// but only when noExitRuntime is false.

var EXITSTATUS = 0;

/** @type {function(*, string=)} */

function assert(condition, text) {

  if (!condition) {

    abort('Assertion failed: ' + text);

  }

}

// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)

function getCFunc(ident) {

  var func = Module['_' + ident]; // closure exported function

  assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');

  return func;

}

// C calling interface.

/** @param {string|null=} returnType

    @param {Array=} argTypes

    @param {Arguments|Array=} args

    @param {Object=} opts */

function ccall(ident, returnType, argTypes, args, opts) {

  // For fast lookup of conversion functions

  var toC = {

    'string': function(str) {

      var ret = 0;

      if (str !== null && str !== undefined && str !== 0) { // null string

        // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'

        var len = (str.length << 2) + 1;

        ret = stackAlloc(len);

        stringToUTF8(str, ret, len);

      }

      return ret;

    },

    'array': function(arr) {

      var ret = stackAlloc(arr.length);

      writeArrayToMemory(arr, ret);

      return ret;

    }

  };

  function convertReturnValue(ret) {

    if (returnType === 'string') return UTF8ToString(ret);

    if (returnType === 'boolean') return Boolean(ret);

    return ret;

  }

  var func = getCFunc(ident);

  var cArgs = [];

  var stack = 0;

  assert(returnType !== 'array', 'Return type should not be "array".');

  if (args) {

    for (var i = 0; i < args.length; i++) {

      var converter = toC[argTypes[i]];

      if (converter) {

        if (stack === 0) stack = stackSave();

        cArgs[i] = converter(args[i]);

      } else {

        cArgs[i] = args[i];

      }

    }

  }

  var ret = func.apply(null, cArgs);

  ret = convertReturnValue(ret);

  if (stack !== 0) stackRestore(stack);

  return ret;

}

/** @param {string=} returnType

    @param {Array=} argTypes

    @param {Object=} opts */

function cwrap(ident, returnType, argTypes, opts) {

  return function() {

    return ccall(ident, returnType, argTypes, arguments, opts);

  }

}

var ALLOC_NORMAL = 0; // Tries to use _malloc()

var ALLOC_STACK = 1; // Lives for the duration of the current function call

var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk

var ALLOC_NONE = 3; // Do not allocate

// allocate(): This is for internal use. You can use it yourself as well, but the interface

//             is a little tricky (see docs right below). The reason is that it is optimized

//             for multiple syntaxes to save space in generated code. So you should

//             normally not use allocate(), and instead allocate memory using _malloc(),

//             initialize it with setValue(), and so forth.

// @slab: An array of data, or a number. If a number, then the size of the block to allocate,

//        in *bytes* (note that this is sometimes confusing: the next parameter does not

//        affect this!)

// @types: Either an array of types, one for each byte (or 0 if no type at that position),

//         or a single type which is used for the entire block. This only matters if there

//         is initial data - if @slab is a number, then this does not matter at all and is

//         ignored.

// @allocator: How to allocate memory, see ALLOC_*

/** @type {function((TypedArray|Array<number>|number), string, number, number=)} */

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 = [_malloc,

    stackAlloc,

    dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length));

  }

  if (zeroinit) {

    var stop;

    ptr = ret;

    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(/** @type {!Uint8Array} */ (slab), ret);

    } else {

      HEAPU8.set(new Uint8Array(slab), ret);

    }

    return ret;

  }

  var i = 0, type, typeSize, previousType;

  while (i < size) {

    var curr = slab[i];

    type = singleType || types[i];

    if (type === 0) {

      i++;

      continue;

    }

    assert(type, 'Must know what type to store in allocate!');

    if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later

    setValue(ret+i, curr, type);

    // no need to look up size unless type changes, so cache it

    if (previousType !== type) {

      typeSize = getNativeTypeSize(type);

      previousType = type;

    }

    i += typeSize;

  }

  return ret;

}

// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready

function getMemory(size) {

  if (!runtimeInitialized) return dynamicAlloc(size);

  return _malloc(size);

}

// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.

// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns

// a copy of that string as a Javascript String object.

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

/**

 * @param {number} idx

 * @param {number=} maxBytesToRead

 * @return {string}

 */

function UTF8ArrayToString(heap, idx, maxBytesToRead) {

  var endIdx = idx + maxBytesToRead;

  var endPtr = idx;

  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.

  // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.

  // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)

  while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;

  if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {

    return UTF8Decoder.decode(heap.subarray(idx, endPtr));

  } else {

    var str = '';

    // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that

    while (idx < endPtr) {

      // For UTF8 byte structure, see:

      // http://en.wikipedia.org/wiki/UTF-8#Description

      // https://www.ietf.org/rfc/rfc2279.txt

      // https://tools.ietf.org/html/rfc3629

      var u0 = heap[idx++];

      if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }

      var u1 = heap[idx++] & 63;

      if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }

      var u2 = heap[idx++] & 63;

      if ((u0 & 0xF0) == 0xE0) {

        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;

      } else {

        if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte 0x' + u0.toString(16) + ' encountered when deserializing a UTF-8 string on the asm.js/wasm heap to a JS string!');

        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);

      }

      if (u0 < 0x10000) {

        str += String.fromCharCode(u0);

      } else {

        var ch = u0 - 0x10000;

        str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));

      }

    }

  }

  return str;

}

// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a

// copy of that string as a Javascript String object.

// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit

//                 this parameter to scan the string until the first \0 byte. If maxBytesToRead is

//                 passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the

//                 middle, then the string will cut short at that byte index (i.e. maxBytesToRead will

//                 not produce a string of exact length [ptr, ptr+maxBytesToRead[)

//                 N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may

//                 throw JS JIT optimizations off, so it is worth to consider consistently using one

//                 style or the other.

/**

 * @param {number} ptr

 * @param {number=} maxBytesToRead

 * @return {string}

 */

function UTF8ToString(ptr, maxBytesToRead) {

  return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';

}

// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',

// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.

// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.

// Parameters:

//   str: the Javascript string to copy.

//   heap: the array to copy to. Each index in this array is assumed to be one 8-byte element.

//   outIdx: The starting offset in the array to begin the copying.

//   maxBytesToWrite: The maximum number of bytes this function can write to the array.

//                    This count should include the null terminator,

//                    i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.

//                    maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.

// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {

  if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.

    return 0;

  var startIdx = outIdx;

  var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.

  for (var i = 0; i < str.length; ++i) {

    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.

    // See http://unicode.org/faq/utf_bom.html#utf16-3

    // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629

    var u = str.charCodeAt(i); // possibly a lead surrogate

    if (u >= 0xD800 && u <= 0xDFFF) {

      var u1 = str.charCodeAt(++i);

      u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);

    }

    if (u <= 0x7F) {

      if (outIdx >= endIdx) break;

      heap[outIdx++] = u;

    } else if (u <= 0x7FF) {

      if (outIdx + 1 >= endIdx) break;

      heap[outIdx++] = 0xC0 | (u >> 6);

      heap[outIdx++] = 0x80 | (u & 63);

    } else if (u <= 0xFFFF) {

      if (outIdx + 2 >= endIdx) break;

      heap[outIdx++] = 0xE0 | (u >> 12);

      heap[outIdx++] = 0x80 | ((u >> 6) & 63);

      heap[outIdx++] = 0x80 | (u & 63);

    } else {

      if (outIdx + 3 >= endIdx) break;

      if (u >= 0x200000) warnOnce('Invalid Unicode code point 0x' + u.toString(16) + ' encountered when serializing a JS string to an UTF-8 string on the asm.js/wasm heap! (Valid unicode code points should be in range 0-0x1FFFFF).');

      heap[outIdx++] = 0xF0 | (u >> 18);

      heap[outIdx++] = 0x80 | ((u >> 12) & 63);

      heap[outIdx++] = 0x80 | ((u >> 6) & 63);

      heap[outIdx++] = 0x80 | (u & 63);

    }

  }

  // Null-terminate the pointer to the buffer.

  heap[outIdx] = 0;

  return outIdx - startIdx;

}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',

// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.

// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.

// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF8(str, outPtr, maxBytesToWrite) {

  assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');

  return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);

}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.

function lengthBytesUTF8(str) {

  var len = 0;

  for (var i = 0; i < str.length; ++i) {

    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.

    // See http://unicode.org/faq/utf_bom.html#utf16-3

    var u = str.charCodeAt(i); // possibly a lead surrogate

    if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);

    if (u <= 0x7F) ++len;

    else if (u <= 0x7FF) len += 2;

    else if (u <= 0xFFFF) len += 3;

    else len += 4;

  }

  return len;

}

// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime.

// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns

// a copy of that string as a Javascript String object.

function AsciiToString(ptr) {

  var str = '';

  while (1) {

    var ch = HEAPU8[((ptr++)>>0)];

    if (!ch) return str;

    str += String.fromCharCode(ch);

  }

}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',

// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.

function stringToAscii(str, outPtr) {

  return writeAsciiToMemory(str, outPtr, false);

}

// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns

// a copy of that string as a Javascript String object.

var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;

function UTF16ToString(ptr, maxBytesToRead) {

  assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!');

  var endPtr = ptr;

  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.

  // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.

  var idx = endPtr >> 1;

  var maxIdx = idx + maxBytesToRead / 2;

  // If maxBytesToRead is not passed explicitly, it will be undefined, and this

  // will always evaluate to true. This saves on code size.

  while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;

  endPtr = idx << 1;

  if (endPtr - ptr > 32 && UTF16Decoder) {

    return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));

  } else {

    var i = 0;

    var str = '';

    while (1) {

      var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];

      if (codeUnit == 0 || i == maxBytesToRead / 2) return str;

      ++i;

      // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.

      str += String.fromCharCode(codeUnit);

    }

  }

}

// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',

// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.

// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.

// Parameters:

//   str: the Javascript string to copy.

//   outPtr: Byte address in Emscripten HEAP where to write the string to.

//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null

//                    terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.

//                    maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.

// Returns the number of bytes written, EXCLUDING the null terminator.

function stringToUTF16(str, outPtr, maxBytesToWrite) {

  assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!');

  assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');

  // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.

  if (maxBytesToWrite === undefined) {

    maxBytesToWrite = 0x7FFFFFFF;

  }

  if (maxBytesToWrite < 2) return 0;

  maxBytesToWrite -= 2; // Null terminator.

  var startPtr = outPtr;

  var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;

  for (var i = 0; i < numCharsToWrite; ++i) {

    // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.

    var codeUnit = str.charCodeAt(i); // possibly a lead surrogate

    HEAP16[((outPtr)>>1)]=codeUnit;

    outPtr += 2;

  }

  // Null-terminate the pointer to the HEAP.

  HEAP16[((outPtr)>>1)]=0;

  return outPtr - startPtr;

}

// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.

function lengthBytesUTF16(str) {

  return str.length*2;

}

function UTF32ToString(ptr, maxBytesToRead) {

  assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!');

  var i = 0;

  var str = '';

  // If maxBytesToRead is not passed explicitly, it will be undefined, and this

  // will always evaluate to true. This saves on code size.

  while (!(i >= maxBytesToRead / 4)) {

    var utf32 = HEAP32[(((ptr)+(i*4))>>2)];

    if (utf32 == 0) break;

    ++i;

    // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.

    // See http://unicode.org/faq/utf_bom.html#utf16-3

    if (utf32 >= 0x10000) {

      var ch = utf32 - 0x10000;

      str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));

    } else {

      str += String.fromCharCode(utf32);