#if SIDE_MODULE == 0

// 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.

#if USE_CLOSURE_COMPILER

// if (!Module)` is crucial for Closure Compiler here as it will otherwise replace every `Module` occurrence with a string

var Module;

if (!Module) Module = "__EMSCRIPTEN_PRIVATE_MODULE_EXPORT_NAME_SUBSTITUTION__";

#else

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

#endif // USE_CLOSURE_COMPILER

#endif // SIDE_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];

}

}

Module['arguments'] = [];

Module['thisProgram'] = './this.program';

Module['quit'] = function(status, toThrow) {

throw toThrow;

};

Module['preRun'] = [];

Module['postRun'] = [];

// The environment setup code below is customized to use Module.

// *** Environment setup code ***

var ENVIRONMENT_IS_WEB = false;

var ENVIRONMENT_IS_WORKER = false;

var ENVIRONMENT_IS_NODE = false;

var ENVIRONMENT_IS_SHELL = false;

// Three configurations we can be running in:

// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false)

// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)

// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)

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('Module[\'ENVIRONMENT\'] value is not valid. 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 USE_PTHREADS

var ENVIRONMENT_IS_PTHREAD;

if (!ENVIRONMENT_IS_PTHREAD) ENVIRONMENT_IS_PTHREAD = false; // ENVIRONMENT_IS_PTHREAD=true will have been preset in pthread-main.js. Make it false in the main runtime thread.

var PthreadWorkerInit; // Collects together variables that are needed at initialization time for the web workers that host pthreads.

if (!ENVIRONMENT_IS_PTHREAD) PthreadWorkerInit = {};

var currentScriptUrl = (typeof document !== 'undefined' && document.currentScript) ? document.currentScript.src : undefined;

#endif

if (ENVIRONMENT_IS_NODE) {

// Expose functionality in the same simple way that the shells work

// Note that we pollute the global namespace here, otherwise we break in node

var nodeFS;

var nodePath;

Module['read'] = function shell_read(filename, binary) {

var ret;

#if SUPPORT_BASE64_EMBEDDING

ret = tryParseAsDataURI(filename);

if (!ret) {

#endif

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

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

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

ret = nodeFS['readFileSync'](filename);

#if SUPPORT_BASE64_EMBEDDING

}

#endif

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;

};

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

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

}

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

#if MODULARIZE

// MODULARIZE will export the module in the proper place outside, we don't need to export here

#else

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

module['exports'] = Module;

}

#endif

#if NODEJS_CATCH_EXIT

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

// suppress ExitStatus exceptions from showing an error

if (!(ex instanceof ExitStatus)) {

throw ex;

}

});

#endif

// Currently node will swallow unhandled rejections, but this behavior is

// deprecated, and in the future it will exit with error status.

process['on']('unhandledRejection', function(reason, p) {

#if ASSERTIONS

Module['printErr']('node.js exiting due to unhandled promise rejection');

#endif

process['exit'](1);

});

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

}

else if (ENVIRONMENT_IS_SHELL) {

if (typeof read != 'undefined') {

Module['read'] = function shell_read(f) {

#if SUPPORT_BASE64_EMBEDDING

var data = tryParseAsDataURI(f);

if (data) {

return intArrayToString(data);

}

#endif

return read(f);

};

}

Module['readBinary'] = function readBinary(f) {

var data;

#if SUPPORT_BASE64_EMBEDDING

data = tryParseAsDataURI(f);

if (data) {

return data;

}

#endif

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

return new Uint8Array(readbuffer(f));

}

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;

}

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

Module['quit'] = function(status, toThrow) {

quit(status);

}

}

}

else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {

Module['read'] = function shell_read(url) {

#if SUPPORT_BASE64_EMBEDDING

try {

#endif

var xhr = new XMLHttpRequest();

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

xhr.send(null);

return xhr.responseText;

#if SUPPORT_BASE64_EMBEDDING

} catch (err) {

var data = tryParseAsDataURI(url);

if (data) {

return intArrayToString(data);

}

throw err;

}

#endif

};

if (ENVIRONMENT_IS_WORKER) {

Module['readBinary'] = function readBinary(url) {

#if SUPPORT_BASE64_EMBEDDING

try {

#endif

var xhr = new XMLHttpRequest();

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

xhr.responseType = 'arraybuffer';

xhr.send(null);

return new Uint8Array(xhr.response);

#if SUPPORT_BASE64_EMBEDDING

} catch (err) {

var data = tryParseAsDataURI(url);

if (data) {

return data;

}

throw err;

}

#endif

};

}

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

onload(xhr.response);

return;

}

#if SUPPORT_BASE64_EMBEDDING

var data = tryParseAsDataURI(url);

if (data) {

onload(data.buffer);

return;

}

#endif

onerror();

};

xhr.onerror = onerror;

xhr.send(null);

};

if (typeof arguments != 'undefined') {

Module['arguments'] = arguments;

}

Module['setWindowTitle'] = function(title) { document.title = title };

}

#if ASSERTIONS

else {

// Unreachable because SHELL is dependent on the others

throw new Error('unknown runtime environment');

}

#endif // ASSERTIONS

// console.log is checked first, as 'print' on the web will open a print dialogue

// printErr is preferable to console.warn (works better in shells)

// bind(console) is necessary to fix IE/Edge closed dev tools panel behavior.

Module['print'] = typeof console !== 'undefined' ? console.log.bind(console) : (typeof print !== 'undefined' ? print : null);

Module['printErr'] = typeof printErr !== 'undefined' ? printErr : ((typeof console !== 'undefined' && console.warn.bind(console)) || Module['print']);

// *** Environment setup code ***

// Closure helpers

Module.print = Module['print'];

Module.printErr = Module['printErr'];

// 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 = undefined;

{{BODY}}

// {{MODULE_ADDITIONS}}