Skip to content

Instantly share code, notes, and snippets.

@gatlin

gatlin/hello.js

Created July 6, 2012 01:51
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save gatlin/3057551 to your computer and use it in GitHub Desktop.
Save gatlin/3057551 to your computer and use it in GitHub Desktop.
Download ZIP
Emscripten output for a simple Haskell program
Raw
hello.js
// Note: Some Emscripten settings will significantly limit the speed of the generated code.
// Note: Some Emscripten settings may limit the speed of the generated code.
// TODO: " u s e s t r i c t ";
try {
this['Module'] = Module;
} catch(e) {
this['Module'] = Module = {};
}
// The environment setup code below is customized to use Module.
// *** Environment setup code ***
var ENVIRONMENT_IS_NODE = typeof process === 'object';
var ENVIRONMENT_IS_WEB = typeof window === 'object';
var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
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
Module['print'] = function(x) {
process['stdout'].write(x + '\n');
};
Module['printErr'] = function(x) {
process['stderr'].write(x + '\n');
};
var nodeFS = require('fs');
var nodePath = require('path');
Module['read'] = function(filename) {
filename = nodePath['normalize'](filename);
var ret = nodeFS['readFileSync'](filename).toString();
// The path is absolute if the normalized version is the same as the resolved.
if (!ret && filename != nodePath['resolve'](filename)) {
filename = path.join(__dirname, '..', 'src', filename);
ret = nodeFS['readFileSync'](filename).toString();
}
return ret;
};
Module['load'] = function(f) {
globalEval(read(f));
};
if (!Module['arguments']) {
Module['arguments'] = process['argv'].slice(2);
}
} else if (ENVIRONMENT_IS_SHELL) {
Module['print'] = print;
Module['printErr'] = printErr;
// Polyfill over SpiderMonkey/V8 differences
if (typeof read != 'undefined') {
Module['read'] = read;
} else {
Module['read'] = function(f) { snarf(f) };
}
if (!Module['arguments']) {
if (typeof scriptArgs != 'undefined') {
Module['arguments'] = scriptArgs;
} else if (typeof arguments != 'undefined') {
Module['arguments'] = arguments;
}
}
} else if (ENVIRONMENT_IS_WEB) {
if (!Module['print']) {
Module['print'] = function(x) {
console.log(x);
};
}
if (!Module['printErr']) {
Module['printErr'] = function(x) {
console.log(x);
};
}
Module['read'] = function(url) {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.send(null);
return xhr.responseText;
};
if (!Module['arguments']) {
if (typeof arguments != 'undefined') {
Module['arguments'] = arguments;
}
}
} else if (ENVIRONMENT_IS_WORKER) {
// We can do very little here...
Module['load'] = importScripts;
} else {
throw 'Unknown runtime environment. Where are we?';
}
function globalEval(x) {
eval.call(null, x);
}
if (!Module['load'] == 'undefined' && Module['read']) {
Module['load'] = function(f) {
globalEval(Module['read'](f));
};
}
if (!Module['printErr']) {
Module['printErr'] = function(){};
}
if (!Module['print']) {
Module['print'] = Module['printErr'];
}
if (!Module['arguments']) {
Module['arguments'] = [];
}
// *** Environment setup code ***
// Closure helpers
Module.print = Module['print'];
Module.printErr = Module['printErr'];
// Callbacks
if (!Module['preRun']) Module['preRun'] = [];
if (!Module['postRun']) Module['postRun'] = [];
// === Auto-generated preamble library stuff ===
//========================================
// Runtime code shared with compiler
//========================================
var Runtime = {
stackSave: function () {
return STACKTOP;
},
stackRestore: function (stackTop) {
STACKTOP = stackTop;
},
forceAlign: function (target, quantum) {
quantum = quantum || 4;
if (quantum == 1) return target;
if (isNumber(target) && isNumber(quantum)) {
return Math.ceil(target/quantum)*quantum;
} else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
var logg = log2(quantum);
return '((((' +target + ')+' + (quantum-1) + ')>>' + logg + ')<<' + logg + ')';
}
return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
},
isNumberType: function (type) {
return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
},
isPointerType: function isPointerType(type) {
return type[type.length-1] == '*';
},
isStructType: function isStructType(type) {
if (isPointerType(type)) return false;
if (/^\[\d+\ x\ (.*)\]/.test(type)) return true; // [15 x ?] blocks. Like structs
if (/<?{ ?[^}]* ?}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
// See comment in isStructPointerType()
return type[0] == '%';
},
INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
FLOAT_TYPES: {"float":0,"double":0},
bitshift64: function (low, high, op, bits) {
var ander = Math.pow(2, bits)-1;
if (bits < 32) {
switch (op) {
case 'shl':
return [low << bits, (high << bits) | ((low&(ander << (32 - bits))) >>> (32 - bits))];
case 'ashr':
return [(((low >>> bits ) | ((high&ander) << (32 - bits))) >> 0) >>> 0, (high >> bits) >>> 0];
case 'lshr':
return [((low >>> bits) | ((high&ander) << (32 - bits))) >>> 0, high >>> bits];
}
} else if (bits == 32) {
switch (op) {
case 'shl':
return [0, low];
case 'ashr':
return [high, (high|0) < 0 ? ander : 0];
case 'lshr':
return [high, 0];
}
} else { // bits > 32
switch (op) {
case 'shl':
return [0, low << (bits - 32)];
case 'ashr':
return [(high >> (bits - 32)) >>> 0, (high|0) < 0 ? ander : 0];
case 'lshr':
return [high >>> (bits - 32) , 0];
}
}
abort('unknown bitshift64 op: ' + [value, op, bits]);
},
or64: function (x, y) {
var l = (x | 0) | (y | 0);
var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
return l + h;
},
and64: function (x, y) {
var l = (x | 0) & (y | 0);
var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
return l + h;
},
xor64: function (x, y) {
var l = (x | 0) ^ (y | 0);
var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
return l + h;
},
getNativeTypeSize: function (type, quantumSize) {
if (Runtime.QUANTUM_SIZE == 1) return 1;
var size = {
'%i1': 1,
'%i8': 1,
'%i16': 2,
'%i32': 4,
'%i64': 8,
"%float": 4,
"%double": 8
}['%'+type]; // add '%' since float and double confuse Closure compiler as keys, and also spidermonkey as a compiler will remove 's from '_i8' etc
if (!size) {
if (type[type.length-1] == '*') {
size = Runtime.QUANTUM_SIZE; // A pointer
} else if (type[0] == 'i') {
var bits = parseInt(type.substr(1));
assert(bits % 8 == 0);
size = bits/8;
}
}
return size;
},
getNativeFieldSize: function (type) {
return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
},
dedup: function dedup(items, ident) {
var seen = {};
if (ident) {
return items.filter(function(item) {
if (seen[item[ident]]) return false;
seen[item[ident]] = true;
return true;
});
} else {
return items.filter(function(item) {
if (seen[item]) return false;
seen[item] = true;
return true;
});
}
},
set: function set() {
var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
var ret = {};
for (var i = 0; i < args.length; i++) {
ret[args[i]] = 0;
}
return ret;
},
calculateStructAlignment: function calculateStructAlignment(type) {
type.flatSize = 0;
type.alignSize = 0;
var diffs = [];
var prev = -1;
type.flatIndexes = type.fields.map(function(field) {
var size, alignSize;
if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
alignSize = size;
} else if (Runtime.isStructType(field)) {
size = Types.types[field].flatSize;
alignSize = Types.types[field].alignSize;
} else {
throw 'Unclear type in struct: ' + field + ', in ' + type.name_ + ' :: ' + dump(Types.types[type.name_]);
}
alignSize = type.packed ? 1 : Math.min(alignSize, Runtime.QUANTUM_SIZE);
type.alignSize = Math.max(type.alignSize, alignSize);
var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
type.flatSize = curr + size;
if (prev >= 0) {
diffs.push(curr-prev);
}
prev = curr;
return curr;
});
type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
if (diffs.length == 0) {
type.flatFactor = type.flatSize;
} else if (Runtime.dedup(diffs).length == 1) {
type.flatFactor = diffs[0];
}
type.needsFlattening = (type.flatFactor != 1);
return type.flatIndexes;
},
generateStructInfo: function (struct, typeName, offset) {
var type, alignment;
if (typeName) {
offset = offset || 0;
type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
if (!type) return null;
assert(type.fields.length === struct.length, 'Number of named fields must match the type for ' + typeName);
alignment = type.flatIndexes;
} else {
var type = { fields: struct.map(function(item) { return item[0] }) };
alignment = Runtime.calculateStructAlignment(type);
}
var ret = {
__size__: type.flatSize
};
if (typeName) {
struct.forEach(function(item, i) {
if (typeof item === 'string') {
ret[item] = alignment[i] + offset;
} else {
// embedded struct
var key;
for (var k in item) key = k;
ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
}
});
} else {
struct.forEach(function(item, i) {
ret[item[1]] = alignment[i];
});
}
return ret;
},
addFunction: function (func) {
var ret = FUNCTION_TABLE.length;
FUNCTION_TABLE.push(func);
FUNCTION_TABLE.push(0);
return ret;
},
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) {
if (!Runtime.funcWrappers[func]) {
Runtime.funcWrappers[func] = function() {
FUNCTION_TABLE[func].apply(null, arguments);
};
}
return Runtime.funcWrappers[func];
},
stackAlloc: function stackAlloc(size) { var ret = STACKTOP;STACKTOP += size;STACKTOP = ((((STACKTOP)+3)>>2)<<2);assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"); return ret; },
staticAlloc: function staticAlloc(size) { var ret = STATICTOP;STATICTOP += size;STATICTOP = ((((STATICTOP)+3)>>2)<<2); if (STATICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 4))*(quantum ? quantum : 4); return ret; },
makeBigInt: function makeBigInt(low,high,unsigned) { var ret = (unsigned ? (((low)>>>0)+(((high)>>>0)*4294967296)) : (((low)>>>0)+(((high)|0)*4294967296))); return ret; },
QUANTUM_SIZE: 4,
__dummy__: 0
}
var CorrectionsMonitor = {
MAX_ALLOWED: 0, // XXX
corrections: 0,
sigs: {},
note: function(type, succeed, sig) {
if (!succeed) {
this.corrections++;
if (this.corrections >= this.MAX_ALLOWED) abort('\n\nToo many corrections!');
}
},
print: function() {
}
};
//========================================
// Runtime essentials
//========================================
var __THREW__ = false; // Used in checking for thrown exceptions.
var ABORT = false;
var undef = 0;
// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD;
var tempI64, tempI64b;
function abort(text) {
Module.print(text + ':\n' + (new Error).stack);
ABORT = true;
throw "Assertion: " + text;
}
function assert(condition, text) {
if (!condition) {
abort('Assertion failed: ' + text);
}
}
var globalScope = this;
// C calling interface. A convenient way to call C functions (in C files, or
// defined with extern "C").
//
// Note: LLVM optimizations can inline and remove functions, after which you will not be
// able to call them. Adding
//
// __attribute__((used))
//
// to the function definition will prevent that.
//
// Note: Closure optimizations will minify function names, making
// functions no longer callable. If you run closure (on by default
// in -O2 and above), you should export the functions you will call
// by calling emcc with something like
//
// -s EXPORTED_FUNCTIONS='["_func1","_func2"]'
//
// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
// 'array' for JavaScript arrays and typed arrays).
// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
// except that 'array' is not possible (there is no way for us to know the length of the array)
// @param args An array of the arguments to the function, as native JS values (as in returnType)
// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
// @return The return value, as a native JS value (as in returnType)
function ccall(ident, returnType, argTypes, args) {
var stack = 0;
function toC(value, type) {
if (type == 'string') {
if (value === null || value === undefined || value === 0) return 0; // null string
if (!stack) stack = Runtime.stackSave();
var ret = Runtime.stackAlloc(value.length+1);
writeStringToMemory(value, ret);
return ret;
} else if (type == 'array') {
if (!stack) stack = Runtime.stackSave();
var ret = Runtime.stackAlloc(value.length);
writeArrayToMemory(value, ret);
return ret;
}
return value;
}
function fromC(value, type) {
if (type == 'string') {
return Pointer_stringify(value);
}
assert(type != 'array');
return value;
}
try {
var func = eval('_' + ident);
} catch(e) {
try {
func = globalScope['Module']['_' + ident]; // closure exported function
} catch(e) {}
}
assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
var i = 0;
var cArgs = args ? args.map(function(arg) {
return toC(arg, argTypes[i++]);
}) : [];
var ret = fromC(func.apply(null, cArgs), returnType);
if (stack) Runtime.stackRestore(stack);
return ret;
}
Module["ccall"] = ccall;
// Returns a native JS wrapper for a C function. This is similar to ccall, but
// returns a function you can call repeatedly in a normal way. For example:
//
// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
// alert(my_function(5, 22));
// alert(my_function(99, 12));
//
function cwrap(ident, returnType, argTypes) {
// TODO: optimize this, eval the whole function once instead of going through ccall each time
return function() {
return ccall(ident, returnType, argTypes, Array.prototype.slice.call(arguments));
}
}
Module["cwrap"] = cwrap;
// Sets a value in memory in a dynamic way at run-time. Uses the
// type data. This is the same as makeSetValue, except that
// makeSetValue is done at compile-time and generates the needed
// code then, whereas this function picks the right code at
// run-time.
// Note that setValue and getValue only do *aligned* writes and reads!
// Note that ccall uses JS types as for defining types, while setValue and
// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
function setValue(ptr, value, type, noSafe) {
type = type || 'i8';
if (type[type.length-1] === '*') type = 'i32'; // pointers are 32-bit
switch(type) {
case 'i1': HEAP8[(ptr)]=value; break;
case 'i8': HEAP8[(ptr)]=value; break;
case 'i16': HEAP16[((ptr)>>1)]=value; break;
case 'i32': HEAP32[((ptr)>>2)]=value; break;
case 'i64': HEAP32[((ptr)>>2)]=value; break;
case 'float': HEAPF32[((ptr)>>2)]=value; break;
case 'double': (tempDoubleF64[0]=value,HEAP32[((ptr)>>2)]=tempDoubleI32[0],HEAP32[(((ptr)+(4))>>2)]=tempDoubleI32[1]); break;
default: abort('invalid type for setValue: ' + type);
}
}
Module['setValue'] = setValue;
// Parallel to setValue.
function getValue(ptr, type, noSafe) {
type = type || 'i8';
if (type[type.length-1] === '*') type = 'i32'; // pointers are 32-bit
switch(type) {
case 'i1': return HEAP8[(ptr)];
case 'i8': return HEAP8[(ptr)];
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 (tempDoubleI32[0]=HEAP32[((ptr)>>2)],tempDoubleI32[1]=HEAP32[(((ptr)+(4))>>2)],tempDoubleF64[0]);
default: abort('invalid type for setValue: ' + type);
}
return null;
}
Module['getValue'] = getValue;
// Allocates memory for some data and initializes it properly.
var ALLOC_NORMAL = 0; // Tries to use _malloc()
var ALLOC_STACK = 1; // Lives for the duration of the current function call
var ALLOC_STATIC = 2; // Cannot be freed
Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
Module['ALLOC_STACK'] = ALLOC_STACK;
Module['ALLOC_STATIC'] = ALLOC_STATIC;
function allocate(slab, types, allocator) {
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 = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
if (zeroinit) {
_memset(ret, 0, size);
return ret;
}
var i = 0, type;
while (i < size) {
var curr = slab[i];
if (typeof curr === 'function') {
curr = Runtime.getFunctionIndex(curr);
}
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);
i += Runtime.getNativeTypeSize(type);
}
return ret;
}
Module['allocate'] = allocate;
function Pointer_stringify(ptr, /* optional */ length) {
var nullTerminated = typeof(length) == "undefined";
var ret = "";
var i = 0;
var t;
var nullByte = String.fromCharCode(0);
while (1) {
t = String.fromCharCode(HEAPU8[((ptr)+(i))]);
if (nullTerminated && t == nullByte) { break; } else {}
ret += t;
i += 1;
if (!nullTerminated && i == length) { break; }
}
return ret;
}
Module['Pointer_stringify'] = Pointer_stringify;
function Array_stringify(array) {
var ret = "";
for (var i = 0; i < array.length; i++) {
ret += String.fromCharCode(array[i]);
}
return ret;
}
Module['Array_stringify'] = Array_stringify;
// Memory management
var FUNCTION_TABLE; // XXX: In theory the indexes here can be equal to pointers to stacked or malloced memory. Such comparisons should
// be false, but can turn out true. We should probably set the top bit to prevent such issues.
var PAGE_SIZE = 4096;
function alignMemoryPage(x) {
return ((x+4095)>>12)<<12;
}
var HEAP;
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
var STACK_ROOT, STACKTOP, STACK_MAX;
var STATICTOP;
function enlargeMemory() {
// TOTAL_MEMORY is the current size of the actual array, and STATICTOP is the new top.
Module.printErr('Warning: Enlarging memory arrays, this is not fast! ' + [STATICTOP, TOTAL_MEMORY]);
assert(STATICTOP >= TOTAL_MEMORY);
assert(TOTAL_MEMORY > 4); // So the loop below will not be infinite
while (TOTAL_MEMORY <= STATICTOP) { // Simple heuristic. Override enlargeMemory() if your program has something more optimal for it
TOTAL_MEMORY = alignMemoryPage(2*TOTAL_MEMORY);
}
var oldHEAP8 = HEAP8;
var buffer = new ArrayBuffer(TOTAL_MEMORY);
HEAP8 = new Int8Array(buffer);
HEAP16 = new Int16Array(buffer);
HEAP32 = new Int32Array(buffer);
HEAPU8 = new Uint8Array(buffer);
HEAPU16 = new Uint16Array(buffer);
HEAPU32 = new Uint32Array(buffer);
HEAPF32 = new Float32Array(buffer);
HEAPF64 = new Float64Array(buffer);
HEAP8.set(oldHEAP8);
}
var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 10485760;
var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
// Initialize the runtime's memory
// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
assert(!!Int32Array && !!Float64Array && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
'Cannot fallback to non-typed array case: Code is too specialized');
var buffer = new ArrayBuffer(TOTAL_MEMORY);
HEAP8 = new Int8Array(buffer);
HEAP16 = new Int16Array(buffer);
HEAP32 = new Int32Array(buffer);
HEAPU8 = new Uint8Array(buffer);
HEAPU16 = new Uint16Array(buffer);
HEAPU32 = new Uint32Array(buffer);
HEAPF32 = new Float32Array(buffer);
HEAPF64 = new Float64Array(buffer);
// Endianness check (note: assumes compiler arch was little-endian)
HEAP32[0] = 255;
assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
var base = intArrayFromString('(null)'); // So printing %s of NULL gives '(null)'
// Also this ensures we leave 0 as an invalid address, 'NULL'
STATICTOP = base.length;
for (var i = 0; i < base.length; i++) {
HEAP8[(i)]=base[i]
}
Module['HEAP'] = HEAP;
Module['HEAP8'] = HEAP8;
Module['HEAP16'] = HEAP16;
Module['HEAP32'] = HEAP32;
Module['HEAPU8'] = HEAPU8;
Module['HEAPU16'] = HEAPU16;
Module['HEAPU32'] = HEAPU32;
Module['HEAPF32'] = HEAPF32;
Module['HEAPF64'] = HEAPF64;
STACK_ROOT = STACKTOP = Runtime.alignMemory(STATICTOP);
STACK_MAX = STACK_ROOT + TOTAL_STACK;
var tempDoublePtr = Runtime.alignMemory(STACK_MAX, 8);
var tempDoubleI8 = HEAP8.subarray(tempDoublePtr);
var tempDoubleI32 = HEAP32.subarray(tempDoublePtr >> 2);
var tempDoubleF32 = HEAPF32.subarray(tempDoublePtr >> 2);
var tempDoubleF64 = HEAPF64.subarray(tempDoublePtr >> 3);
function copyTempFloat(ptr) { // functions, because inlining this code is increases code size too much
tempDoubleI8[0] = HEAP8[ptr];
tempDoubleI8[1] = HEAP8[ptr+1];
tempDoubleI8[2] = HEAP8[ptr+2];
tempDoubleI8[3] = HEAP8[ptr+3];
}
function copyTempDouble(ptr) {
tempDoubleI8[0] = HEAP8[ptr];
tempDoubleI8[1] = HEAP8[ptr+1];
tempDoubleI8[2] = HEAP8[ptr+2];
tempDoubleI8[3] = HEAP8[ptr+3];
tempDoubleI8[4] = HEAP8[ptr+4];
tempDoubleI8[5] = HEAP8[ptr+5];
tempDoubleI8[6] = HEAP8[ptr+6];
tempDoubleI8[7] = HEAP8[ptr+7];
}
STACK_MAX = tempDoublePtr + 8;
STATICTOP = alignMemoryPage(STACK_MAX);
function callRuntimeCallbacks(callbacks) {
while(callbacks.length > 0) {
var callback = callbacks.shift();
var func = callback.func;
if (typeof func === 'number') {
func = FUNCTION_TABLE[func];
}
func(callback.arg === undefined ? null : callback.arg);
}
}
var __ATINIT__ = []; // functions called during startup
var __ATMAIN__ = []; // functions called when main() is to be run
var __ATEXIT__ = []; // functions called during shutdown
function initRuntime() {
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function exitRuntime() {
callRuntimeCallbacks(__ATEXIT__);
// Print summary of correction activity
CorrectionsMonitor.print();
}
function String_len(ptr) {
var i = 0;
while (HEAP8[((ptr)+(i))]) i++; // Note: should be |!= 0|, technically. But this helps catch bugs with undefineds
return i;
}
Module['String_len'] = String_len;
// Tools
// This processes a JS string into a C-line array of numbers, 0-terminated.
// For LLVM-originating strings, see parser.js:parseLLVMString function
function intArrayFromString(stringy, dontAddNull, length /* optional */) {
var ret = [];
var t;
var i = 0;
if (length === undefined) {
length = stringy.length;
}
while (i < length) {
var chr = stringy.charCodeAt(i);
if (chr > 0xFF) {
assert(false, 'Character code ' + chr + ' (' + stringy[i] + ') at offset ' + i + ' not in 0x00-0xFF.');
chr &= 0xFF;
}
ret.push(chr);
i = i + 1;
}
if (!dontAddNull) {
ret.push(0);
}
return ret;
}
Module['intArrayFromString'] = intArrayFromString;
function intArrayToString(array) {
var ret = [];
for (var i = 0; i < array.length; i++) {
var chr = array[i];
if (chr > 0xFF) {
assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.');
chr &= 0xFF;
}
ret.push(String.fromCharCode(chr));
}
return ret.join('');
}
Module['intArrayToString'] = intArrayToString;
// Write a Javascript array to somewhere in the heap
function writeStringToMemory(string, buffer, dontAddNull) {
var i = 0;
while (i < string.length) {
var chr = string.charCodeAt(i);
if (chr > 0xFF) {
assert(false, 'Character code ' + chr + ' (' + string[i] + ') at offset ' + i + ' not in 0x00-0xFF.');
chr &= 0xFF;
}
HEAP8[((buffer)+(i))]=chr
i = i + 1;
}
if (!dontAddNull) {
HEAP8[((buffer)+(i))]=0
}
}
Module['writeStringToMemory'] = writeStringToMemory;
function writeArrayToMemory(array, buffer) {
for (var i = 0; i < array.length; i++) {
HEAP8[((buffer)+(i))]=array[i];
}
}
Module['writeArrayToMemory'] = writeArrayToMemory;
var STRING_TABLE = [];
function unSign(value, bits, ignore, sig) {
if (value >= 0) {
return value;
}
return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
: Math.pow(2, bits) + value;
// TODO: clean up previous line
}
function reSign(value, bits, ignore, sig) {
if (value <= 0) {
return value;
}
var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
: Math.pow(2, bits-1);
if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
// but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
// TODO: In i64 mode 1, resign the two parts separately and safely
value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
}
return value;
}
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
function addRunDependency() {
runDependencies++;
if (Module['monitorRunDependencies']) {
Module['monitorRunDependencies'](runDependencies);
}
}
Module['addRunDependency'] = addRunDependency;
function removeRunDependency() {
runDependencies--;
if (Module['monitorRunDependencies']) {
Module['monitorRunDependencies'](runDependencies);
}
if (runDependencies == 0) run();
}
Module['removeRunDependency'] = removeRunDependency;
// === Body ===
function _sfT_info($Base_Arg, $Sp_Arg, $Hp_Arg, $R1_Arg$0, $R1_Arg$1, $R2_Arg$0, $R2_Arg$1, $R3_Arg$0, $R3_Arg$1, $R4_Arg$0, $R4_Arg$1, $R5_Arg$0, $R5_Arg$1, $R6_Arg$0, $R6_Arg$1, $SpLim_Arg$0, $SpLim_Arg$1, $F1_Arg, $F2_Arg, $F3_Arg, $F4_Arg, $D1_Arg, $D2_Arg) {
var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
var __label__;
__label__ = 2;
while(1) switch(__label__) {
case 2:
var $Base_Var;
$Base_Var=$Base_Arg;
var $Sp_Var;
$Sp_Var=$Sp_Arg;
var $Hp_Var;
$Hp_Var=$Hp_Arg;
var $R1_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$7$0=(($R1_Var)|0);
HEAP32[(($st$7$0)>>2)]=$R1_Arg$0;
var $st$7$1=(($R1_Var+4)|0);
HEAP32[(($st$7$1)>>2)]=$R1_Arg$1;
var $R2_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$12$0=(($R2_Var)|0);
HEAP32[(($st$12$0)>>2)]=$R2_Arg$0;
var $st$12$1=(($R2_Var+4)|0);
HEAP32[(($st$12$1)>>2)]=$R2_Arg$1;
var $R3_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$17$0=(($R3_Var)|0);
HEAP32[(($st$17$0)>>2)]=$R3_Arg$0;
var $st$17$1=(($R3_Var+4)|0);
HEAP32[(($st$17$1)>>2)]=$R3_Arg$1;
var $R4_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$22$0=(($R4_Var)|0);
HEAP32[(($st$22$0)>>2)]=$R4_Arg$0;
var $st$22$1=(($R4_Var+4)|0);
HEAP32[(($st$22$1)>>2)]=$R4_Arg$1;
var $R5_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$27$0=(($R5_Var)|0);
HEAP32[(($st$27$0)>>2)]=$R5_Arg$0;
var $st$27$1=(($R5_Var+4)|0);
HEAP32[(($st$27$1)>>2)]=$R5_Arg$1;
var $R6_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$32$0=(($R6_Var)|0);
HEAP32[(($st$32$0)>>2)]=$R6_Arg$0;
var $st$32$1=(($R6_Var+4)|0);
HEAP32[(($st$32$1)>>2)]=$R6_Arg$1;
var $SpLim_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$37$0=(($SpLim_Var)|0);
HEAP32[(($st$37$0)>>2)]=$SpLim_Arg$0;
var $st$37$1=(($SpLim_Var+4)|0);
HEAP32[(($st$37$1)>>2)]=$SpLim_Arg$1;
var $F1_Var;
$F1_Var=$F1_Arg;
var $F2_Var;
$F2_Var=$F2_Arg;
var $F3_Var;
$F3_Var=$F3_Arg;
var $F4_Var;
$F4_Var=$F4_Arg;
var $D1_Var;
$D1_Var=$D1_Arg;
var $D2_Var;
$D2_Var=$D2_Arg;
var $lcgC=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $lnhV=$Sp_Var;
var $lnhW=((($lnhV)-(16))|0);
var $lnhX$0=$lnhW;
var $lnhX$1=0;
var $st$58$0=(($SpLim_Var)|0);
var $lnhY$0=HEAP32[(($st$58$0)>>2)];
var $st$58$1=(($SpLim_Var+4)|0);
var $lnhY$1=HEAP32[(($st$58$1)>>2)];
var $lnhZ=($lnhX$1>>>0) < ($lnhY$1>>>0) || (($lnhX$1>>>0) == ($lnhY$1>>>0) && ($lnhX$0>>>0) < ($lnhY$0>>>0));
if ($lnhZ) { __label__ = 6; break; } else { __label__ = 3; break; }
case 3:
var $lni3=$Hp_Var;
var $lni4=(($lni3+16)|0);
var $lni5$0=$lni4;
var $lni5$1=0;
var $lni6=$lni5;
$Hp_Var=$lni6;
var $lni7=$Hp_Var;
var $lni8$0=$lni7;
var $lni8$1=0;
var $lni9=$Base_Var;
var $lnia=(($lni9+144)|0);
var $lnib=$lnia;
var $st$12$0=(($lnib)|0);
var $lnic$0=HEAP32[(($st$12$0)>>2)];
var $st$12$1=(($lnib+4)|0);
var $lnic$1=HEAP32[(($st$12$1)>>2)];
var $lnid=($lni8$1>>>0) > ($lnic$1>>>0) || (($lni8$1>>>0) == ($lnic$1>>>0) && ($lni8$0>>>0) > ($lnic$0>>>0));
if ($lnid) { __label__ = 7; break; } else { __label__ = 4; break; }
case 4:
var $lnih$0=_stg_CAF_BLACKHOLE_info;
var $lnih$1=0;
var $lnii=$Hp_Var;
var $lnij=((($lnii)-(8))|0);
var $st$4$0=(($lnij)|0);
HEAP32[(($st$4$0)>>2)]=$lnih$0;
var $st$4$1=(($lnij+4)|0);
HEAP32[(($st$4$1)>>2)]=$lnih$1;
var $lnik=$Base_Var;
var $lnil=(($lnik+160)|0);
var $lnim=$lnil;
var $st$11$0=(($lnim)|0);
var $lnin$0=HEAP32[(($st$11$0)>>2)];
var $st$11$1=(($lnim+4)|0);
var $lnin$1=HEAP32[(($st$11$1)>>2)];
var $lnio=$Hp_Var;
var $lnip=(($lnio)|0);
var $st$17$0=(($lnip)|0);
HEAP32[(($st$17$0)>>2)]=$lnin$0;
var $st$17$1=(($lnip+4)|0);
HEAP32[(($st$17$1)>>2)]=$lnin$1;
var $lniq=$Base_Var;
var $lnir$0=$lniq;
var $lnir$1=0;
var $lnis=$lnir;
var $st$25$0=(($R1_Var)|0);
var $lnit$0=HEAP32[(($st$25$0)>>2)];
var $st$25$1=(($R1_Var+4)|0);
var $lnit$1=HEAP32[(($st$25$1)>>2)];
var $lniu=$lnit;
var $lniv=$Hp_Var;
var $lniw=((($lniv)-(8))|0);
var $lnix$0=$lniw;
var $lnix$1=0;
var $lniy=$lnix;
var $st$35$0=(($R3_Var)|0);
HEAP32[(($st$35$0)>>2)]=undef$0;
var $st$35$1=(($R3_Var+4)|0);
HEAP32[(($st$35$1)>>2)]=undef$1;
var $st$39$0=(($R4_Var)|0);
HEAP32[(($st$39$0)>>2)]=undef$0;
var $st$39$1=(($R4_Var+4)|0);
HEAP32[(($st$39$1)>>2)]=undef$1;
var $st$43$0=(($R5_Var)|0);
HEAP32[(($st$43$0)>>2)]=undef$0;
var $st$43$1=(($R5_Var+4)|0);
HEAP32[(($st$43$1)>>2)]=undef$1;
var $st$47$0=(($R6_Var)|0);
HEAP32[(($st$47$0)>>2)]=undef$0;
var $st$47$1=(($R6_Var+4)|0);
HEAP32[(($st$47$1)>>2)]=undef$1;
$F1_Var=undef;
$F2_Var=undef;
$F3_Var=undef;
$F4_Var=undef;
$D1_Var=undef;
$D2_Var=undef;
var $lniz=_newCAF($lnis, $lniu, $lniy);
var $lniz$0=$lniz[0];
var $lniz$1=$lniz[1];
var $st$60$0=(($lcgC)|0);
HEAP32[(($st$60$0)>>2)]=$lniz$0;
var $st$60$1=(($lcgC+4)|0);
HEAP32[(($st$60$1)>>2)]=$lniz$1;
var $st$64$0=(($lcgC)|0);
var $lniA$0=HEAP32[(($st$64$0)>>2)];
var $st$64$1=(($lcgC+4)|0);
var $lniA$1=HEAP32[(($st$64$1)>>2)];
var $$emscripten$temp$0$0=0;
var $$emscripten$temp$0$1=0;
var $lniB=$lniA$0 == $$emscripten$temp$0$0 && $lniA$1 == $$emscripten$temp$0$1;
if ($lniB) { __label__ = 8; break; } else { __label__ = 5; break; }
case 5:
__label__ = 9; break;
case 6:
var $lniF=$Base_Var;
var $lniG=((($lniF)-(16))|0);
var $lniH=$lniG;
var $st$3$0=(($lniH)|0);
var $lniI$0=HEAP32[(($st$3$0)>>2)];
var $st$3$1=(($lniH+4)|0);
var $lniI$1=HEAP32[(($st$3$1)>>2)];
var $lniJ=$lniI;
var $lniK=$Base_Var;
var $lniL=$Sp_Var;
var $lniM=$Hp_Var;
var $st$11$0=(($R1_Var)|0);
var $lniN$0=HEAP32[(($st$11$0)>>2)];
var $st$11$1=(($R1_Var+4)|0);
var $lniN$1=HEAP32[(($st$11$1)>>2)];
var $st$15$0=(($R2_Var)|0);
var $lniO$0=HEAP32[(($st$15$0)>>2)];
var $st$15$1=(($R2_Var+4)|0);
var $lniO$1=HEAP32[(($st$15$1)>>2)];
var $st$19$0=(($R3_Var)|0);
var $lniP$0=HEAP32[(($st$19$0)>>2)];
var $st$19$1=(($R3_Var+4)|0);
var $lniP$1=HEAP32[(($st$19$1)>>2)];
var $st$23$0=(($R4_Var)|0);
var $lniQ$0=HEAP32[(($st$23$0)>>2)];
var $st$23$1=(($R4_Var+4)|0);
var $lniQ$1=HEAP32[(($st$23$1)>>2)];
var $st$27$0=(($R5_Var)|0);
var $lniR$0=HEAP32[(($st$27$0)>>2)];
var $st$27$1=(($R5_Var+4)|0);
var $lniR$1=HEAP32[(($st$27$1)>>2)];
var $st$31$0=(($R6_Var)|0);
var $lniS$0=HEAP32[(($st$31$0)>>2)];
var $st$31$1=(($R6_Var+4)|0);
var $lniS$1=HEAP32[(($st$31$1)>>2)];
var $st$35$0=(($SpLim_Var)|0);
var $lniT$0=HEAP32[(($st$35$0)>>2)];
var $st$35$1=(($SpLim_Var+4)|0);
var $lniT$1=HEAP32[(($st$35$1)>>2)];
var $lniU=$F1_Var;
var $lniV=$F2_Var;
var $lniW=$F3_Var;
var $lniX=$F4_Var;
var $lniY=$D1_Var;
var $lniZ=$D2_Var;
FUNCTION_TABLE[$lniJ]($lniK, $lniL, $lniM, $lniN$0, $lniN$1, $lniO$0, $lniO$1, $lniP$0, $lniP$1, $lniQ$0, $lniQ$1, $lniR$0, $lniR$1, $lniS$0, $lniS$1, $lniT$0, $lniT$1, $lniU, $lniV, $lniW, $lniX, $lniY, $lniZ);
STACKTOP = __stackBase__;
return;
case 7:
var $lnj0=$Base_Var;
var $lnj1=(($lnj0+192)|0);
var $$emscripten$temp$1$0=16;
var $$emscripten$temp$1$1=0;
var $st$4$0=(($lnj1)|0);
HEAP32[(($st$4$0)>>2)]=$$emscripten$temp$1$0;
var $st$4$1=(($lnj1+4)|0);
HEAP32[(($st$4$1)>>2)]=$$emscripten$temp$1$1;
__label__ = 6; break;
case 8:
var $st$0$0=(($R1_Var)|0);
var $lnj2$0=HEAP32[(($st$0$0)>>2)];
var $st$0$1=(($R1_Var+4)|0);
var $lnj2$1=HEAP32[(($st$0$1)>>2)];
var $lnj3=$lnj2;
var $st$5$0=(($lnj3)|0);
var $lnj4$0=HEAP32[(($st$5$0)>>2)];
var $st$5$1=(($lnj3+4)|0);
var $lnj4$1=HEAP32[(($st$5$1)>>2)];
var $lnj5=$lnj4;
var $lnj6=$Base_Var;
var $lnj7=$Sp_Var;
var $lnj8=$Hp_Var;
var $st$13$0=(($R1_Var)|0);
var $lnj9$0=HEAP32[(($st$13$0)>>2)];
var $st$13$1=(($R1_Var+4)|0);
var $lnj9$1=HEAP32[(($st$13$1)>>2)];
var $st$17$0=(($R2_Var)|0);
var $lnja$0=HEAP32[(($st$17$0)>>2)];
var $st$17$1=(($R2_Var+4)|0);
var $lnja$1=HEAP32[(($st$17$1)>>2)];
var $st$21$0=(($R3_Var)|0);
var $lnjb$0=HEAP32[(($st$21$0)>>2)];
var $st$21$1=(($R3_Var+4)|0);
var $lnjb$1=HEAP32[(($st$21$1)>>2)];
var $st$25$0=(($R4_Var)|0);
var $lnjc$0=HEAP32[(($st$25$0)>>2)];
var $st$25$1=(($R4_Var+4)|0);
var $lnjc$1=HEAP32[(($st$25$1)>>2)];
var $st$29$0=(($R5_Var)|0);
var $lnjd$0=HEAP32[(($st$29$0)>>2)];
var $st$29$1=(($R5_Var+4)|0);
var $lnjd$1=HEAP32[(($st$29$1)>>2)];
var $st$33$0=(($R6_Var)|0);
var $lnje$0=HEAP32[(($st$33$0)>>2)];
var $st$33$1=(($R6_Var+4)|0);
var $lnje$1=HEAP32[(($st$33$1)>>2)];
var $st$37$0=(($SpLim_Var)|0);
var $lnjf$0=HEAP32[(($st$37$0)>>2)];
var $st$37$1=(($SpLim_Var+4)|0);
var $lnjf$1=HEAP32[(($st$37$1)>>2)];
var $lnjg=$F1_Var;
var $lnjh=$F2_Var;
var $lnji=$F3_Var;
var $lnjj=$F4_Var;
var $lnjk=$D1_Var;
var $lnjl=$D2_Var;
FUNCTION_TABLE[$lnj5]($lnj6, $lnj7, $lnj8, $lnj9$0, $lnj9$1, $lnja$0, $lnja$1, $lnjb$0, $lnjb$1, $lnjc$0, $lnjc$1, $lnjd$0, $lnjd$1, $lnje$0, $lnje$1, $lnjf$0, $lnjf$1, $lnjg, $lnjh, $lnji, $lnjj, $lnjk, $lnjl);
STACKTOP = __stackBase__;
return;
case 9:
var $lnjm$0=_stg_bh_upd_frame_info;
var $lnjm$1=0;
var $lnjn=$Sp_Var;
var $lnjo=((($lnjn)-(16))|0);
var $st$4$0=(($lnjo)|0);
HEAP32[(($st$4$0)>>2)]=$lnjm$0;
var $st$4$1=(($lnjo+4)|0);
HEAP32[(($st$4$1)>>2)]=$lnjm$1;
var $lnjp=$Hp_Var;
var $lnjq=((($lnjp)-(8))|0);
var $lnjr$0=$lnjq;
var $lnjr$1=0;
var $lnjs=$Sp_Var;
var $lnjt=((($lnjs)-(8))|0);
var $st$14$0=(($lnjt)|0);
HEAP32[(($st$14$0)>>2)]=$lnjr$0;
var $st$14$1=(($lnjt+4)|0);
HEAP32[(($st$14$1)>>2)]=$lnjr$1;
var $lnju$0=_ghczmprim_GHCziCString_unpackCStringzh_closure;
var $lnju$1=0;
var $st$20$0=(($R1_Var)|0);
HEAP32[(($st$20$0)>>2)]=$lnju$0;
var $st$20$1=(($R1_Var+4)|0);
HEAP32[(($st$20$1)>>2)]=$lnju$1;
var $lnjv$0=_cg1_str;
var $lnjv$1=0;
var $st$26$0=(($R2_Var)|0);
HEAP32[(($st$26$0)>>2)]=$lnjv$0;
var $st$26$1=(($R2_Var+4)|0);
HEAP32[(($st$26$1)>>2)]=$lnjv$1;
var $lnjw=$Sp_Var;
var $lnjx=((($lnjw)-(16))|0);
var $lnjy$0=$lnjx;
var $lnjy$1=0;
var $lnjz=$lnjy;
$Sp_Var=$lnjz;
var $lnjA=$Base_Var;
var $lnjB=$Sp_Var;
var $lnjC=$Hp_Var;
var $st$39$0=(($R1_Var)|0);
var $lnjD$0=HEAP32[(($st$39$0)>>2)];
var $st$39$1=(($R1_Var+4)|0);
var $lnjD$1=HEAP32[(($st$39$1)>>2)];
var $st$43$0=(($R2_Var)|0);
var $lnjE$0=HEAP32[(($st$43$0)>>2)];
var $st$43$1=(($R2_Var+4)|0);
var $lnjE$1=HEAP32[(($st$43$1)>>2)];
var $st$47$0=(($R3_Var)|0);
var $lnjF$0=HEAP32[(($st$47$0)>>2)];
var $st$47$1=(($R3_Var+4)|0);
var $lnjF$1=HEAP32[(($st$47$1)>>2)];
var $st$51$0=(($R4_Var)|0);
var $lnjG$0=HEAP32[(($st$51$0)>>2)];
var $st$51$1=(($R4_Var+4)|0);
var $lnjG$1=HEAP32[(($st$51$1)>>2)];
var $st$55$0=(($R5_Var)|0);
var $lnjH$0=HEAP32[(($st$55$0)>>2)];
var $st$55$1=(($R5_Var+4)|0);
var $lnjH$1=HEAP32[(($st$55$1)>>2)];
var $st$59$0=(($R6_Var)|0);
var $lnjI$0=HEAP32[(($st$59$0)>>2)];
var $st$59$1=(($R6_Var+4)|0);
var $lnjI$1=HEAP32[(($st$59$1)>>2)];
var $st$63$0=(($SpLim_Var)|0);
var $lnjJ$0=HEAP32[(($st$63$0)>>2)];
var $st$63$1=(($SpLim_Var+4)|0);
var $lnjJ$1=HEAP32[(($st$63$1)>>2)];
var $lnjK=$F1_Var;
var $lnjL=$F2_Var;
var $lnjM=$F3_Var;
var $lnjN=$F4_Var;
var $lnjO=$D1_Var;
var $lnjP=$D2_Var;
_stg_ap_n_fast($lnjA, $lnjB, $lnjC, $lnjD$0, $lnjD$1, $lnjE$0, $lnjE$1, $lnjF$0, $lnjF$1, $lnjG$0, $lnjG$1, $lnjH$0, $lnjH$1, $lnjI$0, $lnjI$1, $lnjJ$0, $lnjJ$1, $lnjK, $lnjL, $lnjM, $lnjN, $lnjO, $lnjP);
STACKTOP = __stackBase__;
return;
default: assert(0, "bad label: " + __label__);
}
}
_sfT_info["X"]=1;
function _Main_main_info($Base_Arg, $Sp_Arg, $Hp_Arg, $R1_Arg$0, $R1_Arg$1, $R2_Arg$0, $R2_Arg$1, $R3_Arg$0, $R3_Arg$1, $R4_Arg$0, $R4_Arg$1, $R5_Arg$0, $R5_Arg$1, $R6_Arg$0, $R6_Arg$1, $SpLim_Arg$0, $SpLim_Arg$1, $F1_Arg, $F2_Arg, $F3_Arg, $F4_Arg, $D1_Arg, $D2_Arg) {
var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
var __label__;
__label__ = 2;
while(1) switch(__label__) {
case 2:
var $Base_Var;
$Base_Var=$Base_Arg;
var $Sp_Var;
$Sp_Var=$Sp_Arg;
var $Hp_Var;
$Hp_Var=$Hp_Arg;
var $R1_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$7$0=(($R1_Var)|0);
HEAP32[(($st$7$0)>>2)]=$R1_Arg$0;
var $st$7$1=(($R1_Var+4)|0);
HEAP32[(($st$7$1)>>2)]=$R1_Arg$1;
var $R2_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$12$0=(($R2_Var)|0);
HEAP32[(($st$12$0)>>2)]=$R2_Arg$0;
var $st$12$1=(($R2_Var+4)|0);
HEAP32[(($st$12$1)>>2)]=$R2_Arg$1;
var $R3_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$17$0=(($R3_Var)|0);
HEAP32[(($st$17$0)>>2)]=$R3_Arg$0;
var $st$17$1=(($R3_Var+4)|0);
HEAP32[(($st$17$1)>>2)]=$R3_Arg$1;
var $R4_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$22$0=(($R4_Var)|0);
HEAP32[(($st$22$0)>>2)]=$R4_Arg$0;
var $st$22$1=(($R4_Var+4)|0);
HEAP32[(($st$22$1)>>2)]=$R4_Arg$1;
var $R5_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$27$0=(($R5_Var)|0);
HEAP32[(($st$27$0)>>2)]=$R5_Arg$0;
var $st$27$1=(($R5_Var+4)|0);
HEAP32[(($st$27$1)>>2)]=$R5_Arg$1;
var $R6_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$32$0=(($R6_Var)|0);
HEAP32[(($st$32$0)>>2)]=$R6_Arg$0;
var $st$32$1=(($R6_Var+4)|0);
HEAP32[(($st$32$1)>>2)]=$R6_Arg$1;
var $SpLim_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$37$0=(($SpLim_Var)|0);
HEAP32[(($st$37$0)>>2)]=$SpLim_Arg$0;
var $st$37$1=(($SpLim_Var+4)|0);
HEAP32[(($st$37$1)>>2)]=$SpLim_Arg$1;
var $F1_Var;
$F1_Var=$F1_Arg;
var $F2_Var;
$F2_Var=$F2_Arg;
var $F3_Var;
$F3_Var=$F3_Arg;
var $F4_Var;
$F4_Var=$F4_Arg;
var $D1_Var;
$D1_Var=$D1_Arg;
var $D2_Var;
$D2_Var=$D2_Arg;
var $lcku=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $lnlQ=$Sp_Var;
var $lnlR=((($lnlQ)-(16))|0);
var $lnlS$0=$lnlR;
var $lnlS$1=0;
var $st$58$0=(($SpLim_Var)|0);
var $lnlT$0=HEAP32[(($st$58$0)>>2)];
var $st$58$1=(($SpLim_Var+4)|0);
var $lnlT$1=HEAP32[(($st$58$1)>>2)];
var $lnlU=($lnlS$1>>>0) < ($lnlT$1>>>0) || (($lnlS$1>>>0) == ($lnlT$1>>>0) && ($lnlS$0>>>0) < ($lnlT$0>>>0));
if ($lnlU) { __label__ = 6; break; } else { __label__ = 3; break; }
case 3:
var $lnlY=$Hp_Var;
var $lnlZ=(($lnlY+16)|0);
var $lnm0$0=$lnlZ;
var $lnm0$1=0;
var $lnm1=$lnm0;
$Hp_Var=$lnm1;
var $lnm2=$Hp_Var;
var $lnm3$0=$lnm2;
var $lnm3$1=0;
var $lnm4=$Base_Var;
var $lnm5=(($lnm4+144)|0);
var $lnm6=$lnm5;
var $st$12$0=(($lnm6)|0);
var $lnm7$0=HEAP32[(($st$12$0)>>2)];
var $st$12$1=(($lnm6+4)|0);
var $lnm7$1=HEAP32[(($st$12$1)>>2)];
var $lnm8=($lnm3$1>>>0) > ($lnm7$1>>>0) || (($lnm3$1>>>0) == ($lnm7$1>>>0) && ($lnm3$0>>>0) > ($lnm7$0>>>0));
if ($lnm8) { __label__ = 7; break; } else { __label__ = 4; break; }
case 4:
var $lnmc$0=_stg_CAF_BLACKHOLE_info;
var $lnmc$1=0;
var $lnmd=$Hp_Var;
var $lnme=((($lnmd)-(8))|0);
var $st$4$0=(($lnme)|0);
HEAP32[(($st$4$0)>>2)]=$lnmc$0;
var $st$4$1=(($lnme+4)|0);
HEAP32[(($st$4$1)>>2)]=$lnmc$1;
var $lnmf=$Base_Var;
var $lnmg=(($lnmf+160)|0);
var $lnmh=$lnmg;
var $st$11$0=(($lnmh)|0);
var $lnmi$0=HEAP32[(($st$11$0)>>2)];
var $st$11$1=(($lnmh+4)|0);
var $lnmi$1=HEAP32[(($st$11$1)>>2)];
var $lnmj=$Hp_Var;
var $lnmk=(($lnmj)|0);
var $st$17$0=(($lnmk)|0);
HEAP32[(($st$17$0)>>2)]=$lnmi$0;
var $st$17$1=(($lnmk+4)|0);
HEAP32[(($st$17$1)>>2)]=$lnmi$1;
var $lnml=$Base_Var;
var $lnmm$0=$lnml;
var $lnmm$1=0;
var $lnmn=$lnmm;
var $st$25$0=(($R1_Var)|0);
var $lnmo$0=HEAP32[(($st$25$0)>>2)];
var $st$25$1=(($R1_Var+4)|0);
var $lnmo$1=HEAP32[(($st$25$1)>>2)];
var $lnmp=$lnmo;
var $lnmq=$Hp_Var;
var $lnmr=((($lnmq)-(8))|0);
var $lnms$0=$lnmr;
var $lnms$1=0;
var $lnmt=$lnms;
var $st$35$0=(($R3_Var)|0);
HEAP32[(($st$35$0)>>2)]=undef$0;
var $st$35$1=(($R3_Var+4)|0);
HEAP32[(($st$35$1)>>2)]=undef$1;
var $st$39$0=(($R4_Var)|0);
HEAP32[(($st$39$0)>>2)]=undef$0;
var $st$39$1=(($R4_Var+4)|0);
HEAP32[(($st$39$1)>>2)]=undef$1;
var $st$43$0=(($R5_Var)|0);
HEAP32[(($st$43$0)>>2)]=undef$0;
var $st$43$1=(($R5_Var+4)|0);
HEAP32[(($st$43$1)>>2)]=undef$1;
var $st$47$0=(($R6_Var)|0);
HEAP32[(($st$47$0)>>2)]=undef$0;
var $st$47$1=(($R6_Var+4)|0);
HEAP32[(($st$47$1)>>2)]=undef$1;
$F1_Var=undef;
$F2_Var=undef;
$F3_Var=undef;
$F4_Var=undef;
$D1_Var=undef;
$D2_Var=undef;
var $lnmu=_newCAF($lnmn, $lnmp, $lnmt);
var $lnmu$0=$lnmu[0];
var $lnmu$1=$lnmu[1];
var $st$60$0=(($lcku)|0);
HEAP32[(($st$60$0)>>2)]=$lnmu$0;
var $st$60$1=(($lcku+4)|0);
HEAP32[(($st$60$1)>>2)]=$lnmu$1;
var $st$64$0=(($lcku)|0);
var $lnmv$0=HEAP32[(($st$64$0)>>2)];
var $st$64$1=(($lcku+4)|0);
var $lnmv$1=HEAP32[(($st$64$1)>>2)];
var $$emscripten$temp$0$0=0;
var $$emscripten$temp$0$1=0;
var $lnmw=$lnmv$0 == $$emscripten$temp$0$0 && $lnmv$1 == $$emscripten$temp$0$1;
if ($lnmw) { __label__ = 8; break; } else { __label__ = 5; break; }
case 5:
__label__ = 9; break;
case 6:
var $lnmA=$Base_Var;
var $lnmB=((($lnmA)-(16))|0);
var $lnmC=$lnmB;
var $st$3$0=(($lnmC)|0);
var $lnmD$0=HEAP32[(($st$3$0)>>2)];
var $st$3$1=(($lnmC+4)|0);
var $lnmD$1=HEAP32[(($st$3$1)>>2)];
var $lnmE=$lnmD;
var $lnmF=$Base_Var;
var $lnmG=$Sp_Var;
var $lnmH=$Hp_Var;
var $st$11$0=(($R1_Var)|0);
var $lnmI$0=HEAP32[(($st$11$0)>>2)];
var $st$11$1=(($R1_Var+4)|0);
var $lnmI$1=HEAP32[(($st$11$1)>>2)];
var $st$15$0=(($R2_Var)|0);
var $lnmJ$0=HEAP32[(($st$15$0)>>2)];
var $st$15$1=(($R2_Var+4)|0);
var $lnmJ$1=HEAP32[(($st$15$1)>>2)];
var $st$19$0=(($R3_Var)|0);
var $lnmK$0=HEAP32[(($st$19$0)>>2)];
var $st$19$1=(($R3_Var+4)|0);
var $lnmK$1=HEAP32[(($st$19$1)>>2)];
var $st$23$0=(($R4_Var)|0);
var $lnmL$0=HEAP32[(($st$23$0)>>2)];
var $st$23$1=(($R4_Var+4)|0);
var $lnmL$1=HEAP32[(($st$23$1)>>2)];
var $st$27$0=(($R5_Var)|0);
var $lnmM$0=HEAP32[(($st$27$0)>>2)];
var $st$27$1=(($R5_Var+4)|0);
var $lnmM$1=HEAP32[(($st$27$1)>>2)];
var $st$31$0=(($R6_Var)|0);
var $lnmN$0=HEAP32[(($st$31$0)>>2)];
var $st$31$1=(($R6_Var+4)|0);
var $lnmN$1=HEAP32[(($st$31$1)>>2)];
var $st$35$0=(($SpLim_Var)|0);
var $lnmO$0=HEAP32[(($st$35$0)>>2)];
var $st$35$1=(($SpLim_Var+4)|0);
var $lnmO$1=HEAP32[(($st$35$1)>>2)];
var $lnmP=$F1_Var;
var $lnmQ=$F2_Var;
var $lnmR=$F3_Var;
var $lnmS=$F4_Var;
var $lnmT=$D1_Var;
var $lnmU=$D2_Var;
FUNCTION_TABLE[$lnmE]($lnmF, $lnmG, $lnmH, $lnmI$0, $lnmI$1, $lnmJ$0, $lnmJ$1, $lnmK$0, $lnmK$1, $lnmL$0, $lnmL$1, $lnmM$0, $lnmM$1, $lnmN$0, $lnmN$1, $lnmO$0, $lnmO$1, $lnmP, $lnmQ, $lnmR, $lnmS, $lnmT, $lnmU);
STACKTOP = __stackBase__;
return;
case 7:
var $lnmV=$Base_Var;
var $lnmW=(($lnmV+192)|0);
var $$emscripten$temp$1$0=16;
var $$emscripten$temp$1$1=0;
var $st$4$0=(($lnmW)|0);
HEAP32[(($st$4$0)>>2)]=$$emscripten$temp$1$0;
var $st$4$1=(($lnmW+4)|0);
HEAP32[(($st$4$1)>>2)]=$$emscripten$temp$1$1;
__label__ = 6; break;
case 8:
var $st$0$0=(($R1_Var)|0);
var $lnmX$0=HEAP32[(($st$0$0)>>2)];
var $st$0$1=(($R1_Var+4)|0);
var $lnmX$1=HEAP32[(($st$0$1)>>2)];
var $lnmY=$lnmX;
var $st$5$0=(($lnmY)|0);
var $lnmZ$0=HEAP32[(($st$5$0)>>2)];
var $st$5$1=(($lnmY+4)|0);
var $lnmZ$1=HEAP32[(($st$5$1)>>2)];
var $lnn0=$lnmZ;
var $lnn1=$Base_Var;
var $lnn2=$Sp_Var;
var $lnn3=$Hp_Var;
var $st$13$0=(($R1_Var)|0);
var $lnn4$0=HEAP32[(($st$13$0)>>2)];
var $st$13$1=(($R1_Var+4)|0);
var $lnn4$1=HEAP32[(($st$13$1)>>2)];
var $st$17$0=(($R2_Var)|0);
var $lnn5$0=HEAP32[(($st$17$0)>>2)];
var $st$17$1=(($R2_Var+4)|0);
var $lnn5$1=HEAP32[(($st$17$1)>>2)];
var $st$21$0=(($R3_Var)|0);
var $lnn6$0=HEAP32[(($st$21$0)>>2)];
var $st$21$1=(($R3_Var+4)|0);
var $lnn6$1=HEAP32[(($st$21$1)>>2)];
var $st$25$0=(($R4_Var)|0);
var $lnn7$0=HEAP32[(($st$25$0)>>2)];
var $st$25$1=(($R4_Var+4)|0);
var $lnn7$1=HEAP32[(($st$25$1)>>2)];
var $st$29$0=(($R5_Var)|0);
var $lnn8$0=HEAP32[(($st$29$0)>>2)];
var $st$29$1=(($R5_Var+4)|0);
var $lnn8$1=HEAP32[(($st$29$1)>>2)];
var $st$33$0=(($R6_Var)|0);
var $lnn9$0=HEAP32[(($st$33$0)>>2)];
var $st$33$1=(($R6_Var+4)|0);
var $lnn9$1=HEAP32[(($st$33$1)>>2)];
var $st$37$0=(($SpLim_Var)|0);
var $lnna$0=HEAP32[(($st$37$0)>>2)];
var $st$37$1=(($SpLim_Var+4)|0);
var $lnna$1=HEAP32[(($st$37$1)>>2)];
var $lnnb=$F1_Var;
var $lnnc=$F2_Var;
var $lnnd=$F3_Var;
var $lnne=$F4_Var;
var $lnnf=$D1_Var;
var $lnng=$D2_Var;
FUNCTION_TABLE[$lnn0]($lnn1, $lnn2, $lnn3, $lnn4$0, $lnn4$1, $lnn5$0, $lnn5$1, $lnn6$0, $lnn6$1, $lnn7$0, $lnn7$1, $lnn8$0, $lnn8$1, $lnn9$0, $lnn9$1, $lnna$0, $lnna$1, $lnnb, $lnnc, $lnnd, $lnne, $lnnf, $lnng);
STACKTOP = __stackBase__;
return;
case 9:
var $lnnh$0=_stg_bh_upd_frame_info;
var $lnnh$1=0;
var $lnni=$Sp_Var;
var $lnnj=((($lnni)-(16))|0);
var $st$4$0=(($lnnj)|0);
HEAP32[(($st$4$0)>>2)]=$lnnh$0;
var $st$4$1=(($lnnj+4)|0);
HEAP32[(($st$4$1)>>2)]=$lnnh$1;
var $lnnk=$Hp_Var;
var $lnnl=((($lnnk)-(8))|0);
var $lnnm$0=$lnnl;
var $lnnm$1=0;
var $lnnn=$Sp_Var;
var $lnno=((($lnnn)-(8))|0);
var $st$14$0=(($lnno)|0);
HEAP32[(($st$14$0)>>2)]=$lnnm$0;
var $st$14$1=(($lnno+4)|0);
HEAP32[(($st$14$1)>>2)]=$lnnm$1;
var $lnnp$0=_base_GHCziBase_zd_closure;
var $lnnp$1=0;
var $st$20$0=(($R1_Var)|0);
HEAP32[(($st$20$0)>>2)]=$lnnp$0;
var $st$20$1=(($R1_Var+4)|0);
HEAP32[(($st$20$1)>>2)]=$lnnp$1;
var $lnnq$0=_base_SystemziIO_putStrLn_closure;
var $lnnq$1=0;
var $st$26$0=(($R2_Var)|0);
HEAP32[(($st$26$0)>>2)]=$lnnq$0;
var $st$26$1=(($R2_Var+4)|0);
HEAP32[(($st$26$1)>>2)]=$lnnq$1;
var $lnnr$0=_sfT_closure;
var $lnnr$1=0;
var $st$32$0=(($R3_Var)|0);
HEAP32[(($st$32$0)>>2)]=$lnnr$0;
var $st$32$1=(($R3_Var+4)|0);
HEAP32[(($st$32$1)>>2)]=$lnnr$1;
var $lnns=$Sp_Var;
var $lnnt=((($lnns)-(16))|0);
var $lnnu$0=$lnnt;
var $lnnu$1=0;
var $lnnv=$lnnu;
$Sp_Var=$lnnv;
var $lnnw=$Base_Var;
var $lnnx=$Sp_Var;
var $lnny=$Hp_Var;
var $st$45$0=(($R1_Var)|0);
var $lnnz$0=HEAP32[(($st$45$0)>>2)];
var $st$45$1=(($R1_Var+4)|0);
var $lnnz$1=HEAP32[(($st$45$1)>>2)];
var $st$49$0=(($R2_Var)|0);
var $lnnA$0=HEAP32[(($st$49$0)>>2)];
var $st$49$1=(($R2_Var+4)|0);
var $lnnA$1=HEAP32[(($st$49$1)>>2)];
var $st$53$0=(($R3_Var)|0);
var $lnnB$0=HEAP32[(($st$53$0)>>2)];
var $st$53$1=(($R3_Var+4)|0);
var $lnnB$1=HEAP32[(($st$53$1)>>2)];
var $st$57$0=(($R4_Var)|0);
var $lnnC$0=HEAP32[(($st$57$0)>>2)];
var $st$57$1=(($R4_Var+4)|0);
var $lnnC$1=HEAP32[(($st$57$1)>>2)];
var $st$61$0=(($R5_Var)|0);
var $lnnD$0=HEAP32[(($st$61$0)>>2)];
var $st$61$1=(($R5_Var+4)|0);
var $lnnD$1=HEAP32[(($st$61$1)>>2)];
var $st$65$0=(($R6_Var)|0);
var $lnnE$0=HEAP32[(($st$65$0)>>2)];
var $st$65$1=(($R6_Var+4)|0);
var $lnnE$1=HEAP32[(($st$65$1)>>2)];
var $st$69$0=(($SpLim_Var)|0);
var $lnnF$0=HEAP32[(($st$69$0)>>2)];
var $st$69$1=(($SpLim_Var+4)|0);
var $lnnF$1=HEAP32[(($st$69$1)>>2)];
var $lnnG=$F1_Var;
var $lnnH=$F2_Var;
var $lnnI=$F3_Var;
var $lnnJ=$F4_Var;
var $lnnK=$D1_Var;
var $lnnL=$D2_Var;
_stg_ap_pp_fast($lnnw, $lnnx, $lnny, $lnnz$0, $lnnz$1, $lnnA$0, $lnnA$1, $lnnB$0, $lnnB$1, $lnnC$0, $lnnC$1, $lnnD$0, $lnnD$1, $lnnE$0, $lnnE$1, $lnnF$0, $lnnF$1, $lnnG, $lnnH, $lnnI, $lnnJ, $lnnK, $lnnL);
STACKTOP = __stackBase__;
return;
default: assert(0, "bad label: " + __label__);
}
}
_Main_main_info["X"]=1;
function _ZCMain_main_info($Base_Arg, $Sp_Arg, $Hp_Arg, $R1_Arg$0, $R1_Arg$1, $R2_Arg$0, $R2_Arg$1, $R3_Arg$0, $R3_Arg$1, $R4_Arg$0, $R4_Arg$1, $R5_Arg$0, $R5_Arg$1, $R6_Arg$0, $R6_Arg$1, $SpLim_Arg$0, $SpLim_Arg$1, $F1_Arg, $F2_Arg, $F3_Arg, $F4_Arg, $D1_Arg, $D2_Arg) {
var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
var __label__;
__label__ = 2;
while(1) switch(__label__) {
case 2:
var $Base_Var;
$Base_Var=$Base_Arg;
var $Sp_Var;
$Sp_Var=$Sp_Arg;
var $Hp_Var;
$Hp_Var=$Hp_Arg;
var $R1_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$7$0=(($R1_Var)|0);
HEAP32[(($st$7$0)>>2)]=$R1_Arg$0;
var $st$7$1=(($R1_Var+4)|0);
HEAP32[(($st$7$1)>>2)]=$R1_Arg$1;
var $R2_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$12$0=(($R2_Var)|0);
HEAP32[(($st$12$0)>>2)]=$R2_Arg$0;
var $st$12$1=(($R2_Var+4)|0);
HEAP32[(($st$12$1)>>2)]=$R2_Arg$1;
var $R3_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$17$0=(($R3_Var)|0);
HEAP32[(($st$17$0)>>2)]=$R3_Arg$0;
var $st$17$1=(($R3_Var+4)|0);
HEAP32[(($st$17$1)>>2)]=$R3_Arg$1;
var $R4_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$22$0=(($R4_Var)|0);
HEAP32[(($st$22$0)>>2)]=$R4_Arg$0;
var $st$22$1=(($R4_Var+4)|0);
HEAP32[(($st$22$1)>>2)]=$R4_Arg$1;
var $R5_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$27$0=(($R5_Var)|0);
HEAP32[(($st$27$0)>>2)]=$R5_Arg$0;
var $st$27$1=(($R5_Var+4)|0);
HEAP32[(($st$27$1)>>2)]=$R5_Arg$1;
var $R6_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$32$0=(($R6_Var)|0);
HEAP32[(($st$32$0)>>2)]=$R6_Arg$0;
var $st$32$1=(($R6_Var+4)|0);
HEAP32[(($st$32$1)>>2)]=$R6_Arg$1;
var $SpLim_Var=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $st$37$0=(($SpLim_Var)|0);
HEAP32[(($st$37$0)>>2)]=$SpLim_Arg$0;
var $st$37$1=(($SpLim_Var+4)|0);
HEAP32[(($st$37$1)>>2)]=$SpLim_Arg$1;
var $F1_Var;
$F1_Var=$F1_Arg;
var $F2_Var;
$F2_Var=$F2_Arg;
var $F3_Var;
$F3_Var=$F3_Arg;
var $F4_Var;
$F4_Var=$F4_Arg;
var $D1_Var;
$D1_Var=$D1_Arg;
var $D2_Var;
$D2_Var=$D2_Arg;
var $lcoq=STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");
var $lnpL=$Sp_Var;
var $lnpM=((($lnpL)-(16))|0);
var $lnpN$0=$lnpM;
var $lnpN$1=0;
var $st$58$0=(($SpLim_Var)|0);
var $lnpO$0=HEAP32[(($st$58$0)>>2)];
var $st$58$1=(($SpLim_Var+4)|0);
var $lnpO$1=HEAP32[(($st$58$1)>>2)];
var $lnpP=($lnpN$1>>>0) < ($lnpO$1>>>0) || (($lnpN$1>>>0) == ($lnpO$1>>>0) && ($lnpN$0>>>0) < ($lnpO$0>>>0));
if ($lnpP) { __label__ = 6; break; } else { __label__ = 3; break; }
case 3:
var $lnpT=$Hp_Var;
var $lnpU=(($lnpT+16)|0);
var $lnpV$0=$lnpU;
var $lnpV$1=0;
var $lnpW=$lnpV;
$Hp_Var=$lnpW;
var $lnpX=$Hp_Var;
var $lnpY$0=$lnpX;
var $lnpY$1=0;
var $lnpZ=$Base_Var;
var $lnq0=(($lnpZ+144)|0);
var $lnq1=$lnq0;
var $st$12$0=(($lnq1)|0);
var $lnq2$0=HEAP32[(($st$12$0)>>2)];
var $st$12$1=(($lnq1+4)|0);
var $lnq2$1=HEAP32[(($st$12$1)>>2)];
var $lnq3=($lnpY$1>>>0) > ($lnq2$1>>>0) || (($lnpY$1>>>0) == ($lnq2$1>>>0) && ($lnpY$0>>>0) > ($lnq2$0>>>0));
if ($lnq3) { __label__ = 7; break; } else { __label__ = 4; break; }
case 4:
var $lnq7$0=_stg_CAF_BLACKHOLE_info;
var $lnq7$1=0;
var $lnq8=$Hp_Var;
var $lnq9=((($lnq8)-(8))|0);
var $st$4$0=(($lnq9)|0);
HEAP32[(($st$4$0)>>2)]=$lnq7$0;
var $st$4$1=(($lnq9+4)|0);
HEAP32[(($st$4$1)>>2)]=$lnq7$1;
var $lnqa=$Base_Var;
var $lnqb=(($lnqa+160)|0);
var $lnqc=$lnqb;
var $st$11$0=(($lnqc)|0);
var $lnqd$0=HEAP32[(($st$11$0)>>2)];
var $st$11$1=(($lnqc+4)|0);
var $lnqd$1=HEAP32[(($st$11$1)>>2)];
var $lnqe=$Hp_Var;
var $lnqf=(($lnqe)|0);
var $st$17$0=(($lnqf)|0);
HEAP32[(($st$17$0)>>2)]=$lnqd$0;
var $st$17$1=(($lnqf+4)|0);
HEAP32[(($st$17$1)>>2)]=$lnqd$1;
var $lnqg=$Base_Var;
var $lnqh$0=$lnqg;
var $lnqh$1=0;
var $lnqi=$lnqh;
var $st$25$0=(($R1_Var)|0);
var $lnqj$0=HEAP32[(($st$25$0)>>2)];
var $st$25$1=(($R1_Var+4)|0);
var $lnqj$1=HEAP32[(($st$25$1)>>2)];
var $lnqk=$lnqj;
var $lnql=$Hp_Var;
var $lnqm=((($lnql)-(8))|0);
var $lnqn$0=$lnqm;
var $lnqn$1=0;
var $lnqo=$lnqn;
var $st$35$0=(($R3_Var)|0);
HEAP32[(($st$35$0)>>2)]=undef$0;
var $st$35$1=(($R3_Var+4)|0);
HEAP32[(($st$35$1)>>2)]=undef$1;
var $st$39$0=(($R4_Var)|0);
HEAP32[(($st$39$0)>>2)]=undef$0;
var $st$39$1=(($R4_Var+4)|0);
HEAP32[(($st$39$1)>>2)]=undef$1;
var $st$43$0=(($R5_Var)|0);
HEAP32[(($st$43$0)>>2)]=undef$0;
var $st$43$1=(($R5_Var+4)|0);
HEAP32[(($st$43$1)>>2)]=undef$1;
var $st$47$0=(($R6_Var)|0);
HEAP32[(($st$47$0)>>2)]=undef$0;
var $st$47$1=(($R6_Var+4)|0);
HEAP32[(($st$47$1)>>2)]=undef$1;
$F1_Var=undef;
$F2_Var=undef;
$F3_Var=undef;
$F4_Var=undef;
$D1_Var=undef;
$D2_Var=undef;
var $lnqp=_newCAF($lnqi, $lnqk, $lnqo);
var $lnqp$0=$lnqp[0];
var $lnqp$1=$lnqp[1];
var $st$60$0=(($lcoq)|0);
HEAP32[(($st$60$0)>>2)]=$lnqp$0;
var $st$60$1=(($lcoq+4)|0);
HEAP32[(($st$60$1)>>2)]=$lnqp$1;
var $st$64$0=(($lcoq)|0);
var $lnqq$0=HEAP32[(($st$64$0)>>2)];
var $st$64$1=(($lcoq+4)|0);
var $lnqq$1=HEAP32[(($st$64$1)>>2)];
var $$emscripten$temp$0$0=0;
var $$emscripten$temp$0$1=0;
var $lnqr=$lnqq$0 == $$emscripten$temp$0$0 && $lnqq$1 == $$emscripten$temp$0$1;
if ($lnqr) { __label__ = 8; break; } else { __label__ = 5; break; }
case 5:
__label__ = 9; break;
case 6:
var $lnqv=$Base_Var;
var $lnqw=((($lnqv)-(16))|0);
var $lnqx=$lnqw;
var $st$3$0=(($lnqx)|0);
var $lnqy$0=HEAP32[(($st$3$0)>>2)];
var $st$3$1=(($lnqx+4)|0);
var $lnqy$1=HEAP32[(($st$3$1)>>2)];
var $lnqz=$lnqy;
var $lnqA=$Base_Var;
var $lnqB=$Sp_Var;
var $lnqC=$Hp_Var;
var $st$11$0=(($R1_Var)|0);
var $lnqD$0=HEAP32[(($st$11$0)>>2)];
var $st$11$1=(($R1_Var+4)|0);
var $lnqD$1=HEAP32[(($st$11$1)>>2)];
var $st$15$0=(($R2_Var)|0);
var $lnqE$0=HEAP32[(($st$15$0)>>2)];
var $st$15$1=(($R2_Var+4)|0);
var $lnqE$1=HEAP32[(($st$15$1)>>2)];
var $st$19$0=(($R3_Var)|0);
var $lnqF$0=HEAP32[(($st$19$0)>>2)];
var $st$19$1=(($R3_Var+4)|0);
var $lnqF$1=HEAP32[(($st$19$1)>>2)];
var $st$23$0=(($R4_Var)|0);
var $lnqG$0=HEAP32[(($st$23$0)>>2)];
var $st$23$1=(($R4_Var+4)|0);
var $lnqG$1=HEAP32[(($st$23$1)>>2)];
var $st$27$0=(($R5_Var)|0);
var $lnqH$0=HEAP32[(($st$27$0)>>2)];
var $st$27$1=(($R5_Var+4)|0);
var $lnqH$1=HEAP32[(($st$27$1)>>2)];
var $st$31$0=(($R6_Var)|0);
var $lnqI$0=HEAP32[(($st$31$0)>>2)];
var $st$31$1=(($R6_Var+4)|0);
var $lnqI$1=HEAP32[(($st$31$1)>>2)];
var $st$35$0=(($SpLim_Var)|0);
var $lnqJ$0=HEAP32[(($st$35$0)>>2)];
var $st$35$1=(($SpLim_Var+4)|0);
var $lnqJ$1=HEAP32[(($st$35$1)>>2)];
var $lnqK=$F1_Var;
var $lnqL=$F2_Var;
var $lnqM=$F3_Var;
var $lnqN=$F4_Var;
var $lnqO=$D1_Var;
var $lnqP=$D2_Var;
FUNCTION_TABLE[$lnqz]($lnqA, $lnqB, $lnqC, $lnqD$0, $lnqD$1, $lnqE$0, $lnqE$1, $lnqF$0, $lnqF$1, $lnqG$0, $lnqG$1, $lnqH$0, $lnqH$1, $lnqI$0, $lnqI$1, $lnqJ$0, $lnqJ$1, $lnqK, $lnqL, $lnqM, $lnqN, $lnqO, $lnqP);
STACKTOP = __stackBase__;
return;
case 7:
var $lnqQ=$Base_Var;
var $lnqR=(($lnqQ+192)|0);
var $$emscripten$temp$1$0=16;
var $$emscripten$temp$1$1=0;
var $st$4$0=(($lnqR)|0);
HEAP32[(($st$4$0)>>2)]=$$emscripten$temp$1$0;
var $st$4$1=(($lnqR+4)|0);
HEAP32[(($st$4$1)>>2)]=$$emscripten$temp$1$1;
__label__ = 6; break;
case 8:
var $st$0$0=(($R1_Var)|0);
var $lnqS$0=HEAP32[(($st$0$0)>>2)];
var $st$0$1=(($R1_Var+4)|0);
var $lnqS$1=HEAP32[(($st$0$1)>>2)];
var $lnqT=$lnqS;
var $st$5$0=(($lnqT)|0);
var $lnqU$0=HEAP32[(($st$5$0)>>2)];
var $st$5$1=(($lnqT+4)|0);
var $lnqU$1=HEAP32[(($st$5$1)>>2)];
var $lnqV=$lnqU;
var $lnqW=$Base_Var;
var $lnqX=$Sp_Var;
var $lnqY=$Hp_Var;
var $st$13$0=(($R1_Var)|0);
var $lnqZ$0=HEAP32[(($st$13$0)>>2)];
var $st$13$1=(($R1_Var+4)|0);
var $lnqZ$1=HEAP32[(($st$13$1)>>2)];
var $st$17$0=(($R2_Var)|0);
var $lnr0$0=HEAP32[(($st$17$0)>>2)];
var $st$17$1=(($R2_Var+4)|0);
var $lnr0$1=HEAP32[(($st$17$1)>>2)];
var $st$21$0=(($R3_Var)|0);
var $lnr1$0=HEAP32[(($st$21$0)>>2)];
var $st$21$1=(($R3_Var+4)|0);
var $lnr1$1=HEAP32[(($st$21$1)>>2)];
var $st$25$0=(($R4_Var)|0);
var $lnr2$0=HEAP32[(($st$25$0)>>2)];
var $st$25$1=(($R4_Var+4)|0);
var $lnr2$1=HEAP32[(($st$25$1)>>2)];
var $st$29$0=(($R5_Var)|0);
var $lnr3$0=HEAP32[(($st$29$0)>>2)];
var $st$29$1=(($R5_Var+4)|0);
var $lnr3$1=HEAP32[(($st$29$1)>>2)];
var $st$33$0=(($R6_Var)|0);
var $lnr4$0=HEAP32[(($st$33$0)>>2)];
var $st$33$1=(($R6_Var+4)|0);
var $lnr4$1=HEAP32[(($st$33$1)>>2)];
var $st$37$0=(($SpLim_Var)|0);
var $lnr5$0=HEAP32[(($st$37$0)>>2)];
var $st$37$1=(($SpLim_Var+4)|0);
var $lnr5$1=HEAP32[(($st$37$1)>>2)];
var $lnr6=$F1_Var;
var $lnr7=$F2_Var;
var $lnr8=$F3_Var;
var $lnr9=$F4_Var;
var $lnra=$D1_Var;
var $lnrb=$D2_Var;
FUNCTION_TABLE[$lnqV]($lnqW, $lnqX, $lnqY, $lnqZ$0, $lnqZ$1, $lnr0$0, $lnr0$1, $lnr1$0, $lnr1$1, $lnr2$0, $lnr2$1, $lnr3$0, $lnr3$1, $lnr4$0, $lnr4$1, $lnr5$0, $lnr5$1, $lnr6, $lnr7, $lnr8, $lnr9, $lnra, $lnrb);
STACKTOP = __stackBase__;
return;
case 9:
var $lnrc$0=_stg_bh_upd_frame_info;
var $lnrc$1=0;
var $lnrd=$Sp_Var;
var $lnre=((($lnrd)-(16))|0);
var $st$4$0=(($lnre)|0);
HEAP32[(($st$4$0)>>2)]=$lnrc$0;
var $st$4$1=(($lnre+4)|0);
HEAP32[(($st$4$1)>>2)]=$lnrc$1;
var $lnrf=$Hp_Var;
var $lnrg=((($lnrf)-(8))|0);
var $lnrh$0=$lnrg;
var $lnrh$1=0;
var $lnri=$Sp_Var;
var $lnrj=((($lnri)-(8))|0);
var $st$14$0=(($lnrj)|0);
HEAP32[(($st$14$0)>>2)]=$lnrh$0;
var $st$14$1=(($lnrj+4)|0);
HEAP32[(($st$14$1)>>2)]=$lnrh$1;
var $lnrk$0=_base_GHCziTopHandler_runMainIO_closure;
var $lnrk$1=0;
var $st$20$0=(($R1_Var)|0);
HEAP32[(($st$20$0)>>2)]=$lnrk$0;
var $st$20$1=(($R1_Var+4)|0);
HEAP32[(($st$20$1)>>2)]=$lnrk$1;
var $lnrl$0=_Main_main_closure;
var $lnrl$1=0;
var $st$26$0=(($R2_Var)|0);
HEAP32[(($st$26$0)>>2)]=$lnrl$0;
var $st$26$1=(($R2_Var+4)|0);
HEAP32[(($st$26$1)>>2)]=$lnrl$1;
var $lnrm=$Sp_Var;
var $lnrn=((($lnrm)-(16))|0);
var $lnro$0=$lnrn;
var $lnro$1=0;
var $lnrp=$lnro;
$Sp_Var=$lnrp;
var $lnrq=$Base_Var;
var $lnrr=$Sp_Var;
var $lnrs=$Hp_Var;
var $st$39$0=(($R1_Var)|0);
var $lnrt$0=HEAP32[(($st$39$0)>>2)];
var $st$39$1=(($R1_Var+4)|0);
var $lnrt$1=HEAP32[(($st$39$1)>>2)];
var $st$43$0=(($R2_Var)|0);
var $lnru$0=HEAP32[(($st$43$0)>>2)];
var $st$43$1=(($R2_Var+4)|0);
var $lnru$1=HEAP32[(($st$43$1)>>2)];
var $st$47$0=(($R3_Var)|0);
var $lnrv$0=HEAP32[(($st$47$0)>>2)];
var $st$47$1=(($R3_Var+4)|0);
var $lnrv$1=HEAP32[(($st$47$1)>>2)];
var $st$51$0=(($R4_Var)|0);
var $lnrw$0=HEAP32[(($st$51$0)>>2)];
var $st$51$1=(($R4_Var+4)|0);
var $lnrw$1=HEAP32[(($st$51$1)>>2)];
var $st$55$0=(($R5_Var)|0);
var $lnrx$0=HEAP32[(($st$55$0)>>2)];
var $st$55$1=(($R5_Var+4)|0);
var $lnrx$1=HEAP32[(($st$55$1)>>2)];
var $st$59$0=(($R6_Var)|0);
var $lnry$0=HEAP32[(($st$59$0)>>2)];
var $st$59$1=(($R6_Var+4)|0);
var $lnry$1=HEAP32[(($st$59$1)>>2)];
var $st$63$0=(($SpLim_Var)|0);
var $lnrz$0=HEAP32[(($st$63$0)>>2)];
var $st$63$1=(($SpLim_Var+4)|0);
var $lnrz$1=HEAP32[(($st$63$1)>>2)];
var $lnrA=$F1_Var;
var $lnrB=$F2_Var;
var $lnrC=$F3_Var;
var $lnrD=$F4_Var;
var $lnrE=$D1_Var;
var $lnrF=$D2_Var;
_stg_ap_p_fast($lnrq, $lnrr, $lnrs, $lnrt$0, $lnrt$1, $lnru$0, $lnru$1, $lnrv$0, $lnrv$1, $lnrw$0, $lnrw$1, $lnrx$0, $lnrx$1, $lnry$0, $lnry$1, $lnrz$0, $lnrz$1, $lnrA, $lnrB, $lnrC, $lnrD, $lnrE, $lnrF);
STACKTOP = __stackBase__;
return;
default: assert(0, "bad label: " + __label__);
}
}
_ZCMain_main_info["X"]=1;
// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
var i64Math = null;
var _newCAF; // stub for _newCAF
var _stg_ap_n_fast; // stub for _stg_ap_n_fast
var _stg_ap_pp_fast; // stub for _stg_ap_pp_fast
var _stg_ap_p_fast; // stub for _stg_ap_p_fast
function _memcpy(dest, src, num, align) {
assert(num % 1 === 0, 'memcpy given ' + num + ' bytes to copy. Problem with quantum=1 corrections perhaps?');
if (num >= 20 && src % 2 == dest % 2) {
// This is unaligned, but quite large, and potentially alignable, so work hard to get to aligned settings
if (src % 4 == dest % 4) {
var stop = src + num;
while (src % 4) { // no need to check for stop, since we have large num
HEAP8[dest++] = HEAP8[src++];
}
var src4 = src >> 2, dest4 = dest >> 2, stop4 = stop >> 2;
while (src4 < stop4) {
HEAP32[dest4++] = HEAP32[src4++];
}
src = src4 << 2;
dest = dest4 << 2;
while (src < stop) {
HEAP8[dest++] = HEAP8[src++];
}
} else {
var stop = src + num;
if (src % 2) { // no need to check for stop, since we have large num
HEAP8[dest++] = HEAP8[src++];
}
var src2 = src >> 1, dest2 = dest >> 1, stop2 = stop >> 1;
while (src2 < stop2) {
HEAP16[dest2++] = HEAP16[src2++];
}
src = src2 << 1;
dest = dest2 << 1;
if (src < stop) {
HEAP8[dest++] = HEAP8[src++];
}
}
} else {
while (num--) {
HEAP8[dest++] = HEAP8[src++];
}
}
}
function _memset(ptr, value, num, align) {
// TODO: make these settings, and in memcpy, {{'s
if (num >= 20) {
// This is unaligned, but quite large, so work hard to get to aligned settings
var stop = ptr + num;
while (ptr % 4) { // no need to check for stop, since we have large num
HEAP8[ptr++] = value;
}
if (value < 0) value += 256; // make it unsigned
var ptr4 = ptr >> 2, stop4 = stop >> 2, value4 = value | (value << 8) | (value << 16) | (value << 24);
while (ptr4 < stop4) {
HEAP32[ptr4++] = value4;
}
ptr = ptr4 << 2;
while (ptr < stop) {
HEAP8[ptr++] = value;
}
} else {
while (num--) {
HEAP8[ptr++] = value;
}
}
}
function _malloc(bytes) {
/* Over-allocate to make sure it is byte-aligned by 8.
* This will leak memory, but this is only the dummy
* implementation (replaced by dlmalloc normally) so
* not an issue.
*/
ptr = Runtime.staticAlloc(bytes + 8);
return (ptr+8) & 0xFFFFFFF8;
}
Module["_malloc"] = _malloc;
function _free(){}
Module["_free"] = _free;
var Browser={mainLoop:{scheduler:null,shouldPause:false,paused:false},pointerLock:false,moduleContextCreatedCallbacks:[],createContext:function (canvas, useWebGL, setInModule) {
try {
var ctx = canvas.getContext(useWebGL ? 'experimental-webgl' : '2d');
if (!ctx) throw ':(';
} catch (e) {
Module.print('Could not create canvas - ' + e);
return null;
}
if (useWebGL) {
// Set the background of the WebGL canvas to black
canvas.style.backgroundColor = "black";
// Warn on context loss
canvas.addEventListener('webglcontextlost', function(event) {
alert('WebGL context lost. You will need to reload the page.');
}, false);
}
if (setInModule) {
Module.ctx = ctx;
Module.useWebGL = useWebGL;
Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
}
return ctx;
},requestFullScreen:function () {
var canvas = Module.canvas;
function fullScreenChange() {
if (Module['onFullScreen']) Module['onFullScreen']();
if (document['webkitFullScreenElement'] === canvas ||
document['mozFullScreenElement'] === canvas ||
document['fullScreenElement'] === canvas) {
canvas.requestPointerLock = canvas['requestPointerLock'] ||
canvas['mozRequestPointerLock'] ||
canvas['webkitRequestPointerLock'];
canvas.requestPointerLock();
}
}
document.addEventListener('fullscreenchange', fullScreenChange, false);
document.addEventListener('mozfullscreenchange', fullScreenChange, false);
document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
function pointerLockChange() {
Browser.pointerLock = document['pointerLockElement'] === canvas ||
document['mozPointerLockElement'] === canvas ||
document['webkitPointerLockElement'] === canvas;
}
document.addEventListener('pointerlockchange', pointerLockChange, false);
document.addEventListener('mozpointerlockchange', pointerLockChange, false);
document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
canvas.requestFullScreen = canvas['requestFullScreen'] ||
canvas['mozRequestFullScreen'] ||
(canvas['webkitRequestFullScreen'] ? function() { canvas['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
canvas.requestFullScreen();
},requestAnimationFrame:function (func) {
if (!window.requestAnimationFrame) {
window.requestAnimationFrame = window['requestAnimationFrame'] ||
window['mozRequestAnimationFrame'] ||
window['webkitRequestAnimationFrame'] ||
window['msRequestAnimationFrame'] ||
window['oRequestAnimationFrame'] ||
window['setTimeout'];
}
window.requestAnimationFrame(func);
},getMovementX:function (event) {
return event['movementX'] ||
event['mozMovementX'] ||
event['webkitMovementX'] ||
0;
},getMovementY:function (event) {
return event['movementY'] ||
event['mozMovementY'] ||
event['webkitMovementY'] ||
0;
},xhrLoad:function (url, onload, onerror) {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.responseType = 'arraybuffer';
xhr.onload = function() {
if (xhr.status == 200) {
onload(xhr.response);
} else {
onerror();
}
};
xhr.onerror = onerror;
xhr.send(null);
},asyncLoad:function (url, callback) {
Browser.xhrLoad(url, function(arrayBuffer) {
assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
callback(new Uint8Array(arrayBuffer));
removeRunDependency();
}, function(event) {
throw 'Loading data file "' + url + '" failed.';
});
addRunDependency();
}};
Module["requestFullScreen"] = function() { Browser.requestFullScreen() };
// === Auto-generated postamble setup entry stuff ===
Module.callMain = function callMain(args) {
var argc = args.length+1;
function pad() {
for (var i = 0; i < 4-1; i++) {
argv.push(0);
}
}
var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_STATIC) ];
pad();
for (var i = 0; i < argc-1; i = i + 1) {
argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_STATIC));
pad();
}
argv.push(0);
argv = allocate(argv, 'i32', ALLOC_STATIC);
return _main(argc, argv, 0);
}
var ___stginit_Main;
var _sfT_srt;
var _ghczmprim_GHCziCString_unpackCStringzh_closure;
var _sfT_closure;
var _cg1_str;
var _Main_main_srt;
var _base_GHCziBase_zd_closure;
var _base_SystemziIO_putStrLn_closure;
var _Main_main_closure;
var _ZCMain_main_srt;
var _base_GHCziTopHandler_runMainIO_closure;
var _ZCMain_main_closure;
var _sfT_info_itable;
var _stg_CAF_BLACKHOLE_info;
var _stg_bh_upd_frame_info;
var _Main_main_info_itable;
var _ZCMain_main_info_itable;
var _llvm_used;
___stginit_Main=allocate([], [], ALLOC_STATIC);
_sfT_srt=allocate([[, 0, 0, 0, 0, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_sfT_closure=allocate([[, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_cg1_str=allocate([72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0], "i8", ALLOC_STATIC);
_Main_main_srt=allocate([[, 0, 0, 0, 0, 0, 0, 0, [, 0, 0, 0, 0, 0, 0, 0, [, 0, 0, 0, 0, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_Main_main_closure=allocate([[, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_ZCMain_main_srt=allocate([[, 0, 0, 0, 0, 0, 0, 0, [, 0, 0, 0, 0, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_ZCMain_main_closure=allocate([[, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_sfT_info_itable=allocate([0, 0, 0, 0, i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 1, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_Main_main_info_itable=allocate([0, 0, 0, 0, i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 7, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_ZCMain_main_info_itable=allocate([0, 0, 0, 0, i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 3, 0, 0, 0], ["i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0,"i64",0,0,0,"i32",0,0,0], ALLOC_STATIC);
_llvm_used=allocate(4, "*", ALLOC_STATIC);
HEAP32[(((_sfT_srt)+(4))>>2)]=(;
HEAP32[(((_Main_main_srt)+(4))>>2)]=(;
HEAP32[(((_Main_main_srt)+(12))>>2)]=(;
HEAP32[(((_Main_main_srt)+(20))>>2)]=(;
HEAP32[(((_ZCMain_main_srt)+(4))>>2)]=(;
HEAP32[(((_ZCMain_main_srt)+(12))>>2)]=(;
HEAP32[((_sfT_info_itable)>>2)]=(;
HEAP32[((_Main_main_info_itable)>>2)]=(;
HEAP32[((_ZCMain_main_info_itable)>>2)]=(;
HEAP32[((_llvm_used)>>2)]=_sfT_info_itable;
FUNCTION_TABLE = [0,0,_sfT_info,0,_Main_main_info,0,_ZCMain_main_info,0]; Module["FUNCTION_TABLE"] = FUNCTION_TABLE;
function run(args) {
args = args || Module['arguments'];
if (Module['preRun']) {
if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
while (Module['preRun'].length > 0) {
Module['preRun'].pop()();
if (runDependencies > 0) {
// preRun added a dependency, run will be called later
return 0;
}
}
}
function doRun() {
var ret = 0;
if (Module['_main']) {
preMain();
ret = Module.callMain(args);
if (!Module['noExitRuntime']) {
exitRuntime();
}
}
if (Module['postRun']) {
if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
while (Module['postRun'].length > 0) {
Module['postRun'].pop()();
}
}
return ret;
}
if (Module['setStatus']) {
Module['setStatus']('Running...');
setTimeout(function() {
setTimeout(function() {
Module['setStatus']('');
}, 1);
doRun();
}, 1);
return 0;
} else {
return doRun();
}
}
Module['run'] = run;
// {{PRE_RUN_ADDITIONS}}
initRuntime();
if (Module['noInitialRun']) {
addRunDependency();
}
if (runDependencies == 0) {
var ret = run();
}
// {{POST_RUN_ADDITIONS}}
// {{MODULE_ADDITIONS}}
// EMSCRIPTEN_GENERATED_FUNCTIONS: ["_sfT_info","_Main_main_info","_ZCMain_main_info"]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment