// This object will hold all exports.
var Haste = {};
/* Thunk
Creates a thunk representing the given closure.
Since we want automatic memoization of as many expressions as possible, we
use a JS object as a sort of tagged pointer, where the member x denotes the
object actually pointed to. If a "pointer" points to a thunk, it has a
member 't' which is set to true; if it points to a value, be it a function,
a value of an algebraic type of a primitive value, it has no member 't'.
*/
function T(f) {
this.f = new F(f);
}
function F(f) {
this.f = f;
}
/* Apply
Applies the function f to the arguments args. If the application is under-
saturated, a closure is returned, awaiting further arguments. If it is over-
saturated, the function is fully applied, and the result (assumed to be a
function) is then applied to the remaining arguments.
*/
function A(f, args) {
if(f instanceof T) {
f = E(f);
}
// Closure does some funny stuff with functions that occasionally
// results in non-functions getting applied, so we have to deal with
// it.
if(!(f instanceof Function)) {
f = B(f);
if(!(f instanceof Function)) {
return f;
}
}
if(f.arity === undefined) {
f.arity = f.length;
}
if(args.length === f.arity) {
switch(f.arity) {
case 0: return f();
case 1: return f(args[0]);
default: return f.apply(null, args);
}
} else if(args.length > f.arity) {
switch(f.arity) {
case 0: return f();
case 1: return A(f(args.shift()), args);
default: return A(f.apply(null, args.splice(0, f.arity)), args);
}
} else {
var g = function() {
return A(f, args.concat(Array.prototype.slice.call(arguments)));
};
g.arity = f.arity - args.length;
return g;
}
}
/* Eval
Evaluate the given thunk t into head normal form.
If the "thunk" we get isn't actually a thunk, just return it.
*/
function E(t) {
if(t instanceof T) {
if(t.f instanceof F) {
return t.f = t.f.f();
} else {
return t.f;
}
} else {
return t;
}
}
/* Bounce
Bonuce on a trampoline for as long as we get a function back.
*/
function B(f) {
while(f instanceof F) {
f = f.f();
}
return f;
}
// Export Haste, A and E. Haste because we need to preserve exports, A and E
// because they're handy for Haste.Foreign.
if(!window) {
var window = {};
}
window['Haste'] = Haste;
window['A'] = A;
window['E'] = E;
/* Throw an error.
We need to be able to use throw as an exception so we wrap it in a function.
*/
function die(err) {
throw err;
}
function quot(a, b) {
return (a-a%b)/b;
}
function quotRemI(a, b) {
return [0, (a-a%b)/b, a%b];
}
// 32 bit integer multiplication, with correct overflow behavior
// note that |0 or >>>0 needs to be applied to the result, for int and word
// respectively.
function imul(a, b) {
// ignore high a * high a as the result will always be truncated
var lows = (a & 0xffff) * (b & 0xffff); // low a * low b
var aB = (a & 0xffff) * (b & 0xffff0000); // low a * high b
var bA = (a & 0xffff0000) * (b & 0xffff); // low b * high a
return lows + aB + bA; // sum will not exceed 52 bits, so it's safe
}
function addC(a, b) {
var x = a+b;
return [0, x & 0xffffffff, x > 0x7fffffff];
}
function subC(a, b) {
var x = a-b;
return [0, x & 0xffffffff, x < -2147483648];
}
function sinh (arg) {
return (Math.exp(arg) - Math.exp(-arg)) / 2;
}
function tanh (arg) {
return (Math.exp(arg) - Math.exp(-arg)) / (Math.exp(arg) + Math.exp(-arg));
}
function cosh (arg) {
return (Math.exp(arg) + Math.exp(-arg)) / 2;
}
// Scratch space for byte arrays.
var rts_scratchBuf = new ArrayBuffer(8);
var rts_scratchW32 = new Uint32Array(rts_scratchBuf);
var rts_scratchFloat = new Float32Array(rts_scratchBuf);
var rts_scratchDouble = new Float64Array(rts_scratchBuf);
function decodeFloat(x) {
rts_scratchFloat[0] = x;
var sign = x < 0 ? -1 : 1;
var exp = ((rts_scratchW32[0] >> 23) & 0xff) - 150;
var man = rts_scratchW32[0] & 0x7fffff;
if(exp === 0) {
++exp;
} else {
man |= (1 << 23);
}
return [0, sign*man, exp];
}
function decodeDouble(x) {
rts_scratchDouble[0] = x;
var sign = x < 0 ? -1 : 1;
var manHigh = rts_scratchW32[1] & 0xfffff;
var manLow = rts_scratchW32[0];
var exp = ((rts_scratchW32[1] >> 20) & 0x7ff) - 1075;
if(exp === 0) {
++exp;
} else {
manHigh |= (1 << 20);
}
return [0, sign, manHigh, manLow, exp];
}
function isFloatFinite(x) {
return isFinite(x);
}
function isDoubleFinite(x) {
return isFinite(x);
}
function err(str) {
die(toJSStr(str));
}
/* unpackCString#
NOTE: update constructor tags if the code generator starts munging them.
*/
function unCStr(str) {return unAppCStr(str, [0]);}
function unFoldrCStr(str, f, z) {
var acc = z;
for(var i = str.length-1; i >= 0; --i) {
acc = A(f, [[0, str.charCodeAt(i)], acc]);
}
return acc;
}
function unAppCStr(str, chrs) {
var i = arguments[2] ? arguments[2] : 0;
if(i >= str.length) {
return E(chrs);
} else {
return [1,[0,str.charCodeAt(i)],new T(function() {
return unAppCStr(str,chrs,i+1);
})];
}
}
function charCodeAt(str, i) {return str.charCodeAt(i);}
function fromJSStr(str) {
return unCStr(E(str));
}
function toJSStr(hsstr) {
var s = '';
for(var str = E(hsstr); str[0] == 1; str = E(str[2])) {
s += String.fromCharCode(E(str[1])[1]);
}
return s;
}
// newMutVar
function nMV(val) {
return ({x: val});
}
// readMutVar
function rMV(mv) {
return mv.x;
}
// writeMutVar
function wMV(mv, val) {
mv.x = val;
}
// atomicModifyMutVar
function mMV(mv, f) {
var x = A(f, [mv.x]);
mv.x = x[1];
return x[2];
}
function localeEncoding() {
var le = newByteArr(5);
le['b']['i8'] = 'U'.charCodeAt(0);
le['b']['i8'] = 'T'.charCodeAt(0);
le['b']['i8'] = 'F'.charCodeAt(0);
le['b']['i8'] = '-'.charCodeAt(0);
le['b']['i8'] = '8'.charCodeAt(0);
return le;
}
var isDoubleNaN = isNaN;
var isFloatNaN = isNaN;
function isDoubleInfinite(d) {
return (d === Infinity);
}
var isFloatInfinite = isDoubleInfinite;
function isDoubleNegativeZero(x) {
return (x===0 && (1/x)===-Infinity);
}
var isFloatNegativeZero = isDoubleNegativeZero;
function strEq(a, b) {
return a == b;
}
function strOrd(a, b) {
if(a < b) {
return [0];
} else if(a == b) {
return [1];
}
return [2];
}
function jsCatch(act, handler) {
try {
return A(act,[0]);
} catch(e) {
return A(handler,[e, 0]);
}
}
/* Haste represents constructors internally using 1 for the first constructor,
2 for the second, etc.
However, dataToTag should use 0, 1, 2, etc. Also, booleans might be unboxed.
*/
function dataToTag(x) {
if(x instanceof Array) {
return x[0];
} else {
return x;
}
}
function __word_encodeDouble(d, e) {
return d * Math.pow(2,e);
}
var __word_encodeFloat = __word_encodeDouble;
var jsRound = Math.round; // Stupid GHC doesn't like periods in FFI IDs...
var realWorld = undefined;
if(typeof _ == 'undefined') {
var _ = undefined;
}
function popCnt(i) {
i = i - ((i >> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}