Created
September 24, 2012 20:33
-
-
Save luite/3778197 to your computer and use it in GitHub Desktop.
n-queens
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
StgRec [ | |
( Main.listAppend,StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [ds,l2] | |
( StgCase | |
( StgApp ds [] | |
) | |
UniqSet UniqSet wild SRT Alg Main.List [ | |
( DataAlt Main.Cons,[a,l1],[True,True],StgLet | |
( StgNonRec sat_s1Pj | |
( StgRhsClosure CostCentreStack StgBinderInfo [l1,l2] Updatable SRT [] | |
( StgApp Main.listAppend [StgVarArg l1 :: Main.List a,StgVarArg l2 :: Main.List a] | |
) | |
) | |
) | |
( StgConApp Main.Cons [StgVarArg a :: a,StgVarArg sat_s1Pj :: Main.List a] | |
) | |
) | |
, | |
( DataAlt Main.Nil,[],[],StgApp l2 [] | |
) | |
] | |
) | |
) | |
] | |
*/ | |
/* | |
StgRec [ | |
( Main.listConcat,StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [ds] | |
( StgCase | |
( StgApp ds [] | |
) | |
UniqSet UniqSet wild SRT Alg Main.List [ | |
( DataAlt Main.Cons,[xs,l],[True,True],StgLet | |
( StgNonRec sat_s1Ps | |
( StgRhsClosure CostCentreStack StgBinderInfo [l] Updatable SRT [] | |
( StgApp Main.listConcat [StgVarArg l :: Main.List | |
( Main.List a | |
) | |
] | |
) | |
) | |
) | |
( StgApp Main.listAppend [StgVarArg xs :: Main.List a,StgVarArg sat_s1Ps :: Main.List a] | |
) | |
) | |
, | |
( DataAlt Main.Nil,[],[],StgConApp Main.Nil [] | |
) | |
] | |
) | |
) | |
] | |
*/ | |
/* | |
StgRec [ | |
( Main.listFilter,StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [f,ds] | |
( StgCase | |
( StgApp ds [] | |
) | |
UniqSet UniqSet wild SRT Alg Main.List [ | |
( DataAlt Main.Cons,[a,l],[True,True],StgCase | |
( StgApp f [StgVarArg a :: a] | |
) | |
UniqSet UniqSet wild1 SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgApp Main.listFilter [StgVarArg f :: a -> GHC.Types.Bool,StgVarArg l :: Main.List a] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgLet | |
( StgNonRec sat_s1PD | |
( StgRhsClosure CostCentreStack StgBinderInfo [f,l] Updatable SRT [] | |
( StgApp Main.listFilter [StgVarArg f :: a -> GHC.Types.Bool,StgVarArg l :: Main.List a] | |
) | |
) | |
) | |
( StgConApp Main.Cons [StgVarArg a :: a,StgVarArg sat_s1PD :: Main.List a] | |
) | |
) | |
] | |
) | |
, | |
( DataAlt Main.Nil,[],[],StgConApp Main.Nil [] | |
) | |
] | |
) | |
) | |
] | |
*/ | |
/* | |
StgNonRec Main.$wlistFromTo | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [ww,ww1] | |
( StgLet | |
( StgRec [ | |
( $wgo,StgRhsClosure CostCentreStack StgBinderInfo [ww1,$wgo] ReEntrant SRT [ww2] | |
( StgCase | |
( StgOpApp | |
( StgPrimOp IntLeOp | |
) | |
[StgVarArg ww2 :: GHC.Prim.Int#,StgVarArg ww1 :: GHC.Prim.Int#] GHC.Types.Bool | |
) | |
UniqSet UniqSet wild SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgConApp Main.Nil [] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgLet | |
( StgNonRec sat_s1PO | |
( StgRhsClosure CostCentreStack StgBinderInfo [ww2,$wgo] Updatable SRT [] | |
( StgCase | |
( StgOpApp | |
( StgPrimOp IntAddOp | |
) | |
[StgVarArg ww2 :: GHC.Prim.Int#,StgLitArg MachInt 1] GHC.Prim.Int# | |
) | |
UniqSet UniqSet sat_s1Ns SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgApp $wgo [StgVarArg sat_s1Ns :: GHC.Prim.Int#] | |
) | |
] | |
) | |
) | |
) | |
( StgLet | |
( StgNonRec sat_s1PP | |
( StgRhsCon CostCentreStack GHC.Types.I# [StgVarArg ww2 :: GHC.Prim.Int#] | |
) | |
) | |
( StgConApp Main.Cons [StgVarArg sat_s1PP :: GHC.Types.Int,StgVarArg sat_s1PO :: Main.List GHC.Types.Int] | |
) | |
) | |
) | |
] | |
) | |
) | |
] | |
) | |
( StgApp $wgo [StgVarArg ww :: GHC.Prim.Int#] | |
) | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.listFromTo | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [w,w1] | |
( StgCase | |
( StgApp w [] | |
) | |
UniqSet UniqSet w2 SRT Alg GHC.Types.Int [ | |
( DataAlt GHC.Types.I#,[ww],[True],StgCase | |
( StgApp w1 [] | |
) | |
UniqSet UniqSet w3 SRT Alg GHC.Types.Int [ | |
( DataAlt GHC.Types.I#,[ww1],[True],StgApp Main.$wlistFromTo [StgVarArg ww :: GHC.Prim.Int#,StgVarArg ww1 :: GHC.Prim.Int#] | |
) | |
] | |
) | |
] | |
) | |
) | |
*/ | |
/* | |
StgRec [ | |
( Main.listMap,StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [f,ds] | |
( StgCase | |
( StgApp ds [] | |
) | |
UniqSet UniqSet wild SRT Alg Main.List [ | |
( DataAlt Main.Cons,[e,l],[True,True],StgLet | |
( StgNonRec sat_s1Qd | |
( StgRhsClosure CostCentreStack StgBinderInfo [f,l] Updatable SRT [] | |
( StgApp Main.listMap [StgVarArg f :: a -> b,StgVarArg l :: Main.List a] | |
) | |
) | |
) | |
( StgLet | |
( StgNonRec sat_s1Qe | |
( StgRhsClosure CostCentreStack StgBinderInfo [e,f] Updatable SRT [] | |
( StgApp f [StgVarArg e :: a] | |
) | |
) | |
) | |
( StgConApp Main.Cons [StgVarArg sat_s1Qe :: b,StgVarArg sat_s1Qd :: Main.List b] | |
) | |
) | |
) | |
, | |
( DataAlt Main.Nil,[],[],StgConApp Main.Nil [] | |
) | |
] | |
) | |
) | |
] | |
*/ | |
/* | |
StgRec [ | |
( Main.$wlistLength,StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [w] | |
( StgCase | |
( StgApp w [] | |
) | |
UniqSet UniqSet wild SRT Alg Main.List [ | |
( DataAlt Main.Cons,[ds,l],[False,True],StgCase | |
( StgApp Main.$wlistLength [StgVarArg l :: Main.List a] | |
) | |
UniqSet UniqSet ww SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgOpApp | |
( StgPrimOp IntAddOp | |
) | |
[StgLitArg MachInt 1,StgVarArg ww :: GHC.Prim.Int#] GHC.Prim.Int# | |
) | |
] | |
) | |
, | |
( DataAlt Main.Nil,[],[],StgLit | |
( MachInt 0 | |
) | |
) | |
] | |
) | |
) | |
] | |
*/ | |
/* | |
StgNonRec Main.listLength | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [w] | |
( StgCase | |
( StgApp Main.$wlistLength [StgVarArg w :: Main.List a] | |
) | |
UniqSet UniqSet ww SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgConApp GHC.Types.I# [StgVarArg ww :: GHC.Prim.Int#] | |
) | |
] | |
) | |
) | |
*/ | |
/* | |
StgRec [ | |
( Main.main_$ssafe,StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [sc,sc1,sc2] | |
( StgCase | |
( StgApp sc [] | |
) | |
UniqSet UniqSet wild SRT Alg Main.List [ | |
( DataAlt Main.Cons,[q,l],[True,True],StgCase | |
( StgApp q [] | |
) | |
UniqSet UniqSet wild1 SRT Alg GHC.Types.Int [ | |
( DataAlt GHC.Types.I#,[y],[True],StgCase | |
( StgOpApp | |
( StgPrimOp IntNeOp | |
) | |
[StgVarArg sc1 :: GHC.Prim.Int#,StgVarArg y :: GHC.Prim.Int#] GHC.Types.Bool | |
) | |
UniqSet UniqSet wild2 SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgConApp GHC.Types.False [] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntAddOp | |
) | |
[StgVarArg y :: GHC.Prim.Int#,StgVarArg sc2 :: GHC.Prim.Int#] GHC.Prim.Int# | |
) | |
UniqSet UniqSet sat_s1QG SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntNeOp | |
) | |
[StgVarArg sc1 :: GHC.Prim.Int#,StgVarArg sat_s1QG :: GHC.Prim.Int#] GHC.Types.Bool | |
) | |
UniqSet UniqSet wild3 SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgConApp GHC.Types.False [] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntSubOp | |
) | |
[StgVarArg y :: GHC.Prim.Int#,StgVarArg sc2 :: GHC.Prim.Int#] GHC.Prim.Int# | |
) | |
UniqSet UniqSet sat_s1QI SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntNeOp | |
) | |
[StgVarArg sc1 :: GHC.Prim.Int#,StgVarArg sat_s1QI :: GHC.Prim.Int#] GHC.Types.Bool | |
) | |
UniqSet UniqSet wild4 SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgConApp GHC.Types.False [] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntAddOp | |
) | |
[StgVarArg sc2 :: GHC.Prim.Int#,StgLitArg MachInt 1] GHC.Prim.Int# | |
) | |
UniqSet UniqSet sat_s1QK SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgApp Main.main_$ssafe [StgVarArg l :: Main.List GHC.Types.Int,StgVarArg sc1 :: GHC.Prim.Int#,StgVarArg sat_s1QK :: GHC.Prim.Int#] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
, | |
( DataAlt Main.Nil,[],[],StgConApp GHC.Types.True [] | |
) | |
] | |
) | |
) | |
] | |
*/ | |
/* | |
StgNonRec Main.main3 | |
( StgRhsCon CostCentreStack Main.Cons [StgVarArg Main.Nil :: forall a. Main.List a,StgVarArg Main.Nil :: forall a. Main.List a] | |
) | |
*/ | |
/* | |
StgNonRec Main.$wnsoln | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [ww] | |
( StgLet | |
( StgNonRec lvl | |
( StgRhsClosure CostCentreStack StgBinderInfo [ww] Updatable SRT [] | |
( StgApp Main.$wlistFromTo [StgLitArg MachInt 1,StgVarArg ww :: GHC.Prim.Int#] | |
) | |
) | |
) | |
( StgLet | |
( StgNonRec lvl1 | |
( StgRhsClosure CostCentreStack StgBinderInfo [lvl] ReEntrant SRT [bs] | |
( StgLet | |
( StgNonRec sat_s1Rg | |
( StgRhsClosure CostCentreStack StgBinderInfo [bs] ReEntrant SRT [q] | |
( StgCase | |
( StgApp bs [] | |
) | |
UniqSet UniqSet wild SRT Alg Main.List [ | |
( DataAlt Main.Cons,[q1,l],[True,True],StgCase | |
( StgApp q [] | |
) | |
UniqSet UniqSet wild1 SRT Alg GHC.Types.Int [ | |
( DataAlt GHC.Types.I#,[x],[True],StgCase | |
( StgApp q1 [] | |
) | |
UniqSet UniqSet wild2 SRT Alg GHC.Types.Int [ | |
( DataAlt GHC.Types.I#,[y],[True],StgCase | |
( StgOpApp | |
( StgPrimOp IntNeOp | |
) | |
[StgVarArg x :: GHC.Prim.Int#,StgVarArg y :: GHC.Prim.Int#] GHC.Types.Bool | |
) | |
UniqSet UniqSet wild3 SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgConApp GHC.Types.False [] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntAddOp | |
) | |
[StgVarArg y :: GHC.Prim.Int#,StgLitArg MachInt 1] GHC.Prim.Int# | |
) | |
UniqSet UniqSet sat_s1Rl SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntNeOp | |
) | |
[StgVarArg x :: GHC.Prim.Int#,StgVarArg sat_s1Rl :: GHC.Prim.Int#] GHC.Types.Bool | |
) | |
UniqSet UniqSet wild4 SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgConApp GHC.Types.False [] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntSubOp | |
) | |
[StgVarArg y :: GHC.Prim.Int#,StgLitArg MachInt 1] GHC.Prim.Int# | |
) | |
UniqSet UniqSet sat_s1Rm SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgCase | |
( StgOpApp | |
( StgPrimOp IntNeOp | |
) | |
[StgVarArg x :: GHC.Prim.Int#,StgVarArg sat_s1Rm :: GHC.Prim.Int#] GHC.Types.Bool | |
) | |
UniqSet UniqSet wild5 SRT Alg GHC.Types.Bool [ | |
( DataAlt GHC.Types.False,[],[],StgConApp GHC.Types.False [] | |
) | |
, | |
( DataAlt GHC.Types.True,[],[],StgApp Main.main_$ssafe [StgVarArg l :: Main.List GHC.Types.Int,StgVarArg x :: GHC.Prim.Int#,StgLitArg MachInt 2] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
, | |
( DataAlt Main.Nil,[],[],StgConApp GHC.Types.True [] | |
) | |
] | |
) | |
) | |
) | |
( StgCase | |
( StgApp Main.listFilter [StgVarArg sat_s1Rg :: GHC.Types.Int -> GHC.Types.Bool,StgVarArg lvl :: Main.List GHC.Types.Int] | |
) | |
UniqSet UniqSet sat_s1Rh SRT Alg Main.List [ | |
( DEFAULT,[],[],StgLet | |
( StgNonRec sat_s1Ri | |
( StgRhsClosure CostCentreStack StgBinderInfo [bs] ReEntrant SRT [q] | |
( StgConApp Main.Cons [StgVarArg q :: GHC.Types.Int,StgVarArg bs :: Main.List GHC.Types.Int] | |
) | |
) | |
) | |
( StgApp Main.listMap [StgVarArg sat_s1Ri :: GHC.Types.Int -> Main.List GHC.Types.Int,StgVarArg sat_s1Rh :: Main.List GHC.Types.Int] | |
) | |
) | |
] | |
) | |
) | |
) | |
) | |
( StgLet | |
( StgRec [ | |
( $wgen,StgRhsClosure CostCentreStack StgBinderInfo [lvl1,$wgen] ReEntrant SRT [ww1] | |
( StgCase | |
( StgApp ww1 [] | |
) | |
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_s1OY SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgCase | |
( StgApp $wgen [StgVarArg sat_s1OY :: GHC.Prim.Int#] | |
) | |
UniqSet UniqSet sat_s1P0 SRT Alg Main.List [ | |
( DEFAULT,[],[],StgCase | |
( StgApp Main.listMap [StgVarArg lvl1 :: Main.List GHC.Types.Int -> Main.List | |
( Main.List GHC.Types.Int | |
) | |
,StgVarArg sat_s1P0 :: Main.List | |
( Main.List GHC.Types.Int | |
) | |
] | |
) | |
UniqSet UniqSet sat_s1Rj SRT Alg Main.List [ | |
( DEFAULT,[],[],StgApp Main.listConcat [StgVarArg sat_s1Rj :: Main.List | |
( Main.List | |
( Main.List GHC.Types.Int | |
) | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
] | |
) | |
, | |
( LitAlt | |
( MachInt 0 | |
) | |
,[],[],StgApp Main.main3 [] | |
) | |
] | |
) | |
) | |
] | |
) | |
( StgCase | |
( StgApp $wgen [StgVarArg ww :: GHC.Prim.Int#] | |
) | |
UniqSet UniqSet sat_s1Rk SRT Alg Main.List [ | |
( DEFAULT,[],[],StgApp Main.$wlistLength [StgVarArg sat_s1Rk :: Main.List | |
( Main.List GHC.Types.Int | |
) | |
] | |
) | |
] | |
) | |
) | |
) | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.nsoln | |
( 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 Main.$wnsoln [StgVarArg ww :: GHC.Prim.Int#] | |
) | |
UniqSet UniqSet ww1 SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgConApp GHC.Types.I# [StgVarArg ww1 :: GHC.Prim.Int#] | |
) | |
] | |
) | |
] | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.solvijg | |
( StgRhsClosure CostCentreStack StgBinderInfo [] Updatable SRT [] | |
( StgCase | |
( StgApp Main.$wnsoln [StgLitArg MachInt 5] | |
) | |
UniqSet UniqSet ww SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgConApp GHC.Types.I# [StgVarArg ww :: GHC.Prim.Int#] | |
) | |
] | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.main2 | |
( StgRhsClosure CostCentreStack StgBinderInfo [] Updatable SRT [] | |
( StgCase | |
( StgApp Main.$wnsoln [StgLitArg MachInt 11] | |
) | |
UniqSet UniqSet ww SRT Prim GHC.Prim.Int# [ | |
( DEFAULT,[],[],StgConApp GHC.Types.I# [StgVarArg ww :: GHC.Prim.Int#] | |
) | |
] | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.main1 | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [eta] | |
( StgConApp | |
( #,# | |
) | |
[StgVarArg eta :: GHC.Prim.State# GHC.Prim.RealWorld,StgVarArg Main.main2 :: GHC.Types.Int] | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.main | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [eta_B1] | |
( StgApp Main.main1 [StgVarArg eta_B1 :: GHC.Prim.State# GHC.Prim.RealWorld] | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.main4 | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [eta] | |
( StgApp GHC.TopHandler.runMainIO1 [StgVarArg Main.main1 :: GHC.Prim.State# GHC.Prim.RealWorld | |
-> | |
( # GHC.Prim.State# GHC.Prim.RealWorld, GHC.Types.Int # | |
) | |
,StgVarArg eta :: GHC.Prim.State# GHC.Prim.RealWorld] | |
) | |
) | |
*/ | |
/* | |
StgNonRec :Main.main | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [eta_B1] | |
( StgApp Main.main4 [StgVarArg eta_B1 :: GHC.Prim.State# GHC.Prim.RealWorld] | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.Cons | |
( StgRhsClosure CostCentreStack StgBinderInfo [] ReEntrant SRT [eta_B2,eta_B1] | |
( StgConApp Main.Cons [StgVarArg eta_B2 :: a,StgVarArg eta_B1 :: Main.List a] | |
) | |
) | |
*/ | |
/* | |
StgNonRec Main.Nil | |
( StgRhsCon CostCentreStack Main.Nil [] | |
) | |
*/ | |
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 = 200000; | |
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.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.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.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.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.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(); | |
}; | |
}); | |
stg_ap_1_fast.i = [2, "stg_ap_1_fast"]; | |
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(); | |
}; | |
}); | |
stg_ap_2_fast.i = [3, "stg_ap_2_fast"]; | |
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(); | |
}; | |
}); | |
stg_ap_3_fast.i = [4, "stg_ap_3_fast"]; | |
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(); | |
}; | |
}); | |
stg_ap_4_fast.i = [5, "stg_ap_4_fast"]; | |
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(); | |
}; | |
}); | |
stg_ap_5_fast.i = [6, "stg_ap_5_fast"]; | |
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.t = 12; | |
stg_pap_1.gai = 1; | |
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.t = 12; | |
stg_pap_2.gai = 1; | |
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.gai = [1]; | |
stg_upd_frame.gi = [2, 1]; | |
stg_upd_frame.gtag = 258; | |
stg_upd_frame.i = [2, "stg_upd_frame"]; | |
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) | |
{ | |
log(((("gc > hp: " + RTS_73) + " sp: ") + RTS_75)); | |
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); | |
log((((("< gc " + RTS_121) + " (") + RTS_158) + "ms)")); | |
log((("< gc (total: " + RTS_71) + "ms)")); | |
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((typeof(RTS_171) !== "number")) | |
{ | |
} | |
else | |
{ | |
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; | |
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; | |
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; | |
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; | |
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_MainzilistAppend_e; | |
$hs_MainzilistAppend_e = (function() | |
{ | |
var $hs_ds_1929386713; | |
$hs_ds_1929386713 = r2; | |
var $hs_l2_1929386719; | |
$hs_l2_1929386719 = r3; | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_0; | |
stack[(sp - 1)] = $hs_l2_1929386719; | |
r1 = $hs_ds_1929386713; | |
var $hs_Main_id_4; | |
$hs_Main_id_4 = heap[r1]; | |
var $hs_Main_id_5; | |
$hs_Main_id_5 = $hs_Main_id_4.t; | |
if(($hs_Main_id_5 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_5 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_4; | |
}; | |
}; | |
}); | |
$hs_MainzilistAppend_e.gai = [2, 3]; | |
var $hs_MainzilistAppend; | |
$hs_MainzilistAppend = static_fun($hs_MainzilistAppend_e, 2, | |
"$hs_MainzilistAppend"); | |
var $hs_Main_id_0; | |
$hs_Main_id_0 = (function() | |
{ | |
var $hs_wild_1929386866; | |
$hs_wild_1929386866 = r1; | |
var $hs_l2_1929386719; | |
$hs_l2_1929386719 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
if((heap[$hs_wild_1929386866].a === 1)) | |
{ | |
var $hs_a_1929386717; | |
$hs_a_1929386717 = heap[(r1 + 1)]; | |
var $hs_l1_1929386718; | |
$hs_l1_1929386718 = heap[(r1 + 2)]; | |
var $hs_satzus1Pj_1929386865; | |
$hs_satzus1Pj_1929386865 = (hp + 0); | |
heap[(hp + 2)] = $hs_l2_1929386719; | |
heap[(hp + 1)] = $hs_l1_1929386718; | |
heap[hp] = $hs_satzus1Pj_e_1929386865; | |
hp = (hp + 3); | |
var $hs_Main_id_1; | |
$hs_Main_id_1 = (hp + 0); | |
heap[(hp + 2)] = $hs_satzus1Pj_1929386865; | |
heap[(hp + 1)] = $hs_a_1929386717; | |
heap[hp] = $hs_MainziCons_con_e; | |
hp = (hp + 3); | |
r1 = $hs_Main_id_1; | |
return stack[sp]; | |
} | |
else | |
{ | |
r1 = $hs_l2_1929386719; | |
var $hs_Main_id_2; | |
$hs_Main_id_2 = heap[r1]; | |
var $hs_Main_id_3; | |
$hs_Main_id_3 = $hs_Main_id_2.t; | |
if(($hs_Main_id_3 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_3 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_2; | |
}; | |
}; | |
}; | |
}); | |
$hs_satzus1Pj_e_1929386865 = (function() | |
{ | |
var $hs_l1_1929386718; | |
$hs_l1_1929386718 = heap[(r1 + 1)]; | |
var $hs_l2_1929386719; | |
$hs_l2_1929386719 = heap[(r1 + 2)]; | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
r1 = $hs_MainzilistAppend; | |
r2 = $hs_l1_1929386718; | |
r3 = $hs_l2_1929386719; | |
return $hs_MainzilistAppend_e; | |
}); | |
$hs_satzus1Pj_e_1929386865.i = [3, "sat_s1Pj", 0, 0]; | |
$hs_satzus1Pj_e_1929386865.gi = [3, 1, 2]; | |
$hs_satzus1Pj_e_1929386865.gtag = 771; | |
$hs_satzus1Pj_e_1929386865.t = 10; | |
$hs_satzus1Pj_e_1929386865.a = 0; | |
$hs_satzus1Pj_e_1929386865.gai = [1]; | |
$hs_Main_id_0.i = [2, "$hs_Main_id_0", 0]; | |
$hs_Main_id_0.gai = [1]; | |
$hs_Main_id_0.gi = [2, 1]; | |
$hs_Main_id_0.gtag = 258; | |
$hs_Main_id_0.a = 0; | |
$hs_Main_id_0.t = 3; | |
var $hs_MainzilistConcat_e; | |
$hs_MainzilistConcat_e = (function() | |
{ | |
var $hs_ds_1929386722; | |
$hs_ds_1929386722 = r2; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_6; | |
r1 = $hs_ds_1929386722; | |
var $hs_Main_id_8; | |
$hs_Main_id_8 = heap[r1]; | |
var $hs_Main_id_9; | |
$hs_Main_id_9 = $hs_Main_id_8.t; | |
if(($hs_Main_id_9 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_9 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_8; | |
}; | |
}; | |
}); | |
$hs_MainzilistConcat_e.gai = [2]; | |
var $hs_MainzilistConcat; | |
$hs_MainzilistConcat = static_fun($hs_MainzilistConcat_e, 1, | |
"$hs_MainzilistConcat"); | |
var $hs_Main_id_6; | |
$hs_Main_id_6 = (function() | |
{ | |
var $hs_wild_1929386875; | |
$hs_wild_1929386875 = r1; | |
sp = (sp - 1); | |
if((heap[$hs_wild_1929386875].a === 1)) | |
{ | |
var $hs_xs_1929386726; | |
$hs_xs_1929386726 = heap[(r1 + 1)]; | |
var $hs_l_1929386727; | |
$hs_l_1929386727 = heap[(r1 + 2)]; | |
var $hs_satzus1Ps_1929386874; | |
$hs_satzus1Ps_1929386874 = (hp + 0); | |
heap[(hp + 1)] = $hs_l_1929386727; | |
heap[hp] = $hs_satzus1Ps_e_1929386874; | |
hp = (hp + 2); | |
r1 = $hs_MainzilistAppend; | |
r2 = $hs_xs_1929386726; | |
r3 = $hs_satzus1Ps_1929386874; | |
return $hs_MainzilistAppend_e; | |
} | |
else | |
{ | |
var $hs_Main_id_7; | |
$hs_Main_id_7 = $hs_MainziNil; | |
r1 = $hs_Main_id_7; | |
return stack[sp]; | |
}; | |
}); | |
$hs_satzus1Ps_e_1929386874 = (function() | |
{ | |
var $hs_l_1929386727; | |
$hs_l_1929386727 = heap[(r1 + 1)]; | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
r1 = $hs_MainzilistConcat; | |
r2 = $hs_l_1929386727; | |
return $hs_MainzilistConcat_e; | |
}); | |
$hs_satzus1Ps_e_1929386874.i = [2, "sat_s1Ps", 0]; | |
$hs_satzus1Ps_e_1929386874.gi = [2, 1]; | |
$hs_satzus1Ps_e_1929386874.gtag = 258; | |
$hs_satzus1Ps_e_1929386874.t = 10; | |
$hs_satzus1Ps_e_1929386874.a = 0; | |
$hs_satzus1Ps_e_1929386874.gai = [1]; | |
$hs_Main_id_6.i = [1, "$hs_Main_id_6"]; | |
$hs_Main_id_6.gai = [1]; | |
$hs_Main_id_6.gi = [1]; | |
$hs_Main_id_6.gtag = 1; | |
$hs_Main_id_6.a = 0; | |
$hs_Main_id_6.t = 3; | |
var $hs_MainzilistFilter_e; | |
$hs_MainzilistFilter_e = (function() | |
{ | |
var $hs_f_1929386736; | |
$hs_f_1929386736 = r2; | |
var $hs_ds_1929386731; | |
$hs_ds_1929386731 = r3; | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_10; | |
stack[(sp - 1)] = $hs_f_1929386736; | |
r1 = $hs_ds_1929386731; | |
var $hs_Main_id_14; | |
$hs_Main_id_14 = heap[r1]; | |
var $hs_Main_id_15; | |
$hs_Main_id_15 = $hs_Main_id_14.t; | |
if(($hs_Main_id_15 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_15 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_14; | |
}; | |
}; | |
}); | |
$hs_MainzilistFilter_e.gai = [2, 3]; | |
var $hs_MainzilistFilter; | |
$hs_MainzilistFilter = static_fun($hs_MainzilistFilter_e, 2, | |
"$hs_MainzilistFilter"); | |
var $hs_Main_id_10; | |
$hs_Main_id_10 = (function() | |
{ | |
var $hs_wild_1929386884; | |
$hs_wild_1929386884 = r1; | |
var $hs_f_1929386736; | |
$hs_f_1929386736 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
if((heap[$hs_wild_1929386884].a === 1)) | |
{ | |
var $hs_a_1929386735; | |
$hs_a_1929386735 = heap[(r1 + 1)]; | |
var $hs_l_1929386738; | |
$hs_l_1929386738 = heap[(r1 + 2)]; | |
sp = (sp + 4); | |
stack[sp] = $hs_Main_id_11; | |
stack[(sp - 1)] = $hs_l_1929386738; | |
stack[(sp - 2)] = $hs_f_1929386736; | |
stack[(sp - 3)] = $hs_a_1929386735; | |
r1 = $hs_f_1929386736; | |
r2 = $hs_a_1929386735; | |
return stg_ap_1_fast(); | |
} | |
else | |
{ | |
var $hs_Main_id_13; | |
$hs_Main_id_13 = $hs_MainziNil; | |
r1 = $hs_Main_id_13; | |
return stack[sp]; | |
}; | |
}); | |
var $hs_Main_id_11; | |
$hs_Main_id_11 = (function() | |
{ | |
var $hs_wild1_1929386883; | |
$hs_wild1_1929386883 = r1; | |
var $hs_a_1929386735; | |
var $hs_f_1929386736; | |
var $hs_l_1929386738; | |
$hs_l_1929386738 = stack[(sp - 1)]; | |
$hs_f_1929386736 = stack[(sp - 2)]; | |
$hs_a_1929386735 = stack[(sp - 3)]; | |
sp = (sp - 4); | |
if(($hs_wild1_1929386883 === 0)) | |
{ | |
r1 = $hs_MainzilistFilter; | |
r2 = $hs_f_1929386736; | |
r3 = $hs_l_1929386738; | |
return $hs_MainzilistFilter_e; | |
} | |
else | |
{ | |
var $hs_satzus1PD_1929386885; | |
$hs_satzus1PD_1929386885 = (hp + 0); | |
heap[(hp + 2)] = $hs_l_1929386738; | |
heap[(hp + 1)] = $hs_f_1929386736; | |
heap[hp] = $hs_satzus1PD_e_1929386885; | |
hp = (hp + 3); | |
var $hs_Main_id_12; | |
$hs_Main_id_12 = (hp + 0); | |
heap[(hp + 2)] = $hs_satzus1PD_1929386885; | |
heap[(hp + 1)] = $hs_a_1929386735; | |
heap[hp] = $hs_MainziCons_con_e; | |
hp = (hp + 3); | |
r1 = $hs_Main_id_12; | |
return stack[sp]; | |
}; | |
}); | |
$hs_satzus1PD_e_1929386885 = (function() | |
{ | |
var $hs_f_1929386736; | |
$hs_f_1929386736 = heap[(r1 + 1)]; | |
var $hs_l_1929386738; | |
$hs_l_1929386738 = heap[(r1 + 2)]; | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
r1 = $hs_MainzilistFilter; | |
r2 = $hs_f_1929386736; | |
r3 = $hs_l_1929386738; | |
return $hs_MainzilistFilter_e; | |
}); | |
$hs_satzus1PD_e_1929386885.i = [3, "sat_s1PD", 0, 0]; | |
$hs_satzus1PD_e_1929386885.gi = [3, 1, 2]; | |
$hs_satzus1PD_e_1929386885.gtag = 771; | |
$hs_satzus1PD_e_1929386885.t = 10; | |
$hs_satzus1PD_e_1929386885.a = 0; | |
$hs_satzus1PD_e_1929386885.gai = [1]; | |
$hs_Main_id_11.i = [4, "$hs_Main_id_11", 0, 0, 0]; | |
$hs_Main_id_11.gai = [1]; | |
$hs_Main_id_11.gi = [4, 1, 2, 3]; | |
$hs_Main_id_11.gtag = 1796; | |
$hs_Main_id_11.a = 0; | |
$hs_Main_id_11.t = 3; | |
$hs_Main_id_10.i = [2, "$hs_Main_id_10", 0]; | |
$hs_Main_id_10.gai = [1]; | |
$hs_Main_id_10.gi = [2, 1]; | |
$hs_Main_id_10.gtag = 258; | |
$hs_Main_id_10.a = 0; | |
$hs_Main_id_10.t = 3; | |
var $hs_MainzizdwlistFromTo_e; | |
$hs_MainzizdwlistFromTo_e = (function() | |
{ | |
var $hs_ww_1929386752; | |
$hs_ww_1929386752 = r2; | |
var $hs_ww1_1929386745; | |
$hs_ww1_1929386745 = r3; | |
var $hs_zdwgo_1929386748; | |
$hs_zdwgo_1929386748 = (hp + 0); | |
heap[(hp + 2)] = $hs_zdwgo_1929386748; | |
heap[(hp + 1)] = $hs_ww1_1929386745; | |
heap[hp] = $hs_zdwgo_e_1929386748; | |
hp = (hp + 3); | |
r1 = $hs_zdwgo_1929386748; | |
r2 = $hs_ww_1929386752; | |
return $hs_zdwgo_e_1929386748; | |
}); | |
$hs_MainzizdwlistFromTo_e.gai = []; | |
var $hs_MainzizdwlistFromTo; | |
$hs_MainzizdwlistFromTo = static_fun($hs_MainzizdwlistFromTo_e, 2, | |
"$hs_MainzizdwlistFromTo"); | |
$hs_zdwgo_e_1929386748 = (function() | |
{ | |
var $hs_ww1_1929386745; | |
$hs_ww1_1929386745 = heap[(r1 + 1)]; | |
var $hs_zdwgo_1929386748; | |
$hs_zdwgo_1929386748 = heap[(r1 + 2)]; | |
var $hs_ww2_1929386744; | |
$hs_ww2_1929386744 = r2; | |
$hs_wild_1929386898 = (($hs_ww2_1929386744 | |
<= | |
$hs_ww1_1929386745) ? 1 : 0); | |
if(($hs_wild_1929386898 === 0)) | |
{ | |
var $hs_Main_id_16; | |
$hs_Main_id_16 = $hs_MainziNil; | |
r1 = $hs_Main_id_16; | |
return stack[sp]; | |
} | |
else | |
{ | |
var $hs_satzus1PO_1929386896; | |
$hs_satzus1PO_1929386896 = (hp + 0); | |
heap[(hp + 2)] = $hs_zdwgo_1929386748; | |
heap[(hp + 1)] = $hs_ww2_1929386744; | |
heap[hp] = $hs_satzus1PO_e_1929386896; | |
hp = (hp + 3); | |
var $hs_satzus1PP_1929386897; | |
$hs_satzus1PP_1929386897 = (hp + 0); | |
heap[(hp + 1)] = $hs_ww2_1929386744; | |
heap[hp] = $hs_GHCziTypesziIzh_con_e; | |
hp = (hp + 2); | |
var $hs_Main_id_17; | |
$hs_Main_id_17 = (hp + 0); | |
heap[(hp + 2)] = $hs_satzus1PO_1929386896; | |
heap[(hp + 1)] = $hs_satzus1PP_1929386897; | |
heap[hp] = $hs_MainziCons_con_e; | |
hp = (hp + 3); | |
r1 = $hs_Main_id_17; | |
return stack[sp]; | |
}; | |
}); | |
$hs_zdwgo_e_1929386748.i = [3, "$wgo", 3, 0]; | |
$hs_zdwgo_e_1929386748.gi = [3, 2]; | |
$hs_zdwgo_e_1929386748.gtag = 515; | |
$hs_zdwgo_e_1929386748.t = 3; | |
$hs_zdwgo_e_1929386748.a = 1; | |
$hs_zdwgo_e_1929386748.gai = [1]; | |
$hs_satzus1PO_e_1929386896 = (function() | |
{ | |
var $hs_ww2_1929386744; | |
$hs_ww2_1929386744 = heap[(r1 + 1)]; | |
var $hs_zdwgo_1929386748; | |
$hs_zdwgo_1929386748 = heap[(r1 + 2)]; | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
$hs_satzus1Ns_1929386750 = ($hs_ww2_1929386744 + 1); | |
r1 = $hs_zdwgo_1929386748; | |
r2 = $hs_satzus1Ns_1929386750; | |
return $hs_zdwgo_e_1929386748; | |
}); | |
$hs_satzus1PO_e_1929386896.i = [3, "sat_s1PO", 3, 0]; | |
$hs_satzus1PO_e_1929386896.gi = [3, 2]; | |
$hs_satzus1PO_e_1929386896.gtag = 515; | |
$hs_satzus1PO_e_1929386896.t = 10; | |
$hs_satzus1PO_e_1929386896.a = 0; | |
$hs_satzus1PO_e_1929386896.gai = [1]; | |
var $hs_MainzilistFromTo_e; | |
$hs_MainzilistFromTo_e = (function() | |
{ | |
var $hs_w_1929386755; | |
$hs_w_1929386755 = r2; | |
var $hs_w1_1929386758; | |
$hs_w1_1929386758 = r3; | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_18; | |
stack[(sp - 1)] = $hs_w1_1929386758; | |
r1 = $hs_w_1929386755; | |
var $hs_Main_id_22; | |
$hs_Main_id_22 = heap[r1]; | |
var $hs_Main_id_23; | |
$hs_Main_id_23 = $hs_Main_id_22.t; | |
if(($hs_Main_id_23 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_23 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_22; | |
}; | |
}; | |
}); | |
$hs_MainzilistFromTo_e.gai = [2, 3]; | |
var $hs_MainzilistFromTo; | |
$hs_MainzilistFromTo = static_fun($hs_MainzilistFromTo_e, 2, | |
"$hs_MainzilistFromTo"); | |
var $hs_Main_id_18; | |
$hs_Main_id_18 = (function() | |
{ | |
var $hs_w2_1929386912; | |
$hs_w2_1929386912 = r1; | |
var $hs_w1_1929386758; | |
$hs_w1_1929386758 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
var $hs_ww_1929386761; | |
$hs_ww_1929386761 = heap[(r1 + 1)]; | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_19; | |
stack[(sp - 1)] = $hs_ww_1929386761; | |
r1 = $hs_w1_1929386758; | |
var $hs_Main_id_20; | |
$hs_Main_id_20 = heap[r1]; | |
var $hs_Main_id_21; | |
$hs_Main_id_21 = $hs_Main_id_20.t; | |
if(($hs_Main_id_21 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_21 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_20; | |
}; | |
}; | |
}); | |
var $hs_Main_id_19; | |
$hs_Main_id_19 = (function() | |
{ | |
var $hs_w3_1929386911; | |
$hs_w3_1929386911 = r1; | |
var $hs_ww_1929386761; | |
$hs_ww_1929386761 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
var $hs_ww1_1929386762; | |
$hs_ww1_1929386762 = heap[(r1 + 1)]; | |
r1 = $hs_MainzizdwlistFromTo; | |
r2 = $hs_ww_1929386761; | |
r3 = $hs_ww1_1929386762; | |
return $hs_MainzizdwlistFromTo_e; | |
}); | |
$hs_Main_id_19.i = [2, "$hs_Main_id_19", 3]; | |
$hs_Main_id_19.gai = [1]; | |
$hs_Main_id_19.gi = [2]; | |
$hs_Main_id_19.gtag = 2; | |
$hs_Main_id_19.a = 0; | |
$hs_Main_id_19.t = 3; | |
$hs_Main_id_18.i = [2, "$hs_Main_id_18", 0]; | |
$hs_Main_id_18.gai = [1]; | |
$hs_Main_id_18.gi = [2, 1]; | |
$hs_Main_id_18.gtag = 258; | |
$hs_Main_id_18.a = 0; | |
$hs_Main_id_18.t = 3; | |
var $hs_MainzilistMap_e; | |
$hs_MainzilistMap_e = (function() | |
{ | |
var $hs_f_1929386770; | |
$hs_f_1929386770 = r2; | |
var $hs_ds_1929386765; | |
$hs_ds_1929386765 = r3; | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_24; | |
stack[(sp - 1)] = $hs_f_1929386770; | |
r1 = $hs_ds_1929386765; | |
var $hs_Main_id_27; | |
$hs_Main_id_27 = heap[r1]; | |
var $hs_Main_id_28; | |
$hs_Main_id_28 = $hs_Main_id_27.t; | |
if(($hs_Main_id_28 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_28 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_27; | |
}; | |
}; | |
}); | |
$hs_MainzilistMap_e.gai = [2, 3]; | |
var $hs_MainzilistMap; | |
$hs_MainzilistMap = static_fun($hs_MainzilistMap_e, 2, "$hs_MainzilistMap"); | |
var $hs_Main_id_24; | |
$hs_Main_id_24 = (function() | |
{ | |
var $hs_wild_1929386923; | |
$hs_wild_1929386923 = r1; | |
var $hs_f_1929386770; | |
$hs_f_1929386770 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
if((heap[$hs_wild_1929386923].a === 1)) | |
{ | |
var $hs_e_1929386769; | |
$hs_e_1929386769 = heap[(r1 + 1)]; | |
var $hs_l_1929386772; | |
$hs_l_1929386772 = heap[(r1 + 2)]; | |
var $hs_satzus1Qd_1929386921; | |
$hs_satzus1Qd_1929386921 = (hp + 0); | |
heap[(hp + 2)] = $hs_l_1929386772; | |
heap[(hp + 1)] = $hs_f_1929386770; | |
heap[hp] = $hs_satzus1Qd_e_1929386921; | |
hp = (hp + 3); | |
var $hs_satzus1Qe_1929386922; | |
$hs_satzus1Qe_1929386922 = (hp + 0); | |
heap[(hp + 2)] = $hs_f_1929386770; | |
heap[(hp + 1)] = $hs_e_1929386769; | |
heap[hp] = $hs_satzus1Qe_e_1929386922; | |
hp = (hp + 3); | |
var $hs_Main_id_25; | |
$hs_Main_id_25 = (hp + 0); | |
heap[(hp + 2)] = $hs_satzus1Qd_1929386921; | |
heap[(hp + 1)] = $hs_satzus1Qe_1929386922; | |
heap[hp] = $hs_MainziCons_con_e; | |
hp = (hp + 3); | |
r1 = $hs_Main_id_25; | |
return stack[sp]; | |
} | |
else | |
{ | |
var $hs_Main_id_26; | |
$hs_Main_id_26 = $hs_MainziNil; | |
r1 = $hs_Main_id_26; | |
return stack[sp]; | |
}; | |
}); | |
$hs_satzus1Qd_e_1929386921 = (function() | |
{ | |
var $hs_f_1929386770; | |
$hs_f_1929386770 = heap[(r1 + 1)]; | |
var $hs_l_1929386772; | |
$hs_l_1929386772 = heap[(r1 + 2)]; | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
r1 = $hs_MainzilistMap; | |
r2 = $hs_f_1929386770; | |
r3 = $hs_l_1929386772; | |
return $hs_MainzilistMap_e; | |
}); | |
$hs_satzus1Qd_e_1929386921.i = [3, "sat_s1Qd", 0, 0]; | |
$hs_satzus1Qd_e_1929386921.gi = [3, 1, 2]; | |
$hs_satzus1Qd_e_1929386921.gtag = 771; | |
$hs_satzus1Qd_e_1929386921.t = 10; | |
$hs_satzus1Qd_e_1929386921.a = 0; | |
$hs_satzus1Qd_e_1929386921.gai = [1]; | |
$hs_satzus1Qe_e_1929386922 = (function() | |
{ | |
var $hs_e_1929386769; | |
$hs_e_1929386769 = heap[(r1 + 1)]; | |
var $hs_f_1929386770; | |
$hs_f_1929386770 = heap[(r1 + 2)]; | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
r1 = $hs_f_1929386770; | |
r2 = $hs_e_1929386769; | |
return stg_ap_1_fast(); | |
}); | |
$hs_satzus1Qe_e_1929386922.i = [3, "sat_s1Qe", 0, 0]; | |
$hs_satzus1Qe_e_1929386922.gi = [3, 1, 2]; | |
$hs_satzus1Qe_e_1929386922.gtag = 771; | |
$hs_satzus1Qe_e_1929386922.t = 10; | |
$hs_satzus1Qe_e_1929386922.a = 0; | |
$hs_satzus1Qe_e_1929386922.gai = [1]; | |
$hs_Main_id_24.i = [2, "$hs_Main_id_24", 0]; | |
$hs_Main_id_24.gai = [1]; | |
$hs_Main_id_24.gi = [2, 1]; | |
$hs_Main_id_24.gtag = 258; | |
$hs_Main_id_24.a = 0; | |
$hs_Main_id_24.t = 3; | |
var $hs_MainzizdwlistLength_e; | |
$hs_MainzizdwlistLength_e = (function() | |
{ | |
var $hs_w_1929386775; | |
$hs_w_1929386775 = r2; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_29; | |
r1 = $hs_w_1929386775; | |
var $hs_Main_id_32; | |
$hs_Main_id_32 = heap[r1]; | |
var $hs_Main_id_33; | |
$hs_Main_id_33 = $hs_Main_id_32.t; | |
if(($hs_Main_id_33 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_33 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_32; | |
}; | |
}; | |
}); | |
$hs_MainzizdwlistLength_e.gai = [2]; | |
var $hs_MainzizdwlistLength; | |
$hs_MainzizdwlistLength = static_fun($hs_MainzizdwlistLength_e, 1, | |
"$hs_MainzizdwlistLength"); | |
var $hs_Main_id_29; | |
$hs_Main_id_29 = (function() | |
{ | |
var $hs_wild_1929386932; | |
$hs_wild_1929386932 = r1; | |
sp = (sp - 1); | |
if((heap[$hs_wild_1929386932].a === 1)) | |
{ | |
var $hs_l_1929386779; | |
$hs_l_1929386779 = heap[(r1 + 2)]; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_30; | |
r1 = $hs_MainzizdwlistLength; | |
r2 = $hs_l_1929386779; | |
return $hs_MainzizdwlistLength_e; | |
} | |
else | |
{ | |
r1 = 0; | |
return stack[sp]; | |
}; | |
}); | |
var $hs_Main_id_30; | |
$hs_Main_id_30 = (function() | |
{ | |
var $hs_ww_1929386781; | |
$hs_ww_1929386781 = r1; | |
sp = (sp - 1); | |
var $hs_Main_id_31; | |
$hs_Main_id_31 = (1 + $hs_ww_1929386781); | |
r1 = $hs_Main_id_31; | |
return stack[sp]; | |
}); | |
$hs_Main_id_30.i = [1, "$hs_Main_id_30"]; | |
$hs_Main_id_30.gai = []; | |
$hs_Main_id_30.gi = [1]; | |
$hs_Main_id_30.gtag = 1; | |
$hs_Main_id_30.a = 0; | |
$hs_Main_id_30.t = 3; | |
$hs_Main_id_29.i = [1, "$hs_Main_id_29"]; | |
$hs_Main_id_29.gai = [1]; | |
$hs_Main_id_29.gi = [1]; | |
$hs_Main_id_29.gtag = 1; | |
$hs_Main_id_29.a = 0; | |
$hs_Main_id_29.t = 3; | |
var $hs_MainzilistLength_e; | |
$hs_MainzilistLength_e = (function() | |
{ | |
var $hs_w_1929386783; | |
$hs_w_1929386783 = r2; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_34; | |
r1 = $hs_MainzizdwlistLength; | |
r2 = $hs_w_1929386783; | |
return $hs_MainzizdwlistLength_e; | |
}); | |
$hs_MainzilistLength_e.gai = [2]; | |
var $hs_MainzilistLength; | |
$hs_MainzilistLength = static_fun($hs_MainzilistLength_e, 1, | |
"$hs_MainzilistLength"); | |
var $hs_Main_id_34; | |
$hs_Main_id_34 = (function() | |
{ | |
var $hs_ww_1929386785; | |
$hs_ww_1929386785 = r1; | |
sp = (sp - 1); | |
var $hs_Main_id_35; | |
$hs_Main_id_35 = (hp + 0); | |
heap[(hp + 1)] = $hs_ww_1929386785; | |
heap[hp] = $hs_GHCziTypesziIzh_con_e; | |
hp = (hp + 2); | |
r1 = $hs_Main_id_35; | |
return stack[sp]; | |
}); | |
$hs_Main_id_34.i = [1, "$hs_Main_id_34"]; | |
$hs_Main_id_34.gai = []; | |
$hs_Main_id_34.gi = [1]; | |
$hs_Main_id_34.gtag = 1; | |
$hs_Main_id_34.a = 0; | |
$hs_Main_id_34.t = 3; | |
var $hs_Mainzimainzuzdssafe_e; | |
$hs_Mainzimainzuzdssafe_e = (function() | |
{ | |
var $hs_sc_1929386789; | |
$hs_sc_1929386789 = r2; | |
var $hs_sc1_1929386796; | |
$hs_sc1_1929386796 = r3; | |
var $hs_sc2_1929386799; | |
$hs_sc2_1929386799 = r4; | |
sp = (sp + 3); | |
stack[sp] = $hs_Main_id_36; | |
stack[(sp - 1)] = $hs_sc2_1929386799; | |
stack[(sp - 2)] = $hs_sc1_1929386796; | |
r1 = $hs_sc_1929386789; | |
var $hs_Main_id_44; | |
$hs_Main_id_44 = heap[r1]; | |
var $hs_Main_id_45; | |
$hs_Main_id_45 = $hs_Main_id_44.t; | |
if(($hs_Main_id_45 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_45 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_44; | |
}; | |
}; | |
}); | |
$hs_Mainzimainzuzdssafe_e.gai = [2]; | |
var $hs_Mainzimainzuzdssafe; | |
$hs_Mainzimainzuzdssafe = static_fun($hs_Mainzimainzuzdssafe_e, 3, | |
"$hs_Mainzimainzuzdssafe"); | |
var $hs_Main_id_36; | |
$hs_Main_id_36 = (function() | |
{ | |
var $hs_wild_1929386949; | |
$hs_wild_1929386949 = r1; | |
var $hs_sc1_1929386796; | |
var $hs_sc2_1929386799; | |
$hs_sc2_1929386799 = stack[(sp - 1)]; | |
$hs_sc1_1929386796 = stack[(sp - 2)]; | |
sp = (sp - 3); | |
if((heap[$hs_wild_1929386949].a === 1)) | |
{ | |
var $hs_q_1929386793; | |
$hs_q_1929386793 = heap[(r1 + 1)]; | |
var $hs_l_1929386804; | |
$hs_l_1929386804 = heap[(r1 + 2)]; | |
sp = (sp + 4); | |
stack[sp] = $hs_Main_id_37; | |
stack[(sp - 1)] = $hs_l_1929386804; | |
stack[(sp - 2)] = $hs_sc2_1929386799; | |
stack[(sp - 3)] = $hs_sc1_1929386796; | |
r1 = $hs_q_1929386793; | |
var $hs_Main_id_41; | |
$hs_Main_id_41 = heap[r1]; | |
var $hs_Main_id_42; | |
$hs_Main_id_42 = $hs_Main_id_41.t; | |
if(($hs_Main_id_42 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_42 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_41; | |
}; | |
}; | |
} | |
else | |
{ | |
var $hs_Main_id_43; | |
$hs_Main_id_43 = 1; | |
r1 = $hs_Main_id_43; | |
return stack[sp]; | |
}; | |
}); | |
var $hs_Main_id_37; | |
$hs_Main_id_37 = (function() | |
{ | |
var $hs_wild1_1929386948; | |
$hs_wild1_1929386948 = r1; | |
var $hs_sc1_1929386796; | |
var $hs_sc2_1929386799; | |
var $hs_l_1929386804; | |
$hs_l_1929386804 = stack[(sp - 1)]; | |
$hs_sc2_1929386799 = stack[(sp - 2)]; | |
$hs_sc1_1929386796 = stack[(sp - 3)]; | |
sp = (sp - 4); | |
var $hs_y_1929386797; | |
$hs_y_1929386797 = heap[(r1 + 1)]; | |
$hs_wild2_1929386947 = (($hs_sc1_1929386796 !== $hs_y_1929386797) ? 1 : 0); | |
if(($hs_wild2_1929386947 === 0)) | |
{ | |
var $hs_Main_id_38; | |
$hs_Main_id_38 = 0; | |
r1 = $hs_Main_id_38; | |
return stack[sp]; | |
} | |
else | |
{ | |
$hs_satzus1QG_1929386950 = ($hs_y_1929386797 + $hs_sc2_1929386799); | |
$hs_wild3_1929386951 = (($hs_sc1_1929386796 | |
!== | |
$hs_satzus1QG_1929386950) ? 1 : 0); | |
if(($hs_wild3_1929386951 === 0)) | |
{ | |
var $hs_Main_id_39; | |
$hs_Main_id_39 = 0; | |
r1 = $hs_Main_id_39; | |
return stack[sp]; | |
} | |
else | |
{ | |
$hs_satzus1QI_1929386952 = (($hs_y_1929386797 - $hs_sc2_1929386799) | 0); | |
$hs_wild4_1929386953 = (($hs_sc1_1929386796 | |
!== | |
$hs_satzus1QI_1929386952) ? 1 : 0); | |
if(($hs_wild4_1929386953 === 0)) | |
{ | |
var $hs_Main_id_40; | |
$hs_Main_id_40 = 0; | |
r1 = $hs_Main_id_40; | |
return stack[sp]; | |
} | |
else | |
{ | |
$hs_satzus1QK_1929386954 = ($hs_sc2_1929386799 + 1); | |
r1 = $hs_Mainzimainzuzdssafe; | |
r2 = $hs_l_1929386804; | |
r3 = $hs_sc1_1929386796; | |
r4 = $hs_satzus1QK_1929386954; | |
return $hs_Mainzimainzuzdssafe_e; | |
}; | |
}; | |
}; | |
}); | |
$hs_Main_id_37.i = [4, "$hs_Main_id_37", 3, 3, 0]; | |
$hs_Main_id_37.gai = [1]; | |
$hs_Main_id_37.gi = [4, 3]; | |
$hs_Main_id_37.gtag = 1028; | |
$hs_Main_id_37.a = 0; | |
$hs_Main_id_37.t = 3; | |
$hs_Main_id_36.i = [3, "$hs_Main_id_36", 3, 3]; | |
$hs_Main_id_36.gai = [1]; | |
$hs_Main_id_36.gi = [3]; | |
$hs_Main_id_36.gtag = 3; | |
$hs_Main_id_36.a = 0; | |
$hs_Main_id_36.t = 3; | |
var $hs_Mainzizdwnsoln_e; | |
$hs_Mainzizdwnsoln_e = (function() | |
{ | |
var $hs_ww_1929386808; | |
$hs_ww_1929386808 = r2; | |
var $hs_lvl_1929386809; | |
$hs_lvl_1929386809 = (hp + 0); | |
heap[(hp + 1)] = $hs_ww_1929386808; | |
heap[hp] = $hs_lvl_e_1929386809; | |
hp = (hp + 2); | |
var $hs_lvl1_1929386836; | |
$hs_lvl1_1929386836 = (hp + 0); | |
heap[(hp + 1)] = $hs_lvl_1929386809; | |
heap[hp] = $hs_lvl1_e_1929386836; | |
hp = (hp + 2); | |
var $hs_zdwgen_1929386842; | |
$hs_zdwgen_1929386842 = (hp + 0); | |
heap[(hp + 2)] = $hs_zdwgen_1929386842; | |
heap[(hp + 1)] = $hs_lvl1_1929386836; | |
heap[hp] = $hs_zdwgen_e_1929386842; | |
hp = (hp + 3); | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_65; | |
r1 = $hs_zdwgen_1929386842; | |
r2 = $hs_ww_1929386808; | |
return $hs_zdwgen_e_1929386842; | |
}); | |
$hs_Mainzizdwnsoln_e.gai = []; | |
var $hs_Mainzizdwnsoln; | |
$hs_Mainzizdwnsoln = static_fun($hs_Mainzizdwnsoln_e, 1, "$hs_Mainzizdwnsoln"); | |
$hs_lvl_e_1929386809 = (function() | |
{ | |
var $hs_ww_1929386808; | |
$hs_ww_1929386808 = heap[(r1 + 1)]; | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
r1 = $hs_MainzizdwlistFromTo; | |
r2 = 1; | |
r3 = $hs_ww_1929386808; | |
return $hs_MainzizdwlistFromTo_e; | |
}); | |
$hs_lvl_e_1929386809.i = [2, "lvl", 3]; | |
$hs_lvl_e_1929386809.gi = [2]; | |
$hs_lvl_e_1929386809.gtag = 2; | |
$hs_lvl_e_1929386809.t = 10; | |
$hs_lvl_e_1929386809.a = 0; | |
$hs_lvl_e_1929386809.gai = [1]; | |
$hs_lvl1_e_1929386836 = (function() | |
{ | |
var $hs_lvl_1929386809; | |
$hs_lvl_1929386809 = heap[(r1 + 1)]; | |
var $hs_bs_1929386814; | |
$hs_bs_1929386814 = r2; | |
var $hs_satzus1Rg_1929386986; | |
$hs_satzus1Rg_1929386986 = (hp + 0); | |
heap[(hp + 1)] = $hs_bs_1929386814; | |
heap[hp] = $hs_satzus1Rg_e_1929386986; | |
hp = (hp + 2); | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_59; | |
stack[(sp - 1)] = $hs_bs_1929386814; | |
r1 = $hs_MainzilistFilter; | |
r2 = $hs_satzus1Rg_1929386986; | |
r3 = $hs_lvl_1929386809; | |
return $hs_MainzilistFilter_e; | |
}); | |
$hs_lvl1_e_1929386836.i = [2, "lvl1", 0]; | |
$hs_lvl1_e_1929386836.gi = [2, 1]; | |
$hs_lvl1_e_1929386836.gtag = 258; | |
$hs_lvl1_e_1929386836.t = 3; | |
$hs_lvl1_e_1929386836.a = 1; | |
$hs_lvl1_e_1929386836.gai = [1, 2]; | |
$hs_satzus1Rg_e_1929386986 = (function() | |
{ | |
var $hs_bs_1929386814; | |
$hs_bs_1929386814 = heap[(r1 + 1)]; | |
var $hs_q_1929386820; | |
$hs_q_1929386820 = r2; | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_46; | |
stack[(sp - 1)] = $hs_q_1929386820; | |
r1 = $hs_bs_1929386814; | |
var $hs_Main_id_57; | |
$hs_Main_id_57 = heap[r1]; | |
var $hs_Main_id_58; | |
$hs_Main_id_58 = $hs_Main_id_57.t; | |
if(($hs_Main_id_58 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_58 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_57; | |
}; | |
}; | |
}); | |
$hs_satzus1Rg_e_1929386986.i = [2, "sat_s1Rg", 0]; | |
$hs_satzus1Rg_e_1929386986.gi = [2, 1]; | |
$hs_satzus1Rg_e_1929386986.gtag = 258; | |
$hs_satzus1Rg_e_1929386986.t = 3; | |
$hs_satzus1Rg_e_1929386986.a = 1; | |
$hs_satzus1Rg_e_1929386986.gai = [1, 2]; | |
var $hs_Main_id_46; | |
$hs_Main_id_46 = (function() | |
{ | |
var $hs_wild_1929386996; | |
$hs_wild_1929386996 = r1; | |
var $hs_q_1929386820; | |
$hs_q_1929386820 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
if((heap[$hs_wild_1929386996].a === 1)) | |
{ | |
var $hs_q1_1929386823; | |
$hs_q1_1929386823 = heap[(r1 + 1)]; | |
var $hs_l_1929386833; | |
$hs_l_1929386833 = heap[(r1 + 2)]; | |
sp = (sp + 3); | |
stack[sp] = $hs_Main_id_47; | |
stack[(sp - 1)] = $hs_l_1929386833; | |
stack[(sp - 2)] = $hs_q1_1929386823; | |
r1 = $hs_q_1929386820; | |
var $hs_Main_id_54; | |
$hs_Main_id_54 = heap[r1]; | |
var $hs_Main_id_55; | |
$hs_Main_id_55 = $hs_Main_id_54.t; | |
if(($hs_Main_id_55 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_55 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_54; | |
}; | |
}; | |
} | |
else | |
{ | |
var $hs_Main_id_56; | |
$hs_Main_id_56 = 1; | |
r1 = $hs_Main_id_56; | |
return stack[sp]; | |
}; | |
}); | |
var $hs_Main_id_47; | |
$hs_Main_id_47 = (function() | |
{ | |
var $hs_wild1_1929386995; | |
$hs_wild1_1929386995 = r1; | |
var $hs_q1_1929386823; | |
var $hs_l_1929386833; | |
$hs_l_1929386833 = stack[(sp - 1)]; | |
$hs_q1_1929386823 = stack[(sp - 2)]; | |
sp = (sp - 3); | |
var $hs_x_1929386826; | |
$hs_x_1929386826 = heap[(r1 + 1)]; | |
sp = (sp + 3); | |
stack[sp] = $hs_Main_id_48; | |
stack[(sp - 1)] = $hs_l_1929386833; | |
stack[(sp - 2)] = $hs_x_1929386826; | |
r1 = $hs_q1_1929386823; | |
var $hs_Main_id_52; | |
$hs_Main_id_52 = heap[r1]; | |
var $hs_Main_id_53; | |
$hs_Main_id_53 = $hs_Main_id_52.t; | |
if(($hs_Main_id_53 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_53 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_52; | |
}; | |
}; | |
}); | |
var $hs_Main_id_48; | |
$hs_Main_id_48 = (function() | |
{ | |
var $hs_wild2_1929386994; | |
$hs_wild2_1929386994 = r1; | |
var $hs_x_1929386826; | |
var $hs_l_1929386833; | |
$hs_l_1929386833 = stack[(sp - 1)]; | |
$hs_x_1929386826 = stack[(sp - 2)]; | |
sp = (sp - 3); | |
var $hs_y_1929386827; | |
$hs_y_1929386827 = heap[(r1 + 1)]; | |
$hs_wild3_1929386993 = (($hs_x_1929386826 !== $hs_y_1929386827) ? 1 : 0); | |
if(($hs_wild3_1929386993 === 0)) | |
{ | |
var $hs_Main_id_49; | |
$hs_Main_id_49 = 0; | |
r1 = $hs_Main_id_49; | |
return stack[sp]; | |
} | |
else | |
{ | |
$hs_satzus1Rl_1929386991 = ($hs_y_1929386827 + 1); | |
$hs_wild4_1929386997 = (($hs_x_1929386826 | |
!== | |
$hs_satzus1Rl_1929386991) ? 1 : 0); | |
if(($hs_wild4_1929386997 === 0)) | |
{ | |
var $hs_Main_id_50; | |
$hs_Main_id_50 = 0; | |
r1 = $hs_Main_id_50; | |
return stack[sp]; | |
} | |
else | |
{ | |
$hs_satzus1Rm_1929386992 = (($hs_y_1929386827 - 1) | 0); | |
$hs_wild5_1929386998 = (($hs_x_1929386826 | |
!== | |
$hs_satzus1Rm_1929386992) ? 1 : 0); | |
if(($hs_wild5_1929386998 === 0)) | |
{ | |
var $hs_Main_id_51; | |
$hs_Main_id_51 = 0; | |
r1 = $hs_Main_id_51; | |
return stack[sp]; | |
} | |
else | |
{ | |
r1 = $hs_Mainzimainzuzdssafe; | |
r2 = $hs_l_1929386833; | |
r3 = $hs_x_1929386826; | |
r4 = 2; | |
return $hs_Mainzimainzuzdssafe_e; | |
}; | |
}; | |
}; | |
}); | |
$hs_Main_id_48.i = [3, "$hs_Main_id_48", 3, 0]; | |
$hs_Main_id_48.gai = [1]; | |
$hs_Main_id_48.gi = [3, 2]; | |
$hs_Main_id_48.gtag = 515; | |
$hs_Main_id_48.a = 0; | |
$hs_Main_id_48.t = 3; | |
$hs_Main_id_47.i = [3, "$hs_Main_id_47", 0, 0]; | |
$hs_Main_id_47.gai = [1]; | |
$hs_Main_id_47.gi = [3, 1, 2]; | |
$hs_Main_id_47.gtag = 771; | |
$hs_Main_id_47.a = 0; | |
$hs_Main_id_47.t = 3; | |
$hs_Main_id_46.i = [2, "$hs_Main_id_46", 0]; | |
$hs_Main_id_46.gai = [1]; | |
$hs_Main_id_46.gi = [2, 1]; | |
$hs_Main_id_46.gtag = 258; | |
$hs_Main_id_46.a = 0; | |
$hs_Main_id_46.t = 3; | |
var $hs_Main_id_59; | |
$hs_Main_id_59 = (function() | |
{ | |
var $hs_satzus1Rh_1929386987; | |
$hs_satzus1Rh_1929386987 = r1; | |
var $hs_bs_1929386814; | |
$hs_bs_1929386814 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
var $hs_satzus1Ri_1929386988; | |
$hs_satzus1Ri_1929386988 = (hp + 0); | |
heap[(hp + 1)] = $hs_bs_1929386814; | |
heap[hp] = $hs_satzus1Ri_e_1929386988; | |
hp = (hp + 2); | |
r1 = $hs_MainzilistMap; | |
r2 = $hs_satzus1Ri_1929386988; | |
r3 = $hs_satzus1Rh_1929386987; | |
return $hs_MainzilistMap_e; | |
}); | |
$hs_satzus1Ri_e_1929386988 = (function() | |
{ | |
var $hs_bs_1929386814; | |
$hs_bs_1929386814 = heap[(r1 + 1)]; | |
var $hs_q_1929386813; | |
$hs_q_1929386813 = r2; | |
var $hs_Main_id_60; | |
$hs_Main_id_60 = (hp + 0); | |
heap[(hp + 2)] = $hs_bs_1929386814; | |
heap[(hp + 1)] = $hs_q_1929386813; | |
heap[hp] = $hs_MainziCons_con_e; | |
hp = (hp + 3); | |
r1 = $hs_Main_id_60; | |
return stack[sp]; | |
}); | |
$hs_satzus1Ri_e_1929386988.i = [2, "sat_s1Ri", 0]; | |
$hs_satzus1Ri_e_1929386988.gi = [2, 1]; | |
$hs_satzus1Ri_e_1929386988.gtag = 258; | |
$hs_satzus1Ri_e_1929386988.t = 3; | |
$hs_satzus1Ri_e_1929386988.a = 1; | |
$hs_satzus1Ri_e_1929386988.gai = [1, 2]; | |
$hs_Main_id_59.i = [2, "$hs_Main_id_59", 0]; | |
$hs_Main_id_59.gai = [1]; | |
$hs_Main_id_59.gi = [2, 1]; | |
$hs_Main_id_59.gtag = 258; | |
$hs_Main_id_59.a = 0; | |
$hs_Main_id_59.t = 3; | |
$hs_zdwgen_e_1929386842 = (function() | |
{ | |
var $hs_lvl1_1929386836; | |
$hs_lvl1_1929386836 = heap[(r1 + 1)]; | |
var $hs_zdwgen_1929386842; | |
$hs_zdwgen_1929386842 = heap[(r1 + 2)]; | |
var $hs_ww1_1929386839; | |
$hs_ww1_1929386839 = r2; | |
var $hs_ds_1929386841; | |
$hs_ds_1929386841 = $hs_ww1_1929386839; | |
if(($hs_ds_1929386841 === 0)) | |
{ | |
r1 = $hs_Mainzimain3; | |
var $hs_Main_id_61; | |
$hs_Main_id_61 = heap[r1]; | |
var $hs_Main_id_62; | |
$hs_Main_id_62 = $hs_Main_id_61.t; | |
if(($hs_Main_id_62 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_62 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_61; | |
}; | |
}; | |
} | |
else | |
{ | |
$hs_satzus1OY_1929386844 = (($hs_ds_1929386841 - 1) | 0); | |
sp = (sp + 2); | |
stack[sp] = $hs_Main_id_63; | |
stack[(sp - 1)] = $hs_lvl1_1929386836; | |
r1 = $hs_zdwgen_1929386842; | |
r2 = $hs_satzus1OY_1929386844; | |
return $hs_zdwgen_e_1929386842; | |
}; | |
}); | |
$hs_zdwgen_e_1929386842.i = [3, "$wgen", 0, 0]; | |
$hs_zdwgen_e_1929386842.gi = [3, 1, 2]; | |
$hs_zdwgen_e_1929386842.gtag = 771; | |
$hs_zdwgen_e_1929386842.t = 3; | |
$hs_zdwgen_e_1929386842.a = 1; | |
$hs_zdwgen_e_1929386842.gai = [1]; | |
var $hs_Main_id_63; | |
$hs_Main_id_63 = (function() | |
{ | |
var $hs_satzus1P0_1929386846; | |
$hs_satzus1P0_1929386846 = r1; | |
var $hs_lvl1_1929386836; | |
$hs_lvl1_1929386836 = stack[(sp - 1)]; | |
sp = (sp - 2); | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_64; | |
r1 = $hs_MainzilistMap; | |
r2 = $hs_lvl1_1929386836; | |
r3 = $hs_satzus1P0_1929386846; | |
return $hs_MainzilistMap_e; | |
}); | |
var $hs_Main_id_64; | |
$hs_Main_id_64 = (function() | |
{ | |
var $hs_satzus1Rj_1929386989; | |
$hs_satzus1Rj_1929386989 = r1; | |
sp = (sp - 1); | |
r1 = $hs_MainzilistConcat; | |
r2 = $hs_satzus1Rj_1929386989; | |
return $hs_MainzilistConcat_e; | |
}); | |
$hs_Main_id_64.i = [1, "$hs_Main_id_64"]; | |
$hs_Main_id_64.gai = [1]; | |
$hs_Main_id_64.gi = [1]; | |
$hs_Main_id_64.gtag = 1; | |
$hs_Main_id_64.a = 0; | |
$hs_Main_id_64.t = 3; | |
$hs_Main_id_63.i = [2, "$hs_Main_id_63", 0]; | |
$hs_Main_id_63.gai = [1]; | |
$hs_Main_id_63.gi = [2, 1]; | |
$hs_Main_id_63.gtag = 258; | |
$hs_Main_id_63.a = 0; | |
$hs_Main_id_63.t = 3; | |
var $hs_Main_id_65; | |
$hs_Main_id_65 = (function() | |
{ | |
var $hs_satzus1Rk_1929386990; | |
$hs_satzus1Rk_1929386990 = r1; | |
sp = (sp - 1); | |
r1 = $hs_MainzizdwlistLength; | |
r2 = $hs_satzus1Rk_1929386990; | |
return $hs_MainzizdwlistLength_e; | |
}); | |
$hs_Main_id_65.i = [1, "$hs_Main_id_65"]; | |
$hs_Main_id_65.gai = [1]; | |
$hs_Main_id_65.gi = [1]; | |
$hs_Main_id_65.gtag = 1; | |
$hs_Main_id_65.a = 0; | |
$hs_Main_id_65.t = 3; | |
var $hs_Mainzinsoln_e; | |
$hs_Mainzinsoln_e = (function() | |
{ | |
var $hs_w_1929386850; | |
$hs_w_1929386850 = r2; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_66; | |
r1 = $hs_w_1929386850; | |
var $hs_Main_id_69; | |
$hs_Main_id_69 = heap[r1]; | |
var $hs_Main_id_70; | |
$hs_Main_id_70 = $hs_Main_id_69.t; | |
if(($hs_Main_id_70 === 5)) | |
{ | |
return stack[sp]; | |
} | |
else | |
{ | |
if(($hs_Main_id_70 === 14)) | |
{ | |
r1 = heap[(r1 + 1)]; | |
return stack[sp]; | |
} | |
else | |
{ | |
return $hs_Main_id_69; | |
}; | |
}; | |
}); | |
$hs_Mainzinsoln_e.gai = [2]; | |
var $hs_Mainzinsoln; | |
$hs_Mainzinsoln = static_fun($hs_Mainzinsoln_e, 1, "$hs_Mainzinsoln"); | |
var $hs_Main_id_66; | |
$hs_Main_id_66 = (function() | |
{ | |
var $hs_w1_1929387053; | |
$hs_w1_1929387053 = r1; | |
sp = (sp - 1); | |
var $hs_ww_1929386853; | |
$hs_ww_1929386853 = heap[(r1 + 1)]; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_67; | |
r1 = $hs_Mainzizdwnsoln; | |
r2 = $hs_ww_1929386853; | |
return $hs_Mainzizdwnsoln_e; | |
}); | |
var $hs_Main_id_67; | |
$hs_Main_id_67 = (function() | |
{ | |
var $hs_ww1_1929386855; | |
$hs_ww1_1929386855 = r1; | |
sp = (sp - 1); | |
var $hs_Main_id_68; | |
$hs_Main_id_68 = (hp + 0); | |
heap[(hp + 1)] = $hs_ww1_1929386855; | |
heap[hp] = $hs_GHCziTypesziIzh_con_e; | |
hp = (hp + 2); | |
r1 = $hs_Main_id_68; | |
return stack[sp]; | |
}); | |
$hs_Main_id_67.i = [1, "$hs_Main_id_67"]; | |
$hs_Main_id_67.gai = []; | |
$hs_Main_id_67.gi = [1]; | |
$hs_Main_id_67.gtag = 1; | |
$hs_Main_id_67.a = 0; | |
$hs_Main_id_67.t = 3; | |
$hs_Main_id_66.i = [1, "$hs_Main_id_66"]; | |
$hs_Main_id_66.gai = [1]; | |
$hs_Main_id_66.gi = [1]; | |
$hs_Main_id_66.gtag = 1; | |
$hs_Main_id_66.a = 0; | |
$hs_Main_id_66.t = 3; | |
var $hs_Mainzisolvijg_e; | |
$hs_Mainzisolvijg_e = (function() | |
{ | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_71; | |
r1 = $hs_Mainzizdwnsoln; | |
r2 = 5; | |
return $hs_Mainzizdwnsoln_e; | |
}); | |
$hs_Mainzisolvijg_e.gai = []; | |
var $hs_Mainzisolvijg; | |
$hs_Mainzisolvijg = static_thunk($hs_Mainzisolvijg_e, "$hs_Mainzisolvijg"); | |
var $hs_Main_id_71; | |
$hs_Main_id_71 = (function() | |
{ | |
var $hs_ww_1929386857; | |
$hs_ww_1929386857 = r1; | |
sp = (sp - 1); | |
var $hs_Main_id_72; | |
$hs_Main_id_72 = (hp + 0); | |
heap[(hp + 1)] = $hs_ww_1929386857; | |
heap[hp] = $hs_GHCziTypesziIzh_con_e; | |
hp = (hp + 2); | |
r1 = $hs_Main_id_72; | |
return stack[sp]; | |
}); | |
$hs_Main_id_71.i = [1, "$hs_Main_id_71"]; | |
$hs_Main_id_71.gai = []; | |
$hs_Main_id_71.gi = [1]; | |
$hs_Main_id_71.gtag = 1; | |
$hs_Main_id_71.a = 0; | |
$hs_Main_id_71.t = 3; | |
var $hs_Mainzimain2_e; | |
$hs_Mainzimain2_e = (function() | |
{ | |
heap[r1] = blackhole; | |
sp = (sp + 2); | |
stack[sp] = stg_upd_frame; | |
stack[(sp - 1)] = r1; | |
sp = (sp + 1); | |
stack[sp] = $hs_Main_id_73; | |
r1 = $hs_Mainzizdwnsoln; | |
r2 = 11; | |
return $hs_Mainzizdwnsoln_e; | |
}); | |
$hs_Mainzimain2_e.gai = []; | |
var $hs_Mainzimain2; | |
$hs_Mainzimain2 = static_thunk($hs_Mainzimain2_e, "$hs_Mainzimain2"); | |
var $hs_Main_id_73; | |
$hs_Main_id_73 = (function() | |
{ | |
var $hs_ww_1929386859; | |
$hs_ww_1929386859 = r1; | |
sp = (sp - 1); | |
var $hs_Main_id_74; | |
$hs_Main_id_74 = (hp + 0); | |
heap[(hp + 1)] = $hs_ww_1929386859; | |
heap[hp] = $hs_GHCziTypesziIzh_con_e; | |
hp = (hp + 2); | |
r1 = $hs_Main_id_74; | |
return stack[sp]; | |
}); | |
$hs_Main_id_73.i = [1, "$hs_Main_id_73"]; | |
$hs_Main_id_73.gai = []; | |
$hs_Main_id_73.gi = [1]; | |
$hs_Main_id_73.gtag = 1; | |
$hs_Main_id_73.a = 0; | |
$hs_Main_id_73.t = 3; | |
var $hs_Mainzimain1_e; | |
$hs_Mainzimain1_e = (function() | |
{ | |
r1 = $hs_Mainzimain2; | |
return stack[sp]; | |
}); | |
$hs_Mainzimain1_e.gai = []; | |
var $hs_Mainzimain1; | |
$hs_Mainzimain1 = static_fun($hs_Mainzimain1_e, 1, "$hs_Mainzimain1"); | |
var $hs_Mainzimain_e; | |
$hs_Mainzimain_e = (function() | |
{ | |
r1 = $hs_Mainzimain1; | |
return stg_ap_v_fast(); | |
}); | |
$hs_Mainzimain_e.gai = []; | |
var $hs_Mainzimain; | |
$hs_Mainzimain = static_fun($hs_Mainzimain_e, 1, "$hs_Mainzimain"); | |
var $hs_Mainzimain4_e; | |
$hs_Mainzimain4_e = (function() | |
{ | |
r1 = $hs_GHCziTopHandlerzirunMainIO1; | |
r2 = $hs_Mainzimain1; | |
return $hs_GHCziTopHandlerzirunMainIO1_e; | |
}); | |
$hs_Mainzimain4_e.gai = []; | |
var $hs_Mainzimain4; | |
$hs_Mainzimain4 = static_fun($hs_Mainzimain4_e, 1, "$hs_Mainzimain4"); | |
var $hs_ZCMainzimain_e; | |
$hs_ZCMainzimain_e = (function() | |
{ | |
r1 = $hs_Mainzimain4; | |
return stg_ap_v_fast(); | |
}); | |
$hs_ZCMainzimain_e.gai = []; | |
var $hs_ZCMainzimain; | |
$hs_ZCMainzimain = static_fun($hs_ZCMainzimain_e, 1, "$hs_ZCMainzimain"); | |
var $hs_MainziCons_e; | |
$hs_MainziCons_e = (function() | |
{ | |
var $hs_etazuB2_1107296258; | |
$hs_etazuB2_1107296258 = r2; | |
var $hs_etazuB1_1107296257; | |
$hs_etazuB1_1107296257 = r3; | |
var $hs_Main_id_75; | |
$hs_Main_id_75 = (hp + 0); | |
heap[(hp + 2)] = $hs_etazuB1_1107296257; | |
heap[(hp + 1)] = $hs_etazuB2_1107296258; | |
heap[hp] = $hs_MainziCons_con_e; | |
hp = (hp + 3); | |
r1 = $hs_Main_id_75; | |
return stack[sp]; | |
}); | |
$hs_MainziCons_e.gai = [2, 3]; | |
var $hs_MainziCons; | |
$hs_MainziCons = static_fun($hs_MainziCons_e, 2, "$hs_MainziCons"); | |
var $hs_Mainzimain3; | |
$hs_Mainzimain3 = alloc_static(3); | |
initStatic.push((function() | |
{ | |
init_closure($hs_Mainzimain3, $hs_MainziCons_con_e, [$hs_MainziNil, | |
$hs_MainziNil]); | |
})); | |
var $hs_MainziCons_con_e; | |
$hs_MainziCons_con_e = (function() | |
{ | |
return stack[sp]; | |
}); | |
$hs_MainziCons_con_e.i = [3, "Main.Cons", 0, 0]; | |
$hs_MainziCons_con_e.gi = [3, 1, 2]; | |
$hs_MainziCons_con_e.gtag = 771; | |
$hs_MainziCons_con_e.t = 5; | |
$hs_MainziCons_con_e.a = 1; | |
$hs_MainziCons_con_e.gai = [1]; | |
var $hs_MainziNil_con_e; | |
$hs_MainziNil_con_e = (function() | |
{ | |
return stack[sp]; | |
}); | |
$hs_MainziNil_con_e.i = [1, "Main.Nil"]; | |
$hs_MainziNil_con_e.gi = [1]; | |
$hs_MainziNil_con_e.gtag = 1; | |
$hs_MainziNil_con_e.t = 5; | |
$hs_MainziNil_con_e.a = 2; | |
$hs_MainziNil_con_e.gai = [1]; | |
var $hs_MainziNil; | |
$hs_MainziNil = static_con0($hs_MainziNil_con_e); | |
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_MainzilistAppend_e = $hs_MainzilistAppend_e; | |
exports.$hs_MainzilistAppend = $hs_MainzilistAppend; | |
exports.$hs_Main_id_0 = $hs_Main_id_0; | |
exports.$hs_MainzilistConcat_e = $hs_MainzilistConcat_e; | |
exports.$hs_MainzilistConcat = $hs_MainzilistConcat; | |
exports.$hs_Main_id_6 = $hs_Main_id_6; | |
exports.$hs_MainzilistFilter_e = $hs_MainzilistFilter_e; | |
exports.$hs_MainzilistFilter = $hs_MainzilistFilter; | |
exports.$hs_Main_id_10 = $hs_Main_id_10; | |
exports.$hs_Main_id_11 = $hs_Main_id_11; | |
exports.$hs_MainzizdwlistFromTo_e = $hs_MainzizdwlistFromTo_e; | |
exports.$hs_MainzizdwlistFromTo = $hs_MainzizdwlistFromTo; | |
exports.$hs_MainzilistFromTo_e = $hs_MainzilistFromTo_e; | |
exports.$hs_MainzilistFromTo = $hs_MainzilistFromTo; | |
exports.$hs_Main_id_18 = $hs_Main_id_18; | |
exports.$hs_Main_id_19 = $hs_Main_id_19; | |
exports.$hs_MainzilistMap_e = $hs_MainzilistMap_e; | |
exports.$hs_MainzilistMap = $hs_MainzilistMap; | |
exports.$hs_Main_id_24 = $hs_Main_id_24; | |
exports.$hs_MainzizdwlistLength_e = $hs_MainzizdwlistLength_e; | |
exports.$hs_MainzizdwlistLength = $hs_MainzizdwlistLength; | |
exports.$hs_Main_id_29 = $hs_Main_id_29; | |
exports.$hs_Main_id_30 = $hs_Main_id_30; | |
exports.$hs_MainzilistLength_e = $hs_MainzilistLength_e; | |
exports.$hs_MainzilistLength = $hs_MainzilistLength; | |
exports.$hs_Main_id_34 = $hs_Main_id_34; | |
exports.$hs_Mainzimainzuzdssafe_e = $hs_Mainzimainzuzdssafe_e; | |
exports.$hs_Mainzimainzuzdssafe = $hs_Mainzimainzuzdssafe; | |
exports.$hs_Main_id_36 = $hs_Main_id_36; | |
exports.$hs_Main_id_37 = $hs_Main_id_37; | |
exports.$hs_Mainzizdwnsoln_e = $hs_Mainzizdwnsoln_e; | |
exports.$hs_Mainzizdwnsoln = $hs_Mainzizdwnsoln; | |
exports.$hs_Main_id_46 = $hs_Main_id_46; | |
exports.$hs_Main_id_47 = $hs_Main_id_47; | |
exports.$hs_Main_id_48 = $hs_Main_id_48; | |
exports.$hs_Main_id_59 = $hs_Main_id_59; | |
exports.$hs_Main_id_63 = $hs_Main_id_63; | |
exports.$hs_Main_id_64 = $hs_Main_id_64; | |
exports.$hs_Main_id_65 = $hs_Main_id_65; | |
exports.$hs_Mainzinsoln_e = $hs_Mainzinsoln_e; | |
exports.$hs_Mainzinsoln = $hs_Mainzinsoln; | |
exports.$hs_Main_id_66 = $hs_Main_id_66; | |
exports.$hs_Main_id_67 = $hs_Main_id_67; | |
exports.$hs_Mainzisolvijg_e = $hs_Mainzisolvijg_e; | |
exports.$hs_Mainzisolvijg = $hs_Mainzisolvijg; | |
exports.$hs_Main_id_71 = $hs_Main_id_71; | |
exports.$hs_Mainzimain2_e = $hs_Mainzimain2_e; | |
exports.$hs_Mainzimain2 = $hs_Mainzimain2; | |
exports.$hs_Main_id_73 = $hs_Main_id_73; | |
exports.$hs_Mainzimain1_e = $hs_Mainzimain1_e; | |
exports.$hs_Mainzimain1 = $hs_Mainzimain1; | |
exports.$hs_Mainzimain_e = $hs_Mainzimain_e; | |
exports.$hs_Mainzimain = $hs_Mainzimain; | |
exports.$hs_Mainzimain4_e = $hs_Mainzimain4_e; | |
exports.$hs_Mainzimain4 = $hs_Mainzimain4; | |
exports.$hs_ZCMainzimain_e = $hs_ZCMainzimain_e; | |
exports.$hs_ZCMainzimain = $hs_ZCMainzimain; | |
exports.$hs_MainziCons_e = $hs_MainziCons_e; | |
exports.$hs_MainziCons = $hs_MainziCons; | |
exports.$hs_Mainzimain3 = $hs_Mainzimain3; | |
exports.$hs_MainziCons_con_e = $hs_MainziCons_con_e; | |
exports.$hs_MainziNil_con_e = $hs_MainziNil_con_e; | |
exports.$hs_MainziNil = $hs_MainziNil; | |
}; | |
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_Mainzimain), 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