Skip to content

Instantly share code, notes, and snippets.

@luite

luite/fib35.js

Created September 24, 2012 22:06
Show Gist options
  • Save luite/3778732 to your computer and use it in GitHub Desktop.
Save luite/3778732 to your computer and use it in GitHub Desktop.
Download ZIP
calculates 35th fibonacci number
Raw
fib35.js
/*
StgRec [
( Fibs.$wfib,StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [ww]
( StgCase
( StgApp ww []
)
UniqSet UniqSet ds SRT Prim GHC.Prim.Int# [
( DEFAULT,[],[],StgCase
( StgOpApp
( StgPrimOp IntSubOp
)
[StgVarArg ds :: GHC.Prim.Int#,StgLitArg MachInt 1] GHC.Prim.Int#
)
UniqSet UniqSet sat_sqC SRT Prim GHC.Prim.Int# [
( DEFAULT,[],[],StgCase
( StgApp Fibs.$wfib [StgVarArg sat_sqC :: GHC.Prim.Int#]
)
UniqSet UniqSet ww1 SRT Prim GHC.Prim.Int# [
( DEFAULT,[],[],StgCase
( StgOpApp
( StgPrimOp IntSubOp
)
[StgVarArg ds :: GHC.Prim.Int#,StgLitArg MachInt 2] GHC.Prim.Int#
)
UniqSet UniqSet sat_sqB SRT Prim GHC.Prim.Int# [
( DEFAULT,[],[],StgCase
( StgApp Fibs.$wfib [StgVarArg sat_sqB :: GHC.Prim.Int#]
)
UniqSet UniqSet ww2 SRT Prim GHC.Prim.Int# [
( DEFAULT,[],[],StgOpApp
( StgPrimOp IntAddOp
)
[StgVarArg ww1 :: GHC.Prim.Int#,StgVarArg ww2 :: GHC.Prim.Int#] GHC.Prim.Int#
)
]
)
]
)
]
)
]
)
,
( LitAlt
( MachInt 0
)
,[],[],StgLit
( MachInt 0
)
)
,
( LitAlt
( MachInt 1
)
,[],[],StgLit
( MachInt 1
)
)
]
)
)
]
*/
/*
StgNonRec Fibs.fib
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [w]
( StgCase
( StgApp w []
)
UniqSet UniqSet w1 SRT Alg GHC.Types.Int [
( DataAlt GHC.Types.I#,[ww],[True],StgCase
( StgApp Fibs.$wfib [StgVarArg ww :: GHC.Prim.Int#]
)
UniqSet UniqSet ww1 SRT Prim GHC.Prim.Int# [
( DEFAULT,[],[],StgConApp GHC.Types.I# [StgVarArg ww1 :: GHC.Prim.Int#]
)
]
)
]
)
)
*/
/*
StgNonRec Fibs.main1
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [eta]
( StgCase
( StgApp Fibs.$wfib [StgLitArg MachInt 35]
)
UniqSet UniqSet ww SRT Prim GHC.Prim.Int# [
( DEFAULT,[],[],StgLet
( StgNonRec sat_sr4
( StgRhsCon CostCentreStack GHC.Types.I# [StgVarArg ww :: GHC.Prim.Int#]
)
)
( StgConApp
( #,#
)
[StgVarArg eta :: GHC.Prim.State# GHC.Prim.RealWorld,StgVarArg sat_sr4 :: GHC.Types.Int]
)
)
]
)
)
*/
/*
StgNonRec Fibs.main
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [eta_B1]
( StgApp Fibs.main1 [StgVarArg eta_B1 :: GHC.Prim.State# GHC.Prim.RealWorld]
)
)
*/
var RTS_0;
var getGlbl;
getGlbl = (function()
{
RTS_0 = this;
});
getGlbl();
var log;
log = (function()
{
if((RTS_0.console && RTS_0.console.log))
{
RTS_0.console.log.apply(RTS_0.console, arguments);
}
else
{
RTS_0.print.apply(this, arguments);
};
});
var stack;
stack = [];
var RTS_1;
RTS_1 = 0;
while((RTS_1 < 400))
{
stack.push(0);
RTS_1++;
};
var heap;
heap = [];
var RTS_2;
RTS_2 = 0;
while((RTS_2 < 200000))
{
heap.push(0);
RTS_2++;
};
var hpDyn;
hpDyn = 10000;
var hpS;
hpS = 2;
var hp;
hp = hpDyn;
var hpOld;
hpOld = hpDyn;
var hpForward;
hpForward = [];
var staticForward;
staticForward = [];
var initStatic;
initStatic = [];
var sp;
sp = 0;
var staticFree;
staticFree = 2000;
var allocArea;
allocArea = 2444440;
var hpLim;
hpLim = (hpDyn + allocArea);
var gcInc;
gcInc = 10;
var gcIncCurrent;
gcIncCurrent = gcInc;
var r1;
var r2;
var r3;
var r4;
var r5;
var r6;
var r7;
var r8;
var r9;
var r10;
var r11;
var r12;
var r13;
var r14;
var r15;
var r16;
var r17;
var r18;
var r19;
var r20;
var r21;
var r22;
var r23;
var r24;
var r25;
var r26;
var r27;
var r28;
var r29;
var r30;
var r31;
var r32;
var blackhole;
blackhole = (function()
{
throw("<<loop>>");
return 0;
});
blackhole.i = [2, "blackhole"];
blackhole.gi = [2];
blackhole.gtag = 2;
blackhole.gai = [];
blackhole.t = 16;
var done;
done = (function()
{
return done;
});
done.i = [1, "done"];
done.gi = [1];
done.gtag = 1;
done.gai = [1];
var false_e;
false_e = (function()
{
return stack[sp];
});
false_e.i = [1, "GHC.Types.False"];
false_e.gtag = 1;
false_e.gai = [];
false_e.gi = [1];
false_e.a = 1;
false_e.t = 5;
var true_e;
true_e = (function()
{
return stack[sp];
});
true_e.i = [1, "GHC.Types.True"];
true_e.gtag = 1;
true_e.gai = [];
true_e.gi = [1];
true_e.a = 2;
true_e.t = 5;
heap[0] = false_e;
var $hs_GHCziTypesziFalse;
$hs_GHCziTypesziFalse = 0;
heap[1] = true_e;
var $hs_GHCziTypesziTrue;
$hs_GHCziTypesziTrue = 1;
var reduce;
reduce = (function()
{
if(heap[r1].t)
{
do
{
switch (heap[r1].t)
{
case (10):
return heap[r1];
case (14):
r1 = heap[(r1 + 1)];
continue;
default:
sp = (sp - 1);
return stack[sp];
};
}
while (true);
}
else
{
sp = (sp - 1);
return stack[sp];
};
});
reduce.i = [1, "reduce"];
reduce.gai = [1];
reduce.gi = [1];
reduce.gtag = 1;
var gc_check;
gc_check = (function(RTS_3)
{
if((hp > hpLim))
{
if((true || (gcIncCurrent <= 0)))
{
hp = gc(heap, hp, stack, sp, RTS_3, hpDyn, hpOld, true);
hpForward = [];
gcIncCurrent = gcInc;
}
else
{
hp = gc(heap, hp, stack, sp, RTS_3, hpDyn, hpOld, false);
gcIncCurrent--;
};
hpOld = hp;
hpLim = (hp + allocArea);
heap[(hpLim + 1000)] = 0;
};
});
var static_fun;
static_fun = (function(RTS_4, RTS_5, RTS_6)
{
if(((hpS + 1) >= hpDyn))
{
run_gc();
};
var RTS_7;
RTS_7 = hpS;
heap[hpS++] = RTS_4;
RTS_4.a = RTS_5;
RTS_4.t = 3;
RTS_4.i = [1, RTS_6];
RTS_4.gi = [1];
RTS_4.gtag = 1;
return RTS_7;
});
var static_thunk;
static_thunk = (function(RTS_8, RTS_9)
{
if(((hpS + 2) >= hpDyn))
{
run_gc();
};
var RTS_10;
RTS_10 = hpS;
heap[hpS] = RTS_8;
hpS = (hpS + 2);
RTS_8.t = 10;
RTS_8.i = [2, RTS_9];
RTS_8.gi = [2];
RTS_8.gtag = 2;
return RTS_10;
});
var printcl;
printcl = (function(RTS_11)
{
var RTS_12;
RTS_12 = heap[RTS_11];
var RTS_13;
RTS_13 = "";
switch (RTS_12.t)
{
case (10):
RTS_13 = (RTS_13 + "thunk");
break;
case (5):
RTS_13 = (RTS_13 + (("con[" + RTS_12.a) + "]"));
break;
case (12):
RTS_13 = (RTS_13 + (("pap[" + RTS_12.a) + "]"));
break;
case (3):
RTS_13 = (RTS_13 + (("fun[" + RTS_12.a) + "]"));
break;
default:
RTS_13 = (RTS_13 + "unknown closure type");
break;
};
RTS_13 = (RTS_13 + ((" :: " + RTS_12.i[1]) + " ->"));
var RTS_14;
RTS_14 = (RTS_11 + 1);
var RTS_15;
RTS_15 = 2;
while((RTS_15 < RTS_12.i.length))
{
RTS_13 = (RTS_13 + " ");
switch (RTS_12.i[RTS_15])
{
case (0):
RTS_13 = (RTS_13
+
(((("[" + heap[RTS_14]) + " :: ") + heap[heap[RTS_14]].i[1]) + "]"));
RTS_14++;
break;
case (1):
RTS_13 = (RTS_13 + "void");
break;
case (2):
RTS_13 = (RTS_13 + (("(" + heap[RTS_14]) + " :: double)"));
RTS_14++;
break;
case (3):
RTS_13 = (RTS_13 + (("(" + heap[RTS_14]) + " :: int)"));
RTS_14++;
break;
case (4):
RTS_13 = (RTS_13
+
(((("(" + heap[RTS_14]) + ",") + heap[(RTS_14 + 1)]) + " :: long)"));
RTS_14 = (RTS_14 + 2);
break;
case (5):
RTS_13 = (RTS_13
+
(((("(" + heap[RTS_14].length) + ",") + heap[(RTS_14 + 1)]) + " :: ptr)"));
RTS_14 = (RTS_14 + 2);
break;
default:
};
RTS_15++;
};
log(RTS_13);
});
var static_con0;
static_con0 = (function(RTS_16)
{
if(((hpS + 1) >= hpDyn))
{
run_gc();
};
var RTS_17;
RTS_17 = hpS;
heap[hpS++] = RTS_16;
return RTS_17;
});
var static_con;
static_con = (function(RTS_18, RTS_19)
{
if((((hpS + 1) + RTS_19.length) >= hpDyn))
{
run_gc();
};
var RTS_20;
RTS_20 = hpS;
var RTS_21;
RTS_21 = RTS_19.length;
heap[RTS_20] = RTS_18;
var RTS_22;
RTS_22 = 0;
while((RTS_22 < RTS_21))
{
heap[((hpS + RTS_22) + 1)] = RTS_19[RTS_22];
RTS_22++;
};
hpS = (hpS + (RTS_21 + 1));
return RTS_20;
});
var alloc_static;
alloc_static = (function(RTS_23)
{
if(((hpS + RTS_23) >= hpDyn))
{
run_gc();
};
var RTS_24;
RTS_24 = hpS;
hpS = (hpS + RTS_23);
return RTS_24;
});
var init_closure;
init_closure = (function(RTS_25, RTS_26, RTS_27)
{
heap[RTS_25] = RTS_26;
var RTS_28;
RTS_28 = (RTS_27.length - 1);
while((RTS_28 >= 0))
{
heap[((RTS_25 + RTS_28) + 1)] = RTS_27[RTS_28];
RTS_28--;
};
});
var run_init_static;
run_init_static = (function()
{
if((initStatic.length == 0))
{
return null;
};
var RTS_29;
RTS_29 = (initStatic.length - 1);
while((RTS_29 >= 0))
{
initStatic[RTS_29]();
RTS_29--;
};
initStatic = [];
});
var logCall;
logCall = (function(RTS_30)
{
var RTS_31;
RTS_31 = RTS_30;
if(RTS_30.i)
{
RTS_31 = RTS_30.i[1];
};
log(((((("trampoline calling: " + RTS_31) + " ")
+
JSON.stringify([r1, r2, r3, r4, r5]))
+
" hp: ")
+
hp));
});
var runhs;
runhs = (function(RTS_32, RTS_33)
{
log("runhs");
run_init_static();
stack[0] = done;
stack[1] = reduce;
sp = 1;
var RTS_34;
RTS_34 = heap[RTS_32];
r1 = RTS_32;
while((RTS_34 !== done))
{
RTS_34 = RTS_34();
RTS_34 = RTS_34();
RTS_34 = RTS_34();
RTS_34 = RTS_34();
RTS_34 = RTS_34();
RTS_34 = RTS_34();
RTS_34 = RTS_34();
RTS_34 = RTS_34();
RTS_34 = RTS_34();
gc_check(RTS_34);
};
while((r1.t === 14))
{
r1 = heap[(r1 + 1)];
};
RTS_33(r1);
});
var stg_ap_1;
stg_ap_1 = (function()
{
do
{
var RTS_35;
RTS_35 = heap[r1];
switch (RTS_35.t)
{
case (10):
stack[sp] = stg_ap_1;
return RTS_35;
case (3):
switch (RTS_35.a)
{
case (1):
sp = (sp - 1);
r2 = stack[sp];
sp = (sp - 1);
return RTS_35;
default:
var RTS_37;
RTS_37 = RTS_35.a;
var RTS_36;
RTS_36 = (hp + 0);
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = RTS_35;
heap[(hp + 1)] = (RTS_37 - 1);
heap[hp] = stg_pap_1;
hp = (hp + 4);
r1 = RTS_36;
sp = (sp - 2);
return stack[sp];
};
case (12):
var RTS_39;
RTS_39 = heap[(r1 + 1)];
if((1 === RTS_39))
{
sp = (sp - 1);
r2 = stack[sp];
sp = (sp - 1);
return RTS_35;
}
else
{
if((1 < RTS_39))
{
var RTS_38;
RTS_38 = (hp + 0);
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = r1;
heap[(hp + 1)] = (RTS_39 - 1);
heap[hp] = stg_pap_1;
hp = (hp + 4);
r1 = RTS_38;
sp = (sp - 2);
return stack[sp];
}
else
{
log(((("n: " + 1) + " ca: ") + RTS_39));
throw("unimplemented pap oversat");
};
};
case (14):
r1 = heap[(r1 + 1)];
continue;
default:
log(("panic: stg_ap, unexpected closure type: " + RTS_35.t));
throw("stg_ap");
};
}
while (true);
});
stg_ap_1.t = 3;
stg_ap_1.a = 0;
stg_ap_1.i = [2, "stg_ap_1"];
stg_ap_1.gi = [2, 1];
stg_ap_1.gtag = 258;
stg_ap_1.gai = [1];
var stg_ap_2;
stg_ap_2 = (function()
{
do
{
var RTS_40;
RTS_40 = heap[r1];
switch (RTS_40.t)
{
case (10):
stack[sp] = stg_ap_2;
return RTS_40;
case (3):
switch (RTS_40.a)
{
case (1):
throw("oversat");
case (2):
sp = (sp - 1);
r3 = stack[sp];
r2 = stack[(sp - 1)];
sp = (sp - 2);
return RTS_40;
default:
var RTS_42;
RTS_42 = RTS_40.a;
var RTS_41;
RTS_41 = (hp + 0);
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = RTS_40;
heap[(hp + 1)] = (RTS_42 - 2);
heap[hp] = stg_pap_2;
hp = (hp + 5);
r1 = RTS_41;
sp = (sp - 3);
return stack[sp];
};
case (12):
var RTS_44;
RTS_44 = heap[(r1 + 1)];
if((2 === RTS_44))
{
sp = (sp - 1);
r3 = stack[sp];
r2 = stack[(sp - 1)];
sp = (sp - 2);
return RTS_40;
}
else
{
if((2 < RTS_44))
{
var RTS_43;
RTS_43 = (hp + 0);
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = r1;
heap[(hp + 1)] = (RTS_44 - 2);
heap[hp] = stg_pap_2;
hp = (hp + 5);
r1 = RTS_43;
sp = (sp - 3);
return stack[sp];
}
else
{
log(((("n: " + 2) + " ca: ") + RTS_44));
throw("unimplemented pap oversat");
};
};
case (14):
r1 = heap[(r1 + 1)];
continue;
default:
log(("panic: stg_ap, unexpected closure type: " + RTS_40.t));
throw("stg_ap");
};
}
while (true);
});
stg_ap_2.t = 3;
stg_ap_2.a = 0;
stg_ap_2.i = [3, "stg_ap_2"];
stg_ap_2.gi = [3, 1, 2];
stg_ap_2.gtag = 771;
stg_ap_2.gai = [1];
var stg_ap_3;
stg_ap_3 = (function()
{
do
{
var RTS_45;
RTS_45 = heap[r1];
switch (RTS_45.t)
{
case (10):
stack[sp] = stg_ap_3;
return RTS_45;
case (3):
switch (RTS_45.a)
{
case (1):
throw("oversat");
case (2):
throw("oversat");
case (3):
sp = (sp - 1);
r4 = stack[sp];
r3 = stack[(sp - 1)];
r2 = stack[(sp - 2)];
sp = (sp - 3);
return RTS_45;
default:
var RTS_47;
RTS_47 = RTS_45.a;
var RTS_46;
RTS_46 = (hp + 0);
heap[(hp + 5)] = stack[(sp - 3)];
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = RTS_45;
heap[(hp + 1)] = (RTS_47 - 3);
heap[hp] = stg_pap_3;
hp = (hp + 6);
r1 = RTS_46;
sp = (sp - 4);
return stack[sp];
};
case (12):
var RTS_49;
RTS_49 = heap[(r1 + 1)];
if((3 === RTS_49))
{
sp = (sp - 1);
r4 = stack[sp];
r3 = stack[(sp - 1)];
r2 = stack[(sp - 2)];
sp = (sp - 3);
return RTS_45;
}
else
{
if((3 < RTS_49))
{
var RTS_48;
RTS_48 = (hp + 0);
heap[(hp + 5)] = stack[(sp - 3)];
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = r1;
heap[(hp + 1)] = (RTS_49 - 3);
heap[hp] = stg_pap_3;
hp = (hp + 6);
r1 = RTS_48;
sp = (sp - 4);
return stack[sp];
}
else
{
log(((("n: " + 3) + " ca: ") + RTS_49));
throw("unimplemented pap oversat");
};
};
case (14):
r1 = heap[(r1 + 1)];
continue;
default:
log(("panic: stg_ap, unexpected closure type: " + RTS_45.t));
throw("stg_ap");
};
}
while (true);
});
stg_ap_3.t = 3;
stg_ap_3.a = 0;
stg_ap_3.i = [4, "stg_ap_3"];
stg_ap_3.gi = [4, 1, 2, 3];
stg_ap_3.gtag = 1796;
stg_ap_3.gai = [1];
var stg_ap_4;
stg_ap_4 = (function()
{
do
{
var RTS_50;
RTS_50 = heap[r1];
switch (RTS_50.t)
{
case (10):
stack[sp] = stg_ap_4;
return RTS_50;
case (3):
switch (RTS_50.a)
{
case (1):
throw("oversat");
case (2):
throw("oversat");
case (3):
throw("oversat");
case (4):
sp = (sp - 1);
r5 = stack[sp];
r4 = stack[(sp - 1)];
r3 = stack[(sp - 2)];
r2 = stack[(sp - 3)];
sp = (sp - 4);
return RTS_50;
default:
var RTS_52;
RTS_52 = RTS_50.a;
var RTS_51;
RTS_51 = (hp + 0);
heap[(hp + 6)] = stack[(sp - 4)];
heap[(hp + 5)] = stack[(sp - 3)];
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = RTS_50;
heap[(hp + 1)] = (RTS_52 - 4);
heap[hp] = stg_pap_4;
hp = (hp + 7);
r1 = RTS_51;
sp = (sp - 5);
return stack[sp];
};
case (12):
var RTS_54;
RTS_54 = heap[(r1 + 1)];
if((4 === RTS_54))
{
sp = (sp - 1);
r5 = stack[sp];
r4 = stack[(sp - 1)];
r3 = stack[(sp - 2)];
r2 = stack[(sp - 3)];
sp = (sp - 4);
return RTS_50;
}
else
{
if((4 < RTS_54))
{
var RTS_53;
RTS_53 = (hp + 0);
heap[(hp + 6)] = stack[(sp - 4)];
heap[(hp + 5)] = stack[(sp - 3)];
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = r1;
heap[(hp + 1)] = (RTS_54 - 4);
heap[hp] = stg_pap_4;
hp = (hp + 7);
r1 = RTS_53;
sp = (sp - 5);
return stack[sp];
}
else
{
log(((("n: " + 4) + " ca: ") + RTS_54));
throw("unimplemented pap oversat");
};
};
case (14):
r1 = heap[(r1 + 1)];
continue;
default:
log(("panic: stg_ap, unexpected closure type: " + RTS_50.t));
throw("stg_ap");
};
}
while (true);
});
stg_ap_4.t = 3;
stg_ap_4.a = 0;
stg_ap_4.i = [5, "stg_ap_4"];
stg_ap_4.gi = [5, 1, 2, 3, 4];
stg_ap_4.gtag = 3845;
stg_ap_4.gai = [1];
var stg_ap_5;
stg_ap_5 = (function()
{
do
{
var RTS_55;
RTS_55 = heap[r1];
switch (RTS_55.t)
{
case (10):
stack[sp] = stg_ap_5;
return RTS_55;
case (3):
switch (RTS_55.a)
{
case (1):
throw("oversat");
case (2):
throw("oversat");
case (3):
throw("oversat");
case (4):
throw("oversat");
case (5):
sp = (sp - 1);
r6 = stack[sp];
r5 = stack[(sp - 1)];
r4 = stack[(sp - 2)];
r3 = stack[(sp - 3)];
r2 = stack[(sp - 4)];
sp = (sp - 5);
return RTS_55;
default:
var RTS_57;
RTS_57 = RTS_55.a;
var RTS_56;
RTS_56 = (hp + 0);
heap[(hp + 7)] = stack[(sp - 5)];
heap[(hp + 6)] = stack[(sp - 4)];
heap[(hp + 5)] = stack[(sp - 3)];
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = RTS_55;
heap[(hp + 1)] = (RTS_57 - 5);
heap[hp] = stg_pap_5;
hp = (hp + 8);
r1 = RTS_56;
sp = (sp - 6);
return stack[sp];
};
case (12):
var RTS_59;
RTS_59 = heap[(r1 + 1)];
if((5 === RTS_59))
{
sp = (sp - 1);
r6 = stack[sp];
r5 = stack[(sp - 1)];
r4 = stack[(sp - 2)];
r3 = stack[(sp - 3)];
r2 = stack[(sp - 4)];
sp = (sp - 5);
return RTS_55;
}
else
{
if((5 < RTS_59))
{
var RTS_58;
RTS_58 = (hp + 0);
heap[(hp + 7)] = stack[(sp - 5)];
heap[(hp + 6)] = stack[(sp - 4)];
heap[(hp + 5)] = stack[(sp - 3)];
heap[(hp + 4)] = stack[(sp - 2)];
heap[(hp + 3)] = stack[(sp - 1)];
heap[(hp + 2)] = r1;
heap[(hp + 1)] = (RTS_59 - 5);
heap[hp] = stg_pap_5;
hp = (hp + 8);
r1 = RTS_58;
sp = (sp - 6);
return stack[sp];
}
else
{
log(((("n: " + 5) + " ca: ") + RTS_59));
throw("unimplemented pap oversat");
};
};
case (14):
r1 = heap[(r1 + 1)];
continue;
default:
log(("panic: stg_ap, unexpected closure type: " + RTS_55.t));
throw("stg_ap");
};
}
while (true);
});
stg_ap_5.t = 3;
stg_ap_5.a = 0;
stg_ap_5.i = [6, "stg_ap_5"];
stg_ap_5.gi = [6, 1, 2, 3, 4, 5];
stg_ap_5.gtag = 7942;
stg_ap_5.gai = [1];
var stg_ap_1_fast;
stg_ap_1_fast = (function()
{
var RTS_60;
RTS_60 = heap[r1];
if((RTS_60.t === 3))
{
switch (RTS_60.a)
{
case (1):
return RTS_60;
default:
sp = (sp + 2);
stack[sp] = stg_ap_1;
stack[(sp - 1)] = r2;
return stg_ap_1();
};
}
else
{
sp = (sp + 2);
stack[sp] = stg_ap_1;
stack[(sp - 1)] = r2;
return stg_ap_1();
};
});
var stg_ap_2_fast;
stg_ap_2_fast = (function()
{
var RTS_61;
RTS_61 = heap[r1];
if((RTS_61.t === 3))
{
switch (RTS_61.a)
{
case (1):
sp = (sp + 3);
stack[sp] = stg_ap_1;
stack[(sp - 1)] = r2;
stack[(sp - 2)] = r3;
return RTS_61;
case (2):
return RTS_61;
default:
sp = (sp + 3);
stack[sp] = stg_ap_2;
stack[(sp - 1)] = r3;
stack[(sp - 2)] = r2;
return stg_ap_2();
};
}
else
{
sp = (sp + 3);
stack[sp] = stg_ap_2;
stack[(sp - 1)] = r3;
stack[(sp - 2)] = r2;
return stg_ap_2();
};
});
var stg_ap_3_fast;
stg_ap_3_fast = (function()
{
var RTS_62;
RTS_62 = heap[r1];
if((RTS_62.t === 3))
{
switch (RTS_62.a)
{
case (1):
sp = (sp + 4);
stack[sp] = stg_ap_2;
stack[(sp - 1)] = r2;
stack[(sp - 2)] = r3;
stack[(sp - 3)] = r4;
return RTS_62;
case (2):
sp = (sp + 3);
stack[sp] = stg_ap_1;
stack[(sp - 1)] = r3;
stack[(sp - 2)] = r4;
return RTS_62;
case (3):
return RTS_62;
default:
sp = (sp + 4);
stack[sp] = stg_ap_3;
stack[(sp - 1)] = r4;
stack[(sp - 2)] = r3;
stack[(sp - 3)] = r2;
return stg_ap_3();
};
}
else
{
sp = (sp + 4);
stack[sp] = stg_ap_3;
stack[(sp - 1)] = r4;
stack[(sp - 2)] = r3;
stack[(sp - 3)] = r2;
return stg_ap_3();
};
});
var stg_ap_4_fast;
stg_ap_4_fast = (function()
{
var RTS_63;
RTS_63 = heap[r1];
if((RTS_63.t === 3))
{
switch (RTS_63.a)
{
case (1):
sp = (sp + 5);
stack[sp] = stg_ap_3;
stack[(sp - 1)] = r2;
stack[(sp - 2)] = r3;
stack[(sp - 3)] = r4;
stack[(sp - 4)] = r5;
return RTS_63;
case (2):
sp = (sp + 4);
stack[sp] = stg_ap_2;
stack[(sp - 1)] = r3;
stack[(sp - 2)] = r4;
stack[(sp - 3)] = r5;
return RTS_63;
case (3):
sp = (sp + 3);
stack[sp] = stg_ap_1;
stack[(sp - 1)] = r4;
stack[(sp - 2)] = r5;
return RTS_63;
case (4):
return RTS_63;
default:
sp = (sp + 5);
stack[sp] = stg_ap_4;
stack[(sp - 1)] = r5;
stack[(sp - 2)] = r4;
stack[(sp - 3)] = r3;
stack[(sp - 4)] = r2;
return stg_ap_4();
};
}
else
{
sp = (sp + 5);
stack[sp] = stg_ap_4;
stack[(sp - 1)] = r5;
stack[(sp - 2)] = r4;
stack[(sp - 3)] = r3;
stack[(sp - 4)] = r2;
return stg_ap_4();
};
});
var stg_ap_5_fast;
stg_ap_5_fast = (function()
{
var RTS_64;
RTS_64 = heap[r1];
if((RTS_64.t === 3))
{
switch (RTS_64.a)
{
case (1):
sp = (sp + 6);
stack[sp] = stg_ap_4;
stack[(sp - 1)] = r2;
stack[(sp - 2)] = r3;
stack[(sp - 3)] = r4;
stack[(sp - 4)] = r5;
stack[(sp - 5)] = r6;
return RTS_64;
case (2):
sp = (sp + 5);
stack[sp] = stg_ap_3;
stack[(sp - 1)] = r3;
stack[(sp - 2)] = r4;
stack[(sp - 3)] = r5;
stack[(sp - 4)] = r6;
return RTS_64;
case (3):
sp = (sp + 4);
stack[sp] = stg_ap_2;
stack[(sp - 1)] = r4;
stack[(sp - 2)] = r5;
stack[(sp - 3)] = r6;
return RTS_64;
case (4):
sp = (sp + 3);
stack[sp] = stg_ap_1;
stack[(sp - 1)] = r5;
stack[(sp - 2)] = r6;
return RTS_64;
case (5):
return RTS_64;
default:
sp = (sp + 6);
stack[sp] = stg_ap_5;
stack[(sp - 1)] = r6;
stack[(sp - 2)] = r5;
stack[(sp - 3)] = r4;
stack[(sp - 4)] = r3;
stack[(sp - 5)] = r2;
return stg_ap_5();
};
}
else
{
sp = (sp + 6);
stack[sp] = stg_ap_5;
stack[(sp - 1)] = r6;
stack[(sp - 2)] = r5;
stack[(sp - 3)] = r4;
stack[(sp - 4)] = r3;
stack[(sp - 5)] = r2;
return stg_ap_5();
};
});
var stg_pap_1;
stg_pap_1 = (function()
{
var RTS_65;
RTS_65 = heap[(r1 + 2)];
switch (heap[(r1 + 1)])
{
case (5):
r6 = r5;
case (4):
r5 = r4;
case (3):
r4 = r3;
default:
r3 = r2;
};
r2 = heap[(r1 + 3)];
r1 = heap[(r1 + 2)];
return RTS_65;
});
stg_pap_1.i = [4, "stg_pap_1"];
stg_pap_1.gai = [1];
stg_pap_1.gi = [2];
stg_pap_1.gtag = 2;
stg_pap_1.a = 0;
stg_pap_1.t = 12;
var stg_pap_2;
stg_pap_2 = (function()
{
var RTS_66;
RTS_66 = heap[(r1 + 2)];
switch (heap[(r1 + 1)])
{
case (5):
r7 = r5;
case (4):
r6 = r4;
case (3):
r5 = r3;
default:
r4 = r2;
};
r2 = heap[(r1 + 3)];
r3 = heap[(r1 + 4)];
r1 = heap[(r1 + 2)];
return RTS_66;
});
stg_pap_2.i = [5, "stg_pap_2"];
stg_pap_2.gai = [1];
stg_pap_2.gi = [2];
stg_pap_2.gtag = 2;
stg_pap_2.a = 0;
stg_pap_2.t = 12;
var stg_ap_0_fast;
stg_ap_0_fast = (function()
{
var RTS_67;
RTS_67 = heap[r1];
do
{
switch (RTS_67.t)
{
case (14):
r1 = heap[(r1 + 1)];
continue;
case (3):
case (12):
return stack[sp];
default:
return RTS_67;
};
}
while (true);
});
stg_ap_0_fast.i = [1, "stg_ap_0_fast"];
stg_ap_0_fast.gi = [1];
stg_ap_0_fast.gtag = 1;
stg_ap_0_fast.gai = [1];
var stg_ap_v_fast;
stg_ap_v_fast = (function()
{
var RTS_68;
RTS_68 = heap[r1];
switch (RTS_68.t)
{
case (3):
if((RTS_68.a === 1))
{
return RTS_68;
}
else
{
log("stg_ap_v_fast: PAP");
};
default:
sp--;
return stg_ap_v;
};
});
var ind_entry;
ind_entry = (function()
{
r1 = heap[(r1 + 1)];
return heap[r1];
});
ind_entry.t = 14;
ind_entry.gi = [2, 1];
ind_entry.gtag = 258;
ind_entry.i = [2, "updated frame"];
var stg_upd_frame;
stg_upd_frame = (function()
{
var RTS_69;
RTS_69 = stack[(sp - 1)];
sp = (sp - 2);
heap[RTS_69] = ind_entry;
heap[(RTS_69 + 1)] = r1;
if((RTS_69 < hpOld))
{
hpForward.push(RTS_69);
};
return stack[sp];
});
stg_upd_frame.i = [2, "stg_upd_frame"];
stg_upd_frame.gai = [1];
stg_upd_frame.gi = [2, 1];
stg_upd_frame.gtag = 258;
stg_upd_frame.a = 0;
stg_upd_frame.t = 3;
var popCntTable;
popCntTable = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3,
3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2,
3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,
3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4,
5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2,
2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4,
5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4,
5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6,
6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8];
var THUNK_CLOSURE;
THUNK_CLOSURE = 10;
var FUN_CLOSURE;
FUN_CLOSURE = 3;
var PAP_CLOSURE;
PAP_CLOSURE = 12;
var CON_CLOSURE;
CON_CLOSURE = 5;
var IND_CLOSURE;
IND_CLOSURE = 14;
var BLACKHOLE_CLOSURE;
BLACKHOLE_CLOSURE = 16;
var closureTypeName;
closureTypeName = (function(RTS_70)
{
if((RTS_70 === 10))
{
return "Thunk";
};
if((RTS_70 === 3))
{
return "Fun";
};
if((RTS_70 === 12))
{
return "Pap";
};
if((RTS_70 === 5))
{
return "Con";
};
if((RTS_70 === 14))
{
return "Ind";
};
if((RTS_70 === 16))
{
return "Blackhole";
};
return "InvalidClosureType";
});
var RTS_71;
RTS_71 = 0;
var gc;
gc = (function(RTS_72, RTS_73, RTS_74, RTS_75, RTS_76, RTS_77, RTS_78, RTS_79,
RTS_80, RTS_81)
{
var RTS_82;
RTS_82 = new Date().getTime();
var RTS_83;
RTS_83 = RTS_82;
var RTS_84;
RTS_84 = [];
var RTS_85;
RTS_85 = (RTS_81 ? RTS_78 : RTS_77);
var RTS_86;
RTS_86 = [];
var RTS_87;
RTS_87 = [];
var RTS_88;
RTS_88 = [];
walkStack(RTS_74, RTS_75, RTS_72, RTS_85, RTS_88, RTS_86, RTS_87);
loadArgs(RTS_76, RTS_84, RTS_85);
if(RTS_81)
{
var RTS_89;
RTS_89 = (RTS_79.length - 1);
while((RTS_89 >= 0))
{
var RTS_90;
RTS_90 = RTS_79[RTS_89];
var RTS_91;
RTS_91 = RTS_72[RTS_90];
var RTS_92;
RTS_92 = RTS_91.gtag;
var RTS_93;
if((RTS_92 !== 0))
{
var RTS_94;
RTS_94 = (1 << 8);
var RTS_95;
RTS_95 = 1;
while((RTS_92 >= RTS_94))
{
if((RTS_92 & RTS_94))
{
RTS_93 = RTS_72[(RTS_90 + RTS_95)];
if((typeof(RTS_93) !== "number"))
{
log(((((("invalid pointer: " + RTS_90) + " + ") + RTS_95) + " ")
+
RTS_91.i[1]));
};
if((typeof(RTS_93) !== "number"))
{
log(("invalid pointer: " + RTS_93));
};
if((RTS_93 >= RTS_85))
{
RTS_84.push(RTS_93);
};
};
RTS_95++;
RTS_94 = (RTS_94 << 1);
};
}
else
{
var RTS_96;
RTS_96 = RTS_91.gi;
var RTS_97;
RTS_97 = (RTS_96.length - 1);
while((RTS_97 >= 1))
{
RTS_93 = RTS_72[(RTS_90 + RTS_96[RTS_97])];
if((typeof(RTS_93) !== "number"))
{
log(((((("invalid pointer: " + RTS_90) + " + ") + RTS_96[RTS_97]) + " ")
+
RTS_91.i[1]));
};
if((typeof(RTS_93) !== "number"))
{
log(("invalid pointer: " + RTS_93));
};
if((RTS_93 >= RTS_85))
{
RTS_84.push(RTS_93);
};
RTS_97--;
};
};
RTS_89--;
};
};
var RTS_98;
var RTS_99;
var RTS_100;
var RTS_101;
var RTS_102;
var RTS_103;
var RTS_104;
RTS_98 = RTS_84.pop();
var RTS_105;
RTS_105 = RTS_86.length;
var RTS_106;
RTS_106 = RTS_88.length;
while((RTS_98 !== undefined))
{
var RTS_107;
RTS_107 = RTS_72[RTS_98];
if((RTS_98 >= RTS_85))
{
if((typeof(RTS_107) === "function"))
{
if((RTS_107.t === 14))
{
var RTS_108;
RTS_108 = RTS_72[(RTS_98 + 1)];
RTS_88[RTS_106++] = RTS_98;
RTS_72[RTS_98] = 1;
RTS_98 = RTS_108;
}
else
{
RTS_86[RTS_105] = RTS_98;
RTS_87[RTS_105++] = RTS_107;
RTS_72[RTS_98] = 0;
var RTS_109;
RTS_109 = RTS_107.gtag;
var RTS_110;
if((RTS_109 !== 0))
{
var RTS_111;
RTS_111 = (1 << 8);
var RTS_112;
RTS_112 = 1;
while((RTS_109 >= RTS_111))
{
if((RTS_109 & RTS_111))
{
RTS_110 = RTS_72[(RTS_98 + RTS_112)];
if((typeof(RTS_110) !== "number"))
{
log(((((("invalid pointer: " + RTS_98) + " + ") + RTS_112) + " ")
+
RTS_107.i[1]));
};
if(((RTS_110 >= RTS_85) && (typeof(RTS_72[RTS_110]) === "function")))
{
RTS_84.push(RTS_110);
};
};
RTS_112++;
RTS_111 = (RTS_111 << 1);
};
}
else
{
var RTS_113;
RTS_113 = RTS_107.gi;
var RTS_114;
RTS_114 = (RTS_113.length - 1);
while((RTS_114 >= 1))
{
RTS_110 = RTS_72[(RTS_98 + RTS_113[RTS_114])];
if((typeof(RTS_110) !== "number"))
{
log(((((("invalid pointer: " + RTS_98) + " + ") + RTS_113[RTS_114]) + " ")
+
RTS_107.i[1]));
};
if(((RTS_110 >= RTS_85) && (typeof(RTS_72[RTS_110]) === "function")))
{
RTS_84.push(RTS_110);
};
RTS_114--;
};
};
RTS_98 = RTS_84.pop();
};
}
else
{
RTS_98 = RTS_84.pop();
};
}
else
{
var RTS_115;
RTS_115 = RTS_107.gtag;
var RTS_116;
if((RTS_115 !== 0))
{
var RTS_117;
RTS_117 = (1 << 8);
var RTS_118;
RTS_118 = 1;
while((RTS_115 >= RTS_117))
{
if((RTS_115 & RTS_117))
{
RTS_116 = RTS_72[(RTS_98 + RTS_118)];
if((typeof(RTS_116) !== "number"))
{
log(((((("invalid pointer: " + RTS_98) + " + ") + RTS_118) + " ")
+
RTS_107.i[1]));
};
if(((RTS_116 >= RTS_85) && (typeof(RTS_72[RTS_116]) === "function")))
{
RTS_84.push(RTS_116);
};
};
RTS_118++;
RTS_117 = (RTS_117 << 1);
};
}
else
{
var RTS_119;
RTS_119 = RTS_107.gi;
var RTS_120;
RTS_120 = (RTS_119.length - 1);
while((RTS_120 >= 1))
{
RTS_116 = RTS_72[(RTS_98 + RTS_119[RTS_120])];
if((typeof(RTS_116) !== "number"))
{
log(((((("invalid pointer: " + RTS_98) + " + ") + RTS_119[RTS_120]) + " ")
+
RTS_107.i[1]));
};
if(((RTS_116 >= RTS_85) && (typeof(RTS_72[RTS_116]) === "function")))
{
RTS_84.push(RTS_116);
};
RTS_120--;
};
};
RTS_98 = RTS_84.pop();
};
};
sortBoth(RTS_86, RTS_87);
var RTS_121;
RTS_121 = RTS_85;
var RTS_122;
RTS_122 = 0;
while((RTS_122 < RTS_86.length))
{
var RTS_123;
RTS_123 = RTS_86[RTS_122];
var RTS_124;
RTS_124 = RTS_87[RTS_122];
RTS_72[RTS_123] = (RTS_121 - RTS_123);
if(!RTS_124.gi)
{
log(("no gi property (1): " + RTS_123));
log(("no gi property (2): " + RTS_124.i[1]));
};
RTS_121 = (RTS_121 + RTS_124.gi[0]);
RTS_122++;
};
var RTS_125;
RTS_125 = (RTS_88.length - 1);
while((RTS_125 >= 0))
{
var RTS_126;
RTS_126 = RTS_88[RTS_125];
var RTS_127;
RTS_127 = RTS_72[(RTS_126 + 1)];
if((RTS_72[RTS_127] === 1))
{
throw("todo: follow\/update chains of indirections");
};
var RTS_128;
RTS_128 = RTS_72[RTS_127];
if((typeof(RTS_128) !== "number"))
{
RTS_128 = 0;
};
var RTS_129;
RTS_129 = (RTS_127 + RTS_128);
RTS_72[RTS_126] = (RTS_129 - RTS_126);
RTS_125--;
};
var RTS_130;
RTS_130 = (RTS_86.length - 1);
while((RTS_130 >= 0))
{
var RTS_131;
RTS_131 = RTS_86[RTS_130];
var RTS_132;
RTS_132 = RTS_87[RTS_130];
var RTS_133;
RTS_133 = RTS_132.gtag;
var RTS_134;
if((RTS_133 !== 0))
{
var RTS_135;
RTS_135 = (1 << 8);
var RTS_136;
RTS_136 = 1;
while((RTS_133 >= RTS_135))
{
if((RTS_133 & RTS_135))
{
RTS_134 = (RTS_131 + RTS_136);
var RTS_137;
RTS_137 = RTS_72[RTS_134];
if((RTS_137 >= RTS_85))
{
if(((typeof(RTS_72[RTS_137]) !== "number") || isNaN(RTS_72[RTS_137])))
{
throw(new Error((((("Invalid adjustment at: " + RTS_137) + " (referenced by: ")
+
RTS_134)
+
")")));
};
RTS_72[RTS_134] = (RTS_137 + RTS_72[RTS_137]);
};
};
RTS_136++;
RTS_135 = (RTS_135 << 1);
};
}
else
{
var RTS_138;
RTS_138 = RTS_132.gi;
var RTS_139;
RTS_139 = (RTS_138.length - 1);
while((RTS_139 >= 1))
{
RTS_134 = (RTS_131 + RTS_138[RTS_139]);
var RTS_140;
RTS_140 = RTS_72[RTS_134];
if((RTS_140 >= RTS_85))
{
if(((typeof(RTS_72[RTS_140]) !== "number") || isNaN(RTS_72[RTS_140])))
{
throw(new Error((((("Invalid adjustment at: " + RTS_140) + " (referenced by: ")
+
RTS_134)
+
")")));
};
RTS_72[RTS_134] = (RTS_140 + RTS_72[RTS_140]);
};
RTS_139--;
};
};
RTS_130--;
};
if(RTS_81)
{
var RTS_141;
RTS_141 = (RTS_79.length - 1);
while((RTS_141 >= 0))
{
var RTS_142;
RTS_142 = RTS_79[RTS_141];
var RTS_143;
RTS_143 = RTS_72[RTS_142];
var RTS_144;
RTS_144 = RTS_143.gtag;
var RTS_145;
if((RTS_144 !== 0))
{
var RTS_146;
RTS_146 = (1 << 8);
var RTS_147;
RTS_147 = 1;
while((RTS_144 >= RTS_146))
{
if((RTS_144 & RTS_146))
{
RTS_145 = (RTS_142 + RTS_147);
var RTS_148;
RTS_148 = RTS_72[RTS_145];
if((RTS_148 >= RTS_85))
{
if(((typeof(RTS_72[RTS_148]) !== "number") || isNaN(RTS_72[RTS_148])))
{
throw(new Error((((("Invalid adjustment at: " + RTS_148)
+
" (referenced by: ")
+
RTS_145)
+
")")));
};
RTS_72[RTS_145] = (RTS_148 + RTS_72[RTS_148]);
};
};
RTS_147++;
RTS_146 = (RTS_146 << 1);
};
}
else
{
var RTS_149;
RTS_149 = RTS_143.gi;
var RTS_150;
RTS_150 = (RTS_149.length - 1);
while((RTS_150 >= 1))
{
RTS_145 = (RTS_142 + RTS_149[RTS_150]);
var RTS_151;
RTS_151 = RTS_72[RTS_145];
if((RTS_151 >= RTS_85))
{
if(((typeof(RTS_72[RTS_151]) !== "number") || isNaN(RTS_72[RTS_151])))
{
throw(new Error((((("Invalid adjustment at: " + RTS_151) + " (referenced by: ")
+
RTS_145)
+
")")));
};
RTS_72[RTS_145] = (RTS_151 + RTS_72[RTS_151]);
};
RTS_150--;
};
};
RTS_141--;
};
};
adjustStack(RTS_74, RTS_75, RTS_72, RTS_85);
adjustArgs(RTS_76, RTS_72, RTS_85);
var RTS_152;
RTS_152 = 0;
while((RTS_152 < RTS_86.length))
{
var RTS_153;
RTS_153 = RTS_86[RTS_152];
var RTS_154;
RTS_154 = RTS_87[RTS_152];
var RTS_155;
RTS_155 = RTS_154.gi[0];
var RTS_156;
RTS_156 = (RTS_153 + RTS_72[RTS_153]);
RTS_72[RTS_156] = RTS_154;
var RTS_157;
RTS_157 = 1;
while((RTS_157 < RTS_155))
{
RTS_72[(RTS_156 + RTS_157)] = RTS_72[(RTS_153 + RTS_157)];
RTS_157++;
};
RTS_152++;
};
var RTS_158;
RTS_158 = (new Date().getTime() - RTS_83);
RTS_71 = (RTS_71 + RTS_158);
return RTS_121;
});
var walkStack;
walkStack = (function(RTS_159, RTS_160, RTS_161, RTS_162, RTS_163, RTS_164,
RTS_165)
{
var RTS_166;
RTS_166 = [];
var RTS_167;
RTS_167 = (RTS_162 | 0);
var RTS_168;
RTS_168 = RTS_164.length;
var RTS_169;
RTS_169 = RTS_163.length;
while((RTS_160 > 0))
{
var RTS_170;
RTS_170 = (RTS_159[RTS_160].gtag | 0);
var RTS_171;
if((RTS_170 !== 0))
{
var RTS_172;
RTS_172 = 1;
var RTS_173;
RTS_173 = (1 << 8);
while((RTS_170 >= RTS_173))
{
if((RTS_170 & RTS_173))
{
RTS_171 = RTS_159[(RTS_160 - RTS_172)];
if((RTS_171 >= RTS_167))
{
while((RTS_171 !== undefined))
{
var RTS_174;
RTS_174 = RTS_161[RTS_171];
if((RTS_171 >= RTS_162))
{
if((typeof(RTS_174) === "function"))
{
if((RTS_174.t === 14))
{
var RTS_175;
RTS_175 = RTS_161[(RTS_171 + 1)];
RTS_163[RTS_169++] = RTS_171;
RTS_161[RTS_171] = 1;
RTS_171 = RTS_175;
}
else
{
RTS_164[RTS_168] = RTS_171;
RTS_165[RTS_168++] = RTS_174;
RTS_161[RTS_171] = 0;
var RTS_176;
RTS_176 = RTS_174.gtag;
var RTS_177;
if((RTS_176 !== 0))
{
var RTS_178;
RTS_178 = (1 << 8);
var RTS_179;
RTS_179 = 1;
while((RTS_176 >= RTS_178))
{
if((RTS_176 & RTS_178))
{
RTS_177 = RTS_161[(RTS_171 + RTS_179)];
if((typeof(RTS_177) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ") + RTS_179)
+
" ")
+
RTS_174.i[1]));
};
if(((RTS_177 >= RTS_162)
&&
(typeof(RTS_161[RTS_177]) === "function")))
{
RTS_166.push(RTS_177);
};
};
RTS_179++;
RTS_178 = (RTS_178 << 1);
};
}
else
{
var RTS_180;
RTS_180 = RTS_174.gi;
var RTS_181;
RTS_181 = (RTS_180.length - 1);
while((RTS_181 >= 1))
{
RTS_177 = RTS_161[(RTS_171 + RTS_180[RTS_181])];
if((typeof(RTS_177) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ")
+
RTS_180[RTS_181])
+
" ")
+
RTS_174.i[1]));
};
if(((RTS_177 >= RTS_162)
&&
(typeof(RTS_161[RTS_177]) === "function")))
{
RTS_166.push(RTS_177);
};
RTS_181--;
};
};
RTS_171 = RTS_166.pop();
};
}
else
{
RTS_171 = RTS_166.pop();
};
}
else
{
var RTS_182;
RTS_182 = RTS_174.gtag;
var RTS_183;
if((RTS_182 !== 0))
{
var RTS_184;
RTS_184 = (1 << 8);
var RTS_185;
RTS_185 = 1;
while((RTS_182 >= RTS_184))
{
if((RTS_182 & RTS_184))
{
RTS_183 = RTS_161[(RTS_171 + RTS_185)];
if((typeof(RTS_183) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ") + RTS_185)
+
" ")
+
RTS_174.i[1]));
};
if(((RTS_183 >= RTS_162)
&&
(typeof(RTS_161[RTS_183]) === "function")))
{
RTS_166.push(RTS_183);
};
};
RTS_185++;
RTS_184 = (RTS_184 << 1);
};
}
else
{
var RTS_186;
RTS_186 = RTS_174.gi;
var RTS_187;
RTS_187 = (RTS_186.length - 1);
while((RTS_187 >= 1))
{
RTS_183 = RTS_161[(RTS_171 + RTS_186[RTS_187])];
if((typeof(RTS_183) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ")
+
RTS_186[RTS_187])
+
" ")
+
RTS_174.i[1]));
};
if(((RTS_183 >= RTS_162)
&&
(typeof(RTS_161[RTS_183]) === "function")))
{
RTS_166.push(RTS_183);
};
RTS_187--;
};
};
RTS_171 = RTS_166.pop();
};
};
};
};
RTS_172++;
RTS_173 = (RTS_173 << 1);
};
RTS_160 = (RTS_160 - (RTS_170 & 255));
}
else
{
var RTS_188;
RTS_188 = RTS_159[RTS_160].gi;
var RTS_189;
RTS_189 = (RTS_188.length - 1);
while((RTS_189 >= 1))
{
RTS_171 = RTS_159[(RTS_160 - RTS_188[RTS_189])];
if((RTS_171 >= RTS_167))
{
while((RTS_171 !== undefined))
{
var RTS_190;
RTS_190 = RTS_161[RTS_171];
if((RTS_171 >= RTS_162))
{
if((typeof(RTS_190) === "function"))
{
if((RTS_190.t === 14))
{
var RTS_191;
RTS_191 = RTS_161[(RTS_171 + 1)];
RTS_163[RTS_169++] = RTS_171;
RTS_161[RTS_171] = 1;
RTS_171 = RTS_191;
}
else
{
RTS_164[RTS_168] = RTS_171;
RTS_165[RTS_168++] = RTS_190;
RTS_161[RTS_171] = 0;
var RTS_192;
RTS_192 = RTS_190.gtag;
var RTS_193;
if((RTS_192 !== 0))
{
var RTS_194;
RTS_194 = (1 << 8);
var RTS_195;
RTS_195 = 1;
while((RTS_192 >= RTS_194))
{
if((RTS_192 & RTS_194))
{
RTS_193 = RTS_161[(RTS_171 + RTS_195)];
if((typeof(RTS_193) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ") + RTS_195)
+
" ")
+
RTS_190.i[1]));
};
if(((RTS_193 >= RTS_162)
&&
(typeof(RTS_161[RTS_193]) === "function")))
{
RTS_166.push(RTS_193);
};
};
RTS_195++;
RTS_194 = (RTS_194 << 1);
};
}
else
{
var RTS_196;
RTS_196 = RTS_190.gi;
var RTS_197;
RTS_197 = (RTS_196.length - 1);
while((RTS_197 >= 1))
{
RTS_193 = RTS_161[(RTS_171 + RTS_196[RTS_197])];
if((typeof(RTS_193) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ")
+
RTS_196[RTS_197])
+
" ")
+
RTS_190.i[1]));
};
if(((RTS_193 >= RTS_162)
&&
(typeof(RTS_161[RTS_193]) === "function")))
{
RTS_166.push(RTS_193);
};
RTS_197--;
};
};
RTS_171 = RTS_166.pop();
};
}
else
{
RTS_171 = RTS_166.pop();
};
}
else
{
var RTS_198;
RTS_198 = RTS_190.gtag;
var RTS_199;
if((RTS_198 !== 0))
{
var RTS_200;
RTS_200 = (1 << 8);
var RTS_201;
RTS_201 = 1;
while((RTS_198 >= RTS_200))
{
if((RTS_198 & RTS_200))
{
RTS_199 = RTS_161[(RTS_171 + RTS_201)];
if((typeof(RTS_199) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ") + RTS_201)
+
" ")
+
RTS_190.i[1]));
};
if(((RTS_199 >= RTS_162)
&&
(typeof(RTS_161[RTS_199]) === "function")))
{
RTS_166.push(RTS_199);
};
};
RTS_201++;
RTS_200 = (RTS_200 << 1);
};
}
else
{
var RTS_202;
RTS_202 = RTS_190.gi;
var RTS_203;
RTS_203 = (RTS_202.length - 1);
while((RTS_203 >= 1))
{
RTS_199 = RTS_161[(RTS_171 + RTS_202[RTS_203])];
if((typeof(RTS_199) !== "number"))
{
log(((((("invalid pointer: " + RTS_171) + " + ")
+
RTS_202[RTS_203])
+
" ")
+
RTS_190.i[1]));
};
if(((RTS_199 >= RTS_162)
&&
(typeof(RTS_161[RTS_199]) === "function")))
{
RTS_166.push(RTS_199);
};
RTS_203--;
};
};
RTS_171 = RTS_166.pop();
};
};
log(("reachable: " + RTS_171));
};
RTS_189--;
};
RTS_160 = (RTS_160 - RTS_188[0]);
};
};
});
var adjustStack;
adjustStack = (function(RTS_204, RTS_205, RTS_206, RTS_207)
{
if((typeof(RTS_204[RTS_205]) !== "function"))
{
log("incomplete stack frame");
};
var RTS_208;
var RTS_209;
while((RTS_205 > 0))
{
var RTS_210;
RTS_210 = RTS_204[RTS_205].gtag;
if((RTS_210 !== 0))
{
var RTS_211;
RTS_211 = 1;
var RTS_212;
RTS_212 = (1 << 8);
while((RTS_210 >= RTS_212))
{
if((RTS_210 & RTS_212))
{
RTS_209 = (RTS_205 - RTS_211);
RTS_208 = RTS_204[RTS_209];
if(((typeof(RTS_208) === "number") && (RTS_208 >= RTS_207)))
{
RTS_204[RTS_209] = (RTS_208 + RTS_206[RTS_208]);
};
};
RTS_211++;
RTS_212 = (RTS_212 << 1);
};
RTS_205 = (RTS_205 - (RTS_210 & 255));
}
else
{
var RTS_213;
RTS_213 = RTS_204[RTS_205].gi;
var RTS_214;
RTS_214 = 1;
while((RTS_214 < RTS_213.length))
{
var RTS_215;
RTS_215 = (RTS_205 - RTS_213[RTS_214]);
RTS_208 = RTS_204[RTS_215];
if(((typeof(RTS_208) === "number") && (RTS_208 >= RTS_207)))
{
RTS_204[RTS_215] = (RTS_208 + RTS_206[RTS_208]);
};
RTS_214++;
};
RTS_205 = (RTS_205 - RTS_213[0]);
};
};
});
var checkC;
checkC = (function(RTS_216, RTS_217)
{
if(!RTS_216[RTS_217].i)
{
throw(new Error(("not an entry at: " + RTS_217)));
};
var RTS_218;
RTS_218 = RTS_216[RTS_217].i[0];
if(((RTS_218 != RTS_216[RTS_217].gi[0])
||
(RTS_218 != (RTS_216[RTS_217].gtag & 255))))
{
throw(new Error(("inconsistent closure sizes at: " + RTS_217)));
};
var RTS_219;
RTS_219 = 1;
while((RTS_219 < RTS_218))
{
if((typeof(RTS_216[(RTS_217 + RTS_219)]) === "function"))
{
throw(new Error(("invalid closure variable at: " + RTS_217)));
};
RTS_219++;
};
var RTS_220;
RTS_220 = RTS_216[RTS_217].gi;
var RTS_221;
RTS_221 = 1;
while((RTS_221 < (RTS_220.length - 1)))
{
if((typeof(RTS_216[(RTS_217 + RTS_220[RTS_221])]) !== "number"))
{
throw(new Error(("invalid closure variable (expected pointer): " + RTS_217)));
};
RTS_221++;
};
});
var dumpStack;
dumpStack = (function(RTS_222, RTS_223)
{
dumpStackTop(RTS_222, 0, RTS_223);
});
var dumpStackTop;
dumpStackTop = (function(RTS_224, RTS_225, RTS_226)
{
var RTS_227;
RTS_227 = RTS_225;
while((RTS_227 <= RTS_226))
{
var RTS_228;
RTS_228 = RTS_224[RTS_227];
if((RTS_228 && RTS_228.i))
{
log((((((("stack[" + RTS_227) + "] = ") + RTS_228.i[1]) + " (")
+
RTS_228.i[0])
+
")"));
}
else
{
log(((("stack[" + RTS_227) + "] = ") + RTS_228));
};
RTS_227++;
};
});
var dh;
dh = (function()
{
dumpHeap(heap);
});
var dumpHeap;
dumpHeap = (function(RTS_229)
{
log("static heap:");
dumpHeapFromTo(RTS_229, 0, hpDyn);
log("\ndynamic heap:");
dumpHeapFromTo(RTS_229, hpDyn, -1);
});
var dumpHeapTo;
dumpHeapTo = (function(RTS_230, RTS_231)
{
log("static heap:");
dumpHeapFromTo(RTS_230, 0, hpDyn);
log("\ndynamic heap:");
dumpHeapFromTo(RTS_230, hpDyn, RTS_231);
});
var dumpHeapFromTo;
dumpHeapFromTo = (function(RTS_232, RTS_233, RTS_234)
{
var RTS_235;
RTS_235 = 0;
var RTS_236;
RTS_236 = RTS_233;
while(((RTS_236 < RTS_234) || (RTS_234 < 0)))
{
var RTS_237;
RTS_237 = RTS_232[RTS_236];
if(((RTS_237 === undefined) || (RTS_237 === 0)))
{
RTS_235++;
}
else
{
RTS_235 = 0;
};
if((RTS_235 >= 10))
{
break;
};
if((RTS_237 && RTS_237.i))
{
log((((((((("heap[" + RTS_236) + "] = ") + RTS_237.i[1]) + " (")
+
closureTypeName(RTS_237.t))
+
" ")
+
RTS_237.i[0])
+
")"));
}
else
{
log(((("heap[" + RTS_236) + "] = ") + RTS_237));
};
RTS_236++;
};
});
var loadArgs;
loadArgs = (function(RTS_238, RTS_239)
{
var RTS_240;
RTS_240 = RTS_238.gai;
var RTS_241;
RTS_241 = (RTS_240.length - 1);
while((RTS_241 >= 0))
{
var RTS_242;
RTS_242 = RTS_240[RTS_241];
switch (RTS_242)
{
case (1):
RTS_239.push(r1);
break;
case (2):
RTS_239.push(r2);
break;
case (3):
RTS_239.push(r3);
break;
case (4):
RTS_239.push(r4);
break;
case (5):
RTS_239.push(r5);
break;
case (6):
RTS_239.push(r6);
break;
case (7):
RTS_239.push(r7);
break;
case (8):
RTS_239.push(r8);
break;
case (9):
RTS_239.push(r9);
break;
case (10):
RTS_239.push(r10);
break;
case (11):
RTS_239.push(r11);
break;
case (12):
RTS_239.push(r12);
break;
case (13):
RTS_239.push(r13);
break;
case (14):
RTS_239.push(r14);
break;
case (15):
RTS_239.push(r15);
break;
case (16):
RTS_239.push(r16);
break;
case (17):
RTS_239.push(r17);
break;
case (18):
RTS_239.push(r18);
break;
case (19):
RTS_239.push(r19);
break;
case (20):
RTS_239.push(r20);
break;
case (21):
RTS_239.push(r21);
break;
case (22):
RTS_239.push(r22);
break;
case (23):
RTS_239.push(r23);
break;
case (24):
RTS_239.push(r24);
break;
case (25):
RTS_239.push(r25);
break;
case (26):
RTS_239.push(r26);
break;
case (27):
RTS_239.push(r27);
break;
case (28):
RTS_239.push(r28);
break;
case (29):
RTS_239.push(r29);
break;
case (30):
RTS_239.push(r30);
break;
case (31):
RTS_239.push(r31);
break;
case (32):
RTS_239.push(r32);
break;
default:
};
RTS_241--;
};
});
var adjustArgs;
adjustArgs = (function(RTS_243, RTS_244, RTS_245)
{
var RTS_246;
RTS_246 = RTS_243.gai;
var RTS_247;
RTS_247 = (RTS_246.length - 1);
while((RTS_247 >= 0))
{
var RTS_248;
RTS_248 = RTS_246[RTS_247];
switch (RTS_248)
{
case (1):
if((r1 >= RTS_245))
{
r1 = (r1 + RTS_244[r1]);
};
break;
case (2):
if((r2 >= RTS_245))
{
r2 = (r2 + RTS_244[r2]);
};
break;
case (3):
if((r3 >= RTS_245))
{
r3 = (r3 + RTS_244[r3]);
};
break;
case (4):
if((r4 >= RTS_245))
{
r4 = (r4 + RTS_244[r4]);
};
break;
case (5):
if((r5 >= RTS_245))
{
r5 = (r5 + RTS_244[r5]);
};
break;
case (6):
if((r6 >= RTS_245))
{
r6 = (r6 + RTS_244[r6]);
};
break;
case (7):
if((r7 >= RTS_245))
{
r7 = (r7 + RTS_244[r7]);
};
break;
case (8):
if((r8 >= RTS_245))
{
r8 = (r8 + RTS_244[r8]);
};
break;
case (9):
if((r9 >= RTS_245))
{
r9 = (r9 + RTS_244[r9]);
};
break;
case (10):
if((r10 >= RTS_245))
{
r10 = (r10 + RTS_244[r10]);
};
break;
case (11):
if((r11 >= RTS_245))
{
r11 = (r11 + RTS_244[r11]);
};
break;
case (12):
if((r12 >= RTS_245))
{
r12 = (r12 + RTS_244[r12]);
};
break;
case (13):
if((r13 >= RTS_245))
{
r13 = (r13 + RTS_244[r13]);
};
break;
case (14):
if((r14 >= RTS_245))
{
r14 = (r14 + RTS_244[r14]);
};
break;
case (15):
if((r15 >= RTS_245))
{
r15 = (r15 + RTS_244[r15]);
};
break;
case (16):
if((r16 >= RTS_245))
{
r16 = (r16 + RTS_244[r16]);
};
break;
case (17):
if((r17 >= RTS_245))
{
r17 = (r17 + RTS_244[r17]);
};
break;
case (18):
if((r18 >= RTS_245))
{
r18 = (r18 + RTS_244[r18]);
};
break;
case (19):
if((r19 >= RTS_245))
{
r19 = (r19 + RTS_244[r19]);
};
break;
case (20):
if((r20 >= RTS_245))
{
r20 = (r20 + RTS_244[r20]);
};
break;
case (21):
if((r21 >= RTS_245))
{
r21 = (r21 + RTS_244[r21]);
};
break;
case (22):
if((r22 >= RTS_245))
{
r22 = (r22 + RTS_244[r22]);
};
break;
case (23):
if((r23 >= RTS_245))
{
r23 = (r23 + RTS_244[r23]);
};
break;
case (24):
if((r24 >= RTS_245))
{
r24 = (r24 + RTS_244[r24]);
};
break;
case (25):
if((r25 >= RTS_245))
{
r25 = (r25 + RTS_244[r25]);
};
break;
case (26):
if((r26 >= RTS_245))
{
r26 = (r26 + RTS_244[r26]);
};
break;
case (27):
if((r27 >= RTS_245))
{
r27 = (r27 + RTS_244[r27]);
};
break;
case (28):
if((r28 >= RTS_245))
{
r28 = (r28 + RTS_244[r28]);
};
break;
case (29):
if((r29 >= RTS_245))
{
r29 = (r29 + RTS_244[r29]);
};
break;
case (30):
if((r30 >= RTS_245))
{
r30 = (r30 + RTS_244[r30]);
};
break;
case (31):
if((r31 >= RTS_245))
{
r31 = (r31 + RTS_244[r31]);
};
break;
case (32):
if((r32 >= RTS_245))
{
r32 = (r32 + RTS_244[r32]);
};
break;
default:
};
RTS_247--;
};
});
var setReg;
setReg = (function(RTS_249, RTS_250)
{
log(((("setting reg: r" + RTS_249) + " = ") + RTS_250));
if((RTS_249 === 1))
{
r1 = RTS_250;
};
if((RTS_249 === 2))
{
r2 = RTS_250;
};
if((RTS_249 === 3))
{
r3 = RTS_250;
};
if((RTS_249 === 4))
{
r4 = RTS_250;
};
if((RTS_249 === 5))
{
r5 = RTS_250;
};
if((RTS_249 === 6))
{
r6 = RTS_250;
};
if((RTS_249 === 7))
{
r7 = RTS_250;
};
if((RTS_249 === 8))
{
r8 = RTS_250;
};
if((RTS_249 === 9))
{
r9 = RTS_250;
};
if((RTS_249 === 10))
{
r10 = RTS_250;
};
if((RTS_249 === 11))
{
r11 = RTS_250;
};
if((RTS_249 === 12))
{
r12 = RTS_250;
};
if((RTS_249 === 13))
{
r13 = RTS_250;
};
if((RTS_249 === 14))
{
r14 = RTS_250;
};
if((RTS_249 === 15))
{
r15 = RTS_250;
};
if((RTS_249 === 16))
{
r16 = RTS_250;
};
if((RTS_249 === 17))
{
r17 = RTS_250;
};
if((RTS_249 === 18))
{
r18 = RTS_250;
};
if((RTS_249 === 19))
{
r19 = RTS_250;
};
if((RTS_249 === 20))
{
r20 = RTS_250;
};
if((RTS_249 === 21))
{
r21 = RTS_250;
};
if((RTS_249 === 22))
{
r22 = RTS_250;
};
if((RTS_249 === 23))
{
r23 = RTS_250;
};
if((RTS_249 === 24))
{
r24 = RTS_250;
};
if((RTS_249 === 25))
{
r25 = RTS_250;
};
if((RTS_249 === 26))
{
r26 = RTS_250;
};
if((RTS_249 === 27))
{
r27 = RTS_250;
};
if((RTS_249 === 28))
{
r28 = RTS_250;
};
if((RTS_249 === 29))
{
r29 = RTS_250;
};
if((RTS_249 === 30))
{
r30 = RTS_250;
};
if((RTS_249 === 31))
{
r31 = RTS_250;
};
if((RTS_249 === 32))
{
r32 = RTS_250;
};
});
var getReg;
getReg = (function(RTS_251)
{
if((RTS_251 === 1))
{
return r1;
};
if((RTS_251 === 2))
{
return r2;
};
if((RTS_251 === 3))
{
return r3;
};
if((RTS_251 === 4))
{
return r4;
};
if((RTS_251 === 5))
{
return r5;
};
if((RTS_251 === 6))
{
return r6;
};
if((RTS_251 === 7))
{
return r7;
};
if((RTS_251 === 8))
{
return r8;
};
if((RTS_251 === 9))
{
return r9;
};
if((RTS_251 === 10))
{
return r10;
};
if((RTS_251 === 11))
{
return r11;
};
if((RTS_251 === 12))
{
return r12;
};
if((RTS_251 === 13))
{
return r13;
};
if((RTS_251 === 14))
{
return r14;
};
if((RTS_251 === 15))
{
return r15;
};
if((RTS_251 === 16))
{
return r16;
};
if((RTS_251 === 17))
{
return r17;
};
if((RTS_251 === 18))
{
return r18;
};
if((RTS_251 === 19))
{
return r19;
};
if((RTS_251 === 20))
{
return r20;
};
if((RTS_251 === 21))
{
return r21;
};
if((RTS_251 === 22))
{
return r22;
};
if((RTS_251 === 23))
{
return r23;
};
if((RTS_251 === 24))
{
return r24;
};
if((RTS_251 === 25))
{
return r25;
};
if((RTS_251 === 26))
{
return r26;
};
if((RTS_251 === 27))
{
return r27;
};
if((RTS_251 === 28))
{
return r28;
};
if((RTS_251 === 29))
{
return r29;
};
if((RTS_251 === 30))
{
return r30;
};
if((RTS_251 === 31))
{
return r31;
};
if((RTS_251 === 32))
{
return r32;
};
return -1;
});
var sortBoth;
sortBoth = (function(RTS_252, RTS_253)
{
return quicksortBoth(RTS_252, RTS_253);
});
var quicksortBoth;
quicksortBoth = (function(RTS_254, RTS_255)
{
var RTS_256;
RTS_256 = [];
var RTS_257;
RTS_257 = 0;
var RTS_258;
RTS_258 = (RTS_254.length - 1);
var RTS_259;
var RTS_260;
var RTS_261;
var RTS_262;
var RTS_263;
var RTS_264;
while(true)
{
if(((RTS_258 - RTS_257) <= 25))
{
RTS_260 = (RTS_257 + 1);
while((RTS_260 <= RTS_258))
{
RTS_261 = RTS_254[RTS_260];
RTS_262 = RTS_255[RTS_260];
RTS_259 = (RTS_260 - 1);
while(((RTS_259 >= RTS_257) && (RTS_254[RTS_259] > RTS_261)))
{
RTS_254[(RTS_259 + 1)] = RTS_254[RTS_259];
RTS_255[(RTS_259 + 1)] = RTS_255[RTS_259--];
};
RTS_254[(RTS_259 + 1)] = RTS_261;
RTS_255[(RTS_259 + 1)] = RTS_262;
RTS_260++;
};
if((RTS_256.length == 0))
{
break;
};
RTS_258 = RTS_256.pop();
RTS_257 = RTS_256.pop();
}
else
{
var RTS_265;
RTS_265 = ((RTS_257 + RTS_258) >> 1);
RTS_259 = (RTS_257 + 1);
RTS_260 = RTS_258;
RTS_261 = RTS_254[RTS_265];
RTS_262 = RTS_255[RTS_265];
RTS_254[RTS_265] = RTS_254[RTS_259];
RTS_255[RTS_265] = RTS_255[RTS_259];
RTS_254[RTS_259] = RTS_261;
RTS_255[RTS_259] = RTS_262;
if((RTS_254[RTS_257] > RTS_254[RTS_258]))
{
RTS_261 = RTS_254[RTS_257];
RTS_262 = RTS_255[RTS_257];
RTS_254[RTS_257] = RTS_254[RTS_258];
RTS_255[RTS_257] = RTS_255[RTS_258];
RTS_254[RTS_258] = RTS_261;
RTS_255[RTS_258] = RTS_262;
};
if((RTS_254[RTS_259] > RTS_254[RTS_258]))
{
RTS_261 = RTS_254[RTS_259];
RTS_262 = RTS_255[RTS_259];
RTS_254[RTS_259] = RTS_254[RTS_258];
RTS_255[RTS_259] = RTS_255[RTS_258];
RTS_254[RTS_258] = RTS_261;
RTS_255[RTS_258] = RTS_262;
};
if((RTS_254[RTS_257] > RTS_254[RTS_259]))
{
RTS_261 = RTS_254[RTS_257];
RTS_262 = RTS_255[RTS_257];
RTS_254[RTS_257] = RTS_254[RTS_259];
RTS_255[RTS_257] = RTS_255[RTS_259];
RTS_254[RTS_259] = RTS_261;
RTS_255[RTS_259] = RTS_262;
};
RTS_263 = RTS_254[RTS_259];
RTS_264 = RTS_255[RTS_259];
while(true)
{
do
{
RTS_259++;
}
while ((RTS_254[RTS_259] < RTS_263));
do
{
RTS_260--;
}
while ((RTS_254[RTS_260] > RTS_263));
if((RTS_260 < RTS_259))
{
break;
};
RTS_261 = RTS_254[RTS_259];
RTS_262 = RTS_255[RTS_259];
RTS_254[RTS_259] = RTS_254[RTS_260];
RTS_255[RTS_259] = RTS_255[RTS_260];
RTS_254[RTS_260] = RTS_261;
RTS_255[RTS_260] = RTS_262;
};
RTS_254[(RTS_257 + 1)] = RTS_254[RTS_260];
RTS_255[(RTS_257 + 1)] = RTS_255[RTS_260];
RTS_254[RTS_260] = RTS_263;
RTS_255[RTS_260] = RTS_264;
if((((RTS_258 - RTS_259) + 1) >= (RTS_260 - RTS_257)))
{
RTS_256.push(RTS_259);
RTS_256.push(RTS_258);
RTS_258 = (RTS_260 - 1);
}
else
{
RTS_256.push(RTS_257);
RTS_256.push((RTS_260 - 1));
RTS_257 = RTS_259;
};
};
};
});
var $hs_GHCziTypesziIzh_e;
$hs_GHCziTypesziIzh_e = (function()
{
return stack[sp];
});
$hs_GHCziTypesziIzh_e.t = 5;
$hs_GHCziTypesziIzh_e.a = 1;
$hs_GHCziTypesziIzh_e.i = [2, "$hs_GHC.Types.I#_e", 2];
$hs_GHCziTypesziIzh_e.gi = [2];
$hs_GHCziTypesziIzh_e.gtag = 2;
$hs_GHCziTypesziIzh_e.gai = [];
var $hs_GHCziPrimziZLzhz2cUzhZR_e;
$hs_GHCziPrimziZLzhz2cUzhZR_e = (function()
{
return stack[sp];
});
$hs_GHCziPrimziZLzhz2cUzhZR_e.t = 5;
$hs_GHCziPrimziZLzhz2cUzhZR_e.a = 1;
$hs_GHCziPrimziZLzhz2cUzhZR_e.i = [2, "$hs_GHC.Prim.(#,#)_e", 2];
$hs_GHCziPrimziZLzhz2cUzhZR_e.gi = [2];
$hs_GHCziPrimziZLzhz2cUzhZR_e.gtag = 2;
$hs_GHCziPrimziZLzhz2cUzhZR_e.gai = [];
var $hs_GHCziTypesziIzh_con_e;
$hs_GHCziTypesziIzh_con_e = (function()
{
return stack[sp];
});
$hs_GHCziTypesziIzh_con_e.t = 5;
$hs_GHCziTypesziIzh_con_e.a = 1;
$hs_GHCziTypesziIzh_con_e.i = [2, "$hs_GHC.Types.I#_con_e", 2];
$hs_GHCziTypesziIzh_con_e.gi = [2];
$hs_GHCziTypesziIzh_con_e.gtag = 2;
$hs_GHCziTypesziIzh_con_e.gai = [];
var $hs_GHCziPrimziZLzhz2cUzhZR_con_e;
$hs_GHCziPrimziZLzhz2cUzhZR_con_e = (function()
{
return stack[sp];
});
$hs_GHCziPrimziZLzhz2cUzhZR_con_e.t = 5;
$hs_GHCziPrimziZLzhz2cUzhZR_con_e.a = 1;
$hs_GHCziPrimziZLzhz2cUzhZR_con_e.i = [2, "$hs_GHC.Prim.(#,#)_con_e", 2];
$hs_GHCziPrimziZLzhz2cUzhZR_con_e.gi = [2];
$hs_GHCziPrimziZLzhz2cUzhZR_con_e.gtag = 2;
$hs_GHCziPrimziZLzhz2cUzhZR_con_e.gai = [];
var ubxFst;
ubxFst = (function()
{
r1 = heap[(r1 + 1)];
return stack[--sp];
});
ubxFst.i = [1, "ubxFst"];
ubxFst.gi = [1];
ubxFst.gtag = 1;
ubxFst.gai = [1];
var runio_e;
runio_e = (function()
{
r1 = heap[(r1 + 1)];
return stg_ap_v_fast();
});
runio_e.t = 10;
runio_e.i = [2, "runio", 10];
runio_e.gi = [1];
runio_e.gtag = 1;
var runio;
runio = (function(RTS_266)
{
var RTS_267;
RTS_267 = hp;
heap[RTS_267] = runio_e;
heap[(RTS_267 + 1)] = RTS_266;
hp = (hp + 2);
return RTS_267;
});
var $hs_Fibszizdwfib_e;
$hs_Fibszizdwfib_e = (function()
{
var $hs_ww_1929381467;
$hs_ww_1929381467 = r2;
var $hs_ds_1929381469;
$hs_ds_1929381469 = $hs_ww_1929381467;
switch ($hs_ds_1929381469)
{
case (0):
r1 = 0;
return stack[sp];
case (1):
r1 = 1;
return stack[sp];
default:
$hs_satzusqC_1929381490 = (($hs_ds_1929381469 - 1) | 0);
sp = (sp + 2);
stack[sp] = $hs_Fibs_id_0;
stack[(sp - 1)] = $hs_ds_1929381469;
r1 = $hs_Fibszizdwfib;
r2 = $hs_satzusqC_1929381490;
return $hs_Fibszizdwfib_e;
};
});
$hs_Fibszizdwfib_e.gai = [];
var $hs_Fibszizdwfib;
$hs_Fibszizdwfib = static_fun($hs_Fibszizdwfib_e, 1, "$hs_Fibszizdwfib");
var $hs_Fibs_id_0;
$hs_Fibs_id_0 = (function()
{
var $hs_ww1_1929381474;
$hs_ww1_1929381474 = r1;
var $hs_ds_1929381469;
$hs_ds_1929381469 = stack[(sp - 1)];
sp = (sp - 2);
$hs_satzusqB_1929381489 = (($hs_ds_1929381469 - 2) | 0);
sp = (sp + 2);
stack[sp] = $hs_Fibs_id_1;
stack[(sp - 1)] = $hs_ww1_1929381474;
r1 = $hs_Fibszizdwfib;
r2 = $hs_satzusqB_1929381489;
return $hs_Fibszizdwfib_e;
});
var $hs_Fibs_id_1;
$hs_Fibs_id_1 = (function()
{
var $hs_ww2_1929381475;
$hs_ww2_1929381475 = r1;
var $hs_ww1_1929381474;
$hs_ww1_1929381474 = stack[(sp - 1)];
sp = (sp - 2);
var $hs_Fibs_id_2;
$hs_Fibs_id_2 = ($hs_ww1_1929381474 + $hs_ww2_1929381475);
r1 = $hs_Fibs_id_2;
return stack[sp];
});
$hs_Fibs_id_1.i = [2, "$hs_Fibs_id_1", 3];
$hs_Fibs_id_1.gai = [];
$hs_Fibs_id_1.gi = [2];
$hs_Fibs_id_1.gtag = 2;
$hs_Fibs_id_1.a = 0;
$hs_Fibs_id_1.t = 3;
$hs_Fibs_id_0.i = [2, "$hs_Fibs_id_0", 3];
$hs_Fibs_id_0.gai = [];
$hs_Fibs_id_0.gi = [2];
$hs_Fibs_id_0.gtag = 2;
$hs_Fibs_id_0.a = 0;
$hs_Fibs_id_0.t = 3;
var $hs_Fibszifib_e;
$hs_Fibszifib_e = (function()
{
var $hs_w_1929381477;
$hs_w_1929381477 = r2;
sp = (sp + 1);
stack[sp] = $hs_Fibs_id_3;
r1 = $hs_w_1929381477;
var $hs_Fibs_id_6;
$hs_Fibs_id_6 = heap[r1];
var $hs_Fibs_id_7;
$hs_Fibs_id_7 = $hs_Fibs_id_6.t;
if(($hs_Fibs_id_7 === 5))
{
return stack[sp];
}
else
{
if(($hs_Fibs_id_7 === 14))
{
r1 = heap[(r1 + 1)];
return stack[sp];
}
else
{
return $hs_Fibs_id_6;
};
};
});
$hs_Fibszifib_e.gai = [2];
var $hs_Fibszifib;
$hs_Fibszifib = static_fun($hs_Fibszifib_e, 1, "$hs_Fibszifib");
var $hs_Fibs_id_3;
$hs_Fibs_id_3 = (function()
{
var $hs_w1_1929381510;
$hs_w1_1929381510 = r1;
sp = (sp - 1);
var $hs_ww_1929381480;
$hs_ww_1929381480 = heap[(r1 + 1)];
sp = (sp + 1);
stack[sp] = $hs_Fibs_id_4;
r1 = $hs_Fibszizdwfib;
r2 = $hs_ww_1929381480;
return $hs_Fibszizdwfib_e;
});
var $hs_Fibs_id_4;
$hs_Fibs_id_4 = (function()
{
var $hs_ww1_1929381482;
$hs_ww1_1929381482 = r1;
sp = (sp - 1);
var $hs_Fibs_id_5;
$hs_Fibs_id_5 = (hp + 0);
heap[(hp + 1)] = $hs_ww1_1929381482;
heap[hp] = $hs_GHCziTypesziIzh_con_e;
hp = (hp + 2);
r1 = $hs_Fibs_id_5;
return stack[sp];
});
$hs_Fibs_id_4.i = [1, "$hs_Fibs_id_4"];
$hs_Fibs_id_4.gai = [];
$hs_Fibs_id_4.gi = [1];
$hs_Fibs_id_4.gtag = 1;
$hs_Fibs_id_4.a = 0;
$hs_Fibs_id_4.t = 3;
$hs_Fibs_id_3.i = [1, "$hs_Fibs_id_3"];
$hs_Fibs_id_3.gai = [1];
$hs_Fibs_id_3.gi = [1];
$hs_Fibs_id_3.gtag = 1;
$hs_Fibs_id_3.a = 0;
$hs_Fibs_id_3.t = 3;
var $hs_Fibszimain1_e;
$hs_Fibszimain1_e = (function()
{
sp = (sp + 1);
stack[sp] = $hs_Fibs_id_8;
r1 = $hs_Fibszizdwfib;
r2 = 35;
return $hs_Fibszizdwfib_e;
});
$hs_Fibszimain1_e.gai = [];
var $hs_Fibszimain1;
$hs_Fibszimain1 = static_fun($hs_Fibszimain1_e, 1, "$hs_Fibszimain1");
var $hs_Fibs_id_8;
$hs_Fibs_id_8 = (function()
{
var $hs_ww_1929381486;
$hs_ww_1929381486 = r1;
sp = (sp - 1);
var $hs_satzusr4_1929381518;
$hs_satzusr4_1929381518 = (hp + 0);
heap[(hp + 1)] = $hs_ww_1929381486;
heap[hp] = $hs_GHCziTypesziIzh_con_e;
hp = (hp + 2);
r1 = $hs_satzusr4_1929381518;
return stack[sp];
});
$hs_Fibs_id_8.i = [1, "$hs_Fibs_id_8", 1];
$hs_Fibs_id_8.gai = [];
$hs_Fibs_id_8.gi = [1];
$hs_Fibs_id_8.gtag = 1;
$hs_Fibs_id_8.a = 0;
$hs_Fibs_id_8.t = 3;
var $hs_Fibszimain_e;
$hs_Fibszimain_e = (function()
{
r1 = $hs_Fibszimain1;
return stg_ap_v_fast();
});
$hs_Fibszimain_e.gai = [];
var $hs_Fibszimain;
$hs_Fibszimain = static_fun($hs_Fibszimain_e, 1, "$hs_Fibszimain");
if((typeof(exports) !== "undefined"))
{
exports.RTS_0 = RTS_0;
exports.getGlbl = getGlbl;
exports.log = log;
exports.stack = stack;
exports.RTS_1 = RTS_1;
exports.heap = heap;
exports.RTS_2 = RTS_2;
exports.hpDyn = hpDyn;
exports.hpS = hpS;
exports.hp = hp;
exports.hpOld = hpOld;
exports.hpForward = hpForward;
exports.staticForward = staticForward;
exports.initStatic = initStatic;
exports.sp = sp;
exports.staticFree = staticFree;
exports.allocArea = allocArea;
exports.hpLim = hpLim;
exports.gcInc = gcInc;
exports.gcIncCurrent = gcIncCurrent;
exports.r1 = r1;
exports.r2 = r2;
exports.r3 = r3;
exports.r4 = r4;
exports.r5 = r5;
exports.r6 = r6;
exports.r7 = r7;
exports.r8 = r8;
exports.r9 = r9;
exports.r10 = r10;
exports.r11 = r11;
exports.r12 = r12;
exports.r13 = r13;
exports.r14 = r14;
exports.r15 = r15;
exports.r16 = r16;
exports.r17 = r17;
exports.r18 = r18;
exports.r19 = r19;
exports.r20 = r20;
exports.r21 = r21;
exports.r22 = r22;
exports.r23 = r23;
exports.r24 = r24;
exports.r25 = r25;
exports.r26 = r26;
exports.r27 = r27;
exports.r28 = r28;
exports.r29 = r29;
exports.r30 = r30;
exports.r31 = r31;
exports.r32 = r32;
exports.blackhole = blackhole;
exports.done = done;
exports.false_e = false_e;
exports.true_e = true_e;
exports.$hs_GHCziTypesziFalse = $hs_GHCziTypesziFalse;
exports.$hs_GHCziTypesziTrue = $hs_GHCziTypesziTrue;
exports.reduce = reduce;
exports.gc_check = gc_check;
exports.static_fun = static_fun;
exports.static_thunk = static_thunk;
exports.printcl = printcl;
exports.static_con0 = static_con0;
exports.static_con = static_con;
exports.alloc_static = alloc_static;
exports.init_closure = init_closure;
exports.run_init_static = run_init_static;
exports.logCall = logCall;
exports.runhs = runhs;
exports.stg_ap_1 = stg_ap_1;
exports.stg_ap_2 = stg_ap_2;
exports.stg_ap_3 = stg_ap_3;
exports.stg_ap_4 = stg_ap_4;
exports.stg_ap_5 = stg_ap_5;
exports.stg_ap_1_fast = stg_ap_1_fast;
exports.stg_ap_2_fast = stg_ap_2_fast;
exports.stg_ap_3_fast = stg_ap_3_fast;
exports.stg_ap_4_fast = stg_ap_4_fast;
exports.stg_ap_5_fast = stg_ap_5_fast;
exports.stg_pap_1 = stg_pap_1;
exports.stg_pap_2 = stg_pap_2;
exports.stg_ap_0_fast = stg_ap_0_fast;
exports.stg_ap_v_fast = stg_ap_v_fast;
exports.ind_entry = ind_entry;
exports.stg_upd_frame = stg_upd_frame;
exports.popCntTable = popCntTable;
exports.THUNK_CLOSURE = THUNK_CLOSURE;
exports.FUN_CLOSURE = FUN_CLOSURE;
exports.PAP_CLOSURE = PAP_CLOSURE;
exports.CON_CLOSURE = CON_CLOSURE;
exports.IND_CLOSURE = IND_CLOSURE;
exports.BLACKHOLE_CLOSURE = BLACKHOLE_CLOSURE;
exports.closureTypeName = closureTypeName;
exports.RTS_71 = RTS_71;
exports.gc = gc;
exports.walkStack = walkStack;
exports.adjustStack = adjustStack;
exports.checkC = checkC;
exports.dumpStack = dumpStack;
exports.dumpStackTop = dumpStackTop;
exports.dh = dh;
exports.dumpHeap = dumpHeap;
exports.dumpHeapTo = dumpHeapTo;
exports.dumpHeapFromTo = dumpHeapFromTo;
exports.loadArgs = loadArgs;
exports.adjustArgs = adjustArgs;
exports.setReg = setReg;
exports.getReg = getReg;
exports.sortBoth = sortBoth;
exports.quicksortBoth = quicksortBoth;
exports.$hs_GHCziTypesziIzh_e = $hs_GHCziTypesziIzh_e;
exports.$hs_GHCziPrimziZLzhz2cUzhZR_e = $hs_GHCziPrimziZLzhz2cUzhZR_e;
exports.$hs_GHCziTypesziIzh_con_e = $hs_GHCziTypesziIzh_con_e;
exports.$hs_GHCziPrimziZLzhz2cUzhZR_con_e = $hs_GHCziPrimziZLzhz2cUzhZR_con_e;
exports.ubxFst = ubxFst;
exports.runio_e = runio_e;
exports.runio = runio;
exports.$hs_Fibszizdwfib_e = $hs_Fibszizdwfib_e;
exports.$hs_Fibszizdwfib = $hs_Fibszizdwfib;
exports.$hs_Fibs_id_0 = $hs_Fibs_id_0;
exports.$hs_Fibs_id_1 = $hs_Fibs_id_1;
exports.$hs_Fibszifib_e = $hs_Fibszifib_e;
exports.$hs_Fibszifib = $hs_Fibszifib;
exports.$hs_Fibs_id_3 = $hs_Fibs_id_3;
exports.$hs_Fibs_id_4 = $hs_Fibs_id_4;
exports.$hs_Fibszimain1_e = $hs_Fibszimain1_e;
exports.$hs_Fibszimain1 = $hs_Fibszimain1;
exports.$hs_Fibs_id_8 = $hs_Fibs_id_8;
exports.$hs_Fibszimain_e = $hs_Fibszimain_e;
exports.$hs_Fibszimain = $hs_Fibszimain;
};
run_init_static();
debugger;
try {var dumpRes;
dumpRes = (function(jmId_0)
{
console.log(jmId_0);
var jmId_1;
jmId_1 = 1;
while((jmId_1 < 10))
{
console.log(((("heap[" + (jmId_0 + jmId_1)) + "] = ")
+
heap[(jmId_0 + jmId_1)]));
jmId_1++;
};
});
runhs(runio($hs_Fibszimain), printcl);
if((typeof(exports) !== "undefined"))
{
exports.dumpRes = dumpRes;
};
} catch(e) { log(e.stack); debugger; log('exception, r1: ' + r1); throw e; }
debugger;
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment