Created
January 23, 2015 09:52
-
-
Save viclib/9108f02fb1655cdc0787 to your computer and use it in GitHub Desktop.
print array after result
This file has been truncated, but you can view the full file.
This file contains hidden or 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
var h$currentThread = null; | |
var h$stack = null; | |
var h$sp = 0; | |
var h$initStatic = []; | |
var h$staticThunks = {}; | |
var h$staticThunksArr = []; | |
var h$regs = []; | |
var h$r1 = 0; | |
var h$r2 = 0; | |
var h$r3 = 0; | |
var h$r4 = 0; | |
var h$r5 = 0; | |
var h$r6 = 0; | |
var h$r7 = 0; | |
var h$r8 = 0; | |
var h$r9 = 0; | |
var h$r10 = 0; | |
var h$r11 = 0; | |
var h$r12 = 0; | |
var h$r13 = 0; | |
var h$r14 = 0; | |
var h$r15 = 0; | |
var h$r16 = 0; | |
var h$r17 = 0; | |
var h$r18 = 0; | |
var h$r19 = 0; | |
var h$r20 = 0; | |
var h$r21 = 0; | |
var h$r22 = 0; | |
var h$r23 = 0; | |
var h$r24 = 0; | |
var h$r25 = 0; | |
var h$r26 = 0; | |
var h$r27 = 0; | |
var h$r28 = 0; | |
var h$r29 = 0; | |
var h$r30 = 0; | |
var h$r31 = 0; | |
var h$r32 = 0; | |
function h$getReg(h$RTSD_0) | |
{ | |
switch (h$RTSD_0) | |
{ | |
case (1): | |
return h$r1; | |
case (2): | |
return h$r2; | |
case (3): | |
return h$r3; | |
case (4): | |
return h$r4; | |
case (5): | |
return h$r5; | |
case (6): | |
return h$r6; | |
case (7): | |
return h$r7; | |
case (8): | |
return h$r8; | |
case (9): | |
return h$r9; | |
case (10): | |
return h$r10; | |
case (11): | |
return h$r11; | |
case (12): | |
return h$r12; | |
case (13): | |
return h$r13; | |
case (14): | |
return h$r14; | |
case (15): | |
return h$r15; | |
case (16): | |
return h$r16; | |
case (17): | |
return h$r17; | |
case (18): | |
return h$r18; | |
case (19): | |
return h$r19; | |
case (20): | |
return h$r20; | |
case (21): | |
return h$r21; | |
case (22): | |
return h$r22; | |
case (23): | |
return h$r23; | |
case (24): | |
return h$r24; | |
case (25): | |
return h$r25; | |
case (26): | |
return h$r26; | |
case (27): | |
return h$r27; | |
case (28): | |
return h$r28; | |
case (29): | |
return h$r29; | |
case (30): | |
return h$r30; | |
case (31): | |
return h$r31; | |
case (32): | |
return h$r32; | |
case (33): | |
return h$regs[0]; | |
case (34): | |
return h$regs[1]; | |
case (35): | |
return h$regs[2]; | |
case (36): | |
return h$regs[3]; | |
case (37): | |
return h$regs[4]; | |
case (38): | |
return h$regs[5]; | |
case (39): | |
return h$regs[6]; | |
case (40): | |
return h$regs[7]; | |
case (41): | |
return h$regs[8]; | |
case (42): | |
return h$regs[9]; | |
case (43): | |
return h$regs[10]; | |
case (44): | |
return h$regs[11]; | |
case (45): | |
return h$regs[12]; | |
case (46): | |
return h$regs[13]; | |
case (47): | |
return h$regs[14]; | |
case (48): | |
return h$regs[15]; | |
case (49): | |
return h$regs[16]; | |
case (50): | |
return h$regs[17]; | |
case (51): | |
return h$regs[18]; | |
case (52): | |
return h$regs[19]; | |
case (53): | |
return h$regs[20]; | |
case (54): | |
return h$regs[21]; | |
case (55): | |
return h$regs[22]; | |
case (56): | |
return h$regs[23]; | |
case (57): | |
return h$regs[24]; | |
case (58): | |
return h$regs[25]; | |
case (59): | |
return h$regs[26]; | |
case (60): | |
return h$regs[27]; | |
case (61): | |
return h$regs[28]; | |
case (62): | |
return h$regs[29]; | |
case (63): | |
return h$regs[30]; | |
case (64): | |
return h$regs[31]; | |
case (65): | |
return h$regs[32]; | |
case (66): | |
return h$regs[33]; | |
case (67): | |
return h$regs[34]; | |
case (68): | |
return h$regs[35]; | |
case (69): | |
return h$regs[36]; | |
case (70): | |
return h$regs[37]; | |
case (71): | |
return h$regs[38]; | |
case (72): | |
return h$regs[39]; | |
case (73): | |
return h$regs[40]; | |
case (74): | |
return h$regs[41]; | |
case (75): | |
return h$regs[42]; | |
case (76): | |
return h$regs[43]; | |
case (77): | |
return h$regs[44]; | |
case (78): | |
return h$regs[45]; | |
case (79): | |
return h$regs[46]; | |
case (80): | |
return h$regs[47]; | |
case (81): | |
return h$regs[48]; | |
case (82): | |
return h$regs[49]; | |
case (83): | |
return h$regs[50]; | |
case (84): | |
return h$regs[51]; | |
case (85): | |
return h$regs[52]; | |
case (86): | |
return h$regs[53]; | |
case (87): | |
return h$regs[54]; | |
case (88): | |
return h$regs[55]; | |
case (89): | |
return h$regs[56]; | |
case (90): | |
return h$regs[57]; | |
case (91): | |
return h$regs[58]; | |
case (92): | |
return h$regs[59]; | |
case (93): | |
return h$regs[60]; | |
case (94): | |
return h$regs[61]; | |
case (95): | |
return h$regs[62]; | |
case (96): | |
return h$regs[63]; | |
case (97): | |
return h$regs[64]; | |
case (98): | |
return h$regs[65]; | |
case (99): | |
return h$regs[66]; | |
case (100): | |
return h$regs[67]; | |
case (101): | |
return h$regs[68]; | |
case (102): | |
return h$regs[69]; | |
case (103): | |
return h$regs[70]; | |
case (104): | |
return h$regs[71]; | |
case (105): | |
return h$regs[72]; | |
case (106): | |
return h$regs[73]; | |
case (107): | |
return h$regs[74]; | |
case (108): | |
return h$regs[75]; | |
case (109): | |
return h$regs[76]; | |
case (110): | |
return h$regs[77]; | |
case (111): | |
return h$regs[78]; | |
case (112): | |
return h$regs[79]; | |
case (113): | |
return h$regs[80]; | |
case (114): | |
return h$regs[81]; | |
case (115): | |
return h$regs[82]; | |
case (116): | |
return h$regs[83]; | |
case (117): | |
return h$regs[84]; | |
case (118): | |
return h$regs[85]; | |
case (119): | |
return h$regs[86]; | |
case (120): | |
return h$regs[87]; | |
case (121): | |
return h$regs[88]; | |
case (122): | |
return h$regs[89]; | |
case (123): | |
return h$regs[90]; | |
case (124): | |
return h$regs[91]; | |
case (125): | |
return h$regs[92]; | |
case (126): | |
return h$regs[93]; | |
case (127): | |
return h$regs[94]; | |
case (128): | |
return h$regs[95]; | |
default: | |
}; | |
}; | |
function h$setReg(h$RTSD_1, h$RTSD_2) | |
{ | |
switch (h$RTSD_1) | |
{ | |
case (1): | |
h$r1 = h$RTSD_2; | |
return undefined; | |
case (2): | |
h$r2 = h$RTSD_2; | |
return undefined; | |
case (3): | |
h$r3 = h$RTSD_2; | |
return undefined; | |
case (4): | |
h$r4 = h$RTSD_2; | |
return undefined; | |
case (5): | |
h$r5 = h$RTSD_2; | |
return undefined; | |
case (6): | |
h$r6 = h$RTSD_2; | |
return undefined; | |
case (7): | |
h$r7 = h$RTSD_2; | |
return undefined; | |
case (8): | |
h$r8 = h$RTSD_2; | |
return undefined; | |
case (9): | |
h$r9 = h$RTSD_2; | |
return undefined; | |
case (10): | |
h$r10 = h$RTSD_2; | |
return undefined; | |
case (11): | |
h$r11 = h$RTSD_2; | |
return undefined; | |
case (12): | |
h$r12 = h$RTSD_2; | |
return undefined; | |
case (13): | |
h$r13 = h$RTSD_2; | |
return undefined; | |
case (14): | |
h$r14 = h$RTSD_2; | |
return undefined; | |
case (15): | |
h$r15 = h$RTSD_2; | |
return undefined; | |
case (16): | |
h$r16 = h$RTSD_2; | |
return undefined; | |
case (17): | |
h$r17 = h$RTSD_2; | |
return undefined; | |
case (18): | |
h$r18 = h$RTSD_2; | |
return undefined; | |
case (19): | |
h$r19 = h$RTSD_2; | |
return undefined; | |
case (20): | |
h$r20 = h$RTSD_2; | |
return undefined; | |
case (21): | |
h$r21 = h$RTSD_2; | |
return undefined; | |
case (22): | |
h$r22 = h$RTSD_2; | |
return undefined; | |
case (23): | |
h$r23 = h$RTSD_2; | |
return undefined; | |
case (24): | |
h$r24 = h$RTSD_2; | |
return undefined; | |
case (25): | |
h$r25 = h$RTSD_2; | |
return undefined; | |
case (26): | |
h$r26 = h$RTSD_2; | |
return undefined; | |
case (27): | |
h$r27 = h$RTSD_2; | |
return undefined; | |
case (28): | |
h$r28 = h$RTSD_2; | |
return undefined; | |
case (29): | |
h$r29 = h$RTSD_2; | |
return undefined; | |
case (30): | |
h$r30 = h$RTSD_2; | |
return undefined; | |
case (31): | |
h$r31 = h$RTSD_2; | |
return undefined; | |
case (32): | |
h$r32 = h$RTSD_2; | |
return undefined; | |
case (33): | |
h$regs[0] = h$RTSD_2; | |
return undefined; | |
case (34): | |
h$regs[1] = h$RTSD_2; | |
return undefined; | |
case (35): | |
h$regs[2] = h$RTSD_2; | |
return undefined; | |
case (36): | |
h$regs[3] = h$RTSD_2; | |
return undefined; | |
case (37): | |
h$regs[4] = h$RTSD_2; | |
return undefined; | |
case (38): | |
h$regs[5] = h$RTSD_2; | |
return undefined; | |
case (39): | |
h$regs[6] = h$RTSD_2; | |
return undefined; | |
case (40): | |
h$regs[7] = h$RTSD_2; | |
return undefined; | |
case (41): | |
h$regs[8] = h$RTSD_2; | |
return undefined; | |
case (42): | |
h$regs[9] = h$RTSD_2; | |
return undefined; | |
case (43): | |
h$regs[10] = h$RTSD_2; | |
return undefined; | |
case (44): | |
h$regs[11] = h$RTSD_2; | |
return undefined; | |
case (45): | |
h$regs[12] = h$RTSD_2; | |
return undefined; | |
case (46): | |
h$regs[13] = h$RTSD_2; | |
return undefined; | |
case (47): | |
h$regs[14] = h$RTSD_2; | |
return undefined; | |
case (48): | |
h$regs[15] = h$RTSD_2; | |
return undefined; | |
case (49): | |
h$regs[16] = h$RTSD_2; | |
return undefined; | |
case (50): | |
h$regs[17] = h$RTSD_2; | |
return undefined; | |
case (51): | |
h$regs[18] = h$RTSD_2; | |
return undefined; | |
case (52): | |
h$regs[19] = h$RTSD_2; | |
return undefined; | |
case (53): | |
h$regs[20] = h$RTSD_2; | |
return undefined; | |
case (54): | |
h$regs[21] = h$RTSD_2; | |
return undefined; | |
case (55): | |
h$regs[22] = h$RTSD_2; | |
return undefined; | |
case (56): | |
h$regs[23] = h$RTSD_2; | |
return undefined; | |
case (57): | |
h$regs[24] = h$RTSD_2; | |
return undefined; | |
case (58): | |
h$regs[25] = h$RTSD_2; | |
return undefined; | |
case (59): | |
h$regs[26] = h$RTSD_2; | |
return undefined; | |
case (60): | |
h$regs[27] = h$RTSD_2; | |
return undefined; | |
case (61): | |
h$regs[28] = h$RTSD_2; | |
return undefined; | |
case (62): | |
h$regs[29] = h$RTSD_2; | |
return undefined; | |
case (63): | |
h$regs[30] = h$RTSD_2; | |
return undefined; | |
case (64): | |
h$regs[31] = h$RTSD_2; | |
return undefined; | |
case (65): | |
h$regs[32] = h$RTSD_2; | |
return undefined; | |
case (66): | |
h$regs[33] = h$RTSD_2; | |
return undefined; | |
case (67): | |
h$regs[34] = h$RTSD_2; | |
return undefined; | |
case (68): | |
h$regs[35] = h$RTSD_2; | |
return undefined; | |
case (69): | |
h$regs[36] = h$RTSD_2; | |
return undefined; | |
case (70): | |
h$regs[37] = h$RTSD_2; | |
return undefined; | |
case (71): | |
h$regs[38] = h$RTSD_2; | |
return undefined; | |
case (72): | |
h$regs[39] = h$RTSD_2; | |
return undefined; | |
case (73): | |
h$regs[40] = h$RTSD_2; | |
return undefined; | |
case (74): | |
h$regs[41] = h$RTSD_2; | |
return undefined; | |
case (75): | |
h$regs[42] = h$RTSD_2; | |
return undefined; | |
case (76): | |
h$regs[43] = h$RTSD_2; | |
return undefined; | |
case (77): | |
h$regs[44] = h$RTSD_2; | |
return undefined; | |
case (78): | |
h$regs[45] = h$RTSD_2; | |
return undefined; | |
case (79): | |
h$regs[46] = h$RTSD_2; | |
return undefined; | |
case (80): | |
h$regs[47] = h$RTSD_2; | |
return undefined; | |
case (81): | |
h$regs[48] = h$RTSD_2; | |
return undefined; | |
case (82): | |
h$regs[49] = h$RTSD_2; | |
return undefined; | |
case (83): | |
h$regs[50] = h$RTSD_2; | |
return undefined; | |
case (84): | |
h$regs[51] = h$RTSD_2; | |
return undefined; | |
case (85): | |
h$regs[52] = h$RTSD_2; | |
return undefined; | |
case (86): | |
h$regs[53] = h$RTSD_2; | |
return undefined; | |
case (87): | |
h$regs[54] = h$RTSD_2; | |
return undefined; | |
case (88): | |
h$regs[55] = h$RTSD_2; | |
return undefined; | |
case (89): | |
h$regs[56] = h$RTSD_2; | |
return undefined; | |
case (90): | |
h$regs[57] = h$RTSD_2; | |
return undefined; | |
case (91): | |
h$regs[58] = h$RTSD_2; | |
return undefined; | |
case (92): | |
h$regs[59] = h$RTSD_2; | |
return undefined; | |
case (93): | |
h$regs[60] = h$RTSD_2; | |
return undefined; | |
case (94): | |
h$regs[61] = h$RTSD_2; | |
return undefined; | |
case (95): | |
h$regs[62] = h$RTSD_2; | |
return undefined; | |
case (96): | |
h$regs[63] = h$RTSD_2; | |
return undefined; | |
case (97): | |
h$regs[64] = h$RTSD_2; | |
return undefined; | |
case (98): | |
h$regs[65] = h$RTSD_2; | |
return undefined; | |
case (99): | |
h$regs[66] = h$RTSD_2; | |
return undefined; | |
case (100): | |
h$regs[67] = h$RTSD_2; | |
return undefined; | |
case (101): | |
h$regs[68] = h$RTSD_2; | |
return undefined; | |
case (102): | |
h$regs[69] = h$RTSD_2; | |
return undefined; | |
case (103): | |
h$regs[70] = h$RTSD_2; | |
return undefined; | |
case (104): | |
h$regs[71] = h$RTSD_2; | |
return undefined; | |
case (105): | |
h$regs[72] = h$RTSD_2; | |
return undefined; | |
case (106): | |
h$regs[73] = h$RTSD_2; | |
return undefined; | |
case (107): | |
h$regs[74] = h$RTSD_2; | |
return undefined; | |
case (108): | |
h$regs[75] = h$RTSD_2; | |
return undefined; | |
case (109): | |
h$regs[76] = h$RTSD_2; | |
return undefined; | |
case (110): | |
h$regs[77] = h$RTSD_2; | |
return undefined; | |
case (111): | |
h$regs[78] = h$RTSD_2; | |
return undefined; | |
case (112): | |
h$regs[79] = h$RTSD_2; | |
return undefined; | |
case (113): | |
h$regs[80] = h$RTSD_2; | |
return undefined; | |
case (114): | |
h$regs[81] = h$RTSD_2; | |
return undefined; | |
case (115): | |
h$regs[82] = h$RTSD_2; | |
return undefined; | |
case (116): | |
h$regs[83] = h$RTSD_2; | |
return undefined; | |
case (117): | |
h$regs[84] = h$RTSD_2; | |
return undefined; | |
case (118): | |
h$regs[85] = h$RTSD_2; | |
return undefined; | |
case (119): | |
h$regs[86] = h$RTSD_2; | |
return undefined; | |
case (120): | |
h$regs[87] = h$RTSD_2; | |
return undefined; | |
case (121): | |
h$regs[88] = h$RTSD_2; | |
return undefined; | |
case (122): | |
h$regs[89] = h$RTSD_2; | |
return undefined; | |
case (123): | |
h$regs[90] = h$RTSD_2; | |
return undefined; | |
case (124): | |
h$regs[91] = h$RTSD_2; | |
return undefined; | |
case (125): | |
h$regs[92] = h$RTSD_2; | |
return undefined; | |
case (126): | |
h$regs[93] = h$RTSD_2; | |
return undefined; | |
case (127): | |
h$regs[94] = h$RTSD_2; | |
return undefined; | |
case (128): | |
h$regs[95] = h$RTSD_2; | |
return undefined; | |
default: | |
}; | |
}; | |
function h$l1(x1) | |
{ | |
h$r1 = x1; | |
}; | |
function h$l2(x1, x2) | |
{ | |
h$r2 = x1; | |
h$r1 = x2; | |
}; | |
function h$l3(x1, x2, x3) | |
{ | |
h$r3 = x1; | |
h$r2 = x2; | |
h$r1 = x3; | |
}; | |
function h$l4(x1, x2, x3, x4) | |
{ | |
h$r4 = x1; | |
h$r3 = x2; | |
h$r2 = x3; | |
h$r1 = x4; | |
}; | |
function h$l5(x1, x2, x3, x4, x5) | |
{ | |
h$r5 = x1; | |
h$r4 = x2; | |
h$r3 = x3; | |
h$r2 = x4; | |
h$r1 = x5; | |
}; | |
function h$l6(x1, x2, x3, x4, x5, x6) | |
{ | |
h$r6 = x1; | |
h$r5 = x2; | |
h$r4 = x3; | |
h$r3 = x4; | |
h$r2 = x5; | |
h$r1 = x6; | |
}; | |
function h$l7(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$r7 = x1; | |
h$r6 = x2; | |
h$r5 = x3; | |
h$r4 = x4; | |
h$r3 = x5; | |
h$r2 = x6; | |
h$r1 = x7; | |
}; | |
function h$l8(x1, x2, x3, x4, x5, x6, x7, x8) | |
{ | |
h$r8 = x1; | |
h$r7 = x2; | |
h$r6 = x3; | |
h$r5 = x4; | |
h$r4 = x5; | |
h$r3 = x6; | |
h$r2 = x7; | |
h$r1 = x8; | |
}; | |
function h$l9(x1, x2, x3, x4, x5, x6, x7, x8, x9) | |
{ | |
h$r9 = x1; | |
h$r8 = x2; | |
h$r7 = x3; | |
h$r6 = x4; | |
h$r5 = x5; | |
h$r4 = x6; | |
h$r3 = x7; | |
h$r2 = x8; | |
h$r1 = x9; | |
}; | |
function h$l10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) | |
{ | |
h$r10 = x1; | |
h$r9 = x2; | |
h$r8 = x3; | |
h$r7 = x4; | |
h$r6 = x5; | |
h$r5 = x6; | |
h$r4 = x7; | |
h$r3 = x8; | |
h$r2 = x9; | |
h$r1 = x10; | |
}; | |
function h$l11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) | |
{ | |
h$r11 = x1; | |
h$r10 = x2; | |
h$r9 = x3; | |
h$r8 = x4; | |
h$r7 = x5; | |
h$r6 = x6; | |
h$r5 = x7; | |
h$r4 = x8; | |
h$r3 = x9; | |
h$r2 = x10; | |
h$r1 = x11; | |
}; | |
function h$l12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) | |
{ | |
h$r12 = x1; | |
h$r11 = x2; | |
h$r10 = x3; | |
h$r9 = x4; | |
h$r8 = x5; | |
h$r7 = x6; | |
h$r6 = x7; | |
h$r5 = x8; | |
h$r4 = x9; | |
h$r3 = x10; | |
h$r2 = x11; | |
h$r1 = x12; | |
}; | |
function h$l13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) | |
{ | |
h$r13 = x1; | |
h$r12 = x2; | |
h$r11 = x3; | |
h$r10 = x4; | |
h$r9 = x5; | |
h$r8 = x6; | |
h$r7 = x7; | |
h$r6 = x8; | |
h$r5 = x9; | |
h$r4 = x10; | |
h$r3 = x11; | |
h$r2 = x12; | |
h$r1 = x13; | |
}; | |
function h$l14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) | |
{ | |
h$r14 = x1; | |
h$r13 = x2; | |
h$r12 = x3; | |
h$r11 = x4; | |
h$r10 = x5; | |
h$r9 = x6; | |
h$r8 = x7; | |
h$r7 = x8; | |
h$r6 = x9; | |
h$r5 = x10; | |
h$r4 = x11; | |
h$r3 = x12; | |
h$r2 = x13; | |
h$r1 = x14; | |
}; | |
function h$l15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) | |
{ | |
h$r15 = x1; | |
h$r14 = x2; | |
h$r13 = x3; | |
h$r12 = x4; | |
h$r11 = x5; | |
h$r10 = x6; | |
h$r9 = x7; | |
h$r8 = x8; | |
h$r7 = x9; | |
h$r6 = x10; | |
h$r5 = x11; | |
h$r4 = x12; | |
h$r3 = x13; | |
h$r2 = x14; | |
h$r1 = x15; | |
}; | |
function h$l16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) | |
{ | |
h$r16 = x1; | |
h$r15 = x2; | |
h$r14 = x3; | |
h$r13 = x4; | |
h$r12 = x5; | |
h$r11 = x6; | |
h$r10 = x7; | |
h$r9 = x8; | |
h$r8 = x9; | |
h$r7 = x10; | |
h$r6 = x11; | |
h$r5 = x12; | |
h$r4 = x13; | |
h$r3 = x14; | |
h$r2 = x15; | |
h$r1 = x16; | |
}; | |
function h$l17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) | |
{ | |
h$r17 = x1; | |
h$r16 = x2; | |
h$r15 = x3; | |
h$r14 = x4; | |
h$r13 = x5; | |
h$r12 = x6; | |
h$r11 = x7; | |
h$r10 = x8; | |
h$r9 = x9; | |
h$r8 = x10; | |
h$r7 = x11; | |
h$r6 = x12; | |
h$r5 = x13; | |
h$r4 = x14; | |
h$r3 = x15; | |
h$r2 = x16; | |
h$r1 = x17; | |
}; | |
function h$l18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) | |
{ | |
h$r18 = x1; | |
h$r17 = x2; | |
h$r16 = x3; | |
h$r15 = x4; | |
h$r14 = x5; | |
h$r13 = x6; | |
h$r12 = x7; | |
h$r11 = x8; | |
h$r10 = x9; | |
h$r9 = x10; | |
h$r8 = x11; | |
h$r7 = x12; | |
h$r6 = x13; | |
h$r5 = x14; | |
h$r4 = x15; | |
h$r3 = x16; | |
h$r2 = x17; | |
h$r1 = x18; | |
}; | |
function h$l19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) | |
{ | |
h$r19 = x1; | |
h$r18 = x2; | |
h$r17 = x3; | |
h$r16 = x4; | |
h$r15 = x5; | |
h$r14 = x6; | |
h$r13 = x7; | |
h$r12 = x8; | |
h$r11 = x9; | |
h$r10 = x10; | |
h$r9 = x11; | |
h$r8 = x12; | |
h$r7 = x13; | |
h$r6 = x14; | |
h$r5 = x15; | |
h$r4 = x16; | |
h$r3 = x17; | |
h$r2 = x18; | |
h$r1 = x19; | |
}; | |
function h$l20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) | |
{ | |
h$r20 = x1; | |
h$r19 = x2; | |
h$r18 = x3; | |
h$r17 = x4; | |
h$r16 = x5; | |
h$r15 = x6; | |
h$r14 = x7; | |
h$r13 = x8; | |
h$r12 = x9; | |
h$r11 = x10; | |
h$r10 = x11; | |
h$r9 = x12; | |
h$r8 = x13; | |
h$r7 = x14; | |
h$r6 = x15; | |
h$r5 = x16; | |
h$r4 = x17; | |
h$r3 = x18; | |
h$r2 = x19; | |
h$r1 = x20; | |
}; | |
function h$l21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) | |
{ | |
h$r21 = x1; | |
h$r20 = x2; | |
h$r19 = x3; | |
h$r18 = x4; | |
h$r17 = x5; | |
h$r16 = x6; | |
h$r15 = x7; | |
h$r14 = x8; | |
h$r13 = x9; | |
h$r12 = x10; | |
h$r11 = x11; | |
h$r10 = x12; | |
h$r9 = x13; | |
h$r8 = x14; | |
h$r7 = x15; | |
h$r6 = x16; | |
h$r5 = x17; | |
h$r4 = x18; | |
h$r3 = x19; | |
h$r2 = x20; | |
h$r1 = x21; | |
}; | |
function h$l22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) | |
{ | |
h$r22 = x1; | |
h$r21 = x2; | |
h$r20 = x3; | |
h$r19 = x4; | |
h$r18 = x5; | |
h$r17 = x6; | |
h$r16 = x7; | |
h$r15 = x8; | |
h$r14 = x9; | |
h$r13 = x10; | |
h$r12 = x11; | |
h$r11 = x12; | |
h$r10 = x13; | |
h$r9 = x14; | |
h$r8 = x15; | |
h$r7 = x16; | |
h$r6 = x17; | |
h$r5 = x18; | |
h$r4 = x19; | |
h$r3 = x20; | |
h$r2 = x21; | |
h$r1 = x22; | |
}; | |
function h$l23(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23) | |
{ | |
h$r23 = x1; | |
h$r22 = x2; | |
h$r21 = x3; | |
h$r20 = x4; | |
h$r19 = x5; | |
h$r18 = x6; | |
h$r17 = x7; | |
h$r16 = x8; | |
h$r15 = x9; | |
h$r14 = x10; | |
h$r13 = x11; | |
h$r12 = x12; | |
h$r11 = x13; | |
h$r10 = x14; | |
h$r9 = x15; | |
h$r8 = x16; | |
h$r7 = x17; | |
h$r6 = x18; | |
h$r5 = x19; | |
h$r4 = x20; | |
h$r3 = x21; | |
h$r2 = x22; | |
h$r1 = x23; | |
}; | |
function h$l24(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24) | |
{ | |
h$r24 = x1; | |
h$r23 = x2; | |
h$r22 = x3; | |
h$r21 = x4; | |
h$r20 = x5; | |
h$r19 = x6; | |
h$r18 = x7; | |
h$r17 = x8; | |
h$r16 = x9; | |
h$r15 = x10; | |
h$r14 = x11; | |
h$r13 = x12; | |
h$r12 = x13; | |
h$r11 = x14; | |
h$r10 = x15; | |
h$r9 = x16; | |
h$r8 = x17; | |
h$r7 = x18; | |
h$r6 = x19; | |
h$r5 = x20; | |
h$r4 = x21; | |
h$r3 = x22; | |
h$r2 = x23; | |
h$r1 = x24; | |
}; | |
function h$l25(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25) | |
{ | |
h$r25 = x1; | |
h$r24 = x2; | |
h$r23 = x3; | |
h$r22 = x4; | |
h$r21 = x5; | |
h$r20 = x6; | |
h$r19 = x7; | |
h$r18 = x8; | |
h$r17 = x9; | |
h$r16 = x10; | |
h$r15 = x11; | |
h$r14 = x12; | |
h$r13 = x13; | |
h$r12 = x14; | |
h$r11 = x15; | |
h$r10 = x16; | |
h$r9 = x17; | |
h$r8 = x18; | |
h$r7 = x19; | |
h$r6 = x20; | |
h$r5 = x21; | |
h$r4 = x22; | |
h$r3 = x23; | |
h$r2 = x24; | |
h$r1 = x25; | |
}; | |
function h$l26(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26) | |
{ | |
h$r26 = x1; | |
h$r25 = x2; | |
h$r24 = x3; | |
h$r23 = x4; | |
h$r22 = x5; | |
h$r21 = x6; | |
h$r20 = x7; | |
h$r19 = x8; | |
h$r18 = x9; | |
h$r17 = x10; | |
h$r16 = x11; | |
h$r15 = x12; | |
h$r14 = x13; | |
h$r13 = x14; | |
h$r12 = x15; | |
h$r11 = x16; | |
h$r10 = x17; | |
h$r9 = x18; | |
h$r8 = x19; | |
h$r7 = x20; | |
h$r6 = x21; | |
h$r5 = x22; | |
h$r4 = x23; | |
h$r3 = x24; | |
h$r2 = x25; | |
h$r1 = x26; | |
}; | |
function h$l27(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27) | |
{ | |
h$r27 = x1; | |
h$r26 = x2; | |
h$r25 = x3; | |
h$r24 = x4; | |
h$r23 = x5; | |
h$r22 = x6; | |
h$r21 = x7; | |
h$r20 = x8; | |
h$r19 = x9; | |
h$r18 = x10; | |
h$r17 = x11; | |
h$r16 = x12; | |
h$r15 = x13; | |
h$r14 = x14; | |
h$r13 = x15; | |
h$r12 = x16; | |
h$r11 = x17; | |
h$r10 = x18; | |
h$r9 = x19; | |
h$r8 = x20; | |
h$r7 = x21; | |
h$r6 = x22; | |
h$r5 = x23; | |
h$r4 = x24; | |
h$r3 = x25; | |
h$r2 = x26; | |
h$r1 = x27; | |
}; | |
function h$l28(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28) | |
{ | |
h$r28 = x1; | |
h$r27 = x2; | |
h$r26 = x3; | |
h$r25 = x4; | |
h$r24 = x5; | |
h$r23 = x6; | |
h$r22 = x7; | |
h$r21 = x8; | |
h$r20 = x9; | |
h$r19 = x10; | |
h$r18 = x11; | |
h$r17 = x12; | |
h$r16 = x13; | |
h$r15 = x14; | |
h$r14 = x15; | |
h$r13 = x16; | |
h$r12 = x17; | |
h$r11 = x18; | |
h$r10 = x19; | |
h$r9 = x20; | |
h$r8 = x21; | |
h$r7 = x22; | |
h$r6 = x23; | |
h$r5 = x24; | |
h$r4 = x25; | |
h$r3 = x26; | |
h$r2 = x27; | |
h$r1 = x28; | |
}; | |
function h$l29(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29) | |
{ | |
h$r29 = x1; | |
h$r28 = x2; | |
h$r27 = x3; | |
h$r26 = x4; | |
h$r25 = x5; | |
h$r24 = x6; | |
h$r23 = x7; | |
h$r22 = x8; | |
h$r21 = x9; | |
h$r20 = x10; | |
h$r19 = x11; | |
h$r18 = x12; | |
h$r17 = x13; | |
h$r16 = x14; | |
h$r15 = x15; | |
h$r14 = x16; | |
h$r13 = x17; | |
h$r12 = x18; | |
h$r11 = x19; | |
h$r10 = x20; | |
h$r9 = x21; | |
h$r8 = x22; | |
h$r7 = x23; | |
h$r6 = x24; | |
h$r5 = x25; | |
h$r4 = x26; | |
h$r3 = x27; | |
h$r2 = x28; | |
h$r1 = x29; | |
}; | |
function h$l30(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29, x30) | |
{ | |
h$r30 = x1; | |
h$r29 = x2; | |
h$r28 = x3; | |
h$r27 = x4; | |
h$r26 = x5; | |
h$r25 = x6; | |
h$r24 = x7; | |
h$r23 = x8; | |
h$r22 = x9; | |
h$r21 = x10; | |
h$r20 = x11; | |
h$r19 = x12; | |
h$r18 = x13; | |
h$r17 = x14; | |
h$r16 = x15; | |
h$r15 = x16; | |
h$r14 = x17; | |
h$r13 = x18; | |
h$r12 = x19; | |
h$r11 = x20; | |
h$r10 = x21; | |
h$r9 = x22; | |
h$r8 = x23; | |
h$r7 = x24; | |
h$r6 = x25; | |
h$r5 = x26; | |
h$r4 = x27; | |
h$r3 = x28; | |
h$r2 = x29; | |
h$r1 = x30; | |
}; | |
function h$l31(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29, x30, x31) | |
{ | |
h$r31 = x1; | |
h$r30 = x2; | |
h$r29 = x3; | |
h$r28 = x4; | |
h$r27 = x5; | |
h$r26 = x6; | |
h$r25 = x7; | |
h$r24 = x8; | |
h$r23 = x9; | |
h$r22 = x10; | |
h$r21 = x11; | |
h$r20 = x12; | |
h$r19 = x13; | |
h$r18 = x14; | |
h$r17 = x15; | |
h$r16 = x16; | |
h$r15 = x17; | |
h$r14 = x18; | |
h$r13 = x19; | |
h$r12 = x20; | |
h$r11 = x21; | |
h$r10 = x22; | |
h$r9 = x23; | |
h$r8 = x24; | |
h$r7 = x25; | |
h$r6 = x26; | |
h$r5 = x27; | |
h$r4 = x28; | |
h$r3 = x29; | |
h$r2 = x30; | |
h$r1 = x31; | |
}; | |
function h$l32(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29, x30, x31, x32) | |
{ | |
h$r32 = x1; | |
h$r31 = x2; | |
h$r30 = x3; | |
h$r29 = x4; | |
h$r28 = x5; | |
h$r27 = x6; | |
h$r26 = x7; | |
h$r25 = x8; | |
h$r24 = x9; | |
h$r23 = x10; | |
h$r22 = x11; | |
h$r21 = x12; | |
h$r20 = x13; | |
h$r19 = x14; | |
h$r18 = x15; | |
h$r17 = x16; | |
h$r16 = x17; | |
h$r15 = x18; | |
h$r14 = x19; | |
h$r13 = x20; | |
h$r12 = x21; | |
h$r11 = x22; | |
h$r10 = x23; | |
h$r9 = x24; | |
h$r8 = x25; | |
h$r7 = x26; | |
h$r6 = x27; | |
h$r5 = x28; | |
h$r4 = x29; | |
h$r3 = x30; | |
h$r2 = x31; | |
h$r1 = x32; | |
}; | |
var h$ret1; | |
var h$ret2; | |
var h$ret3; | |
var h$ret4; | |
var h$ret5; | |
var h$ret6; | |
var h$ret7; | |
var h$ret8; | |
var h$ret9; | |
var h$ret10; | |
/* platform-specific setup */ | |
// top-level debug initialization needs this. declare it in case we aren't in the same file as out.js | |
function h$ghcjszmprimZCGHCJSziPrimziJSRef_con_e() { return h$stack[h$sp]; }; | |
/* | |
if browser mode is active (GHCJS_BROWSER is defined), all the runtime platform | |
detection code should be removed by the preprocessor. The h$isPlatform variables | |
are undeclared. | |
in non-browser mode, use h$isNode, h$isJsShell, h$isBrowser to find the current | |
platform. | |
more platforms should be added here in the future | |
*/ | |
var h$isNode = false; // runtime is node.js | |
var h$isJsShell = false; // runtime is SpiderMonkey jsshell | |
var h$isJsCore = false; // runtime is JavaScriptCore jsc | |
var h$isBrowser = false; // running in browser or everything else | |
// load all required node.js modules | |
if(typeof process !== undefined && (typeof h$TH !== 'undefined' || (typeof require !== 'undefined' && typeof module !== 'undefined' && module.exports))) { | |
h$isNode = true; | |
// we have to use these names for the closure compiler externs to work | |
var fs = require('fs'); | |
var path = require('path'); | |
var os = require('os'); | |
var child_process = require('child_process'); | |
var h$fs = fs; | |
var h$path = path; | |
var h$os = os; | |
var h$child = child_process; | |
var h$process = process; | |
var h$processConstants = process['binding']('constants'); | |
} else if(typeof snarf !== 'undefined' && typeof evalInFrame !== 'undefined' && typeof countHeap !== 'undefined') { | |
h$isJsShell = true; | |
this.console = { log: this.print }; | |
} else if(typeof numberOfDFGCompiles !== 'undefined' && typeof jscStack !== 'undefined') { | |
h$isJsCore = true; | |
} else { | |
h$isBrowser = true; | |
} | |
function h$getGlobal(that) { | |
if(typeof global !== 'undefined') return global; | |
return that; | |
} | |
/* | |
set up the google closure library. this is a rather hacky setup | |
to make it work with our shims without requiring compilation | |
or pulling in the google closure library module loader | |
*/ | |
var goog = {}; | |
goog.global = h$getGlobal(this); | |
goog.provide = function() { }; | |
goog.require = function() { }; | |
goog.isDef = function(val) { return val !== undefined; }; | |
goog.inherits = function(childCtor, parentCtor) { | |
/** @constructor */ | |
function tempCtor() {}; | |
tempCtor.prototype = parentCtor.prototype; | |
childCtor.superClass_ = parentCtor.prototype; | |
childCtor.prototype = new tempCtor(); | |
/** @override */ | |
childCtor.prototype.constructor = childCtor; | |
/** | |
* Calls superclass constructor/method. | |
* | |
* This function is only available if you use goog.inherits to | |
* express inheritance relationships between classes. | |
* | |
* NOTE: This is a replacement for goog.base and for superClass_ | |
* property defined in childCtor. | |
* | |
* @param {!Object} me Should always be "this". | |
* @param {string} methodName The method name to call. Calling | |
* superclass constructor can be done with the special string | |
* 'constructor'. | |
* @param {...*} var_args The arguments to pass to superclass | |
* method/constructor. | |
* @return {*} The return value of the superclass method/constructor. | |
*/ | |
childCtor.base = function(me, methodName, var_args) { | |
// Copying using loop to avoid deop due to passing arguments object to | |
// function. This is faster in many JS engines as of late 2014. | |
var args = new Array(arguments.length - 2); | |
for (var i = 2; i < arguments.length; i++) { | |
args[i - 2] = arguments[i]; | |
} | |
return parentCtor.prototype[methodName].apply(me, args); | |
}; | |
}; | |
goog.isString = function(v) { | |
return typeof v === 'string'; | |
} | |
goog.math = {}; | |
goog.crypt = {}; | |
/* | |
Copyright (c) 2010, Linden Research, Inc. | |
Copyright (c) 2014, Joshua Bell | |
Permission is hereby granted, free of charge, to any person obtaining a copy | |
of this software and associated documentation files (the "Software"), to deal | |
in the Software without restriction, including without limitation the rights | |
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
copies of the Software, and to permit persons to whom the Software is | |
furnished to do so, subject to the following conditions: | |
The above copyright notice and this permission notice shall be included in | |
all copies or substantial portions of the Software. | |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
THE SOFTWARE. | |
$/LicenseInfo$ | |
*/ | |
// Original can be found at: | |
// https://bitbucket.org/lindenlab/llsd | |
// Modifications by Joshua Bell [email protected] | |
// https://github.com/inexorabletash/polyfill | |
// ES3/ES5 implementation of the Krhonos Typed Array Specification | |
// Ref: http://www.khronos.org/registry/typedarray/specs/latest/ | |
// Date: 2011-02-01 | |
// | |
// Variations: | |
// * Allows typed_array.get/set() as alias for subscripts (typed_array[]) | |
// * Gradually migrating structure from Khronos spec to ES6 spec | |
(function(global) { | |
'use strict'; | |
var undefined = (void 0); // Paranoia | |
// Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to | |
// create, and consume so much memory, that the browser appears frozen. | |
var MAX_ARRAY_LENGTH = 1e5; | |
// Approximations of internal ECMAScript conversion functions | |
function Type(v) { | |
switch(typeof v) { | |
case 'undefined': return 'undefined'; | |
case 'boolean': return 'boolean'; | |
case 'number': return 'number'; | |
case 'string': return 'string'; | |
default: return v === null ? 'null' : 'object'; | |
} | |
} | |
// Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues: | |
function Class(v) { return Object.prototype.toString.call(v).replace(/^\[object *|\]$/g, ''); } | |
function IsCallable(o) { return typeof o === 'function'; } | |
function ToObject(v) { | |
if (v === null || v === undefined) throw TypeError(); | |
return Object(v); | |
} | |
function ToInt32(v) { return v >> 0; } | |
function ToUint32(v) { return v >>> 0; } | |
// Snapshot intrinsics | |
var LN2 = Math.LN2, | |
abs = Math.abs, | |
floor = Math.floor, | |
log = Math.log, | |
max = Math.max, | |
min = Math.min, | |
pow = Math.pow, | |
round = Math.round; | |
// emulate ES5 getter/setter API using legacy APIs | |
// http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx | |
// (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but | |
// note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless) | |
(function() { | |
var orig = Object.defineProperty; | |
var dom_only = !(function(){try{return Object.defineProperty({},'x',{});}catch(_){return false;}}()); | |
if (!orig || dom_only) { | |
Object.defineProperty = function (o, prop, desc) { | |
// In IE8 try built-in implementation for defining properties on DOM prototypes. | |
if (orig) | |
try { return orig(o, prop, desc); } catch (_) {} | |
if (o !== Object(o)) | |
throw TypeError('Object.defineProperty called on non-object'); | |
if (Object.prototype.__defineGetter__ && ('get' in desc)) | |
Object.prototype.__defineGetter__.call(o, prop, desc.get); | |
if (Object.prototype.__defineSetter__ && ('set' in desc)) | |
Object.prototype.__defineSetter__.call(o, prop, desc.set); | |
if ('value' in desc) | |
o[prop] = desc.value; | |
return o; | |
}; | |
} | |
}()); | |
// ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value) | |
// for index in 0 ... obj.length | |
function makeArrayAccessors(obj) { | |
if (obj.length > MAX_ARRAY_LENGTH) throw RangeError('Array too large for polyfill'); | |
function makeArrayAccessor(index) { | |
Object.defineProperty(obj, index, { | |
'get': function() { return obj._getter(index); }, | |
'set': function(v) { obj._setter(index, v); }, | |
enumerable: true, | |
configurable: false | |
}); | |
} | |
var i; | |
for (i = 0; i < obj.length; i += 1) { | |
makeArrayAccessor(i); | |
} | |
} | |
// Internal conversion functions: | |
// pack<Type>() - take a number (interpreted as Type), output a byte array | |
// unpack<Type>() - take a byte array, output a Type-like number | |
function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; } | |
function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; } | |
function packI8(n) { return [n & 0xff]; } | |
function unpackI8(bytes) { return as_signed(bytes[0], 8); } | |
function packU8(n) { return [n & 0xff]; } | |
function unpackU8(bytes) { return as_unsigned(bytes[0], 8); } | |
function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; } | |
function packI16(n) { return [(n >> 8) & 0xff, n & 0xff]; } | |
function unpackI16(bytes) { return as_signed(bytes[0] << 8 | bytes[1], 16); } | |
function packU16(n) { return [(n >> 8) & 0xff, n & 0xff]; } | |
function unpackU16(bytes) { return as_unsigned(bytes[0] << 8 | bytes[1], 16); } | |
function packI32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; } | |
function unpackI32(bytes) { return as_signed(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); } | |
function packU32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; } | |
function unpackU32(bytes) { return as_unsigned(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); } | |
function packIEEE754(v, ebits, fbits) { | |
var bias = (1 << (ebits - 1)) - 1, | |
s, e, f, ln, | |
i, bits, str, bytes; | |
function roundToEven(n) { | |
var w = floor(n), f = n - w; | |
if (f < 0.5) | |
return w; | |
if (f > 0.5) | |
return w + 1; | |
return w % 2 ? w + 1 : w; | |
} | |
// Compute sign, exponent, fraction | |
if (v !== v) { | |
// NaN | |
// http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping | |
e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0; | |
} else if (v === Infinity || v === -Infinity) { | |
e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0; | |
} else if (v === 0) { | |
e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0; | |
} else { | |
s = v < 0; | |
v = abs(v); | |
if (v >= pow(2, 1 - bias)) { | |
e = min(floor(log(v) / LN2), 1023); | |
f = roundToEven(v / pow(2, e) * pow(2, fbits)); | |
if (f / pow(2, fbits) >= 2) { | |
e = e + 1; | |
f = 1; | |
} | |
if (e > bias) { | |
// Overflow | |
e = (1 << ebits) - 1; | |
f = 0; | |
} else { | |
// Normalized | |
e = e + bias; | |
f = f - pow(2, fbits); | |
} | |
} else { | |
// Denormalized | |
e = 0; | |
f = roundToEven(v / pow(2, 1 - bias - fbits)); | |
} | |
} | |
// Pack sign, exponent, fraction | |
bits = []; | |
for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); } | |
for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); } | |
bits.push(s ? 1 : 0); | |
bits.reverse(); | |
str = bits.join(''); | |
// Bits to bytes | |
bytes = []; | |
while (str.length) { | |
bytes.push(parseInt(str.substring(0, 8), 2)); | |
str = str.substring(8); | |
} | |
return bytes; | |
} | |
function unpackIEEE754(bytes, ebits, fbits) { | |
// Bytes to bits | |
var bits = [], i, j, b, str, | |
bias, s, e, f; | |
for (i = bytes.length; i; i -= 1) { | |
b = bytes[i - 1]; | |
for (j = 8; j; j -= 1) { | |
bits.push(b % 2 ? 1 : 0); b = b >> 1; | |
} | |
} | |
bits.reverse(); | |
str = bits.join(''); | |
// Unpack sign, exponent, fraction | |
bias = (1 << (ebits - 1)) - 1; | |
s = parseInt(str.substring(0, 1), 2) ? -1 : 1; | |
e = parseInt(str.substring(1, 1 + ebits), 2); | |
f = parseInt(str.substring(1 + ebits), 2); | |
// Produce number | |
if (e === (1 << ebits) - 1) { | |
return f !== 0 ? NaN : s * Infinity; | |
} else if (e > 0) { | |
// Normalized | |
return s * pow(2, e - bias) * (1 + f / pow(2, fbits)); | |
} else if (f !== 0) { | |
// Denormalized | |
return s * pow(2, -(bias - 1)) * (f / pow(2, fbits)); | |
} else { | |
return s < 0 ? -0 : 0; | |
} | |
} | |
function unpackF64(b) { return unpackIEEE754(b, 11, 52); } | |
function packF64(v) { return packIEEE754(v, 11, 52); } | |
function unpackF32(b) { return unpackIEEE754(b, 8, 23); } | |
function packF32(v) { return packIEEE754(v, 8, 23); } | |
// | |
// 3 The ArrayBuffer Type | |
// | |
(function() { | |
function ArrayBuffer(length) { | |
length = ToInt32(length); | |
if (length < 0) throw RangeError('ArrayBuffer size is not a small enough positive integer.'); | |
Object.defineProperty(this, 'byteLength', {value: length}); | |
Object.defineProperty(this, '_bytes', {value: Array(length)}); | |
for (var i = 0; i < length; i += 1) | |
this._bytes[i] = 0; | |
} | |
global.ArrayBuffer = global.ArrayBuffer || ArrayBuffer; | |
// | |
// 5 The Typed Array View Types | |
// | |
function $TypedArray$() { | |
// %TypedArray% ( length ) | |
if (!arguments.length || typeof arguments[0] !== 'object') { | |
return (function(length) { | |
length = ToInt32(length); | |
if (length < 0) throw RangeError('length is not a small enough positive integer.'); | |
Object.defineProperty(this, 'length', {value: length}); | |
Object.defineProperty(this, 'byteLength', {value: length * this.BYTES_PER_ELEMENT}); | |
Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(this.byteLength)}); | |
Object.defineProperty(this, 'byteOffset', {value: 0}); | |
}).apply(this, arguments); | |
} | |
// %TypedArray% ( typedArray ) | |
if (arguments.length >= 1 && | |
Type(arguments[0]) === 'object' && | |
arguments[0] instanceof $TypedArray$) { | |
return (function(typedArray){ | |
if (this.constructor !== typedArray.constructor) throw TypeError(); | |
var byteLength = typedArray.length * this.BYTES_PER_ELEMENT; | |
Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)}); | |
Object.defineProperty(this, 'byteLength', {value: byteLength}); | |
Object.defineProperty(this, 'byteOffset', {value: 0}); | |
Object.defineProperty(this, 'length', {value: typedArray.length}); | |
for (var i = 0; i < this.length; i += 1) | |
this._setter(i, typedArray._getter(i)); | |
}).apply(this, arguments); | |
} | |
// %TypedArray% ( array ) | |
if (arguments.length >= 1 && | |
Type(arguments[0]) === 'object' && | |
!(arguments[0] instanceof $TypedArray$) && | |
!(arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) { | |
return (function(array) { | |
var byteLength = array.length * this.BYTES_PER_ELEMENT; | |
Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)}); | |
Object.defineProperty(this, 'byteLength', {value: byteLength}); | |
Object.defineProperty(this, 'byteOffset', {value: 0}); | |
Object.defineProperty(this, 'length', {value: array.length}); | |
for (var i = 0; i < this.length; i += 1) { | |
var s = array[i]; | |
this._setter(i, Number(s)); | |
} | |
}).apply(this, arguments); | |
} | |
// %TypedArray% ( buffer, byteOffset=0, length=undefined ) | |
if (arguments.length >= 1 && | |
Type(arguments[0]) === 'object' && | |
(arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) { | |
return (function(buffer, byteOffset, length) { | |
byteOffset = ToUint32(byteOffset); | |
if (byteOffset > buffer.byteLength) | |
throw RangeError('byteOffset out of range'); | |
// The given byteOffset must be a multiple of the element | |
// size of the specific type, otherwise an exception is raised. | |
if (byteOffset % this.BYTES_PER_ELEMENT) | |
throw RangeError('buffer length minus the byteOffset is not a multiple of the element size.'); | |
if (length === undefined) { | |
var byteLength = buffer.byteLength - byteOffset; | |
if (byteLength % this.BYTES_PER_ELEMENT) | |
throw RangeError('length of buffer minus byteOffset not a multiple of the element size'); | |
length = byteLength / this.BYTES_PER_ELEMENT; | |
} else { | |
length = ToUint32(length); | |
byteLength = length * this.BYTES_PER_ELEMENT; | |
} | |
if ((byteOffset + byteLength) > buffer.byteLength) | |
throw RangeError('byteOffset and length reference an area beyond the end of the buffer'); | |
Object.defineProperty(this, 'buffer', {value: buffer}); | |
Object.defineProperty(this, 'byteLength', {value: byteLength}); | |
Object.defineProperty(this, 'byteOffset', {value: byteOffset}); | |
Object.defineProperty(this, 'length', {value: length}); | |
}).apply(this, arguments); | |
} | |
// %TypedArray% ( all other argument combinations ) | |
throw TypeError(); | |
} | |
// Properties of the %TypedArray Instrinsic Object | |
// %TypedArray%.from ( source , mapfn=undefined, thisArg=undefined ) | |
Object.defineProperty($TypedArray$, 'from', {value: function(iterable) { | |
return new this(iterable); | |
}}); | |
// %TypedArray%.of ( ...items ) | |
Object.defineProperty($TypedArray$, 'of', {value: function(/*...items*/) { | |
return new this(arguments); | |
}}); | |
// %TypedArray%.prototype | |
var $TypedArrayPrototype$ = {}; | |
$TypedArray$.prototype = $TypedArrayPrototype$; | |
// WebIDL: getter type (unsigned long index); | |
Object.defineProperty($TypedArray$.prototype, '_getter', {value: function(index) { | |
if (arguments.length < 1) throw SyntaxError('Not enough arguments'); | |
index = ToUint32(index); | |
if (index >= this.length) | |
return undefined; | |
var bytes = [], i, o; | |
for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT; | |
i < this.BYTES_PER_ELEMENT; | |
i += 1, o += 1) { | |
bytes.push(this.buffer._bytes[o]); | |
} | |
return this._unpack(bytes); | |
}}); | |
// NONSTANDARD: convenience alias for getter: type get(unsigned long index); | |
Object.defineProperty($TypedArray$.prototype, 'get', {value: $TypedArray$.prototype._getter}); | |
// WebIDL: setter void (unsigned long index, type value); | |
Object.defineProperty($TypedArray$.prototype, '_setter', {value: function(index, value) { | |
if (arguments.length < 2) throw SyntaxError('Not enough arguments'); | |
index = ToUint32(index); | |
if (index >= this.length) | |
return; | |
var bytes = this._pack(value), i, o; | |
for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT; | |
i < this.BYTES_PER_ELEMENT; | |
i += 1, o += 1) { | |
this.buffer._bytes[o] = bytes[i]; | |
} | |
}}); | |
// get %TypedArray%.prototype.buffer | |
// get %TypedArray%.prototype.byteLength | |
// get %TypedArray%.prototype.byteOffset | |
// -- applied directly to the object in the constructor | |
// %TypedArray%.prototype.constructor | |
Object.defineProperty($TypedArray$.prototype, 'constructor', {value: $TypedArray$}); | |
// %TypedArray%.prototype.copyWithin (target, start, end = this.length ) | |
Object.defineProperty($TypedArray$.prototype, 'copyWithin', {value: function(target, start) { | |
var end = arguments[2]; | |
var o = ToObject(this); | |
var lenVal = o.length; | |
var len = ToUint32(lenVal); | |
len = max(len, 0); | |
var relativeTarget = ToInt32(target); | |
var to; | |
if (relativeTarget < 0) | |
to = max(len + relativeTarget, 0); | |
else | |
to = min(relativeTarget, len); | |
var relativeStart = ToInt32(start); | |
var from; | |
if (relativeStart < 0) | |
from = max(len + relativeStart, 0); | |
else | |
from = min(relativeStart, len); | |
var relativeEnd; | |
if (end === undefined) | |
relativeEnd = len; | |
else | |
relativeEnd = ToInt32(end); | |
var final0; | |
if (relativeEnd < 0) | |
final0 = max(len + relativeEnd, 0); | |
else | |
final0 = min(relativeEnd, len); | |
var count = min(final0 - from, len - to); | |
var direction; | |
if (from < to && to < from + count) { | |
direction = -1; | |
from = from + count - 1; | |
to = to + count - 1; | |
} else { | |
direction = 1; | |
} | |
while (count > 0) { | |
o._setter(to, o._getter(from)); | |
from = from + direction; | |
to = to + direction; | |
count = count - 1; | |
} | |
return o; | |
}}); | |
// %TypedArray%.prototype.entries ( ) | |
// -- defined in es6.js to shim browsers w/ native TypedArrays | |
// %TypedArray%.prototype.every ( callbackfn, thisArg = undefined ) | |
Object.defineProperty($TypedArray$.prototype, 'every', {value: function(callbackfn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (!IsCallable(callbackfn)) throw TypeError(); | |
var thisArg = arguments[1]; | |
for (var i = 0; i < len; i++) { | |
if (!callbackfn.call(thisArg, t._getter(i), i, t)) | |
return false; | |
} | |
return true; | |
}}); | |
// %TypedArray%.prototype.fill (value, start = 0, end = this.length ) | |
Object.defineProperty($TypedArray$.prototype, 'fill', {value: function(value) { | |
var start = arguments[1], | |
end = arguments[2]; | |
var o = ToObject(this); | |
var lenVal = o.length; | |
var len = ToUint32(lenVal); | |
len = max(len, 0); | |
var relativeStart = ToInt32(start); | |
var k; | |
if (relativeStart < 0) | |
k = max((len + relativeStart), 0); | |
else | |
k = min(relativeStart, len); | |
var relativeEnd; | |
if (end === undefined) | |
relativeEnd = len; | |
else | |
relativeEnd = ToInt32(end); | |
var final0; | |
if (relativeEnd < 0) | |
final0 = max((len + relativeEnd), 0); | |
else | |
final0 = min(relativeEnd, len); | |
while (k < final0) { | |
o._setter(k, value); | |
k += 1; | |
} | |
return o; | |
}}); | |
// %TypedArray%.prototype.filter ( callbackfn, thisArg = undefined ) | |
Object.defineProperty($TypedArray$.prototype, 'filter', {value: function(callbackfn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (!IsCallable(callbackfn)) throw TypeError(); | |
var res = []; | |
var thisp = arguments[1]; | |
for (var i = 0; i < len; i++) { | |
var val = t._getter(i); // in case fun mutates this | |
if (callbackfn.call(thisp, val, i, t)) | |
res.push(val); | |
} | |
return new this.constructor(res); | |
}}); | |
// %TypedArray%.prototype.find (predicate, thisArg = undefined) | |
Object.defineProperty($TypedArray$.prototype, 'find', {value: function(predicate) { | |
var o = ToObject(this); | |
var lenValue = o.length; | |
var len = ToUint32(lenValue); | |
if (!IsCallable(predicate)) throw TypeError(); | |
var t = arguments.length > 1 ? arguments[1] : undefined; | |
var k = 0; | |
while (k < len) { | |
var kValue = o._getter(k); | |
var testResult = predicate.call(t, kValue, k, o); | |
if (Boolean(testResult)) | |
return kValue; | |
++k; | |
} | |
return undefined; | |
}}); | |
// %TypedArray%.prototype.findIndex ( predicate, thisArg = undefined ) | |
Object.defineProperty($TypedArray$.prototype, 'findIndex', {value: function(predicate) { | |
var o = ToObject(this); | |
var lenValue = o.length; | |
var len = ToUint32(lenValue); | |
if (!IsCallable(predicate)) throw TypeError(); | |
var t = arguments.length > 1 ? arguments[1] : undefined; | |
var k = 0; | |
while (k < len) { | |
var kValue = o._getter(k); | |
var testResult = predicate.call(t, kValue, k, o); | |
if (Boolean(testResult)) | |
return k; | |
++k; | |
} | |
return -1; | |
}}); | |
// %TypedArray%.prototype.forEach ( callbackfn, thisArg = undefined ) | |
Object.defineProperty($TypedArray$.prototype, 'forEach', {value: function(callbackfn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (!IsCallable(callbackfn)) throw TypeError(); | |
var thisp = arguments[1]; | |
for (var i = 0; i < len; i++) | |
callbackfn.call(thisp, t._getter(i), i, t); | |
}}); | |
// %TypedArray%.prototype.indexOf (searchElement, fromIndex = 0 ) | |
Object.defineProperty($TypedArray$.prototype, 'indexOf', {value: function(searchElement) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (len === 0) return -1; | |
var n = 0; | |
if (arguments.length > 0) { | |
n = Number(arguments[1]); | |
if (n !== n) { | |
n = 0; | |
} else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) { | |
n = (n > 0 || -1) * floor(abs(n)); | |
} | |
} | |
if (n >= len) return -1; | |
var k = n >= 0 ? n : max(len - abs(n), 0); | |
for (; k < len; k++) { | |
if (t._getter(k) === searchElement) { | |
return k; | |
} | |
} | |
return -1; | |
}}); | |
// %TypedArray%.prototype.join ( separator ) | |
Object.defineProperty($TypedArray$.prototype, 'join', {value: function(separator) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
var tmp = Array(len); | |
for (var i = 0; i < len; ++i) | |
tmp[i] = t._getter(i); | |
return tmp.join(separator === undefined ? ',' : separator); // Hack for IE7 | |
}}); | |
// %TypedArray%.prototype.keys ( ) | |
// -- defined in es6.js to shim browsers w/ native TypedArrays | |
// %TypedArray%.prototype.lastIndexOf ( searchElement, fromIndex = this.length-1 ) | |
Object.defineProperty($TypedArray$.prototype, 'lastIndexOf', {value: function(searchElement) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (len === 0) return -1; | |
var n = len; | |
if (arguments.length > 1) { | |
n = Number(arguments[1]); | |
if (n !== n) { | |
n = 0; | |
} else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) { | |
n = (n > 0 || -1) * floor(abs(n)); | |
} | |
} | |
var k = n >= 0 ? min(n, len - 1) : len - abs(n); | |
for (; k >= 0; k--) { | |
if (t._getter(k) === searchElement) | |
return k; | |
} | |
return -1; | |
}}); | |
// get %TypedArray%.prototype.length | |
// -- applied directly to the object in the constructor | |
// %TypedArray%.prototype.map ( callbackfn, thisArg = undefined ) | |
Object.defineProperty($TypedArray$.prototype, 'map', {value: function(callbackfn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (!IsCallable(callbackfn)) throw TypeError(); | |
var res = []; res.length = len; | |
var thisp = arguments[1]; | |
for (var i = 0; i < len; i++) | |
res[i] = callbackfn.call(thisp, t._getter(i), i, t); | |
return new this.constructor(res); | |
}}); | |
// %TypedArray%.prototype.reduce ( callbackfn [, initialValue] ) | |
Object.defineProperty($TypedArray$.prototype, 'reduce', {value: function(callbackfn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (!IsCallable(callbackfn)) throw TypeError(); | |
// no value to return if no initial value and an empty array | |
if (len === 0 && arguments.length === 1) throw TypeError(); | |
var k = 0; | |
var accumulator; | |
if (arguments.length >= 2) { | |
accumulator = arguments[1]; | |
} else { | |
accumulator = t._getter(k++); | |
} | |
while (k < len) { | |
accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t); | |
k++; | |
} | |
return accumulator; | |
}}); | |
// %TypedArray%.prototype.reduceRight ( callbackfn [, initialValue] ) | |
Object.defineProperty($TypedArray$.prototype, 'reduceRight', {value: function(callbackfn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (!IsCallable(callbackfn)) throw TypeError(); | |
// no value to return if no initial value, empty array | |
if (len === 0 && arguments.length === 1) throw TypeError(); | |
var k = len - 1; | |
var accumulator; | |
if (arguments.length >= 2) { | |
accumulator = arguments[1]; | |
} else { | |
accumulator = t._getter(k--); | |
} | |
while (k >= 0) { | |
accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t); | |
k--; | |
} | |
return accumulator; | |
}}); | |
// %TypedArray%.prototype.reverse ( ) | |
Object.defineProperty($TypedArray$.prototype, 'reverse', {value: function() { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
var half = floor(len / 2); | |
for (var i = 0, j = len - 1; i < half; ++i, --j) { | |
var tmp = t._getter(i); | |
t._setter(i, t._getter(j)); | |
t._setter(j, tmp); | |
} | |
return t; | |
}}); | |
// %TypedArray%.prototype.set(array, offset = 0 ) | |
// %TypedArray%.prototype.set(typedArray, offset = 0 ) | |
// WebIDL: void set(TypedArray array, optional unsigned long offset); | |
// WebIDL: void set(sequence<type> array, optional unsigned long offset); | |
Object.defineProperty($TypedArray$.prototype, 'set', {value: function(index, value) { | |
if (arguments.length < 1) throw SyntaxError('Not enough arguments'); | |
var array, sequence, offset, len, | |
i, s, d, | |
byteOffset, byteLength, tmp; | |
if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) { | |
// void set(TypedArray array, optional unsigned long offset); | |
array = arguments[0]; | |
offset = ToUint32(arguments[1]); | |
if (offset + array.length > this.length) { | |
throw RangeError('Offset plus length of array is out of range'); | |
} | |
byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT; | |
byteLength = array.length * this.BYTES_PER_ELEMENT; | |
if (array.buffer === this.buffer) { | |
tmp = []; | |
for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) { | |
tmp[i] = array.buffer._bytes[s]; | |
} | |
for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) { | |
this.buffer._bytes[d] = tmp[i]; | |
} | |
} else { | |
for (i = 0, s = array.byteOffset, d = byteOffset; | |
i < byteLength; i += 1, s += 1, d += 1) { | |
this.buffer._bytes[d] = array.buffer._bytes[s]; | |
} | |
} | |
} else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') { | |
// void set(sequence<type> array, optional unsigned long offset); | |
sequence = arguments[0]; | |
len = ToUint32(sequence.length); | |
offset = ToUint32(arguments[1]); | |
if (offset + len > this.length) { | |
throw RangeError('Offset plus length of array is out of range'); | |
} | |
for (i = 0; i < len; i += 1) { | |
s = sequence[i]; | |
this._setter(offset + i, Number(s)); | |
} | |
} else { | |
throw TypeError('Unexpected argument type(s)'); | |
} | |
}}); | |
// %TypedArray%.prototype.slice ( start, end ) | |
Object.defineProperty($TypedArray$.prototype, 'slice', {value: function(start, end) { | |
var o = ToObject(this); | |
var lenVal = o.length; | |
var len = ToUint32(lenVal); | |
var relativeStart = ToInt32(start); | |
var k = (relativeStart < 0) ? max(len + relativeStart, 0) : min(relativeStart, len); | |
var relativeEnd = (end === undefined) ? len : ToInt32(end); | |
var final0 = (relativeEnd < 0) ? max(len + relativeEnd, 0) : min(relativeEnd, len); | |
var count = final0 - k; | |
var c = o.constructor; | |
var a = new c(count); | |
var n = 0; | |
while (k < final0) { | |
var kValue = o._getter(k); | |
a._setter(n, kValue); | |
++k; | |
++n; | |
} | |
return a; | |
}}); | |
// %TypedArray%.prototype.some ( callbackfn, thisArg = undefined ) | |
Object.defineProperty($TypedArray$.prototype, 'some', {value: function(callbackfn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
if (!IsCallable(callbackfn)) throw TypeError(); | |
var thisp = arguments[1]; | |
for (var i = 0; i < len; i++) { | |
if (callbackfn.call(thisp, t._getter(i), i, t)) { | |
return true; | |
} | |
} | |
return false; | |
}}); | |
// %TypedArray%.prototype.sort ( comparefn ) | |
Object.defineProperty($TypedArray$.prototype, 'sort', {value: function(comparefn) { | |
if (this === undefined || this === null) throw TypeError(); | |
var t = Object(this); | |
var len = ToUint32(t.length); | |
var tmp = Array(len); | |
for (var i = 0; i < len; ++i) | |
tmp[i] = t._getter(i); | |
if (comparefn) tmp.sort(comparefn); else tmp.sort(); // Hack for IE8/9 | |
for (i = 0; i < len; ++i) | |
t._setter(i, tmp[i]); | |
return t; | |
}}); | |
// %TypedArray%.prototype.subarray(begin = 0, end = this.length ) | |
// WebIDL: TypedArray subarray(long begin, optional long end); | |
Object.defineProperty($TypedArray$.prototype, 'subarray', {value: function(start, end) { | |
function clamp(v, min, max) { return v < min ? min : v > max ? max : v; } | |
start = ToInt32(start); | |
end = ToInt32(end); | |
if (arguments.length < 1) { start = 0; } | |
if (arguments.length < 2) { end = this.length; } | |
if (start < 0) { start = this.length + start; } | |
if (end < 0) { end = this.length + end; } | |
start = clamp(start, 0, this.length); | |
end = clamp(end, 0, this.length); | |
var len = end - start; | |
if (len < 0) { | |
len = 0; | |
} | |
return new this.constructor( | |
this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len); | |
}}); | |
// %TypedArray%.prototype.toLocaleString ( ) | |
// %TypedArray%.prototype.toString ( ) | |
// %TypedArray%.prototype.values ( ) | |
// %TypedArray%.prototype [ @@iterator ] ( ) | |
// get %TypedArray%.prototype [ @@toStringTag ] | |
// -- defined in es6.js to shim browsers w/ native TypedArrays | |
function makeTypedArray(elementSize, pack, unpack) { | |
// Each TypedArray type requires a distinct constructor instance with | |
// identical logic, which this produces. | |
var TypedArray = function() { | |
Object.defineProperty(this, 'constructor', {value: TypedArray}); | |
$TypedArray$.apply(this, arguments); | |
makeArrayAccessors(this); | |
}; | |
if ('__proto__' in TypedArray) { | |
TypedArray.__proto__ = $TypedArray$; | |
} else { | |
TypedArray.from = $TypedArray$.from; | |
TypedArray.of = $TypedArray$.of; | |
} | |
TypedArray.BYTES_PER_ELEMENT = elementSize; | |
var TypedArrayPrototype = function() {}; | |
TypedArrayPrototype.prototype = $TypedArrayPrototype$; | |
TypedArray.prototype = new TypedArrayPrototype(); | |
Object.defineProperty(TypedArray.prototype, 'BYTES_PER_ELEMENT', {value: elementSize}); | |
Object.defineProperty(TypedArray.prototype, '_pack', {value: pack}); | |
Object.defineProperty(TypedArray.prototype, '_unpack', {value: unpack}); | |
return TypedArray; | |
} | |
var Int8Array = makeTypedArray(1, packI8, unpackI8); | |
var Uint8Array = makeTypedArray(1, packU8, unpackU8); | |
var Uint8ClampedArray = makeTypedArray(1, packU8Clamped, unpackU8); | |
var Int16Array = makeTypedArray(2, packI16, unpackI16); | |
var Uint16Array = makeTypedArray(2, packU16, unpackU16); | |
var Int32Array = makeTypedArray(4, packI32, unpackI32); | |
var Uint32Array = makeTypedArray(4, packU32, unpackU32); | |
var Float32Array = makeTypedArray(4, packF32, unpackF32); | |
var Float64Array = makeTypedArray(8, packF64, unpackF64); | |
global.Int8Array = global.Int8Array || Int8Array; | |
global.Uint8Array = global.Uint8Array || Uint8Array; | |
global.Uint8ClampedArray = global.Uint8ClampedArray || Uint8ClampedArray; | |
global.Int16Array = global.Int16Array || Int16Array; | |
global.Uint16Array = global.Uint16Array || Uint16Array; | |
global.Int32Array = global.Int32Array || Int32Array; | |
global.Uint32Array = global.Uint32Array || Uint32Array; | |
global.Float32Array = global.Float32Array || Float32Array; | |
global.Float64Array = global.Float64Array || Float64Array; | |
}()); | |
// | |
// 6 The DataView View Type | |
// | |
(function() { | |
function r(array, index) { | |
return IsCallable(array.get) ? array.get(index) : array[index]; | |
} | |
var IS_BIG_ENDIAN = (function() { | |
var u16array = new Uint16Array([0x1234]), | |
u8array = new Uint8Array(u16array.buffer); | |
return r(u8array, 0) === 0x12; | |
}()); | |
// DataView(buffer, byteOffset=0, byteLength=undefined) | |
// WebIDL: Constructor(ArrayBuffer buffer, | |
// optional unsigned long byteOffset, | |
// optional unsigned long byteLength) | |
function DataView(buffer, byteOffset, byteLength) { | |
if (!(buffer instanceof ArrayBuffer || Class(buffer) === 'ArrayBuffer')) throw TypeError(); | |
byteOffset = ToUint32(byteOffset); | |
if (byteOffset > buffer.byteLength) | |
throw RangeError('byteOffset out of range'); | |
if (byteLength === undefined) | |
byteLength = buffer.byteLength - byteOffset; | |
else | |
byteLength = ToUint32(byteLength); | |
if ((byteOffset + byteLength) > buffer.byteLength) | |
throw RangeError('byteOffset and length reference an area beyond the end of the buffer'); | |
Object.defineProperty(this, 'buffer', {value: buffer}); | |
Object.defineProperty(this, 'byteLength', {value: byteLength}); | |
Object.defineProperty(this, 'byteOffset', {value: byteOffset}); | |
}; | |
// get DataView.prototype.buffer | |
// get DataView.prototype.byteLength | |
// get DataView.prototype.byteOffset | |
// -- applied directly to instances by the constructor | |
function makeGetter(arrayType) { | |
return function GetViewValue(byteOffset, littleEndian) { | |
byteOffset = ToUint32(byteOffset); | |
if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) | |
throw RangeError('Array index out of range'); | |
byteOffset += this.byteOffset; | |
var uint8Array = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT), | |
bytes = []; | |
for (var i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) | |
bytes.push(r(uint8Array, i)); | |
if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) | |
bytes.reverse(); | |
return r(new arrayType(new Uint8Array(bytes).buffer), 0); | |
}; | |
} | |
Object.defineProperty(DataView.prototype, 'getUint8', {value: makeGetter(Uint8Array)}); | |
Object.defineProperty(DataView.prototype, 'getInt8', {value: makeGetter(Int8Array)}); | |
Object.defineProperty(DataView.prototype, 'getUint16', {value: makeGetter(Uint16Array)}); | |
Object.defineProperty(DataView.prototype, 'getInt16', {value: makeGetter(Int16Array)}); | |
Object.defineProperty(DataView.prototype, 'getUint32', {value: makeGetter(Uint32Array)}); | |
Object.defineProperty(DataView.prototype, 'getInt32', {value: makeGetter(Int32Array)}); | |
Object.defineProperty(DataView.prototype, 'getFloat32', {value: makeGetter(Float32Array)}); | |
Object.defineProperty(DataView.prototype, 'getFloat64', {value: makeGetter(Float64Array)}); | |
function makeSetter(arrayType) { | |
return function SetViewValue(byteOffset, value, littleEndian) { | |
byteOffset = ToUint32(byteOffset); | |
if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) | |
throw RangeError('Array index out of range'); | |
// Get bytes | |
var typeArray = new arrayType([value]), | |
byteArray = new Uint8Array(typeArray.buffer), | |
bytes = [], i, byteView; | |
for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) | |
bytes.push(r(byteArray, i)); | |
// Flip if necessary | |
if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) | |
bytes.reverse(); | |
// Write them | |
byteView = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT); | |
byteView.set(bytes); | |
}; | |
} | |
Object.defineProperty(DataView.prototype, 'setUint8', {value: makeSetter(Uint8Array)}); | |
Object.defineProperty(DataView.prototype, 'setInt8', {value: makeSetter(Int8Array)}); | |
Object.defineProperty(DataView.prototype, 'setUint16', {value: makeSetter(Uint16Array)}); | |
Object.defineProperty(DataView.prototype, 'setInt16', {value: makeSetter(Int16Array)}); | |
Object.defineProperty(DataView.prototype, 'setUint32', {value: makeSetter(Uint32Array)}); | |
Object.defineProperty(DataView.prototype, 'setInt32', {value: makeSetter(Int32Array)}); | |
Object.defineProperty(DataView.prototype, 'setFloat32', {value: makeSetter(Float32Array)}); | |
Object.defineProperty(DataView.prototype, 'setFloat64', {value: makeSetter(Float64Array)}); | |
global.DataView = global.DataView || DataView; | |
}()); | |
}(h$getGlobal(this))); | |
/** @constructor */ | |
var BigInteger = (function() { | |
var dbits, DV, BI_FP; | |
// Copyright (c) 2005 Tom Wu | |
// All Rights Reserved. | |
// See "LICENSE" for details. | |
// Basic JavaScript BN library - subset useful for RSA encryption. | |
// Bits per digit | |
var dbits; | |
// JavaScript engine analysis | |
var canary = 0xdeadbeefcafe; | |
var j_lm = ((canary&0xffffff)==0xefcafe); | |
// (public) Constructor | |
/** @constructor */ | |
function BigInteger(a,b,c) { | |
this.data = []; | |
if(a != null) | |
if("number" == typeof a) this.fromNumber(a,b,c); | |
else if(b == null && "string" != typeof a) this.fromString(a,256); | |
else this.fromString(a,b); | |
} | |
// return new, unset BigInteger | |
function nbi() { return new BigInteger(null); } | |
// am: Compute w_j += (x*this_i), propagate carries, | |
// c is initial carry, returns final carry. | |
// c < 3*dvalue, x < 2*dvalue, this_i < dvalue | |
// We need to select the fastest one that works in this environment. | |
// am1: use a single mult and divide to get the high bits, | |
// max digit bits should be 26 because | |
// max internal value = 2*dvalue^2-2*dvalue (< 2^53) | |
function am1(i,x,w,j,c,n) { | |
while(--n >= 0) { | |
var v = x*this.data[i++]+w.data[j]+c; | |
c = Math.floor(v/0x4000000); | |
w.data[j++] = v&0x3ffffff; | |
} | |
return c; | |
} | |
// am2 avoids a big mult-and-extract completely. | |
// Max digit bits should be <= 30 because we do bitwise ops | |
// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31) | |
function am2(i,x,w,j,c,n) { | |
var xl = x&0x7fff, xh = x>>15; | |
while(--n >= 0) { | |
var l = this.data[i]&0x7fff; | |
var h = this.data[i++]>>15; | |
var m = xh*l+h*xl; | |
l = xl*l+((m&0x7fff)<<15)+w.data[j]+(c&0x3fffffff); | |
c = (l>>>30)+(m>>>15)+xh*h+(c>>>30); | |
w.data[j++] = l&0x3fffffff; | |
} | |
return c; | |
} | |
// Alternately, set max digit bits to 28 since some | |
// browsers slow down when dealing with 32-bit numbers. | |
function am3(i,x,w,j,c,n) { | |
var xl = x&0x3fff, xh = x>>14; | |
while(--n >= 0) { | |
var l = this.data[i]&0x3fff; | |
var h = this.data[i++]>>14; | |
var m = xh*l+h*xl; | |
l = xl*l+((m&0x3fff)<<14)+w.data[j]+c; | |
c = (l>>28)+(m>>14)+xh*h; | |
w.data[j++] = l&0xfffffff; | |
} | |
return c; | |
} | |
// node.js (no browser) | |
if(typeof(navigator) === 'undefined') | |
{ | |
BigInteger.prototype.am = am3; | |
dbits = 28; | |
} | |
else if(j_lm && (navigator.appName == "Microsoft Internet Explorer")) { | |
BigInteger.prototype.am = am2; | |
dbits = 30; | |
} | |
else if(j_lm && (navigator.appName != "Netscape")) { | |
BigInteger.prototype.am = am1; | |
dbits = 26; | |
} | |
else { // Mozilla/Netscape seems to prefer am3 | |
BigInteger.prototype.am = am3; | |
dbits = 28; | |
} | |
BigInteger.prototype.DB = dbits; | |
BigInteger.prototype.DM = ((1<<dbits)-1); | |
BigInteger.prototype.DV = (1<<dbits); | |
var BI_FP = 52; | |
BigInteger.prototype.FV = Math.pow(2,BI_FP); | |
BigInteger.prototype.F1 = BI_FP-dbits; | |
BigInteger.prototype.F2 = 2*dbits-BI_FP; | |
// Digit conversions | |
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz"; | |
var BI_RC = new Array(); | |
var rr,vv; | |
rr = "0".charCodeAt(0); | |
for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv; | |
rr = "a".charCodeAt(0); | |
for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv; | |
rr = "A".charCodeAt(0); | |
for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv; | |
function int2char(n) { return BI_RM.charAt(n); } | |
function intAt(s,i) { | |
var c = BI_RC[s.charCodeAt(i)]; | |
return (c==null)?-1:c; | |
} | |
// (protected) copy this to r | |
function bnpCopyTo(r) { | |
for(var i = this.t-1; i >= 0; --i) r.data[i] = this.data[i]; | |
r.t = this.t; | |
r.s = this.s; | |
} | |
// (protected) set from integer value x, -DV <= x < DV | |
function bnpFromInt(x) { | |
this.t = 1; | |
this.s = (x<0)?-1:0; | |
if(x > 0) this.data[0] = x; | |
else if(x < -1) this.data[0] = x+this.DV; | |
else this.t = 0; | |
} | |
// return bigint initialized to value | |
function nbv(i) { var r = nbi(); r.fromInt(i); return r; } | |
// (protected) set from string and radix | |
function bnpFromString(s,b) { | |
var k; | |
if(b == 16) k = 4; | |
else if(b == 8) k = 3; | |
else if(b == 256) k = 8; // byte array | |
else if(b == 2) k = 1; | |
else if(b == 32) k = 5; | |
else if(b == 4) k = 2; | |
else { this.fromRadix(s,b); return; } | |
this.t = 0; | |
this.s = 0; | |
var i = s.length, mi = false, sh = 0; | |
while(--i >= 0) { | |
var x = (k==8)?s[i]&0xff:intAt(s,i); | |
if(x < 0) { | |
if(s.charAt(i) == "-") mi = true; | |
continue; | |
} | |
mi = false; | |
if(sh == 0) | |
this.data[this.t++] = x; | |
else if(sh+k > this.DB) { | |
this.data[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh; | |
this.data[this.t++] = (x>>(this.DB-sh)); | |
} | |
else | |
this.data[this.t-1] |= x<<sh; | |
sh += k; | |
if(sh >= this.DB) sh -= this.DB; | |
} | |
if(k == 8 && (s[0]&0x80) != 0) { | |
this.s = -1; | |
if(sh > 0) this.data[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh; | |
} | |
this.clamp(); | |
if(mi) BigInteger.ZERO.subTo(this,this); | |
} | |
// (protected) clamp off excess high words | |
function bnpClamp() { | |
var c = this.s&this.DM; | |
while(this.t > 0 && this.data[this.t-1] == c) --this.t; | |
} | |
// (public) return string representation in given radix | |
function bnToString(b) { | |
if(this.s < 0) return "-"+this.negate().toString(b); | |
var k; | |
if(b == 16) k = 4; | |
else if(b == 8) k = 3; | |
else if(b == 2) k = 1; | |
else if(b == 32) k = 5; | |
else if(b == 4) k = 2; | |
else return this.toRadix(b); | |
var km = (1<<k)-1, d, m = false, r = "", i = this.t; | |
var p = this.DB-(i*this.DB)%k; | |
if(i-- > 0) { | |
if(p < this.DB && (d = this.data[i]>>p) > 0) { m = true; r = int2char(d); } | |
while(i >= 0) { | |
if(p < k) { | |
d = (this.data[i]&((1<<p)-1))<<(k-p); | |
d |= this.data[--i]>>(p+=this.DB-k); | |
} | |
else { | |
d = (this.data[i]>>(p-=k))&km; | |
if(p <= 0) { p += this.DB; --i; } | |
} | |
if(d > 0) m = true; | |
if(m) r += int2char(d); | |
} | |
} | |
return m?r:"0"; | |
} | |
// (public) -this | |
function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; } | |
// (public) |this| | |
function bnAbs() { return (this.s<0)?this.negate():this; } | |
// (public) return + if this > a, - if this < a, 0 if equal | |
function bnCompareTo(a) { | |
var r = this.s-a.s; | |
if(r != 0) return r; | |
var i = this.t; | |
r = i-a.t; | |
if(r != 0) return (this.s<0)?-r:r; | |
while(--i >= 0) if((r=this.data[i]-a.data[i]) != 0) return r; | |
return 0; | |
} | |
// returns bit length of the integer x | |
function nbits(x) { | |
var r = 1, t; | |
if((t=x>>>16) != 0) { x = t; r += 16; } | |
if((t=x>>8) != 0) { x = t; r += 8; } | |
if((t=x>>4) != 0) { x = t; r += 4; } | |
if((t=x>>2) != 0) { x = t; r += 2; } | |
if((t=x>>1) != 0) { x = t; r += 1; } | |
return r; | |
} | |
// (public) return the number of bits in "this" | |
function bnBitLength() { | |
if(this.t <= 0) return 0; | |
return this.DB*(this.t-1)+nbits(this.data[this.t-1]^(this.s&this.DM)); | |
} | |
// (protected) r = this << n*DB | |
function bnpDLShiftTo(n,r) { | |
var i; | |
for(i = this.t-1; i >= 0; --i) r.data[i+n] = this.data[i]; | |
for(i = n-1; i >= 0; --i) r.data[i] = 0; | |
r.t = this.t+n; | |
r.s = this.s; | |
} | |
// (protected) r = this >> n*DB | |
function bnpDRShiftTo(n,r) { | |
for(var i = n; i < this.t; ++i) r.data[i-n] = this.data[i]; | |
r.t = Math.max(this.t-n,0); | |
r.s = this.s; | |
} | |
// (protected) r = this << n | |
function bnpLShiftTo(n,r) { | |
var bs = n%this.DB; | |
var cbs = this.DB-bs; | |
var bm = (1<<cbs)-1; | |
var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i; | |
for(i = this.t-1; i >= 0; --i) { | |
r.data[i+ds+1] = (this.data[i]>>cbs)|c; | |
c = (this.data[i]&bm)<<bs; | |
} | |
for(i = ds-1; i >= 0; --i) r.data[i] = 0; | |
r.data[ds] = c; | |
r.t = this.t+ds+1; | |
r.s = this.s; | |
r.clamp(); | |
} | |
// (protected) r = this >> n | |
function bnpRShiftTo(n,r) { | |
r.s = this.s; | |
var ds = Math.floor(n/this.DB); | |
if(ds >= this.t) { r.t = 0; return; } | |
var bs = n%this.DB; | |
var cbs = this.DB-bs; | |
var bm = (1<<bs)-1; | |
r.data[0] = this.data[ds]>>bs; | |
for(var i = ds+1; i < this.t; ++i) { | |
r.data[i-ds-1] |= (this.data[i]&bm)<<cbs; | |
r.data[i-ds] = this.data[i]>>bs; | |
} | |
if(bs > 0) r.data[this.t-ds-1] |= (this.s&bm)<<cbs; | |
r.t = this.t-ds; | |
r.clamp(); | |
} | |
// (protected) r = this - a | |
function bnpSubTo(a,r) { | |
var i = 0, c = 0, m = Math.min(a.t,this.t); | |
while(i < m) { | |
c += this.data[i]-a.data[i]; | |
r.data[i++] = c&this.DM; | |
c >>= this.DB; | |
} | |
if(a.t < this.t) { | |
c -= a.s; | |
while(i < this.t) { | |
c += this.data[i]; | |
r.data[i++] = c&this.DM; | |
c >>= this.DB; | |
} | |
c += this.s; | |
} | |
else { | |
c += this.s; | |
while(i < a.t) { | |
c -= a.data[i]; | |
r.data[i++] = c&this.DM; | |
c >>= this.DB; | |
} | |
c -= a.s; | |
} | |
r.s = (c<0)?-1:0; | |
if(c < -1) r.data[i++] = this.DV+c; | |
else if(c > 0) r.data[i++] = c; | |
r.t = i; | |
r.clamp(); | |
} | |
// (protected) r = this * a, r != this,a (HAC 14.12) | |
// "this" should be the larger one if appropriate. | |
function bnpMultiplyTo(a,r) { | |
var x = this.abs(), y = a.abs(); | |
var i = x.t; | |
r.t = i+y.t; | |
while(--i >= 0) r.data[i] = 0; | |
for(i = 0; i < y.t; ++i) r.data[i+x.t] = x.am(0,y.data[i],r,i,0,x.t); | |
r.s = 0; | |
r.clamp(); | |
if(this.s != a.s) BigInteger.ZERO.subTo(r,r); | |
} | |
// (protected) r = this^2, r != this (HAC 14.16) | |
function bnpSquareTo(r) { | |
var x = this.abs(); | |
var i = r.t = 2*x.t; | |
while(--i >= 0) r.data[i] = 0; | |
for(i = 0; i < x.t-1; ++i) { | |
var c = x.am(i,x.data[i],r,2*i,0,1); | |
if((r.data[i+x.t]+=x.am(i+1,2*x.data[i],r,2*i+1,c,x.t-i-1)) >= x.DV) { | |
r.data[i+x.t] -= x.DV; | |
r.data[i+x.t+1] = 1; | |
} | |
} | |
if(r.t > 0) r.data[r.t-1] += x.am(i,x.data[i],r,2*i,0,1); | |
r.s = 0; | |
r.clamp(); | |
} | |
// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20) | |
// r != q, this != m. q or r may be null. | |
function bnpDivRemTo(m,q,r) { | |
var pm = m.abs(); | |
if(pm.t <= 0) return; | |
var pt = this.abs(); | |
if(pt.t < pm.t) { | |
if(q != null) q.fromInt(0); | |
if(r != null) this.copyTo(r); | |
return; | |
} | |
if(r == null) r = nbi(); | |
var y = nbi(), ts = this.s, ms = m.s; | |
var nsh = this.DB-nbits(pm.data[pm.t-1]); // normalize modulus | |
if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); } | |
else { pm.copyTo(y); pt.copyTo(r); } | |
var ys = y.t; | |
var y0 = y.data[ys-1]; | |
if(y0 == 0) return; | |
var yt = y0*(1<<this.F1)+((ys>1)?y.data[ys-2]>>this.F2:0); | |
var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2; | |
var i = r.t, j = i-ys, t = (q==null)?nbi():q; | |
y.dlShiftTo(j,t); | |
if(r.compareTo(t) >= 0) { | |
r.data[r.t++] = 1; | |
r.subTo(t,r); | |
} | |
BigInteger.ONE.dlShiftTo(ys,t); | |
t.subTo(y,y); // "negative" y so we can replace sub with am later | |
while(y.t < ys) y.data[y.t++] = 0; | |
while(--j >= 0) { | |
// Estimate quotient digit | |
var qd = (r.data[--i]==y0)?this.DM:Math.floor(r.data[i]*d1+(r.data[i-1]+e)*d2); | |
if((r.data[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out | |
y.dlShiftTo(j,t); | |
r.subTo(t,r); | |
while(r.data[i] < --qd) r.subTo(t,r); | |
} | |
} | |
if(q != null) { | |
r.drShiftTo(ys,q); | |
if(ts != ms) BigInteger.ZERO.subTo(q,q); | |
} | |
r.t = ys; | |
r.clamp(); | |
if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder | |
if(ts < 0) BigInteger.ZERO.subTo(r,r); | |
} | |
// (public) this mod a | |
function bnMod(a) { | |
var r = nbi(); | |
this.abs().divRemTo(a,null,r); | |
if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r); | |
return r; | |
} | |
// Modular reduction using "classic" algorithm | |
/** @constructor */ | |
function Classic(m) { this.m = m; } | |
function cConvert(x) { | |
if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m); | |
else return x; | |
} | |
function cRevert(x) { return x; } | |
function cReduce(x) { x.divRemTo(this.m,null,x); } | |
function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); } | |
function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); } | |
Classic.prototype.convert = cConvert; | |
Classic.prototype.revert = cRevert; | |
Classic.prototype.reduce = cReduce; | |
Classic.prototype.mulTo = cMulTo; | |
Classic.prototype.sqrTo = cSqrTo; | |
// (protected) return "-1/this % 2^DB"; useful for Mont. reduction | |
// justification: | |
// xy == 1 (mod m) | |
// xy = 1+km | |
// xy(2-xy) = (1+km)(1-km) | |
// x[y(2-xy)] = 1-k^2m^2 | |
// x[y(2-xy)] == 1 (mod m^2) | |
// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2 | |
// should reduce x and y(2-xy) by m^2 at each step to keep size bounded. | |
// JS multiply "overflows" differently from C/C++, so care is needed here. | |
function bnpInvDigit() { | |
if(this.t < 1) return 0; | |
var x = this.data[0]; | |
if((x&1) == 0) return 0; | |
var y = x&3; // y == 1/x mod 2^2 | |
y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4 | |
y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8 | |
y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16 | |
// last step - calculate inverse mod DV directly; | |
// assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints | |
y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits | |
// we really want the negative inverse, and -DV < y < DV | |
return (y>0)?this.DV-y:-y; | |
} | |
// Montgomery reduction | |
/** @constructor */ | |
function Montgomery(m) { | |
this.m = m; | |
this.mp = m.invDigit(); | |
this.mpl = this.mp&0x7fff; | |
this.mph = this.mp>>15; | |
this.um = (1<<(m.DB-15))-1; | |
this.mt2 = 2*m.t; | |
} | |
// xR mod m | |
function montConvert(x) { | |
var r = nbi(); | |
x.abs().dlShiftTo(this.m.t,r); | |
r.divRemTo(this.m,null,r); | |
if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r); | |
return r; | |
} | |
// x/R mod m | |
function montRevert(x) { | |
var r = nbi(); | |
x.copyTo(r); | |
this.reduce(r); | |
return r; | |
} | |
// x = x/R mod m (HAC 14.32) | |
function montReduce(x) { | |
while(x.t <= this.mt2) // pad x so am has enough room later | |
x.data[x.t++] = 0; | |
for(var i = 0; i < this.m.t; ++i) { | |
// faster way of calculating u0 = x.data[i]*mp mod DV | |
var j = x.data[i]&0x7fff; | |
var u0 = (j*this.mpl+(((j*this.mph+(x.data[i]>>15)*this.mpl)&this.um)<<15))&x.DM; | |
// use am to combine the multiply-shift-add into one call | |
j = i+this.m.t; | |
x.data[j] += this.m.am(0,u0,x,i,0,this.m.t); | |
// propagate carry | |
while(x.data[j] >= x.DV) { x.data[j] -= x.DV; x.data[++j]++; } | |
} | |
x.clamp(); | |
x.drShiftTo(this.m.t,x); | |
if(x.compareTo(this.m) >= 0) x.subTo(this.m,x); | |
} | |
// r = "x^2/R mod m"; x != r | |
function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); } | |
// r = "xy/R mod m"; x,y != r | |
function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); } | |
Montgomery.prototype.convert = montConvert; | |
Montgomery.prototype.revert = montRevert; | |
Montgomery.prototype.reduce = montReduce; | |
Montgomery.prototype.mulTo = montMulTo; | |
Montgomery.prototype.sqrTo = montSqrTo; | |
// (protected) true iff this is even | |
function bnpIsEven() { return ((this.t>0)?(this.data[0]&1):this.s) == 0; } | |
// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79) | |
function bnpExp(e,z) { | |
if(e > 0xffffffff || e < 1) return BigInteger.ONE; | |
var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1; | |
g.copyTo(r); | |
while(--i >= 0) { | |
z.sqrTo(r,r2); | |
if((e&(1<<i)) > 0) z.mulTo(r2,g,r); | |
else { var t = r; r = r2; r2 = t; } | |
} | |
return z.revert(r); | |
} | |
// (public) this^e % m, 0 <= e < 2^32 | |
function bnModPowInt(e,m) { | |
var z; | |
if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m); | |
return this.exp(e,z); | |
} | |
// protected | |
BigInteger.prototype.copyTo = bnpCopyTo; | |
BigInteger.prototype.fromInt = bnpFromInt; | |
BigInteger.prototype.fromString = bnpFromString; | |
BigInteger.prototype.clamp = bnpClamp; | |
BigInteger.prototype.dlShiftTo = bnpDLShiftTo; | |
BigInteger.prototype.drShiftTo = bnpDRShiftTo; | |
BigInteger.prototype.lShiftTo = bnpLShiftTo; | |
BigInteger.prototype.rShiftTo = bnpRShiftTo; | |
BigInteger.prototype.subTo = bnpSubTo; | |
BigInteger.prototype.multiplyTo = bnpMultiplyTo; | |
BigInteger.prototype.squareTo = bnpSquareTo; | |
BigInteger.prototype.divRemTo = bnpDivRemTo; | |
BigInteger.prototype.invDigit = bnpInvDigit; | |
BigInteger.prototype.isEven = bnpIsEven; | |
BigInteger.prototype.exp = bnpExp; | |
// public | |
BigInteger.prototype.toString = bnToString; | |
BigInteger.prototype.negate = bnNegate; | |
BigInteger.prototype.abs = bnAbs; | |
BigInteger.prototype.compareTo = bnCompareTo; | |
BigInteger.prototype.bitLength = bnBitLength; | |
BigInteger.prototype.mod = bnMod; | |
BigInteger.prototype.modPowInt = bnModPowInt; | |
// "constants" | |
BigInteger.ZERO = nbv(0); | |
BigInteger.ONE = nbv(1); | |
// Copyright (c) 2005-2009 Tom Wu | |
// All Rights Reserved. | |
// See "LICENSE" for details. | |
// Extended JavaScript BN functions, required for RSA private ops. | |
// Version 1.1: new BigInteger("0", 10) returns "proper" zero | |
// Version 1.2: square() API, isProbablePrime fix | |
// (public) | |
function bnClone() { var r = nbi(); this.copyTo(r); return r; } | |
// (public) return value as integer | |
function bnIntValue() { | |
if(this.s < 0) { | |
if(this.t == 1) return this.data[0]-this.DV; | |
else if(this.t == 0) return -1; | |
} | |
else if(this.t == 1) return this.data[0]; | |
else if(this.t == 0) return 0; | |
// assumes 16 < DB < 32 | |
return ((this.data[1]&((1<<(32-this.DB))-1))<<this.DB)|this.data[0]; | |
} | |
// (public) return value as byte | |
function bnByteValue() { return (this.t==0)?this.s:(this.data[0]<<24)>>24; } | |
// (public) return value as short (assumes DB>=16) | |
function bnShortValue() { return (this.t==0)?this.s:(this.data[0]<<16)>>16; } | |
// (protected) return x s.t. r^x < DV | |
function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); } | |
// (public) 0 if this == 0, 1 if this > 0 | |
function bnSigNum() { | |
if(this.s < 0) return -1; | |
else if(this.t <= 0 || (this.t == 1 && this.data[0] <= 0)) return 0; | |
else return 1; | |
} | |
// (protected) convert to radix string | |
function bnpToRadix(b) { | |
if(b == null) b = 10; | |
if(this.signum() == 0 || b < 2 || b > 36) return "0"; | |
var cs = this.chunkSize(b); | |
var a = Math.pow(b,cs); | |
var d = nbv(a), y = nbi(), z = nbi(), r = ""; | |
this.divRemTo(d,y,z); | |
while(y.signum() > 0) { | |
r = (a+z.intValue()).toString(b).substr(1) + r; | |
y.divRemTo(d,y,z); | |
} | |
return z.intValue().toString(b) + r; | |
} | |
// (protected) convert from radix string | |
function bnpFromRadix(s,b) { | |
this.fromInt(0); | |
if(b == null) b = 10; | |
var cs = this.chunkSize(b); | |
var d = Math.pow(b,cs), mi = false, j = 0, w = 0; | |
for(var i = 0; i < s.length; ++i) { | |
var x = intAt(s,i); | |
if(x < 0) { | |
if(s.charAt(i) == "-" && this.signum() == 0) mi = true; | |
continue; | |
} | |
w = b*w+x; | |
if(++j >= cs) { | |
this.dMultiply(d); | |
this.dAddOffset(w,0); | |
j = 0; | |
w = 0; | |
} | |
} | |
if(j > 0) { | |
this.dMultiply(Math.pow(b,j)); | |
this.dAddOffset(w,0); | |
} | |
if(mi) BigInteger.ZERO.subTo(this,this); | |
} | |
// (protected) alternate constructor | |
function bnpFromNumber(a,b,c) { | |
if("number" == typeof b) { | |
// new BigInteger(int,int,RNG) | |
if(a < 2) this.fromInt(1); | |
else { | |
this.fromNumber(a,c); | |
if(!this.testBit(a-1)) // force MSB set | |
this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this); | |
if(this.isEven()) this.dAddOffset(1,0); // force odd | |
while(!this.isProbablePrime(b)) { | |
this.dAddOffset(2,0); | |
if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this); | |
} | |
} | |
} | |
else { | |
// new BigInteger(int,RNG) | |
var x = new Array(), t = a&7; | |
x.length = (a>>3)+1; | |
b.nextBytes(x); | |
if(t > 0) x[0] &= ((1<<t)-1); else x[0] = 0; | |
this.fromString(x,256); | |
} | |
} | |
// (public) convert to bigendian byte array | |
function bnToByteArray() { | |
var i = this.t, r = new Array(); | |
r[0] = this.s; | |
var p = this.DB-(i*this.DB)%8, d, k = 0; | |
if(i-- > 0) { | |
if(p < this.DB && (d = this.data[i]>>p) != (this.s&this.DM)>>p) | |
r[k++] = d|(this.s<<(this.DB-p)); | |
while(i >= 0) { | |
if(p < 8) { | |
d = (this.data[i]&((1<<p)-1))<<(8-p); | |
d |= this.data[--i]>>(p+=this.DB-8); | |
} | |
else { | |
d = (this.data[i]>>(p-=8))&0xff; | |
if(p <= 0) { p += this.DB; --i; } | |
} | |
if((d&0x80) != 0) d |= -256; | |
if(k == 0 && (this.s&0x80) != (d&0x80)) ++k; | |
if(k > 0 || d != this.s) r[k++] = d; | |
} | |
} | |
return r; | |
} | |
function bnEquals(a) { return(this.compareTo(a)==0); } | |
function bnMin(a) { return(this.compareTo(a)<0)?this:a; } | |
function bnMax(a) { return(this.compareTo(a)>0)?this:a; } | |
// (protected) r = this op a (bitwise) | |
function bnpBitwiseTo(a,op,r) { | |
var i, f, m = Math.min(a.t,this.t); | |
for(i = 0; i < m; ++i) r.data[i] = op(this.data[i],a.data[i]); | |
if(a.t < this.t) { | |
f = a.s&this.DM; | |
for(i = m; i < this.t; ++i) r.data[i] = op(this.data[i],f); | |
r.t = this.t; | |
} | |
else { | |
f = this.s&this.DM; | |
for(i = m; i < a.t; ++i) r.data[i] = op(f,a.data[i]); | |
r.t = a.t; | |
} | |
r.s = op(this.s,a.s); | |
r.clamp(); | |
} | |
// (public) this & a | |
function op_and(x,y) { return x&y; } | |
function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; } | |
// (public) this | a | |
function op_or(x,y) { return x|y; } | |
function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; } | |
// (public) this ^ a | |
function op_xor(x,y) { return x^y; } | |
function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; } | |
// (public) this & ~a | |
function op_andnot(x,y) { return x&~y; } | |
function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; } | |
// (public) ~this | |
function bnNot() { | |
var r = nbi(); | |
for(var i = 0; i < this.t; ++i) r.data[i] = this.DM&~this.data[i]; | |
r.t = this.t; | |
r.s = ~this.s; | |
return r; | |
} | |
// (public) this << n | |
function bnShiftLeft(n) { | |
var r = nbi(); | |
if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r); | |
return r; | |
} | |
// (public) this >> n | |
function bnShiftRight(n) { | |
var r = nbi(); | |
if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r); | |
return r; | |
} | |
// return index of lowest 1-bit in x, x < 2^31 | |
function lbit(x) { | |
if(x == 0) return -1; | |
var r = 0; | |
if((x&0xffff) == 0) { x >>= 16; r += 16; } | |
if((x&0xff) == 0) { x >>= 8; r += 8; } | |
if((x&0xf) == 0) { x >>= 4; r += 4; } | |
if((x&3) == 0) { x >>= 2; r += 2; } | |
if((x&1) == 0) ++r; | |
return r; | |
} | |
// (public) returns index of lowest 1-bit (or -1 if none) | |
function bnGetLowestSetBit() { | |
for(var i = 0; i < this.t; ++i) | |
if(this.data[i] != 0) return i*this.DB+lbit(this.data[i]); | |
if(this.s < 0) return this.t*this.DB; | |
return -1; | |
} | |
// return number of 1 bits in x | |
function cbit(x) { | |
var r = 0; | |
while(x != 0) { x &= x-1; ++r; } | |
return r; | |
} | |
// (public) return number of set bits | |
function bnBitCount() { | |
var r = 0, x = this.s&this.DM; | |
for(var i = 0; i < this.t; ++i) r += cbit(this.data[i]^x); | |
return r; | |
} | |
// (public) true iff nth bit is set | |
function bnTestBit(n) { | |
var j = Math.floor(n/this.DB); | |
if(j >= this.t) return(this.s!=0); | |
return((this.data[j]&(1<<(n%this.DB)))!=0); | |
} | |
// (protected) this op (1<<n) | |
function bnpChangeBit(n,op) { | |
var r = BigInteger.ONE.shiftLeft(n); | |
this.bitwiseTo(r,op,r); | |
return r; | |
} | |
// (public) this | (1<<n) | |
function bnSetBit(n) { return this.changeBit(n,op_or); } | |
// (public) this & ~(1<<n) | |
function bnClearBit(n) { return this.changeBit(n,op_andnot); } | |
// (public) this ^ (1<<n) | |
function bnFlipBit(n) { return this.changeBit(n,op_xor); } | |
// (protected) r = this + a | |
function bnpAddTo(a,r) { | |
var i = 0, c = 0, m = Math.min(a.t,this.t); | |
while(i < m) { | |
c += this.data[i]+a.data[i]; | |
r.data[i++] = c&this.DM; | |
c >>= this.DB; | |
} | |
if(a.t < this.t) { | |
c += a.s; | |
while(i < this.t) { | |
c += this.data[i]; | |
r.data[i++] = c&this.DM; | |
c >>= this.DB; | |
} | |
c += this.s; | |
} | |
else { | |
c += this.s; | |
while(i < a.t) { | |
c += a.data[i]; | |
r.data[i++] = c&this.DM; | |
c >>= this.DB; | |
} | |
c += a.s; | |
} | |
r.s = (c<0)?-1:0; | |
if(c > 0) r.data[i++] = c; | |
else if(c < -1) r.data[i++] = this.DV+c; | |
r.t = i; | |
r.clamp(); | |
} | |
// (public) this + a | |
function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; } | |
// (public) this - a | |
function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; } | |
// (public) this * a | |
function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; } | |
// (public) this^2 | |
function bnSquare() { var r = nbi(); this.squareTo(r); return r; } | |
// (public) this / a | |
function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; } | |
// (public) this % a | |
function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; } | |
// (public) [this/a,this%a] | |
function bnDivideAndRemainder(a) { | |
var q = nbi(), r = nbi(); | |
this.divRemTo(a,q,r); | |
return new Array(q,r); | |
} | |
// (protected) this *= n, this >= 0, 1 < n < DV | |
function bnpDMultiply(n) { | |
this.data[this.t] = this.am(0,n-1,this,0,0,this.t); | |
++this.t; | |
this.clamp(); | |
} | |
// (protected) this += n << w words, this >= 0 | |
function bnpDAddOffset(n,w) { | |
if(n == 0) return; | |
while(this.t <= w) this.data[this.t++] = 0; | |
this.data[w] += n; | |
while(this.data[w] >= this.DV) { | |
this.data[w] -= this.DV; | |
if(++w >= this.t) this.data[this.t++] = 0; | |
++this.data[w]; | |
} | |
} | |
// A "null" reducer | |
/** @constructor */ | |
function NullExp() {} | |
function nNop(x) { return x; } | |
function nMulTo(x,y,r) { x.multiplyTo(y,r); } | |
function nSqrTo(x,r) { x.squareTo(r); } | |
NullExp.prototype.convert = nNop; | |
NullExp.prototype.revert = nNop; | |
NullExp.prototype.mulTo = nMulTo; | |
NullExp.prototype.sqrTo = nSqrTo; | |
// (public) this^e | |
function bnPow(e) { return this.exp(e,new NullExp()); } | |
// (protected) r = lower n words of "this * a", a.t <= n | |
// "this" should be the larger one if appropriate. | |
function bnpMultiplyLowerTo(a,n,r) { | |
var i = Math.min(this.t+a.t,n); | |
r.s = 0; // assumes a,this >= 0 | |
r.t = i; | |
while(i > 0) r.data[--i] = 0; | |
var j; | |
for(j = r.t-this.t; i < j; ++i) r.data[i+this.t] = this.am(0,a.data[i],r,i,0,this.t); | |
for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a.data[i],r,i,0,n-i); | |
r.clamp(); | |
} | |
// (protected) r = "this * a" without lower n words, n > 0 | |
// "this" should be the larger one if appropriate. | |
function bnpMultiplyUpperTo(a,n,r) { | |
--n; | |
var i = r.t = this.t+a.t-n; | |
r.s = 0; // assumes a,this >= 0 | |
while(--i >= 0) r.data[i] = 0; | |
for(i = Math.max(n-this.t,0); i < a.t; ++i) | |
r.data[this.t+i-n] = this.am(n-i,a.data[i],r,0,0,this.t+i-n); | |
r.clamp(); | |
r.drShiftTo(1,r); | |
} | |
// Barrett modular reduction | |
/** @constructor */ | |
function Barrett(m) { | |
// setup Barrett | |
this.r2 = nbi(); | |
this.q3 = nbi(); | |
BigInteger.ONE.dlShiftTo(2*m.t,this.r2); | |
this.mu = this.r2.divide(m); | |
this.m = m; | |
} | |
function barrettConvert(x) { | |
if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m); | |
else if(x.compareTo(this.m) < 0) return x; | |
else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; } | |
} | |
function barrettRevert(x) { return x; } | |
// x = x mod m (HAC 14.42) | |
function barrettReduce(x) { | |
x.drShiftTo(this.m.t-1,this.r2); | |
if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); } | |
this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3); | |
this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2); | |
while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1); | |
x.subTo(this.r2,x); | |
while(x.compareTo(this.m) >= 0) x.subTo(this.m,x); | |
} | |
// r = x^2 mod m; x != r | |
function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); } | |
// r = x*y mod m; x,y != r | |
function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); } | |
Barrett.prototype.convert = barrettConvert; | |
Barrett.prototype.revert = barrettRevert; | |
Barrett.prototype.reduce = barrettReduce; | |
Barrett.prototype.mulTo = barrettMulTo; | |
Barrett.prototype.sqrTo = barrettSqrTo; | |
// (public) this^e % m (HAC 14.85) | |
function bnModPow(e,m) { | |
var i = e.bitLength(), k, r = nbv(1), z; | |
if(i <= 0) return r; | |
else if(i < 18) k = 1; | |
else if(i < 48) k = 3; | |
else if(i < 144) k = 4; | |
else if(i < 768) k = 5; | |
else k = 6; | |
if(i < 8) | |
z = new Classic(m); | |
else if(m.isEven()) | |
z = new Barrett(m); | |
else | |
z = new Montgomery(m); | |
// precomputation | |
var g = new Array(), n = 3, k1 = k-1, km = (1<<k)-1; | |
g[1] = z.convert(this); | |
if(k > 1) { | |
var g2 = nbi(); | |
z.sqrTo(g[1],g2); | |
while(n <= km) { | |
g[n] = nbi(); | |
z.mulTo(g2,g[n-2],g[n]); | |
n += 2; | |
} | |
} | |
var j = e.t-1, w, is1 = true, r2 = nbi(), t; | |
i = nbits(e.data[j])-1; | |
while(j >= 0) { | |
if(i >= k1) w = (e.data[j]>>(i-k1))&km; | |
else { | |
w = (e.data[j]&((1<<(i+1))-1))<<(k1-i); | |
if(j > 0) w |= e.data[j-1]>>(this.DB+i-k1); | |
} | |
n = k; | |
while((w&1) == 0) { w >>= 1; --n; } | |
if((i -= n) < 0) { i += this.DB; --j; } | |
if(is1) { // ret == 1, don't bother squaring or multiplying it | |
g[w].copyTo(r); | |
is1 = false; | |
} | |
else { | |
while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; } | |
if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; } | |
z.mulTo(r2,g[w],r); | |
} | |
while(j >= 0 && (e.data[j]&(1<<i)) == 0) { | |
z.sqrTo(r,r2); t = r; r = r2; r2 = t; | |
if(--i < 0) { i = this.DB-1; --j; } | |
} | |
} | |
return z.revert(r); | |
} | |
// (public) gcd(this,a) (HAC 14.54) | |
function bnGCD(a) { | |
var x = (this.s<0)?this.negate():this.clone(); | |
var y = (a.s<0)?a.negate():a.clone(); | |
if(x.compareTo(y) < 0) { var t = x; x = y; y = t; } | |
var i = x.getLowestSetBit(), g = y.getLowestSetBit(); | |
if(g < 0) return x; | |
if(i < g) g = i; | |
if(g > 0) { | |
x.rShiftTo(g,x); | |
y.rShiftTo(g,y); | |
} | |
while(x.signum() > 0) { | |
if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x); | |
if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y); | |
if(x.compareTo(y) >= 0) { | |
x.subTo(y,x); | |
x.rShiftTo(1,x); | |
} | |
else { | |
y.subTo(x,y); | |
y.rShiftTo(1,y); | |
} | |
} | |
if(g > 0) y.lShiftTo(g,y); | |
return y; | |
} | |
// (protected) this % n, n < 2^26 | |
function bnpModInt(n) { | |
if(n <= 0) return 0; | |
var d = this.DV%n, r = (this.s<0)?n-1:0; | |
if(this.t > 0) | |
if(d == 0) r = this.data[0]%n; | |
else for(var i = this.t-1; i >= 0; --i) r = (d*r+this.data[i])%n; | |
return r; | |
} | |
// (public) 1/this % m (HAC 14.61) | |
function bnModInverse(m) { | |
var ac = m.isEven(); | |
if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO; | |
var u = m.clone(), v = this.clone(); | |
var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1); | |
while(u.signum() != 0) { | |
while(u.isEven()) { | |
u.rShiftTo(1,u); | |
if(ac) { | |
if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); } | |
a.rShiftTo(1,a); | |
} | |
else if(!b.isEven()) b.subTo(m,b); | |
b.rShiftTo(1,b); | |
} | |
while(v.isEven()) { | |
v.rShiftTo(1,v); | |
if(ac) { | |
if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); } | |
c.rShiftTo(1,c); | |
} | |
else if(!d.isEven()) d.subTo(m,d); | |
d.rShiftTo(1,d); | |
} | |
if(u.compareTo(v) >= 0) { | |
u.subTo(v,u); | |
if(ac) a.subTo(c,a); | |
b.subTo(d,b); | |
} | |
else { | |
v.subTo(u,v); | |
if(ac) c.subTo(a,c); | |
d.subTo(b,d); | |
} | |
} | |
if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO; | |
if(d.compareTo(m) >= 0) return d.subtract(m); | |
if(d.signum() < 0) d.addTo(m,d); else return d; | |
if(d.signum() < 0) return d.add(m); else return d; | |
} | |
var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997]; | |
var lplim = (1<<26)/lowprimes[lowprimes.length-1]; | |
// (public) test primality with certainty >= 1-.5^t | |
function bnIsProbablePrime(t) { | |
var i, x = this.abs(); | |
if(x.t == 1 && x.data[0] <= lowprimes[lowprimes.length-1]) { | |
for(i = 0; i < lowprimes.length; ++i) | |
if(x.data[0] == lowprimes[i]) return true; | |
return false; | |
} | |
if(x.isEven()) return false; | |
i = 1; | |
while(i < lowprimes.length) { | |
var m = lowprimes[i], j = i+1; | |
while(j < lowprimes.length && m < lplim) m *= lowprimes[j++]; | |
m = x.modInt(m); | |
while(i < j) if(m%lowprimes[i++] == 0) return false; | |
} | |
return x.millerRabin(t); | |
} | |
// (protected) true if probably prime (HAC 4.24, Miller-Rabin) | |
function bnpMillerRabin(t) { | |
var n1 = this.subtract(BigInteger.ONE); | |
var k = n1.getLowestSetBit(); | |
if(k <= 0) return false; | |
var r = n1.shiftRight(k); | |
t = (t+1)>>1; | |
if(t > lowprimes.length) t = lowprimes.length; | |
var a = nbi(); | |
for(var i = 0; i < t; ++i) { | |
// Pick bases at random, instead of starting at 2 | |
a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]); | |
var y = a.modPow(r,this); | |
if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) { | |
var j = 1; | |
while(j++ < k && y.compareTo(n1) != 0) { | |
y = y.modPowInt(2,this); | |
if(y.compareTo(BigInteger.ONE) == 0) return false; | |
} | |
if(y.compareTo(n1) != 0) return false; | |
} | |
} | |
return true; | |
} | |
// protected | |
BigInteger.prototype.chunkSize = bnpChunkSize; | |
BigInteger.prototype.toRadix = bnpToRadix; | |
BigInteger.prototype.fromRadix = bnpFromRadix; | |
BigInteger.prototype.fromNumber = bnpFromNumber; | |
BigInteger.prototype.bitwiseTo = bnpBitwiseTo; | |
BigInteger.prototype.changeBit = bnpChangeBit; | |
BigInteger.prototype.addTo = bnpAddTo; | |
BigInteger.prototype.dMultiply = bnpDMultiply; | |
BigInteger.prototype.dAddOffset = bnpDAddOffset; | |
BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo; | |
BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo; | |
BigInteger.prototype.modInt = bnpModInt; | |
BigInteger.prototype.millerRabin = bnpMillerRabin; | |
// public | |
BigInteger.prototype.clone = bnClone; | |
BigInteger.prototype.intValue = bnIntValue; | |
BigInteger.prototype.byteValue = bnByteValue; | |
BigInteger.prototype.shortValue = bnShortValue; | |
BigInteger.prototype.signum = bnSigNum; | |
BigInteger.prototype.toByteArray = bnToByteArray; | |
BigInteger.prototype.equals = bnEquals; | |
BigInteger.prototype.min = bnMin; | |
BigInteger.prototype.max = bnMax; | |
BigInteger.prototype.and = bnAnd; | |
BigInteger.prototype.or = bnOr; | |
BigInteger.prototype.xor = bnXor; | |
BigInteger.prototype.andNot = bnAndNot; | |
BigInteger.prototype.not = bnNot; | |
BigInteger.prototype.shiftLeft = bnShiftLeft; | |
BigInteger.prototype.shiftRight = bnShiftRight; | |
BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit; | |
BigInteger.prototype.bitCount = bnBitCount; | |
BigInteger.prototype.testBit = bnTestBit; | |
BigInteger.prototype.setBit = bnSetBit; | |
BigInteger.prototype.clearBit = bnClearBit; | |
BigInteger.prototype.flipBit = bnFlipBit; | |
BigInteger.prototype.add = bnAdd; | |
BigInteger.prototype.subtract = bnSubtract; | |
BigInteger.prototype.multiply = bnMultiply; | |
BigInteger.prototype.divide = bnDivide; | |
BigInteger.prototype.remainder = bnRemainder; | |
BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder; | |
BigInteger.prototype.modPow = bnModPow; | |
BigInteger.prototype.modInverse = bnModInverse; | |
BigInteger.prototype.pow = bnPow; | |
BigInteger.prototype.gcd = bnGCD; | |
BigInteger.prototype.isProbablePrime = bnIsProbablePrime; | |
// JSBN-specific extension | |
BigInteger.prototype.square = bnSquare; | |
// BigInteger interfaces not implemented in jsbn: | |
// BigInteger(int signum, byte[] magnitude) | |
// double doubleValue() | |
// float floatValue() | |
// int hashCode() | |
// long longValue() | |
// static BigInteger valueOf(long val) | |
// customization for GHCJS | |
BigInteger.prototype.am = am3; | |
dbits = 28; | |
DV = (1<<dbits); | |
BigInteger.prototype.DB = dbits; | |
BigInteger.prototype.DM = ((1<<dbits)-1); | |
BigInteger.prototype.DV = (1<<dbits); | |
BI_FP = 52; | |
BigInteger.prototype.FV = Math.pow(2,BI_FP); | |
BigInteger.prototype.F1 = BI_FP-dbits; | |
BigInteger.prototype.F2 = 2*dbits-BI_FP; | |
BigInteger.nbv = nbv; | |
BigInteger.nbi = nbi; | |
return BigInteger; | |
})(); | |
// fixme prefix this | |
var h$nbv = BigInteger.nbv; | |
var h$nbi = BigInteger.nbi; | |
(function (global, undefined) { | |
"use strict"; | |
if (global.setImmediate) { | |
return; | |
} | |
var nextHandle = 1; // Spec says greater than zero | |
var tasksByHandle = {}; | |
var currentlyRunningATask = false; | |
var doc = global.document; | |
var setImmediate; | |
function addFromSetImmediateArguments(args) { | |
tasksByHandle[nextHandle] = partiallyApplied.apply(undefined, args); | |
return nextHandle++; | |
} | |
// This function accepts the same arguments as setImmediate, but | |
// returns a function that requires no arguments. | |
function partiallyApplied(handler) { | |
var args = [].slice.call(arguments, 1); | |
return function() { | |
if (typeof handler === "function") { | |
handler.apply(undefined, args); | |
} else { | |
(new Function("" + handler))(); | |
} | |
}; | |
} | |
function runIfPresent(handle) { | |
// From the spec: "Wait until any invocations of this algorithm started before this one have completed." | |
// So if we're currently running a task, we'll need to delay this invocation. | |
if (currentlyRunningATask) { | |
// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a | |
// "too much recursion" error. | |
setTimeout(partiallyApplied(runIfPresent, handle), 0); | |
} else { | |
var task = tasksByHandle[handle]; | |
if (task) { | |
currentlyRunningATask = true; | |
try { | |
task(); | |
} finally { | |
clearImmediate(handle); | |
currentlyRunningATask = false; | |
} | |
} | |
} | |
} | |
function clearImmediate(handle) { | |
delete tasksByHandle[handle]; | |
} | |
function installNextTickImplementation() { | |
setImmediate = function() { | |
var handle = addFromSetImmediateArguments(arguments); | |
process.nextTick(partiallyApplied(runIfPresent, handle)); | |
return handle; | |
}; | |
} | |
function canUsePostMessage() { | |
// The test against `importScripts` prevents this implementation from being installed inside a web worker, | |
// where `global.postMessage` means something completely different and can't be used for this purpose. | |
if (global.postMessage && !global.importScripts) { | |
var postMessageIsAsynchronous = true; | |
var oldOnMessage = global.onmessage; | |
global.onmessage = function() { | |
postMessageIsAsynchronous = false; | |
}; | |
global.postMessage("", "*"); | |
global.onmessage = oldOnMessage; | |
return postMessageIsAsynchronous; | |
} | |
} | |
function installPostMessageImplementation() { | |
// Installs an event handler on `global` for the `message` event: see | |
// * https://developer.mozilla.org/en/DOM/window.postMessage | |
// * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages | |
var messagePrefix = "setImmediate$" + Math.random() + "$"; | |
var onGlobalMessage = function(event) { | |
if (event.source === global && | |
typeof event.data === "string" && | |
event.data.indexOf(messagePrefix) === 0) { | |
runIfPresent(+event.data.slice(messagePrefix.length)); | |
} | |
}; | |
if (global.addEventListener) { | |
global.addEventListener("message", onGlobalMessage, false); | |
} else { | |
global.attachEvent("onmessage", onGlobalMessage); | |
} | |
setImmediate = function() { | |
var handle = addFromSetImmediateArguments(arguments); | |
global.postMessage(messagePrefix + handle, "*"); | |
return handle; | |
}; | |
} | |
function installMessageChannelImplementation() { | |
var channel = new MessageChannel(); | |
channel.port1.onmessage = function(event) { | |
var handle = event.data; | |
runIfPresent(handle); | |
}; | |
setImmediate = function() { | |
var handle = addFromSetImmediateArguments(arguments); | |
channel.port2.postMessage(handle); | |
return handle; | |
}; | |
} | |
function installReadyStateChangeImplementation() { | |
var html = doc.documentElement; | |
setImmediate = function() { | |
var handle = addFromSetImmediateArguments(arguments); | |
// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted | |
// into the document. Do so, thus queuing up the task. Remember to clean up once it's been called. | |
var script = doc.createElement("script"); | |
script.onreadystatechange = function () { | |
runIfPresent(handle); | |
script.onreadystatechange = null; | |
html.removeChild(script); | |
script = null; | |
}; | |
html.appendChild(script); | |
return handle; | |
}; | |
} | |
function installSetTimeoutImplementation() { | |
// jsshell doesn't even have setTimeout | |
if(typeof setTimeout === 'undefined') setImmediate = function() { return null; }; | |
else | |
setImmediate = function() { | |
var handle = addFromSetImmediateArguments(arguments); | |
setTimeout(partiallyApplied(runIfPresent, handle), 0); | |
return handle; | |
}; | |
} | |
// If supported, we should attach to the prototype of global, since that is where setTimeout et al. live. | |
var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global); | |
attachTo = attachTo && attachTo.setTimeout ? attachTo : global; | |
// Don't get fooled by e.g. browserify environments. | |
if ({}.toString.call(global.process) === "[object process]") { | |
// For Node.js before 0.9 | |
installNextTickImplementation(); | |
} else | |
if (canUsePostMessage()) { | |
// For non-IE10 modern browsers | |
installPostMessageImplementation(); | |
} else if (global.MessageChannel) { | |
// For web workers, where supported | |
installMessageChannelImplementation(); | |
} else if (doc && "onreadystatechange" in doc.createElement("script")) { | |
// For IE 6–8 | |
installReadyStateChangeImplementation(); | |
} else { | |
// For older browsers | |
installSetTimeoutImplementation(); | |
} | |
attachTo.setImmediate = setImmediate; | |
attachTo.clearImmediate = clearImmediate; | |
}(this)); | |
// Copyright 2009 The Closure Library Authors. All Rights Reserved. | |
// | |
// Licensed under the Apache License, Version 2.0 (the "License"); | |
// you may not use this file except in compliance with the License. | |
// You may obtain a copy of the License at | |
// | |
// http://www.apache.org/licenses/LICENSE-2.0 | |
// | |
// Unless required by applicable law or agreed to in writing, software | |
// distributed under the License is distributed on an "AS-IS" BASIS, | |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
// See the License for the specific language governing permissions and | |
// limitations under the License. | |
/** | |
* @fileoverview Defines a Long class for representing a 64-bit two's-complement | |
* integer value, which faithfully simulates the behavior of a Java "long". This | |
* implementation is derived from LongLib in GWT. | |
* | |
*/ | |
goog.provide('goog.math.Long'); | |
/** | |
* Constructs a 64-bit two's-complement integer, given its low and high 32-bit | |
* values as *signed* integers. See the from* functions below for more | |
* convenient ways of constructing Longs. | |
* | |
* The internal representation of a long is the two given signed, 32-bit values. | |
* We use 32-bit pieces because these are the size of integers on which | |
* Javascript performs bit-operations. For operations like addition and | |
* multiplication, we split each number into 16-bit pieces, which can easily be | |
* multiplied within Javascript's floating-point representation without overflow | |
* or change in sign. | |
* | |
* In the algorithms below, we frequently reduce the negative case to the | |
* positive case by negating the input(s) and then post-processing the result. | |
* Note that we must ALWAYS check specially whether those values are MIN_VALUE | |
* (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as | |
* a positive number, it overflows back into a negative). Not handling this | |
* case would often result in infinite recursion. | |
* | |
* @param {number} low The low (signed) 32 bits of the long. | |
* @param {number} high The high (signed) 32 bits of the long. | |
* @struct | |
* @constructor | |
* @final | |
*/ | |
goog.math.Long = function(low, high) { | |
/** | |
* @type {number} | |
* @private | |
*/ | |
this.low_ = low | 0; // force into 32 signed bits. | |
/** | |
* @type {number} | |
* @private | |
*/ | |
this.high_ = high | 0; // force into 32 signed bits. | |
}; | |
// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the | |
// from* methods on which they depend. | |
/** | |
* A cache of the Long representations of small integer values. | |
* @type {!Object} | |
* @private | |
*/ | |
goog.math.Long.IntCache_ = {}; | |
/** | |
* Returns a Long representing the given (32-bit) integer value. | |
* @param {number} value The 32-bit integer in question. | |
* @return {!goog.math.Long} The corresponding Long value. | |
*/ | |
goog.math.Long.fromInt = function(value) { | |
if (-128 <= value && value < 128) { | |
var cachedObj = goog.math.Long.IntCache_[value]; | |
if (cachedObj) { | |
return cachedObj; | |
} | |
} | |
var obj = new goog.math.Long(value | 0, value < 0 ? -1 : 0); | |
if (-128 <= value && value < 128) { | |
goog.math.Long.IntCache_[value] = obj; | |
} | |
return obj; | |
}; | |
/** | |
* Returns a Long representing the given value, provided that it is a finite | |
* number. Otherwise, zero is returned. | |
* @param {number} value The number in question. | |
* @return {!goog.math.Long} The corresponding Long value. | |
*/ | |
goog.math.Long.fromNumber = function(value) { | |
if (isNaN(value) || !isFinite(value)) { | |
return goog.math.Long.ZERO; | |
} else if (value <= -goog.math.Long.TWO_PWR_63_DBL_) { | |
return goog.math.Long.MIN_VALUE; | |
} else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_) { | |
return goog.math.Long.MAX_VALUE; | |
} else if (value < 0) { | |
return goog.math.Long.fromNumber(-value).negate(); | |
} else { | |
return new goog.math.Long( | |
(value % goog.math.Long.TWO_PWR_32_DBL_) | 0, | |
(value / goog.math.Long.TWO_PWR_32_DBL_) | 0); | |
} | |
}; | |
/** | |
* Returns a Long representing the 64-bit integer that comes by concatenating | |
* the given high and low bits. Each is assumed to use 32 bits. | |
* @param {number} lowBits The low 32-bits. | |
* @param {number} highBits The high 32-bits. | |
* @return {!goog.math.Long} The corresponding Long value. | |
*/ | |
goog.math.Long.fromBits = function(lowBits, highBits) { | |
return new goog.math.Long(lowBits, highBits); | |
}; | |
/** | |
* Returns a Long representation of the given string, written using the given | |
* radix. | |
* @param {string} str The textual representation of the Long. | |
* @param {number=} opt_radix The radix in which the text is written. | |
* @return {!goog.math.Long} The corresponding Long value. | |
*/ | |
goog.math.Long.fromString = function(str, opt_radix) { | |
if (str.length == 0) { | |
throw Error('number format error: empty string'); | |
} | |
var radix = opt_radix || 10; | |
if (radix < 2 || 36 < radix) { | |
throw Error('radix out of range: ' + radix); | |
} | |
if (str.charAt(0) == '-') { | |
return goog.math.Long.fromString(str.substring(1), radix).negate(); | |
} else if (str.indexOf('-') >= 0) { | |
throw Error('number format error: interior "-" character: ' + str); | |
} | |
// Do several (8) digits each time through the loop, so as to | |
// minimize the calls to the very expensive emulated div. | |
var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8)); | |
var result = goog.math.Long.ZERO; | |
for (var i = 0; i < str.length; i += 8) { | |
var size = Math.min(8, str.length - i); | |
var value = parseInt(str.substring(i, i + size), radix); | |
if (size < 8) { | |
var power = goog.math.Long.fromNumber(Math.pow(radix, size)); | |
result = result.multiply(power).add(goog.math.Long.fromNumber(value)); | |
} else { | |
result = result.multiply(radixToPower); | |
result = result.add(goog.math.Long.fromNumber(value)); | |
} | |
} | |
return result; | |
}; | |
// NOTE: the compiler should inline these constant values below and then remove | |
// these variables, so there should be no runtime penalty for these. | |
/** | |
* Number used repeated below in calculations. This must appear before the | |
* first call to any from* function below. | |
* @type {number} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16; | |
/** | |
* @type {number} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24; | |
/** | |
* @type {number} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_32_DBL_ = | |
goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_; | |
/** | |
* @type {number} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_31_DBL_ = | |
goog.math.Long.TWO_PWR_32_DBL_ / 2; | |
/** | |
* @type {number} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_48_DBL_ = | |
goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_; | |
/** | |
* @type {number} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_64_DBL_ = | |
goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_; | |
/** | |
* @type {number} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_63_DBL_ = | |
goog.math.Long.TWO_PWR_64_DBL_ / 2; | |
/** @type {!goog.math.Long} */ | |
goog.math.Long.ZERO = goog.math.Long.fromInt(0); | |
/** @type {!goog.math.Long} */ | |
goog.math.Long.ONE = goog.math.Long.fromInt(1); | |
/** @type {!goog.math.Long} */ | |
goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1); | |
/** @type {!goog.math.Long} */ | |
goog.math.Long.MAX_VALUE = | |
goog.math.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0); | |
/** @type {!goog.math.Long} */ | |
goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 0x80000000 | 0); | |
/** | |
* @type {!goog.math.Long} | |
* @private | |
*/ | |
goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24); | |
/** @return {number} The value, assuming it is a 32-bit integer. */ | |
goog.math.Long.prototype.toInt = function() { | |
return this.low_; | |
}; | |
/** @return {number} The closest floating-point representation to this value. */ | |
goog.math.Long.prototype.toNumber = function() { | |
return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ + | |
this.getLowBitsUnsigned(); | |
}; | |
/** | |
* @param {number=} opt_radix The radix in which the text should be written. | |
* @return {string} The textual representation of this value. | |
* @override | |
*/ | |
goog.math.Long.prototype.toString = function(opt_radix) { | |
var radix = opt_radix || 10; | |
if (radix < 2 || 36 < radix) { | |
throw Error('radix out of range: ' + radix); | |
} | |
if (this.isZero()) { | |
return '0'; | |
} | |
if (this.isNegative()) { | |
if (this.equals(goog.math.Long.MIN_VALUE)) { | |
// We need to change the Long value before it can be negated, so we remove | |
// the bottom-most digit in this base and then recurse to do the rest. | |
var radixLong = goog.math.Long.fromNumber(radix); | |
var div = this.div(radixLong); | |
var rem = div.multiply(radixLong).subtract(this); | |
return div.toString(radix) + rem.toInt().toString(radix); | |
} else { | |
return '-' + this.negate().toString(radix); | |
} | |
} | |
// Do several (6) digits each time through the loop, so as to | |
// minimize the calls to the very expensive emulated div. | |
var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6)); | |
var rem = this; | |
var result = ''; | |
while (true) { | |
var remDiv = rem.div(radixToPower); | |
var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt(); | |
var digits = intval.toString(radix); | |
rem = remDiv; | |
if (rem.isZero()) { | |
return digits + result; | |
} else { | |
while (digits.length < 6) { | |
digits = '0' + digits; | |
} | |
result = '' + digits + result; | |
} | |
} | |
}; | |
/** @return {number} The high 32-bits as a signed value. */ | |
goog.math.Long.prototype.getHighBits = function() { | |
return this.high_; | |
}; | |
/** @return {number} The low 32-bits as a signed value. */ | |
goog.math.Long.prototype.getLowBits = function() { | |
return this.low_; | |
}; | |
/** @return {number} The low 32-bits as an unsigned value. */ | |
goog.math.Long.prototype.getLowBitsUnsigned = function() { | |
return (this.low_ >= 0) ? | |
this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_; | |
}; | |
/** | |
* @return {number} Returns the number of bits needed to represent the absolute | |
* value of this Long. | |
*/ | |
goog.math.Long.prototype.getNumBitsAbs = function() { | |
if (this.isNegative()) { | |
if (this.equals(goog.math.Long.MIN_VALUE)) { | |
return 64; | |
} else { | |
return this.negate().getNumBitsAbs(); | |
} | |
} else { | |
var val = this.high_ != 0 ? this.high_ : this.low_; | |
for (var bit = 31; bit > 0; bit--) { | |
if ((val & (1 << bit)) != 0) { | |
break; | |
} | |
} | |
return this.high_ != 0 ? bit + 33 : bit + 1; | |
} | |
}; | |
/** @return {boolean} Whether this value is zero. */ | |
goog.math.Long.prototype.isZero = function() { | |
return this.high_ == 0 && this.low_ == 0; | |
}; | |
/** @return {boolean} Whether this value is negative. */ | |
goog.math.Long.prototype.isNegative = function() { | |
return this.high_ < 0; | |
}; | |
/** @return {boolean} Whether this value is odd. */ | |
goog.math.Long.prototype.isOdd = function() { | |
return (this.low_ & 1) == 1; | |
}; | |
/** | |
* @param {goog.math.Long} other Long to compare against. | |
* @return {boolean} Whether this Long equals the other. | |
*/ | |
goog.math.Long.prototype.equals = function(other) { | |
return (this.high_ == other.high_) && (this.low_ == other.low_); | |
}; | |
/** | |
* @param {goog.math.Long} other Long to compare against. | |
* @return {boolean} Whether this Long does not equal the other. | |
*/ | |
goog.math.Long.prototype.notEquals = function(other) { | |
return (this.high_ != other.high_) || (this.low_ != other.low_); | |
}; | |
/** | |
* @param {goog.math.Long} other Long to compare against. | |
* @return {boolean} Whether this Long is less than the other. | |
*/ | |
goog.math.Long.prototype.lessThan = function(other) { | |
return this.compare(other) < 0; | |
}; | |
/** | |
* @param {goog.math.Long} other Long to compare against. | |
* @return {boolean} Whether this Long is less than or equal to the other. | |
*/ | |
goog.math.Long.prototype.lessThanOrEqual = function(other) { | |
return this.compare(other) <= 0; | |
}; | |
/** | |
* @param {goog.math.Long} other Long to compare against. | |
* @return {boolean} Whether this Long is greater than the other. | |
*/ | |
goog.math.Long.prototype.greaterThan = function(other) { | |
return this.compare(other) > 0; | |
}; | |
/** | |
* @param {goog.math.Long} other Long to compare against. | |
* @return {boolean} Whether this Long is greater than or equal to the other. | |
*/ | |
goog.math.Long.prototype.greaterThanOrEqual = function(other) { | |
return this.compare(other) >= 0; | |
}; | |
/** | |
* Compares this Long with the given one. | |
* @param {goog.math.Long} other Long to compare against. | |
* @return {number} 0 if they are the same, 1 if the this is greater, and -1 | |
* if the given one is greater. | |
*/ | |
goog.math.Long.prototype.compare = function(other) { | |
if (this.equals(other)) { | |
return 0; | |
} | |
var thisNeg = this.isNegative(); | |
var otherNeg = other.isNegative(); | |
if (thisNeg && !otherNeg) { | |
return -1; | |
} | |
if (!thisNeg && otherNeg) { | |
return 1; | |
} | |
// at this point, the signs are the same, so subtraction will not overflow | |
if (this.subtract(other).isNegative()) { | |
return -1; | |
} else { | |
return 1; | |
} | |
}; | |
/** @return {!goog.math.Long} The negation of this value. */ | |
goog.math.Long.prototype.negate = function() { | |
if (this.equals(goog.math.Long.MIN_VALUE)) { | |
return goog.math.Long.MIN_VALUE; | |
} else { | |
return this.not().add(goog.math.Long.ONE); | |
} | |
}; | |
/** | |
* Returns the sum of this and the given Long. | |
* @param {goog.math.Long} other Long to add to this one. | |
* @return {!goog.math.Long} The sum of this and the given Long. | |
*/ | |
goog.math.Long.prototype.add = function(other) { | |
// Divide each number into 4 chunks of 16 bits, and then sum the chunks. | |
var a48 = this.high_ >>> 16; | |
var a32 = this.high_ & 0xFFFF; | |
var a16 = this.low_ >>> 16; | |
var a00 = this.low_ & 0xFFFF; | |
var b48 = other.high_ >>> 16; | |
var b32 = other.high_ & 0xFFFF; | |
var b16 = other.low_ >>> 16; | |
var b00 = other.low_ & 0xFFFF; | |
var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | |
c00 += a00 + b00; | |
c16 += c00 >>> 16; | |
c00 &= 0xFFFF; | |
c16 += a16 + b16; | |
c32 += c16 >>> 16; | |
c16 &= 0xFFFF; | |
c32 += a32 + b32; | |
c48 += c32 >>> 16; | |
c32 &= 0xFFFF; | |
c48 += a48 + b48; | |
c48 &= 0xFFFF; | |
return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32); | |
}; | |
/** | |
* Returns the difference of this and the given Long. | |
* @param {goog.math.Long} other Long to subtract from this. | |
* @return {!goog.math.Long} The difference of this and the given Long. | |
*/ | |
goog.math.Long.prototype.subtract = function(other) { | |
return this.add(other.negate()); | |
}; | |
/** | |
* Returns the product of this and the given long. | |
* @param {goog.math.Long} other Long to multiply with this. | |
* @return {!goog.math.Long} The product of this and the other. | |
*/ | |
goog.math.Long.prototype.multiply = function(other) { | |
if (this.isZero()) { | |
return goog.math.Long.ZERO; | |
} else if (other.isZero()) { | |
return goog.math.Long.ZERO; | |
} | |
if (this.equals(goog.math.Long.MIN_VALUE)) { | |
return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO; | |
} else if (other.equals(goog.math.Long.MIN_VALUE)) { | |
return this.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO; | |
} | |
if (this.isNegative()) { | |
if (other.isNegative()) { | |
return this.negate().multiply(other.negate()); | |
} else { | |
return this.negate().multiply(other).negate(); | |
} | |
} else if (other.isNegative()) { | |
return this.multiply(other.negate()).negate(); | |
} | |
// If both longs are small, use float multiplication | |
if (this.lessThan(goog.math.Long.TWO_PWR_24_) && | |
other.lessThan(goog.math.Long.TWO_PWR_24_)) { | |
return goog.math.Long.fromNumber(this.toNumber() * other.toNumber()); | |
} | |
// Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. | |
// We can skip products that would overflow. | |
var a48 = this.high_ >>> 16; | |
var a32 = this.high_ & 0xFFFF; | |
var a16 = this.low_ >>> 16; | |
var a00 = this.low_ & 0xFFFF; | |
var b48 = other.high_ >>> 16; | |
var b32 = other.high_ & 0xFFFF; | |
var b16 = other.low_ >>> 16; | |
var b00 = other.low_ & 0xFFFF; | |
var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | |
c00 += a00 * b00; | |
c16 += c00 >>> 16; | |
c00 &= 0xFFFF; | |
c16 += a16 * b00; | |
c32 += c16 >>> 16; | |
c16 &= 0xFFFF; | |
c16 += a00 * b16; | |
c32 += c16 >>> 16; | |
c16 &= 0xFFFF; | |
c32 += a32 * b00; | |
c48 += c32 >>> 16; | |
c32 &= 0xFFFF; | |
c32 += a16 * b16; | |
c48 += c32 >>> 16; | |
c32 &= 0xFFFF; | |
c32 += a00 * b32; | |
c48 += c32 >>> 16; | |
c32 &= 0xFFFF; | |
c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; | |
c48 &= 0xFFFF; | |
return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32); | |
}; | |
/** | |
* Returns this Long divided by the given one. | |
* @param {goog.math.Long} other Long by which to divide. | |
* @return {!goog.math.Long} This Long divided by the given one. | |
*/ | |
goog.math.Long.prototype.div = function(other) { | |
if (other.isZero()) { | |
throw Error('division by zero'); | |
} else if (this.isZero()) { | |
return goog.math.Long.ZERO; | |
} | |
if (this.equals(goog.math.Long.MIN_VALUE)) { | |
if (other.equals(goog.math.Long.ONE) || | |
other.equals(goog.math.Long.NEG_ONE)) { | |
return goog.math.Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE | |
} else if (other.equals(goog.math.Long.MIN_VALUE)) { | |
return goog.math.Long.ONE; | |
} else { | |
// At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. | |
var halfThis = this.shiftRight(1); | |
var approx = halfThis.div(other).shiftLeft(1); | |
if (approx.equals(goog.math.Long.ZERO)) { | |
return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE; | |
} else { | |
var rem = this.subtract(other.multiply(approx)); | |
var result = approx.add(rem.div(other)); | |
return result; | |
} | |
} | |
} else if (other.equals(goog.math.Long.MIN_VALUE)) { | |
return goog.math.Long.ZERO; | |
} | |
if (this.isNegative()) { | |
if (other.isNegative()) { | |
return this.negate().div(other.negate()); | |
} else { | |
return this.negate().div(other).negate(); | |
} | |
} else if (other.isNegative()) { | |
return this.div(other.negate()).negate(); | |
} | |
// Repeat the following until the remainder is less than other: find a | |
// floating-point that approximates remainder / other *from below*, add this | |
// into the result, and subtract it from the remainder. It is critical that | |
// the approximate value is less than or equal to the real value so that the | |
// remainder never becomes negative. | |
var res = goog.math.Long.ZERO; | |
var rem = this; | |
while (rem.greaterThanOrEqual(other)) { | |
// Approximate the result of division. This may be a little greater or | |
// smaller than the actual value. | |
var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber())); | |
// We will tweak the approximate result by changing it in the 48-th digit or | |
// the smallest non-fractional digit, whichever is larger. | |
var log2 = Math.ceil(Math.log(approx) / Math.LN2); | |
var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48); | |
// Decrease the approximation until it is smaller than the remainder. Note | |
// that if it is too large, the product overflows and is negative. | |
var approxRes = goog.math.Long.fromNumber(approx); | |
var approxRem = approxRes.multiply(other); | |
while (approxRem.isNegative() || approxRem.greaterThan(rem)) { | |
approx -= delta; | |
approxRes = goog.math.Long.fromNumber(approx); | |
approxRem = approxRes.multiply(other); | |
} | |
// We know the answer can't be zero... and actually, zero would cause | |
// infinite recursion since we would make no progress. | |
if (approxRes.isZero()) { | |
approxRes = goog.math.Long.ONE; | |
} | |
res = res.add(approxRes); | |
rem = rem.subtract(approxRem); | |
} | |
return res; | |
}; | |
/** | |
* Returns this Long modulo the given one. | |
* @param {goog.math.Long} other Long by which to mod. | |
* @return {!goog.math.Long} This Long modulo the given one. | |
*/ | |
goog.math.Long.prototype.modulo = function(other) { | |
return this.subtract(this.div(other).multiply(other)); | |
}; | |
/** @return {!goog.math.Long} The bitwise-NOT of this value. */ | |
goog.math.Long.prototype.not = function() { | |
return goog.math.Long.fromBits(~this.low_, ~this.high_); | |
}; | |
/** | |
* Returns the bitwise-AND of this Long and the given one. | |
* @param {goog.math.Long} other The Long with which to AND. | |
* @return {!goog.math.Long} The bitwise-AND of this and the other. | |
*/ | |
goog.math.Long.prototype.and = function(other) { | |
return goog.math.Long.fromBits(this.low_ & other.low_, | |
this.high_ & other.high_); | |
}; | |
/** | |
* Returns the bitwise-OR of this Long and the given one. | |
* @param {goog.math.Long} other The Long with which to OR. | |
* @return {!goog.math.Long} The bitwise-OR of this and the other. | |
*/ | |
goog.math.Long.prototype.or = function(other) { | |
return goog.math.Long.fromBits(this.low_ | other.low_, | |
this.high_ | other.high_); | |
}; | |
/** | |
* Returns the bitwise-XOR of this Long and the given one. | |
* @param {goog.math.Long} other The Long with which to XOR. | |
* @return {!goog.math.Long} The bitwise-XOR of this and the other. | |
*/ | |
goog.math.Long.prototype.xor = function(other) { | |
return goog.math.Long.fromBits(this.low_ ^ other.low_, | |
this.high_ ^ other.high_); | |
}; | |
/** | |
* Returns this Long with bits shifted to the left by the given amount. | |
* @param {number} numBits The number of bits by which to shift. | |
* @return {!goog.math.Long} This shifted to the left by the given amount. | |
*/ | |
goog.math.Long.prototype.shiftLeft = function(numBits) { | |
numBits &= 63; | |
if (numBits == 0) { | |
return this; | |
} else { | |
var low = this.low_; | |
if (numBits < 32) { | |
var high = this.high_; | |
return goog.math.Long.fromBits( | |
low << numBits, | |
(high << numBits) | (low >>> (32 - numBits))); | |
} else { | |
return goog.math.Long.fromBits(0, low << (numBits - 32)); | |
} | |
} | |
}; | |
/** | |
* Returns this Long with bits shifted to the right by the given amount. | |
* @param {number} numBits The number of bits by which to shift. | |
* @return {!goog.math.Long} This shifted to the right by the given amount. | |
*/ | |
goog.math.Long.prototype.shiftRight = function(numBits) { | |
numBits &= 63; | |
if (numBits == 0) { | |
return this; | |
} else { | |
var high = this.high_; | |
if (numBits < 32) { | |
var low = this.low_; | |
return goog.math.Long.fromBits( | |
(low >>> numBits) | (high << (32 - numBits)), | |
high >> numBits); | |
} else { | |
return goog.math.Long.fromBits( | |
high >> (numBits - 32), | |
high >= 0 ? 0 : -1); | |
} | |
} | |
}; | |
/** | |
* Returns this Long with bits shifted to the right by the given amount, with | |
* zeros placed into the new leading bits. | |
* @param {number} numBits The number of bits by which to shift. | |
* @return {!goog.math.Long} This shifted to the right by the given amount, with | |
* zeros placed into the new leading bits. | |
*/ | |
goog.math.Long.prototype.shiftRightUnsigned = function(numBits) { | |
numBits &= 63; | |
if (numBits == 0) { | |
return this; | |
} else { | |
var high = this.high_; | |
if (numBits < 32) { | |
var low = this.low_; | |
return goog.math.Long.fromBits( | |
(low >>> numBits) | (high << (32 - numBits)), | |
high >>> numBits); | |
} else if (numBits == 32) { | |
return goog.math.Long.fromBits(high, 0); | |
} else { | |
return goog.math.Long.fromBits(high >>> (numBits - 32), 0); | |
} | |
} | |
}; | |
/* | |
simple set with reasonably fast iteration though an array, which may contain nulls | |
elements must be objects that have a unique _key property | |
collections are expected to be homogeneous | |
when iterating over a set with an iterator, the following operations are safe: | |
- adding an element to the set (the existing iterator will iterate over the new elements) | |
- removing the last returned element through the iterator | |
behaviour for deleting elements is unpredictable and unsafe | |
*/ | |
/** @constructor */ | |
function h$Set(s) { | |
this._vals = []; | |
this._keys = []; | |
this._size = 0; | |
} | |
h$Set.prototype.size = function() { | |
return this._size; | |
} | |
h$Set.prototype.add = function(o) { | |
if((typeof o !== 'object' && typeof o !== 'function') || typeof o._key !== 'number') throw ("h$Set.add: invalid element: " + o); | |
if(this._size > 0) { | |
// if(this._storedProto !== o.prototype) throw ("h$Set.add: unexpected element prototype: " + o) | |
} else { | |
this._storedProto = o.prototype; | |
} | |
if(this._keys[o._key] !== undefined && this._vals[this._keys[o._key]] !== o) throw ("h$Set.add: duplicate key: " + o); | |
var k = this._keys, v = this._vals; | |
if(k[o._key] === undefined) { | |
k[o._key] = this._size; | |
v[this._size++] = o; | |
} | |
} | |
h$Set.prototype.remove = function(o) { | |
if(this._size === 0) return; | |
var k = this._keys, v = this._vals, x = k[o._key]; | |
if(x !== undefined) { | |
delete k[o._key]; | |
var ls = --this._size; | |
if(ls !== x) { | |
var l = v[ls]; | |
v[x] = l; | |
k[l._key] = x; | |
} | |
v[ls] = null; | |
if(v.length > 10 && 2 * v.length > 3 * ls) this._vals = v.slice(0, ls); | |
} | |
} | |
h$Set.prototype.has = function(o) { | |
return this._keys[o._key] !== undefined; | |
} | |
h$Set.prototype.clear = function() { | |
if(this._size > 0) { | |
this._keys = []; | |
this._vals = []; | |
this._size = 0; | |
} | |
} | |
h$Set.prototype.iter = function() { | |
return new h$SetIter(this); | |
} | |
// returns an array with all values, might contain additional nulls at the end | |
h$Set.prototype.values = function() { | |
return this._vals; | |
} | |
/** @constructor */ | |
function h$SetIter(s) { | |
this._n = 0; | |
this._s = s; | |
this._r = true; | |
} | |
h$SetIter.prototype.next = function() { | |
if(this._n < this._s._size) { | |
this._r = false; | |
return this._s._vals[this._n++]; | |
} else { | |
this._r = true; | |
return null; | |
} | |
} | |
h$SetIter.prototype.peek = function() { | |
if(this._n < this._s._size) { | |
return this._s.vals[this._n]; | |
} else { | |
return null; | |
} | |
} | |
// remove the last element returned | |
h$SetIter.prototype.remove = function() { | |
if(!this._r) { | |
this._s.remove(this._s._vals[--this._n]); | |
this._r = true; | |
} | |
} | |
/* | |
map, iteration restrictions are the same as for set | |
keys need to be objects with a unique _key property | |
keys are expected to have the same prototype | |
values may be anything (but note that the values array might have additional nulls) | |
*/ | |
/** @constructor */ | |
function h$Map() { | |
this._pairsKeys = []; | |
this._pairsValues = []; | |
this._keys = []; | |
this._size = 0; | |
} | |
h$Map.prototype.size = function() { | |
return this._size; | |
} | |
h$Map.prototype.put = function(k,v) { | |
if((typeof k !== 'object' && typeof k !== 'function') || typeof k._key !== 'number') throw ("h$Map.add: invalid key: " + k); | |
if(this._size > 0) { | |
if(this._storedProto !== k.prototype) throw ("h$Map.add: unexpected key prototype: " + k) | |
} else { | |
this._storedProto = k.prototype; | |
} | |
if(this._keys[k._key] !== undefined && this._pairsKeys[this._keys[k._key]] !== k) throw ("h$Map.add: duplicate key: " + k); | |
var ks = this._keys, pk = this._pairsKeys, pv = this._pairsValues, x = ks[k._key]; | |
if(x === undefined) { | |
var n = this._size++; | |
ks[k._key] = n; | |
pk[n] = k; | |
pv[n] = v; | |
} else { | |
pv[x] = v; | |
} | |
} | |
h$Map.prototype.remove = function(k) { | |
var kk = k._key, ks = this._keys, pk = this._pairsKeys, pv = this._pairsValues, x = ks[kk]; | |
if(x !== undefined) { | |
delete ks[kk]; | |
var ss = --this._size; | |
if(ss !== x) { | |
pks = pk[ss]; | |
pk[x] = pks; | |
pv[x] = pv[ss]; | |
ks[pks._key] = x; | |
} | |
pv[ss] = null; | |
pk[ss] = null; | |
if(pk.length > 10 && 2 * pk.length > 3 * this._size) { | |
this._pairsKeys = pk.slice(0,ss); | |
this._pairsValues = pv.slice(0,ss); | |
} | |
} | |
} | |
h$Map.prototype.has = function(k) { | |
return this._keys[k._key] !== undefined; | |
} | |
h$Map.prototype.get = function(k) { | |
var n = this._keys[k._key]; | |
if(n !== undefined) { | |
return this._pairsValues[n]; | |
} else { | |
return null; | |
} | |
} | |
h$Map.prototype.iter = function() { | |
return new h$MapIter(this); | |
} | |
// returned array might have some trailing nulls | |
h$Map.prototype.keys = function () { | |
return this._pairsKeys; | |
} | |
// returned array might have some trailing nulls | |
h$Map.prototype.values = function() { | |
return this._pairsValues; | |
} | |
/** @constructor */ | |
function h$MapIter(m) { | |
this._n = 0; | |
this._m = m; | |
} | |
h$MapIter.prototype.next = function() { | |
return this._n < this._m._size ? this._m._pairsKeys[this._n++] : null; | |
} | |
h$MapIter.prototype.nextVal = function() { | |
return this._n < this._m._size ? this._m._pairsValues[this._n++] : null; | |
} | |
h$MapIter.prototype.peek = function() { | |
return this._n < this._m._size ? this._m._pairsKeys[this._n] : null; | |
} | |
h$MapIter.prototype.peekVal = function() { | |
return this._n < this._m._size ? this._m._pairsValues[this._n] : null; | |
} | |
/* | |
simple queue, returns null when empty | |
it's safe to enqueue new items while iterating, not safe to dequeue | |
(new items will not be iterated over) | |
*/ | |
/** @constructor */ | |
function h$Queue() { | |
var b = { b: [], n: null }; | |
this._blocks = 1; | |
this._first = b; | |
this._fp = 0; | |
this._last = b; | |
this._lp = 0; | |
} | |
h$Queue.prototype.length = function() { | |
return 1000 * (this._blocks - 1) + this._lp - this._fp; | |
} | |
h$Queue.prototype.isEmpty = function() { | |
return this._blocks === 1 && this._lp >= this._fp; | |
} | |
h$Queue.prototype.enqueue = function(o) { | |
if(this._lp === 1000) { | |
var newBlock = { b: [o], n: null }; | |
this._blocks++; | |
this._last.n = newBlock; | |
this._last = newBlock; | |
this._lp = 1; | |
} else { | |
this._last.b[this._lp++] = o; | |
} | |
} | |
h$Queue.prototype.dequeue = function() { | |
if(this._blocks === 1 && this._fp >= this._lp) { | |
return null; | |
} else { | |
var qfb = this._first.b, r = qfb[this._fp]; | |
qfb[this._fp] = null; | |
if(++this._fp === 1000) { | |
if(this._blocks === 1) { | |
this._lp = 0; | |
} else { | |
this._blocks--; | |
this._first = this._first.n; | |
} | |
this._fp = 0; | |
} else if(this._blocks === 1 && this._fp >= this._lp) { | |
this._lp = this._fp = 0; | |
} | |
return r; | |
} | |
} | |
h$Queue.prototype.peek = function() { | |
if(this._blocks === 0 || (this._blocks === 1 && this._fp >= this._lp)) { | |
return null; | |
} else { | |
return this._first.b[this._fp]; | |
} | |
} | |
h$Queue.prototype.iter = function() { | |
var b = this._first, bp = this._fp, lb = this._last, lp = this._lp; | |
return function() { | |
if(b === null || (b === lb && bp >= lp)) { | |
return null; | |
} else { | |
var r = b.b[bp]; | |
if(++bp === 1000) { | |
b = b.n; | |
bp = 0; | |
if(b === null) lb = null; | |
} | |
return r; | |
} | |
} | |
} | |
/* | |
binary min-heap / set | |
- iteration is not in order of priority | |
- values can be removed, need to have the ._key property | |
*/ | |
/** @constructor */ | |
function h$HeapSet() { | |
this._keys = []; | |
this._prios = []; | |
this._vals = []; | |
this._size = 0; | |
} | |
h$HeapSet.prototype.size = function() { | |
return this._size; | |
} | |
// add a node, if it already exists, it's moved to the new priority | |
h$HeapSet.prototype.add = function(op,o) { | |
if((typeof o !== 'object' && typeof o !== 'function') || typeof o._key !== 'number') throw ("h$HeapSet.add: invalid element: " + o); | |
if(this._size > 0) { | |
if(this._storedProto !== o.prototype) throw ("h$HeapSet.add: unexpected element prototype: " + o) | |
} else { | |
this._storedProto = o.prototype; | |
} | |
if(this._keys[o._key] !== undefined && this._vals[this._keys[o._key]] !== o) throw ("h$Set.add: duplicate key: " + o); | |
var p = this._prios, k = this._keys, v = this._vals, x = k[o._key]; | |
if(x !== undefined) { // adjust node | |
var oop = p[x]; | |
if(oop !== op) { | |
p[x] = op; | |
if(op < oop) { | |
this._upHeap(x); | |
} else { | |
this._downHeap(x); | |
} | |
} | |
} else { // new node | |
var s = this._size++; | |
k[o._key] = s; | |
p[s] = op; | |
v[s] = o; | |
this._upHeap(s); | |
} | |
} | |
h$HeapSet.prototype.has = function(o) { | |
return this._keys[o._key] !== undefined; | |
} | |
h$HeapSet.prototype.prio = function(o) { | |
var x = this._keys[o._key]; | |
if(x !== undefined) { | |
return this._prios[x]; | |
} else { | |
return null; | |
} | |
} | |
h$HeapSet.prototype.peekPrio = function() { | |
return this._size > 0 ? this._prios[0] : null; | |
} | |
h$HeapSet.prototype.peek = function() { | |
return this._size > 0 ? this._vals[0] : null; | |
} | |
h$HeapSet.prototype.pop = function() { | |
if(this._size > 0) { | |
var v = this._vals[0]; | |
this._removeNode(0); | |
return v; | |
} else { | |
return null; | |
} | |
} | |
h$HeapSet.prototype.remove = function(o) { | |
var x = this._keys[o._key]; | |
if(x !== undefined) this._removeNode(x); | |
} | |
h$HeapSet.prototype.iter = function() { | |
var n = 0, v = this._vals, s = this._size; | |
return function() { | |
return n < s ? v[n++] : null; | |
} | |
} | |
// may be longer than this.size(), remainder is filled with nulls | |
h$HeapSet.prototype.values = function() { | |
return this._vals; | |
} | |
h$HeapSet.prototype._removeNode = function(i) { | |
var p = this._prios, v = this._vals, s = --this._size, k = this._keys; | |
delete k[v[i]._key]; | |
if(i !== s) { | |
v[i] = v[s]; | |
p[i] = p[s]; | |
k[v[i]._key] = i; | |
} | |
v[s] = null; | |
p[s] = null; | |
this._downHeap(i,s); | |
} | |
h$HeapSet.prototype._downHeap = function(i,s) { | |
var p = this._prios, v = this._vals, k = this._keys; | |
var j,l,r,ti,tj; | |
while(true) { | |
j = i, r = 2*(i+1), l = r-1; | |
if(l < s && p[l] < p[i]) i = l; | |
if(r < s && p[r] < p[i]) i = r; | |
if(i !== j) { | |
ti = v[i]; | |
tj = v[j]; | |
v[j] = ti; | |
v[i] = tj; | |
k[ti._key] = j; | |
k[tj._key] = i; | |
ti = p[i]; | |
p[i] = p[j]; | |
p[j] = ti; | |
} else { | |
break; | |
} | |
} | |
} | |
h$HeapSet.prototype._upHeap = function(i) { | |
var ti, tj, j, p = this._prios, v = this._vals, k = this._keys; | |
while(i !== 0) { | |
j = (i-1) >> 1; | |
if(p[i] < p[j]) { | |
ti = v[i]; | |
tj = v[j]; | |
v[j] = ti; | |
v[i] = tj; | |
k[ti._key] = j; | |
k[tj._key] = i; | |
ti = p[i]; | |
p[i] = p[j]; | |
p[j] = ti; | |
i = j; | |
} else { | |
break; | |
} | |
} | |
} | |
// #define GHCJS_TRACE_META 1 | |
// memory management and pointer emulation | |
// static init, non-caf | |
function h$sti(i,c,xs) { | |
i.f = c; | |
h$init_closure(i,xs); | |
} | |
// static init, caf | |
function h$stc(i,c) { | |
i.f = c; | |
h$init_closure(i,[]); | |
h$CAFs.push(i); | |
h$CAFsReset.push(i.f); | |
} | |
function h$stl(o, xs, t) { | |
var r = t ? t : h$ghczmprimZCGHCziTypesziZMZN; | |
var x; | |
if(xs.length > 0) { | |
for(var i=xs.length-1;i>=0;i--) { | |
x = xs[i]; | |
if(!x && x !== false && x !== 0) throw "h$toHsList: invalid element"; | |
r = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, x, r); | |
} | |
} | |
o.f = r.f; | |
o.d1 = r.d1; | |
o.d2 = r.d2; | |
o.m = r.m; | |
} | |
// delayed init for top-level closures | |
var h$staticDelayed = []; | |
function h$d() { | |
var c = h$c(null); | |
h$staticDelayed.push(c); | |
return c; | |
} | |
var h$allocN = 0; | |
function h$traceAlloc(x) { | |
h$log("allocating: " + (++h$allocN)); | |
x.alloc = h$allocN; | |
} | |
// fixme remove this when we have a better way to immediately init these things | |
function h$di(c) { | |
h$staticDelayed.push(c); | |
} | |
// initialize global object to primitive value | |
function h$p(x) { | |
h$staticDelayed.push(x); | |
return x; | |
} | |
var h$entriesStack = []; | |
var h$staticsStack = []; | |
var h$labelsStack = []; | |
function h$scheduleInit(entries, objs, lbls, infos, statics) { | |
var d = h$entriesStack.length; | |
h$entriesStack.push(entries); | |
h$staticsStack.push(objs); | |
h$labelsStack.push(lbls); | |
h$initStatic.push(function() { | |
h$initInfoTables(d, entries, objs, lbls, infos, statics); | |
}); | |
} | |
function h$runInitStatic() { | |
if(h$initStatic.length > 0) { | |
for(var i=h$initStatic.length - 1;i>=0;i--) { | |
h$initStatic[i](); | |
} | |
h$initStatic = []; | |
} | |
// free the references to the temporary tables used for | |
// initialising all our static data | |
h$entriesStack = null; | |
h$staticsStack = null; | |
} | |
// initialize packed info tables | |
// see Gen2.Compactor for how the data is encoded | |
function h$initInfoTables ( depth // depth in the base chain | |
, funcs // array with all entry functions | |
, objects // array with all the global heap objects | |
, lbls // array with non-haskell labels | |
, infoMeta // packed info | |
, infoStatic | |
) { | |
; | |
var n, i, j, o, pos = 0, info; | |
function code(c) { | |
if(c < 34) return c - 32; | |
if(c < 92) return c - 33; | |
return c - 34; | |
} | |
function next() { | |
var c = info.charCodeAt(pos); | |
if(c < 124) { | |
; | |
pos++; | |
return code(c); | |
} | |
if(c === 124) { | |
pos+=3; | |
var r = 90 + 90 * code(info.charCodeAt(pos-2)) | |
+ code(info.charCodeAt(pos-1)); | |
; | |
return r; | |
} | |
if(c === 125) { | |
pos+=4; | |
var r = 8190 + 8100 * code(info.charCodeAt(pos-3)) | |
+ 90 * code(info.charCodeAt(pos-2)) | |
+ code(info.charCodeAt(pos-1)); | |
; | |
return r; | |
} | |
throw ("h$initInfoTables: invalid code in info table: " + c + " at " + pos) | |
} | |
function nextCh() { | |
return next(); // fixme map readable chars | |
} | |
function nextInt() { | |
var n = next(); | |
var r; | |
if(n === 0) { | |
var n1 = next(); | |
var n2 = next(); | |
r = n1 << 16 | n2; | |
} else { | |
r = n - 12; | |
} | |
; | |
return r; | |
} | |
function nextSignificand() { | |
var n = next(); | |
var n1, n2, n3, n4, n5; | |
var r; | |
if(n < 2) { | |
n1 = next(); | |
n2 = next(); | |
n3 = next(); | |
n4 = next(); | |
n5 = n1 * 281474976710656 + n2 * 4294967296 + n3 * 65536 + n4; | |
r = n === 0 ? -n5 : n5; | |
} else { | |
r = n - 12; | |
} | |
; | |
return r; | |
} | |
function nextEntry(o) { return nextIndexed("nextEntry", h$entriesStack, o); } | |
function nextObj(o) { return nextIndexed("nextObj", h$staticsStack, o); } | |
function nextLabel(o) { return nextIndexed("nextLabel", h$labelsStack, o); } | |
function nextIndexed(msg, stack, o) { | |
var n = (o === undefined) ? next() : o; | |
var i = depth; | |
while(n > stack[i].length) { | |
n -= stack[i].length; | |
i--; | |
if(i < 0) throw (msg + ": cannot find item " + n + ", stack length: " + stack.length + " depth: " + depth); | |
} | |
return stack[i][n]; | |
} | |
function nextArg() { | |
var o = next(); | |
var n, n1, n2; | |
switch(o) { | |
case 0: | |
; | |
return false; | |
case 1: | |
; | |
return true; | |
case 2: | |
; | |
return 0; | |
case 3: | |
; | |
return 1; | |
case 4: | |
; | |
return nextInt(); | |
case 5: | |
; | |
return null; | |
case 6: | |
; | |
n = next(); | |
switch(n) { | |
case 0: | |
return -0.0; | |
case 1: | |
return 0.0; | |
case 2: | |
return 1/0; | |
case 3: | |
return -1/0; | |
case 4: | |
return 0/0; | |
case 5: | |
n1 = nextInt(); | |
return nextSignificand() * Math.pow(2, n1) | |
default: | |
n1 = n - 36; | |
return nextSignificand() * Math.pow(2, n1); | |
} | |
case 7: | |
; | |
throw "string arg"; | |
return ""; // fixme haskell string | |
case 8: | |
; | |
n = next(); | |
var ba = h$newByteArray(n); | |
var b8 = ba.u8; | |
var p = 0; | |
while(n > 0) { | |
switch(n) { | |
case 1: | |
d0 = next(); | |
d1 = next(); | |
b8[p] = ((d0 << 2) | (d1 >> 4)); | |
break; | |
case 2: | |
d0 = next(); | |
d1 = next(); | |
d2 = next(); | |
b8[p++] = ((d0 << 2) | (d1 >> 4)); | |
b8[p] = ((d1 << 4) | (d2 >> 2)); | |
break; | |
default: | |
d0 = next(); | |
d1 = next(); | |
d2 = next(); | |
d3 = next(); | |
b8[p++] = ((d0 << 2) | (d1 >> 4)); | |
b8[p++] = ((d1 << 4) | (d2 >> 2)); | |
b8[p++] = ((d2 << 6) | d3); | |
break; | |
} | |
n -= 3; | |
} | |
return ba; | |
case 9: | |
var isFun = next() === 1; | |
var lbl = nextLabel(); | |
return h$initPtrLbl(isFun, lbl); | |
case 10: | |
var c = { f: nextEntry(), d1: null, d2: null, m: 0 }; | |
var n = next(); | |
var args = []; | |
while(n--) { | |
args.push(nextArg()); | |
} | |
return h$init_closure(c, args); | |
default: | |
; | |
return nextObj(o-11); | |
} | |
} | |
info = infoMeta; pos = 0; | |
for(i=0;i<funcs.length;i++) { | |
o = funcs[i]; | |
var ot; | |
var oa = 0; | |
var oregs = 256; // one register no skip | |
switch(next()) { | |
case 0: // thunk | |
ot = 0; | |
break; | |
case 1: // fun | |
ot = 1 | |
var arity = next(); | |
var skipRegs = next()-1; | |
if(skipRegs === -1) throw "h$initInfoTables: unknown register info for function"; | |
var skip = skipRegs & 1; | |
var regs = skipRegs >>> 1; | |
oregs = (regs << 8) | skip; | |
oa = arity + ((regs-1+skip) << 8); | |
break; | |
case 2: // con | |
ot = 2; | |
oa = next(); | |
break; | |
case 3: // stack frame | |
ot = -1; | |
oa = 0; | |
oregs = next() - 1; | |
if(oregs !== -1) oregs = ((oregs >>> 1) << 8) | (oregs & 1); | |
break; | |
default: throw ("h$initInfoTables: invalid closure type") | |
} | |
var size = next() - 1; | |
var nsrts = next(); | |
var srt = null; | |
if(nsrts > 0) { | |
srt = []; | |
for(var j=0;j<nsrts;j++) { | |
srt.push(nextObj()); | |
} | |
} | |
// h$log("result: " + ot + " " + oa + " " + oregs + " [" + srt + "] " + size); | |
// h$log("orig: " + o.t + " " + o.a + " " + o.r + " [" + o.s + "] " + o.size); | |
// if(ot !== o.t || oa !== o.a || oregs !== o.r || size !== o.size) throw "inconsistent"; | |
o.t = ot; | |
o.i = []; | |
o.n = ""; | |
o.a = oa; | |
o.r = oregs; | |
o.s = srt; | |
o.m = 0; | |
o.size = size; | |
} | |
info = infoStatic; | |
pos = 0; | |
for(i=0;i<objects.length;i++) { | |
; | |
o = objects[i]; | |
// traceMetaObjBefore(o); | |
var nx = next(); | |
; | |
switch(nx) { | |
case 0: // no init, could be a primitive value (still in the list since others might reference it) | |
// h$log("zero init"); | |
break; | |
case 1: // staticfun | |
o.f = nextEntry(); | |
; | |
break; | |
case 2: // staticThunk | |
; | |
o.f = nextEntry(); | |
h$CAFs.push(o); | |
h$CAFsReset.push(o.f); | |
break; | |
case 3: // staticPrim false, no init | |
; | |
break; | |
case 4: // staticPrim true, no init | |
; | |
break; | |
case 5: | |
; | |
break; | |
case 6: // staticString | |
; | |
break; | |
case 7: // staticBin | |
; | |
n = next(); | |
var b = h$newByteArray(n); | |
for(j=0;j>n;j++) { | |
b.u8[j] = next(); | |
} | |
break; | |
case 8: // staticEmptyList | |
; | |
o.f = h$ghczmprimZCGHCziTypesziZMZN.f; | |
break; | |
case 9: // staticList | |
; | |
n = next(); | |
var hasTail = next(); | |
var c = (hasTail === 1) ? nextObj() : h$ghczmprimZCGHCziTypesziZMZN; | |
; | |
while(n--) { | |
c = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, nextArg(), c); | |
} | |
o.f = c.f; | |
o.d1 = c.d1; | |
o.d2 = c.d2; | |
break; | |
case 10: // staticData n args | |
; | |
n = next(); | |
; | |
o.f = nextEntry(); | |
for(j=0;j<n;j++) { | |
h$setField(o, j, nextArg()); | |
} | |
break; | |
case 11: // staticData 0 args | |
; | |
o.f = nextEntry(); | |
break; | |
case 12: // staticData 1 args | |
; | |
o.f = nextEntry(); | |
o.d1 = nextArg(); | |
break; | |
case 13: // staticData 2 args | |
; | |
o.f = nextEntry(); | |
o.d1 = nextArg(); | |
o.d2 = nextArg(); | |
break; | |
case 14: // staticData 3 args | |
; | |
o.f = nextEntry(); | |
o.d1 = nextArg(); | |
// should be the correct order | |
o.d2 = { d1: nextArg(), d2: nextArg()}; | |
break; | |
case 15: // staticData 4 args | |
; | |
o.f = nextEntry(); | |
o.d1 = nextArg(); | |
// should be the correct order | |
o.d2 = { d1: nextArg(), d2: nextArg(), d3: nextArg() }; | |
break; | |
case 16: // staticData 5 args | |
; | |
o.f = nextEntry(); | |
o.d1 = nextArg(); | |
o.d2 = { d1: nextArg(), d2: nextArg(), d3: nextArg(), d4: nextArg() }; | |
break; | |
case 17: // staticData 6 args | |
; | |
o.f = nextEntry(); | |
o.d1 = nextArg(); | |
o.d2 = { d1: nextArg(), d2: nextArg(), d3: nextArg(), d4: nextArg(), d5: nextArg() }; | |
break; | |
default: | |
throw ("invalid static data initializer: " + nx); | |
} | |
} | |
h$staticDelayed = null; | |
} | |
function h$initPtrLbl(isFun, lbl) { | |
return lbl; | |
} | |
function h$callDynamic(f) { | |
return f.apply(f, Array.prototype.slice.call(arguments, 2)); | |
} | |
// slice an array of heap objects | |
function h$sliceArray(a, start, n) { | |
return a.slice(start, start+n); | |
} | |
function h$memcpy() { | |
if(arguments.length === 3) { // ByteArray# -> ByteArray# copy | |
var dst = arguments[0]; | |
var src = arguments[1]; | |
var n = arguments[2]; | |
for(var i=n-1;i>=0;i--) { | |
dst.u8[i] = src.u8[i]; | |
} | |
h$ret1 = 0; | |
return dst; | |
} else if(arguments.length === 5) { // Addr# -> Addr# copy | |
var dst = arguments[0]; | |
var dst_off = arguments[1] | |
var src = arguments[2]; | |
var src_off = arguments[3]; | |
var n = arguments[4]; | |
for(var i=n-1;i>=0;i--) { | |
dst.u8[i+dst_off] = src.u8[i+src_off]; | |
} | |
h$ret1 = dst_off; | |
return dst; | |
} else { | |
throw "h$memcpy: unexpected argument"; | |
} | |
} | |
// note: only works for objects bigger than two! | |
function h$setField(o,n,v) { | |
if(n > 0 && !o.d2) o.d2 = {}; | |
switch(n) { | |
case 0: | |
o.d1 = v; | |
return; | |
case 1: | |
o.d2.d1 = v; | |
return; | |
case 2: | |
o.d2.d2 = v; | |
return; | |
case 3: | |
o.d2.d3 = v; | |
return; | |
case 4: | |
o.d2.d4 = v; | |
return; | |
case 5: | |
o.d2.d5 = v; | |
return; | |
case 6: | |
o.d2.d6 = v; | |
return; | |
case 7: | |
o.d2.d7 = v; | |
return; | |
case 8: | |
o.d2.d8 = v; | |
return; | |
case 9: | |
o.d2.d9 = v; | |
return; | |
case 10: | |
o.d2.d10 = v; | |
return; | |
case 11: | |
o.d2.d11 = v; | |
return; | |
case 12: | |
o.d2.d12 = v; | |
return; | |
case 13: | |
o.d2.d13 = v; | |
return; | |
case 14: | |
o.d2.d14 = v; | |
return; | |
case 15: | |
o.d2.d15 = v; | |
return; | |
case 16: | |
o.d2.d16 = v; | |
return; | |
case 17: | |
o.d2.d17 = v; | |
return; | |
case 18: | |
o.d2.d18 = v; | |
return; | |
case 19: | |
o.d2.d19 = v; | |
return; | |
case 20: | |
o.d2.d20 = v; | |
return; | |
case 21: | |
o.d2.d21 = v; | |
return; | |
case 22: | |
o.d2.d22 = v; | |
return; | |
case 23: | |
o.d2.d23 = v; | |
return; | |
case 24: | |
o.d2.d24 = v; | |
return; | |
case 25: | |
o.d2.d25 = v; | |
return; | |
case 26: | |
o.d2.d26 = v; | |
return; | |
case 27: | |
o.d2.d27 = v; | |
return; | |
case 28: | |
o.d2.d28 = v; | |
return; | |
case 29: | |
o.d2.d29 = v; | |
return; | |
case 30: | |
o.d2.d30 = v; | |
return; | |
case 31: | |
o.d2.d31 = v; | |
return; | |
case 32: | |
o.d2.d32 = v; | |
return; | |
case 33: | |
o.d2.d33 = v; | |
return; | |
case 34: | |
o.d2.d34 = v; | |
return; | |
case 35: | |
o.d2.d35 = v; | |
return; | |
case 36: | |
o.d2.d36 = v; | |
return; | |
case 37: | |
o.d2.d37 = v; | |
return; | |
case 38: | |
o.d2.d38 = v; | |
return; | |
case 39: | |
o.d2.d39 = v; | |
return; | |
case 40: | |
o.d2.d40 = v; | |
return; | |
case 41: | |
o.d2.d41 = v; | |
return; | |
case 42: | |
o.d2.d42 = v; | |
return; | |
case 43: | |
o.d2.d43 = v; | |
return; | |
case 44: | |
o.d2.d44 = v; | |
return; | |
case 45: | |
o.d2.d45 = v; | |
return; | |
case 45: | |
o.d2.d45 = v; | |
return; | |
case 46: | |
o.d2.d46 = v; | |
return; | |
case 47: | |
o.d2.d47 = v; | |
return; | |
case 48: | |
o.d2.d48 = v; | |
return; | |
case 49: | |
o.d2.d49 = v; | |
return; | |
case 50: | |
o.d2.d50 = v; | |
return; | |
case 51: | |
o.d2.d51 = v; | |
return; | |
case 52: | |
o.d2.d52 = v; | |
return; | |
case 53: | |
o.d2.d53 = v; | |
return; | |
case 54: | |
o.d2.d54 = v; | |
return; | |
case 55: | |
o.d2.d55 = v; | |
return; | |
case 56: | |
o.d2.d56 = v; | |
return; | |
case 57: | |
o.d2.d57 = v; | |
return; | |
case 58: | |
o.d2.d58 = v; | |
return; | |
case 59: | |
o.d2.d59 = v; | |
return; | |
case 60: | |
o.d2.d60 = v; | |
return; | |
case 61: | |
o.d2.d61 = v; | |
return; | |
case 62: | |
o.d2.d62 = v; | |
return; | |
case 63: | |
o.d2.d63 = v; | |
return; | |
case 64: | |
o.d2.d64 = v; | |
return; | |
case 65: | |
o.d2.d65 = v; | |
return; | |
case 66: | |
o.d2.d66 = v; | |
return; | |
case 67: | |
o.d2.d67 = v; | |
return; | |
case 68: | |
o.d2.d68 = v; | |
return; | |
case 69: | |
o.d2.d69 = v; | |
return; | |
case 70: | |
o.d2.d70 = v; | |
return; | |
case 71: | |
o.d2.d71 = v; | |
return; | |
case 72: | |
o.d2.d72 = v; | |
return; | |
case 73: | |
o.d2.d73 = v; | |
return; | |
case 74: | |
o.d2.d74 = v; | |
return; | |
case 75: | |
o.d2.d75 = v; | |
return; | |
case 76: | |
o.d2.d76 = v; | |
return; | |
case 77: | |
o.d2.d77 = v; | |
return; | |
case 78: | |
o.d2.d78 = v; | |
return; | |
case 79: | |
o.d2.d79 = v; | |
return; | |
case 80: | |
o.d2.d80 = v; | |
return; | |
case 81: | |
o.d2.d81 = v; | |
return; | |
case 82: | |
o.d2.d82 = v; | |
return; | |
case 83: | |
o.d2.d83 = v; | |
return; | |
case 84: | |
o.d2.d84 = v; | |
return; | |
case 85: | |
o.d2.d85 = v; | |
return; | |
case 86: | |
o.d2.d86 = v; | |
return; | |
case 87: | |
o.d2.d87 = v; | |
return; | |
case 88: | |
o.d2.d88 = v; | |
return; | |
case 89: | |
o.d2.d89 = v; | |
return; | |
case 90: | |
o.d2.d90 = v; | |
return; | |
case 91: | |
o.d2.d91 = v; | |
return; | |
case 92: | |
o.d2.d92 = v; | |
return; | |
case 93: | |
o.d2.d93 = v; | |
return; | |
case 94: | |
o.d2.d94 = v; | |
return; | |
case 95: | |
o.d2.d95 = v; | |
return; | |
case 96: | |
o.d2.d96 = v; | |
return; | |
case 97: | |
o.d2.d97 = v; | |
return; | |
case 98: | |
o.d2.d98 = v; | |
return; | |
case 99: | |
o.d2.d99 = v; | |
return; | |
case 100: | |
o.d2.d100 = v; | |
return; | |
default: | |
throw ("h$setField: setter not implemented for field: " + n); | |
} | |
} | |
function h$mkExportDyn(t, f) { | |
h$log("making dynamic export: " + t); | |
h$log("haskell fun: " + f + " " + h$collectProps(f)); | |
// fixme register things, global static data | |
var ff = function() { | |
h$log("running some haskell for you"); | |
return 12; | |
}; | |
return h$mkPtr(ff, 0); | |
} | |
function h$memchr(a_v, a_o, c, n) { | |
for(var i=0;i<n;i++) { | |
if(a_v.u8[a_o+i] === c) { | |
h$ret1 = a_o+i; | |
return a_v; | |
} | |
} | |
h$ret1 = 0; | |
return null; | |
} | |
function h$strlen(a_v, a_o) { | |
var i=0; | |
while(true) { | |
if(a_v.u8[a_o+i] === 0) { return i; } | |
i++; | |
} | |
} | |
function h$newArray(len, e) { | |
var r = []; | |
r.__ghcjsArray = true; | |
r.m = 0; | |
if(e === null) e = r; | |
for(var i=0;i<len;i++) r[i] = e; | |
return r; | |
} | |
function h$roundUpToMultipleOf(n,m) { | |
var rem = n % m; | |
return rem === 0 ? n : n - rem + m; | |
} | |
function h$newByteArray(len) { | |
var len0 = Math.max(h$roundUpToMultipleOf(len, 8), 8); | |
var buf = new ArrayBuffer(len0); | |
return { buf: buf | |
, len: len | |
, i3: new Int32Array(buf) | |
, u8: new Uint8Array(buf) | |
, u1: new Uint16Array(buf) | |
, f3: new Float32Array(buf) | |
, f6: new Float64Array(buf) | |
, dv: new DataView(buf) | |
} | |
} | |
/* | |
Unboxed arrays in GHC use the ByteArray# and MutableByteArray# | |
primitives. In GHCJS these primitives are represented by an | |
object that contains a JavaScript ArrayBuffer and several views | |
(typed arrays) on that buffer. | |
Usually you can use GHCJS.Foreign.wrapBuffer and | |
GHCJS.Foreign.wrapMutableBuffer to do the conversion. If you need | |
more control or lower level acces, read on. | |
You can use h$wrapBuffer to wrap any JavaScript ArrayBuffer | |
into such an object, without copying the buffer. Since typed array | |
access is aligned, not all views are available | |
if the offset of the buffer is not a multiple of 8. | |
Since IO has kind * -> *, you cannot return IO ByteArray# | |
from a foreign import, even with the UnliftedFFITypes | |
extension. Return a JSRef instead and use unsafeCoerce | |
to convert it to a Data.Primitive.ByteArray.ByteArray or | |
Data.Primitive.ByteArray.MutableByteArray (primitive package) | |
and pattern match on the constructor to get the | |
primitive value out. | |
These types have the same runtime representation (a data | |
constructor with one regular (one JavaScript variable) | |
field) as a JSRef, so the conversion is safe, as long | |
as everything is fully evaluated. | |
*/ | |
function h$wrapBuffer(buf, unalignedOk, offset, length) { | |
if(!unalignedOk && offset && offset % 8 !== 0) { | |
throw ("h$wrapBuffer: offset not aligned:" + offset); | |
} | |
if(!buf || !(buf instanceof ArrayBuffer)) | |
throw "h$wrapBuffer: not an ArrayBuffer" | |
if(!offset) { offset = 0; } | |
if(!length || length < 0) { length = buf.byteLength - offset; } | |
return { buf: buf | |
, len: length | |
, i3: (offset%4) ? null : new Int32Array(buf, offset, length >> 2) | |
, u8: new Uint8Array(buf, offset, length) | |
, u1: (offset%2) ? null : new Uint16Array(buf, offset, length >> 1) | |
, f3: (offset%4) ? null : new Float32Array(buf, offset, length >> 2) | |
, f6: (offset%8) ? null : new Float64Array(buf, offset, length >> 3) | |
, dv: new DataView(buf, offset, length) | |
}; | |
} | |
var h$stableNameN = 1; | |
/** @constructor */ | |
function h$StableName(m) { | |
this.m = m; | |
this.s = null; | |
} | |
function h$makeStableName(x) { | |
if(typeof x === 'object') { | |
if(typeof x.m !== 'object') { | |
x.m = new h$StableName(x.m); | |
} | |
return x.m; | |
} else { | |
return new h$StableName(0); | |
} | |
} | |
function h$stableNameInt(s) { | |
var x = s.s; | |
if(x === null) { | |
x = s.s = h$stableNameN = (h$stableNameN+1)|0; | |
} | |
return x; | |
} | |
function h$eqStableName(s1o,s2o) { | |
return s1o === s2o ? 1 : 0; | |
} | |
function h$makeStablePtr(v) { | |
var buf = h$newByteArray(4); | |
buf.arr = [v]; | |
h$ret1 = 0; | |
return buf; | |
} | |
function h$hs_free_stable_ptr(stable) { | |
} | |
function h$malloc(n) { | |
h$ret1 = 0; | |
return h$newByteArray(n); | |
} | |
function h$free() { | |
} | |
function h$memset() { | |
var buf_v, buf_off, chr, n; | |
buf_v = arguments[0]; | |
if(arguments.length == 4) { // Addr# | |
buf_off = arguments[1]; | |
chr = arguments[2]; | |
n = arguments[3]; | |
} else if(arguments.length == 3) { // ByteString# | |
buf_off = 0; | |
chr = arguments[1]; | |
n = arguments[2]; | |
} else { | |
throw("h$memset: unexpected argument") | |
} | |
var end = buf_off + n; | |
for(var i=buf_off;i<end;i++) { | |
buf_v.u8[i] = chr; | |
} | |
h$ret1 = buf_off; | |
return buf_v; | |
} | |
function h$memcmp(a_v, a_o, b_v, b_o, n) { | |
for(var i=0;i<n;i++) { | |
var a = a_v.u8[a_o+i]; | |
var b = b_v.u8[b_o+i]; | |
var c = a-b; | |
if(c !== 0) { return c; } | |
} | |
return 0; | |
} | |
function h$memmove(a_v, a_o, b_v, b_o, n) { | |
if(n > 0) { | |
var tmp = new Uint8Array(b_v.buf.slice(b_o,b_o+n)); | |
for(var i=0;i<n;i++) { | |
a_v.u8[a_o+i] = tmp[i]; | |
} | |
} | |
h$ret1 = a_o; | |
return a_v; | |
} | |
function h$mkPtr(v, o) { | |
return h$c2(h$baseZCGHCziPtrziPtr_con_e, v, o); | |
}; | |
function h$mkFunctionPtr(f) { | |
var d = h$newByteArray(4); | |
d.arr = [f]; | |
return d; | |
} | |
var h$freeHaskellFunctionPtr = function () { | |
} | |
/* | |
function h$createAdjustor(cconv, hptr, hptr_2, wptr, wptr_2, type) { | |
h$ret1 = hptr_2; | |
return hptr; | |
}; | |
*/ | |
// extra roots for the heap scanner: objects with root property | |
var h$extraRootsN = 0; | |
var h$extraRoots = new h$Set(); | |
// | |
var h$domRoots = new h$Set(); | |
function h$makeCallback(retain, f, extraArgs, action) { | |
var args = extraArgs.slice(0); | |
args.unshift(action); | |
var c = function() { | |
return f.apply(this, args); | |
} | |
if(retain === true) { | |
c._key = ++h$extraRootsN; | |
c.root = action; | |
h$extraRoots.add(c); | |
} else if(retain) { // DOM retain | |
} | |
return c; | |
} | |
function h$makeCallbackApply(retain, n, f, extraArgs, fun) { | |
var c; | |
if(n === 1) { | |
c = function(x) { | |
var args = extraArgs.slice(0); | |
var action = h$c2(h$ap1_e, fun, h$mkJSRef(x)); | |
args.unshift(action); | |
return f.apply(this, args); | |
} | |
} else if (n === 2) { | |
c = function(x,y) { | |
var args = extraArgs.slice(0); | |
var action = h$c3(h$ap2_e, fun, h$mkJSRef(x), h$mkJSRef(y)); | |
args.unshift(action); | |
return f.apply(this, args); | |
} | |
} else { | |
throw "h$makeCallbackApply: unsupported arity"; | |
} | |
if(retain === true) { | |
c.root = fun; | |
c._key = ++h$extraRootsN; | |
h$extraRoots.add(c); | |
} else if(retain) { | |
// fixme: retain this while `retain' is in some DOM | |
} else { | |
// no retainer | |
} | |
return c; | |
} | |
function h$mkJSRef(x) { | |
return h$c1(h$ghcjszmprimZCGHCJSziPrimziJSRef_con_e, x); | |
} | |
// fixme these don't guarantee that the object has a key! | |
function h$retain(c) { | |
h$extraRoots.add(c); | |
} | |
function h$retainDom(d, c) { | |
h$domRoots.add(c); | |
c.domRoots = new h$Set(); | |
} | |
function h$releasePermanent(c) { | |
h$extraRoots.remove(c); | |
} | |
function h$release(c) { | |
h$extraRoots.remove(c); | |
h$domRoots.remove(c); | |
} | |
function h$releaseDom(c,d) { | |
if(c.domRoots) c.domRoots.remove(d); | |
if(!c.domRoots || c.domRoots.size() == 0) h$domRoots.remove(c); | |
} | |
function h$isInstanceOf(o,c) { | |
return o instanceof c; | |
} | |
function h$getpagesize() { | |
return 4096; | |
} | |
var h$MAP_ANONYMOUS = 0x20; | |
function h$mmap(addr_d, addr_o, len, prot, flags, fd, offset1, offset2) { | |
if(flags & h$MAP_ANONYMOUS || fd === -1) { | |
h$ret1 = 0; | |
return h$newByteArray(len); | |
} else { | |
throw "h$mmap: mapping a file is not yet supported"; | |
} | |
} | |
function h$mprotect(addr_d, addr_o, size, prot) { | |
return 0; | |
} | |
function h$munmap(addr_d, addr_o, size) { | |
if(addr_d && addr_o === 0 && size >= addr_d.len) { | |
addr_d.buf = null; | |
addr_d.i3 = null; | |
addr_d.u8 = null; | |
addr_d.u1 = null; | |
addr_d.f3 = null; | |
addr_d.f6 = null; | |
addr_d.dv = null; | |
} | |
return 0; | |
} | |
/* | |
Do garbage collection where the JavaScript GC doesn't suffice or needs some help: | |
- run finalizers for weak references | |
- find unreferenced CAFs and reset them (unless h$retainCAFs is set) | |
- shorten stacks that are mostly empty | |
- reset unused parts of stacks to null | |
- reset registers to null | |
- reset return variables to null | |
- throw exceptions to threads that are blocked on an unreachable MVar/STM transaction | |
- drop unnecessary references for selector thunks | |
The gc uses the .m field to store its mark in all the objects it marks. for heap objects, | |
the .m field is also used for other things, like stable names, the gc only changes | |
the two least significant bits for these. | |
The gc starts with all threads as roots in addition to callbacks passed to JavaScript | |
that that are retained. If you have custom JavaScript data structures that contain | |
Haskell heap object references, you can use extensible retention to find these | |
references and add thm to the work queue. h$registerExtensibleRetensionRoot(f) calls | |
f(currentMark) at the start of every gc, h$registerExtensibleRetention(f) calls f(o, currentMark) | |
for every unknown object found on the Haskell heap. | |
Extensible retention is a low-level mechanism and should typically only be used by | |
bindings that guarantee that the shape of the JS objects exactly matches what | |
the scanner expects. Care should be taken to make sure that the objects never | |
escape the reach of the scanner. | |
Having correct reachability information is important, even if you choose to turn off | |
features like weak references and deallocating CAFs in production, since it helps | |
debugging by providing the profiler with accurate data and by properly raising | |
exceptions when threads become blocked indefinitely, usually indicating a bug or | |
memory leak. | |
assumptions: | |
- all threads suspended, no active registers | |
- h$currentThread == null or at least unused: | |
1. all reachable threads must be in h$threads or h$blocked | |
2. no registers contain any usable value | |
notes: | |
- gc() may replace the stack of any thread, make sure to reload h$stack after gc() | |
*/ | |
/* | |
fixme, todo: | |
- mark posted exceptions to thread | |
*/ | |
// these macros use a local mark variable | |
var h$gcMark = 2; // 2 or 3 (objects initialized with 0) | |
var h$retainCAFs = false; | |
var h$CAFs = []; | |
var h$CAFsReset = []; | |
// | |
var h$extensibleRetentionRoots = []; | |
var h$extensibleRetentionCallbacks = []; | |
/* | |
after registering an extensible extension root f, | |
f() is called at the start of each gc invocation and is | |
expected to return an array with Haskell heap objects | |
to be treated as extra roots. | |
*/ | |
function h$registerExtensibleRetentionRoot(f) { | |
h$extensibleRetentionRoots.push(f); | |
} | |
function h$unregisterExtensibleRetentionRoot(f) { | |
h$extensibleRetentionRoots = h$extensibleRetentionRoots.filter(function(g) { return f !== g; }); | |
} | |
/* | |
after registering an extensible retention callback f, | |
f(o, currentMark) is called for every unknown object encountered on the | |
Haskell heap. f should return an array with found objects. If no objects | |
are found, f should return a boolean indicating whether the gc should skip | |
processing the objects with other extensible retention callbacks. | |
The gc may encounter the same object multiple times during the same scan, | |
so a callback should attempt to quickly return if the object has been scanned | |
already. | |
return value: | |
- array scan objects contained in array, do not call other extension callbacks | |
- true do not call other extension callbacks with this object | |
- false call other extension callbacks with this object | |
Use -DGHCJS_TRACE_GC_UNKNOWN to find the JavaScript objects reachable | |
(through JSRef) on the Haskell heap for which none of the registered | |
extensible retention callbacks has returned true or an array. | |
*/ | |
function h$registerExtensibleRetention(f) { | |
h$extensibleRetentionCallbacks.push(f); | |
} | |
function h$unregisterExtensibleRetention(f) { | |
h$extensibleRetentionCallbacks = h$extensibleRetentionCallbacks.filter(function(g) { return f !== g; }); | |
} | |
// check whether the object is marked by the latest gc | |
function h$isMarked(obj) { | |
return (typeof obj === 'object' || typeof obj === 'function') && | |
((typeof obj.m === 'number' && (obj.m & 3) === h$gcMark) || (obj.m && typeof obj.m === 'object' && obj.m.m === h$gcMark)); | |
} | |
// do a quick gc of a thread: | |
// - reset the stack (possibly shrinking storage for it) | |
// - reset all global data | |
// checks all known threads if t is null, but not h$currentThread | |
function h$gcQuick(t) { | |
if(h$currentThread !== null) throw "h$gcQuick: GC can only run when no thread is running"; | |
h$resetRegisters(); | |
h$resetResultVars(); | |
var i; | |
if(t !== null) { // reset specified threads | |
if(t instanceof h$Thread) { // only thread t | |
h$resetThread(t); | |
} else { // assume it's an array | |
for(var i=0;i<t.length;i++) h$resetThread(t[i]); | |
} | |
} else { // all threads, h$currentThread assumed unused | |
var nt, runnable = h$threads.iter(); | |
while((nt = runnable()) !== null) h$resetThread(nt); | |
var iter = h$blocked.iter(); | |
while((nt = iter.next()) !== null) h$resetThread(nt); | |
} | |
} | |
// run full marking for threads in h$blocked and h$threads, optionally t if t /= null | |
function h$gc(t) { | |
if(h$currentThread !== null) throw "h$gc: GC can only be run when no thread is running"; | |
; | |
var start = Date.now(); | |
h$resetRegisters(); | |
h$resetResultVars(); | |
h$gcMark = 5-h$gcMark; | |
var i; | |
for(i=h$extensibleRetentionRoots.length-1;i>=0;i--) { | |
var a = h$extensibleRetentionRoots[i](); | |
h$follow(a, a.length-1); | |
} | |
; | |
if(t !== null) h$markThread(t); | |
var nt, runnable = h$threads.iter(); | |
while((nt = runnable()) !== null) h$markThread(nt); | |
var iter = h$blocked.iter(); | |
while((nt = iter.next()) !== null) { | |
if(!(nt.blockedOn instanceof h$MVar) || (nt.stack && nt.stack[nt.sp] === h$unboxFFIResult)) { | |
h$markThread(nt); | |
} | |
} | |
; | |
iter = h$extraRoots.iter(); | |
while((nt = iter.next()) !== null) h$follow(nt.root); | |
// now we've marked all the regular Haskell data, continue marking | |
// weak references and everything retained by DOM retainers | |
h$markRetained(); | |
// now all running threads and threads blocked on something that's | |
// not an MVar operation have been marked, including other threads | |
// they reference through their ThreadId | |
// clean up threads waiting on unreachable MVars: | |
// throw an exception to a thread (which brings it back | |
// to life), then scan it. Killing one thread might be enough | |
// since the killed thread could make other threads reachable again. | |
var killedThread; | |
while(killedThread = h$finalizeMVars()) { | |
h$markThread(killedThread); | |
h$markRetained(); | |
} | |
// mark all blocked threads | |
iter = h$blocked.iter(); | |
while((nt = iter.next()) !== null) h$markThread(nt); | |
// and their weak references etc | |
h$markRetained(); | |
// now everything has been marked, bring out your dead references | |
// run finalizers for all weak references with unreachable keys | |
var finalizers = h$finalizeWeaks(); | |
h$clearWeaks(); | |
for(i=0;i<finalizers.length;i++) { | |
var fin = finalizers[i].finalizer; | |
if(fin !== null && !((typeof fin.m === 'number' && (fin.m & 3) === mark) || (typeof fin.m === 'object' && ((fin.m.m & 3) === mark)))) h$follow(fin); | |
} | |
h$markRetained(); | |
h$clearWeaks(); | |
h$scannedWeaks = []; | |
h$finalizeDom(); // remove all unreachable DOM retainers | |
h$finalizeCAFs(); // restore all unreachable CAFs to unevaluated state | |
var now = Date.now(); | |
h$lastGc = now; | |
} | |
function h$markRetained() { | |
var iter, marked, c, mark = h$gcMark; | |
do { | |
; | |
marked = false; | |
// mark all finalizers of weak references where the key is reachable | |
iter = h$finalizers.iter(); | |
while((c = iter.next()) !== null) { | |
if(!((typeof c.finalizer.m === 'number' && (c.finalizer.m & 3) === mark) || (typeof c.finalizer.m === 'object' && ((c.finalizer.m.m & 3) === mark))) && c.m.m === mark) { | |
; | |
h$follow(c.finalizer); | |
marked = true; | |
} | |
} | |
// mark all callbacks where at least one of the DOM retainers is reachable | |
iter = h$domRoots.iter(); | |
while((c = iter.next()) !== null) { | |
if(!h$isMarked(c.root) && c.domRoots && c.domRoots.size() > 0) { | |
var dr, domRetainers = c.domRoots.iter(); | |
while((dr = domRetainers.next()) !== null) { | |
if(h$isReachableDom(dr)) { | |
; | |
h$follow(c.root); | |
marked = true; | |
} | |
} | |
} | |
} | |
// mark weak values for reachable keys | |
for(var i=h$scannedWeaks.length-1;i>=0;i--) { | |
var w = h$scannedWeaks[i]; | |
if(w.keym.m === mark && w.val !== null && !((typeof w.val.m === 'number' && (w.val.m & 3) === mark) || (typeof w.val.m === 'object' && ((w.val.m.m & 3) === mark)))) { | |
; | |
h$follow(w.val); | |
marked = true; | |
} | |
} | |
// continue for a next round if we have marked something more | |
// note: this will be slow for very deep chains of weak refs, | |
// change this if that becomes a problem. | |
} while(marked); | |
} | |
function h$markThread(t) { | |
var mark = h$gcMark; | |
; | |
if(((typeof t.m === 'number' && (t.m & 3) === mark) || (typeof t.m === 'object' && ((t.m.m & 3) === mark)))) return; | |
if(typeof t.m === 'number') t.m = (t.m&-4)|mark; else t.m.m = (t.m.m & -4)|mark;; | |
if(t.stack === null) return; // thread finished | |
h$follow(t.stack, t.sp); | |
h$resetThread(t); | |
} | |
// big object, not handled by 0..7 cases | |
// keep out of h$follow to prevent deopt | |
function h$followObjGen(c, work, w) { | |
work.push(c.d1); | |
var d = c.d2; | |
for(var x in d) { | |
// if(d.hasOwnProperty(x)) { | |
work[w++] = d[x];; | |
// } | |
} | |
return w; | |
} | |
// follow all references in the object obj and mark them with the current mark | |
// if sp is a number, obj is assumed to be an array for which indices [0..sp] need | |
// to be followed (used for thread stacks) | |
function h$follow(obj, sp) { | |
var i, ii, iter, c, work, w; | |
; | |
var work, mark = h$gcMark; | |
if(typeof sp === 'number') { | |
work = obj.slice(0, sp+1); | |
w = sp + 1; | |
} else { | |
work = [obj]; | |
w = 1; | |
} | |
while(w > 0) { | |
; | |
c = work[--w]; | |
; | |
if(c !== null && c !== undefined && typeof c === 'object' && ((typeof c.m === 'number' && (c.m&3) !== mark) || (typeof c.m === 'object' && c.m !== null && typeof c.m.m === 'number' && (c.m.m&3) !== mark))) { | |
var doMark = false; | |
var cf = c.f; | |
; | |
if(typeof cf === 'function' && (typeof c.m === 'number' || typeof c.m === 'object')) { | |
; | |
// only change the two least significant bits for heap objects | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
// dynamic references | |
var d = c.d2; | |
switch(cf.size) { | |
case 0: break; | |
case 1: work[w++] = c.d1;; break; | |
case 2: { work[w++] = c.d1; work[w++] = d; }; break; | |
case 3: var d3=c.d2; { work[w++] = c.d1; work[w++] = d3.d1; work[w++] = d3.d2; }; break; | |
case 4: var d4=c.d2; { work[w++] = c.d1; work[w++] = d4.d1; work[w++] = d4.d2; work[w++] = d4.d3; }; break; | |
case 5: var d5=c.d2; { work[w++] = c.d1; work[w++] = d5.d1; work[w++] = d5.d2; work[w++] = d5.d3; }; work[w++] = d5.d4;; break; | |
case 6: var d6=c.d2; { work[w++] = c.d1; work[w++] = d6.d1; work[w++] = d6.d2; work[w++] = d6.d3; }; { work[w++] = d6.d4; work[w++] = d6.d5; }; break; | |
case 7: var d7=c.d2; { work[w++] = c.d1; work[w++] = d7.d1; work[w++] = d7.d2; work[w++] = d7.d3; }; { work[w++] = d7.d4; work[w++] = d7.d5; work[w++] = d7.d6; }; break; | |
case 8: var d8=c.d2; { work[w++] = c.d1; work[w++] = d8.d1; work[w++] = d8.d2; work[w++] = d8.d3; }; { work[w++] = d8.d4; work[w++] = d8.d5; work[w++] = d8.d6; work[w++] = d8.d7; }; break; | |
case 9: var d9=c.d2; { work[w++] = c.d1; work[w++] = d9.d1; work[w++] = d9.d2; work[w++] = d9.d3; }; { work[w++] = d9.d4; work[w++] = d9.d5; work[w++] = d9.d6; work[w++] = d9.d7; }; work[w++] = d9.d8;; break; | |
case 10: var d10=c.d2; { work[w++] = c.d1; work[w++] = d10.d1; work[w++] = d10.d2; work[w++] = d10.d3; }; { work[w++] = d10.d4; work[w++] = d10.d5; work[w++] = d10.d6; work[w++] = d10.d7; }; { work[w++] = d10.d8; work[w++] = d10.d9; }; break; | |
case 11: var d11=c.d2; { work[w++] = c.d1; work[w++] = d11.d1; work[w++] = d11.d2; work[w++] = d11.d3; }; { work[w++] = d11.d4; work[w++] = d11.d5; work[w++] = d11.d6; work[w++] = d11.d7; }; { work[w++] = d11.d8; work[w++] = d11.d9; work[w++] = d11.d10; }; break; | |
case 12: var d12=c.d2; { work[w++] = c.d1; work[w++] = d12.d1; work[w++] = d12.d2; work[w++] = d12.d3; }; { work[w++] = d12.d4; work[w++] = d12.d5; work[w++] = d12.d6; work[w++] = d12.d7; }; { work[w++] = d12.d8; work[w++] = d12.d9; work[w++] = d12.d10; work[w++] = d12.d11; }; break; | |
default: w = h$followObjGen(c,work,w); | |
} | |
// static references | |
var s = cf.s; | |
if(s !== null) { | |
; | |
for(var i=0;i<s.length;i++) work[w++] = s[i];; | |
} | |
} else if(c instanceof h$Weak) { | |
; | |
if(c.keym.m === mark) { | |
if(c.val !== null && !((typeof c.val.m === 'number' && (c.val.m & 3) === mark) || (typeof c.val.m === 'object' && ((c.val.m.m & 3) === mark)))) work[w++] = c.val;; | |
} else { | |
// fixme we should keep separate arrays for | |
// value mark pending / cleanup pending? | |
if(c.val !== null) h$scannedWeaks.push(c); | |
} | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
} else if(c instanceof h$MVar) { | |
; | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
/* | |
only push the values in the queues, not the waiting threads | |
the threads will be scanned after threads waiting on unreachable | |
MVars have been cleaned up | |
*/ | |
iter = c.writers.iter(); | |
while((ii = iter()) !== null) work[w++] = ii[1];; | |
if(c.val !== null && !((typeof c.val.m === 'number' && (c.val.m & 3) === mark) || (typeof c.val.m === 'object' && ((c.val.m.m & 3) === mark)))) work[w++] = c.val;; | |
} else if(c instanceof h$MutVar) { | |
; | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
work[w++] = c.val;; | |
} else if(c instanceof h$TVar) { | |
; | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
work[w++] = c.val;; | |
} else if(c instanceof h$Thread) { | |
; | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
if(c.stack) { | |
for(i=c.sp;i>=0;i--) work[w++] = c.stack[i];; | |
} | |
} else if(c instanceof h$Transaction) { | |
/* - the accessed TVar values don't need to be marked | |
- parents are also on the stack, so they should've been marked already | |
*/ | |
; | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
for(i=c.invariants.length-1;i>=0;i--) work[w++] = c.invariants[i];; | |
work[w++] = c.action;; | |
iter = c.tvars.iter(); | |
while((ii = iter.next()) !== null) work[w++] = ii;; | |
} else if(c instanceof Array && c.__ghcjsArray) { // only for Haskell arrays with lifted values | |
if(typeof c.m === 'number') c.m = (c.m&-4)|mark; else c.m.m = (c.m.m & -4)|mark;; | |
; | |
for(i=0;i<c.length;i++) { | |
var x = c[i]; | |
if(typeof x === 'object' && x !== null && !((typeof x.m === 'number' && (x.m & 3) === mark) || (typeof x.m === 'object' && ((x.m.m & 3) === mark)))) work[w++] = x;; | |
} | |
} else if(typeof c === 'object') { | |
; | |
for(i=h$extensibleRetentionCallbacks.length-1;i>=0;i--) { | |
var x = h$extensibleRetentionCallbacks[i](c, mark); | |
if(x === false) continue; | |
if(x !== true) { | |
for(j=x.length-1;j>=0;j--) work[w++] = x[j];; | |
} | |
break; | |
} | |
} // otherwise: not an object, no followable values | |
} | |
} | |
; | |
} | |
// resetThread clears the stack above the stack pointer | |
// and shortens the stack array if there is too much | |
// unused space | |
function h$resetThread(t) { | |
var stack = t.stack; | |
var sp = t.sp; | |
if(stack.length - sp > sp && stack.length > 100) { | |
t.stack = t.stack.slice(0,sp+1); | |
} else { | |
for(var i=sp+1;i<stack.length;i++) { | |
stack[i] = null; | |
} | |
} | |
; | |
} | |
// throw blocked indefinitely exception to the first thread waiting on an unreferenced MVar | |
function h$finalizeMVars() { | |
; | |
var i, t, iter = h$blocked.iter(); | |
while((t = iter.next()) !== null) { | |
if(t.status === h$threadBlocked && t.blockedOn instanceof h$MVar) { | |
// if h$unboxFFIResult is the top of the stack, then we cannot kill | |
// the thread since it's waiting for async FFI | |
if(t.blockedOn.m !== h$gcMark && t.stack[t.sp] !== h$unboxFFIResult) { | |
h$killThread(t, h$ghcjszmprimZCGHCJSziPrimziInternalziblockedIndefinitelyOnMVar); | |
return t; | |
} | |
} | |
} | |
return null; | |
} | |
// clear DOM retainers | |
function h$finalizeDom() { | |
// fixme | |
} | |
// reset unreferenced CAFs to their initial value | |
function h$finalizeCAFs() { | |
if(h$retainCAFs) return; | |
var mark = h$gcMark; | |
for(var i=0;i<h$CAFs.length;i++) { | |
var c = h$CAFs[i]; | |
if(c.m & 3 !== mark) { | |
var cr = h$CAFsReset[i]; | |
if(c.f !== cr) { // has been updated, reset it | |
; | |
c.f = cr; | |
c.d1 = null; | |
c.d2 = null; | |
} | |
} | |
} | |
; | |
} | |
/* include/HsBaseConfig.h. Generated from HsBaseConfig.h.in by configure. */ | |
/* include/HsBaseConfig.h.in. Generated from configure.ac by autoheader. */ | |
/* The value of E2BIG. */ | |
/* The value of EACCES. */ | |
/* The value of EADDRINUSE. */ | |
/* The value of EADDRNOTAVAIL. */ | |
/* The value of EADV. */ | |
/* The value of EAFNOSUPPORT. */ | |
/* The value of EAGAIN. */ | |
/* The value of EALREADY. */ | |
/* The value of EBADF. */ | |
/* The value of EBADMSG. */ | |
/* The value of EBADRPC. */ | |
/* The value of EBUSY. */ | |
/* The value of ECHILD. */ | |
/* The value of ECOMM. */ | |
/* The value of ECONNABORTED. */ | |
/* The value of ECONNREFUSED. */ | |
/* The value of ECONNRESET. */ | |
/* The value of EDEADLK. */ | |
/* The value of EDESTADDRREQ. */ | |
/* The value of EDIRTY. */ | |
/* The value of EDOM. */ | |
/* The value of EDQUOT. */ | |
/* The value of EEXIST. */ | |
/* The value of EFAULT. */ | |
/* The value of EFBIG. */ | |
/* The value of EFTYPE. */ | |
/* The value of EHOSTDOWN. */ | |
/* The value of EHOSTUNREACH. */ | |
/* The value of EIDRM. */ | |
/* The value of EILSEQ. */ | |
/* The value of EINPROGRESS. */ | |
/* The value of EINTR. */ | |
/* The value of EINVAL. */ | |
/* The value of EIO. */ | |
/* The value of EISCONN. */ | |
/* The value of EISDIR. */ | |
/* The value of ELOOP. */ | |
/* The value of EMFILE. */ | |
/* The value of EMLINK. */ | |
/* The value of EMSGSIZE. */ | |
/* The value of EMULTIHOP. */ | |
/* The value of ENAMETOOLONG. */ | |
/* The value of ENETDOWN. */ | |
/* The value of ENETRESET. */ | |
/* The value of ENETUNREACH. */ | |
/* The value of ENFILE. */ | |
/* The value of ENOBUFS. */ | |
/* The value of ENOCIGAR. */ | |
/* The value of ENODATA. */ | |
/* The value of ENODEV. */ | |
/* The value of ENOENT. */ | |
/* The value of ENOEXEC. */ | |
/* The value of ENOLCK. */ | |
/* The value of ENOLINK. */ | |
/* The value of ENOMEM. */ | |
/* The value of ENOMSG. */ | |
/* The value of ENONET. */ | |
/* The value of ENOPROTOOPT. */ | |
/* The value of ENOSPC. */ | |
/* The value of ENOSR. */ | |
/* The value of ENOSTR. */ | |
/* The value of ENOSYS. */ | |
/* The value of ENOTBLK. */ | |
/* The value of ENOTCONN. */ | |
/* The value of ENOTDIR. */ | |
/* The value of ENOTEMPTY. */ | |
/* The value of ENOTSOCK. */ | |
/* The value of ENOTSUP. */ | |
/* The value of ENOTTY. */ | |
/* The value of ENXIO. */ | |
/* The value of EOPNOTSUPP. */ | |
/* The value of EPERM. */ | |
/* The value of EPFNOSUPPORT. */ | |
/* The value of EPIPE. */ | |
/* The value of EPROCLIM. */ | |
/* The value of EPROCUNAVAIL. */ | |
/* The value of EPROGMISMATCH. */ | |
/* The value of EPROGUNAVAIL. */ | |
/* The value of EPROTO. */ | |
/* The value of EPROTONOSUPPORT. */ | |
/* The value of EPROTOTYPE. */ | |
/* The value of ERANGE. */ | |
/* The value of EREMCHG. */ | |
/* The value of EREMOTE. */ | |
/* The value of EROFS. */ | |
/* The value of ERPCMISMATCH. */ | |
/* The value of ERREMOTE. */ | |
/* The value of ESHUTDOWN. */ | |
/* The value of ESOCKTNOSUPPORT. */ | |
/* The value of ESPIPE. */ | |
/* The value of ESRCH. */ | |
/* The value of ESRMNT. */ | |
/* The value of ESTALE. */ | |
/* The value of ETIME. */ | |
/* The value of ETIMEDOUT. */ | |
/* The value of ETOOMANYREFS. */ | |
/* The value of ETXTBSY. */ | |
/* The value of EUSERS. */ | |
/* The value of EWOULDBLOCK. */ | |
/* The value of EXDEV. */ | |
/* The value of O_BINARY. */ | |
/* The value of SIGINT. */ | |
/* Define to 1 if you have the `clock_gettime' function. */ | |
/* #undef HAVE_CLOCK_GETTIME */ | |
/* Define to 1 if you have the <ctype.h> header file. */ | |
/* Define if you have epoll support. */ | |
/* #undef HAVE_EPOLL */ | |
/* Define to 1 if you have the `epoll_ctl' function. */ | |
/* #undef HAVE_EPOLL_CTL */ | |
/* Define to 1 if you have the <errno.h> header file. */ | |
/* Define to 1 if you have the `eventfd' function. */ | |
/* #undef HAVE_EVENTFD */ | |
/* Define to 1 if you have the <fcntl.h> header file. */ | |
/* Define to 1 if you have the `ftruncate' function. */ | |
/* Define to 1 if you have the `getclock' function. */ | |
/* #undef HAVE_GETCLOCK */ | |
/* Define to 1 if you have the `getrusage' function. */ | |
/* Define to 1 if you have the <inttypes.h> header file. */ | |
/* Define to 1 if you have the `iswspace' function. */ | |
/* Define to 1 if you have the `kevent' function. */ | |
/* Define to 1 if you have the `kevent64' function. */ | |
/* Define if you have kqueue support. */ | |
/* Define to 1 if you have the <langinfo.h> header file. */ | |
/* Define to 1 if you have libcharset. */ | |
/* Define to 1 if you have the `rt' library (-lrt). */ | |
/* #undef HAVE_LIBRT */ | |
/* Define to 1 if you have the <limits.h> header file. */ | |
/* Define to 1 if the system has the type `long long'. */ | |
/* Define to 1 if you have the `lstat' function. */ | |
/* Define to 1 if you have the <memory.h> header file. */ | |
/* Define if you have poll support. */ | |
/* Define to 1 if you have the <poll.h> header file. */ | |
/* Define to 1 if you have the <signal.h> header file. */ | |
/* Define to 1 if you have the <stdint.h> header file. */ | |
/* Define to 1 if you have the <stdlib.h> header file. */ | |
/* Define to 1 if you have the <strings.h> header file. */ | |
/* Define to 1 if you have the <string.h> header file. */ | |
/* Define to 1 if you have the <sys/epoll.h> header file. */ | |
/* #undef HAVE_SYS_EPOLL_H */ | |
/* Define to 1 if you have the <sys/eventfd.h> header file. */ | |
/* #undef HAVE_SYS_EVENTFD_H */ | |
/* Define to 1 if you have the <sys/event.h> header file. */ | |
/* Define to 1 if you have the <sys/resource.h> header file. */ | |
/* Define to 1 if you have the <sys/select.h> header file. */ | |
/* Define to 1 if you have the <sys/stat.h> header file. */ | |
/* Define to 1 if you have the <sys/syscall.h> header file. */ | |
/* Define to 1 if you have the <sys/timeb.h> header file. */ | |
/* Define to 1 if you have the <sys/timers.h> header file. */ | |
/* #undef HAVE_SYS_TIMERS_H */ | |
/* Define to 1 if you have the <sys/times.h> header file. */ | |
/* Define to 1 if you have the <sys/time.h> header file. */ | |
/* Define to 1 if you have the <sys/types.h> header file. */ | |
/* Define to 1 if you have the <sys/utsname.h> header file. */ | |
/* Define to 1 if you have the <sys/wait.h> header file. */ | |
/* Define to 1 if you have the <termios.h> header file. */ | |
/* Define to 1 if you have the `times' function. */ | |
/* Define to 1 if you have the <time.h> header file. */ | |
/* Define to 1 if you have the <unistd.h> header file. */ | |
/* Define to 1 if you have the <utime.h> header file. */ | |
/* Define to 1 if you have the <wctype.h> header file. */ | |
/* Define to 1 if you have the <windows.h> header file. */ | |
/* #undef HAVE_WINDOWS_H */ | |
/* Define to 1 if you have the <winsock.h> header file. */ | |
/* #undef HAVE_WINSOCK_H */ | |
/* Define to 1 if you have the `_chsize' function. */ | |
/* #undef HAVE__CHSIZE */ | |
/* Define to Haskell type for cc_t */ | |
/* Define to Haskell type for char */ | |
/* Define to Haskell type for clock_t */ | |
/* Define to Haskell type for dev_t */ | |
/* Define to Haskell type for double */ | |
/* Define to Haskell type for float */ | |
/* Define to Haskell type for gid_t */ | |
/* Define to Haskell type for ino_t */ | |
/* Define to Haskell type for int */ | |
/* Define to Haskell type for intmax_t */ | |
/* Define to Haskell type for intptr_t */ | |
/* Define to Haskell type for long */ | |
/* Define to Haskell type for long long */ | |
/* Define to Haskell type for mode_t */ | |
/* Define to Haskell type for nlink_t */ | |
/* Define to Haskell type for off_t */ | |
/* Define to Haskell type for pid_t */ | |
/* Define to Haskell type for ptrdiff_t */ | |
/* Define to Haskell type for rlim_t */ | |
/* Define to Haskell type for short */ | |
/* Define to Haskell type for signed char */ | |
/* Define to Haskell type for sig_atomic_t */ | |
/* Define to Haskell type for size_t */ | |
/* Define to Haskell type for speed_t */ | |
/* Define to Haskell type for ssize_t */ | |
/* Define to Haskell type for suseconds_t */ | |
/* Define to Haskell type for tcflag_t */ | |
/* Define to Haskell type for time_t */ | |
/* Define to Haskell type for uid_t */ | |
/* Define to Haskell type for uintmax_t */ | |
/* Define to Haskell type for uintptr_t */ | |
/* Define to Haskell type for unsigned char */ | |
/* Define to Haskell type for unsigned int */ | |
/* Define to Haskell type for unsigned long */ | |
/* Define to Haskell type for unsigned long long */ | |
/* Define to Haskell type for unsigned short */ | |
/* Define to Haskell type for useconds_t */ | |
/* Define to Haskell type for wchar_t */ | |
/* Define to the address where bug reports for this package should be sent. */ | |
/* Define to the full name of this package. */ | |
/* Define to the full name and version of this package. */ | |
/* Define to the one symbol short name of this package. */ | |
/* Define to the home page for this package. */ | |
/* Define to the version of this package. */ | |
/* The size of `kev.filter', as computed by sizeof. */ | |
/* The size of `kev.flags', as computed by sizeof. */ | |
/* The size of `struct MD5Context', as computed by sizeof. */ | |
/* Define to 1 if you have the ANSI C header files. */ | |
/* Number of bits in a file offset, on hosts where this is settable. */ | |
/* #undef _FILE_OFFSET_BITS */ | |
/* Define for large files, on AIX-style hosts. */ | |
/* #undef _LARGE_FILES */ | |
var h$errno = 0; | |
function h$__hscore_get_errno() { | |
; | |
return h$errno; | |
} | |
function h$unsupported(status, c) { | |
h$errno = 12456; | |
if(c) c(status); | |
return status; | |
} | |
function h$strerror(err) { | |
h$ret1 = 0; | |
if(err === 12456) return h$encodeUtf8("operation unsupported on this platform"); | |
return h$encodeUtf8(h$errorStrs[err] || "unknown error"); | |
} | |
function h$setErrno(e) { | |
; | |
var es = e.toString(); | |
var getErr = function() { | |
if(es.indexOf('ENOTDIR') !== -1) return 20; | |
if(es.indexOf('ENOENT') !== -1) return 2; | |
if(es.indexOf('EEXIST') !== -1) return 17; | |
if(es.indexOf('ENETUNREACH') !== -1) return 22; // fixme | |
if(es.indexOf('EPERM') !== -1) return 1; | |
if(es.indexOf('EMFILE') !== -1) return 24; | |
if(es.indexOf('EPIPE') !== -1) return 32; | |
if(es.indexOf('EAGAIN') !== -1) return 35; | |
if(es.indexOf('Bad argument') !== -1) return 2; // fixme? | |
throw ("setErrno not yet implemented: " + e); | |
} | |
h$errno = getErr(); | |
} | |
var h$errorStrs = { 7: "too big" | |
, CONST_EACCESS: "no access" | |
, 22: "invalid" | |
, 9: "bad file descriptor" | |
, 20: "not a directory" | |
, 2: "no such file or directory" | |
, 1: "operation not permitted" | |
, 17: "file exists" | |
, 24: "too many open files" | |
, 32: "broken pipe" | |
, 35: "resource temporarily unavailable" | |
} | |
function h$handleErrno(r_err, f) { | |
try { | |
return f(); | |
} catch(e) { | |
h$setErrno(e); | |
return r_err; | |
} | |
} | |
function h$handleErrnoS(r_err, r_success, f) { | |
try { | |
f(); | |
return r_success; | |
} catch(e) { | |
h$setErrno(e); | |
return r_err; | |
} | |
} | |
function h$handleErrnoC(err, r_err, r_success, c) { | |
if(err) { | |
h$setErrno(err); | |
c(r_err); | |
} else { | |
c(r_success); | |
} | |
} | |
function h$MD5Init(ctx, ctx_off) { | |
if(!ctx.arr) { ctx.arr = []; } | |
ctx.arr[ctx_off] = new goog.crypt.Md5(); | |
} | |
var h$__hsbase_MD5Init = h$MD5Init; | |
function h$MD5Update(ctx, ctx_off, data, data_off, len) { | |
var arr = new Uint8Array(data.buf, data_off); | |
ctx.arr[ctx_off].update(arr, len); | |
} | |
var h$__hsbase_MD5Update = h$MD5Update; | |
function h$MD5Final(dst, dst_off, ctx, ctx_off) { | |
var digest = ctx.arr[ctx_off].digest(); | |
for(var i=0;i<16;i++) { | |
dst.u8[dst_off+i] = digest[i]; | |
} | |
} | |
var h$__hsbase_MD5Final = h$MD5Final; | |
function h$hs_eqWord64(a1,a2,b1,b2) { | |
return (a1===b1 && a2===b2) ? 1 : 0; | |
} | |
function h$hs_neWord64(a1,a2,b1,b2) { | |
return (a1 !== b1 || a2 !== b2) ? 1 : 0; | |
} | |
function h$hs_word64ToWord(a1,a2) { | |
return a2; | |
} | |
function h$hs_wordToWord64(w) { | |
h$ret1 = w; | |
return 0; | |
} | |
function h$hs_intToInt64(a) { | |
h$ret1 = a; | |
return (a < 0) ? -1 : 0; | |
} | |
function h$hs_int64ToWord64(a1,a2) { | |
h$ret1 = a2; | |
return a1; | |
} | |
function h$hs_word64ToInt64(a1,a2) { | |
h$ret1 = a2; | |
return a1; | |
} | |
function h$hs_int64ToInt(a1,a2) { | |
return a2; | |
} | |
function h$hs_negateInt64(a1,a2) { | |
var c = goog.math.Long.fromBits(a2,a1).negate(); | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
function h$hs_not64(a1,a2) { | |
h$ret1 = ~a2; | |
return ~a1; | |
} | |
function h$hs_xor64(a1,a2,b1,b2) { | |
h$ret1 = a2 ^ b2; | |
return a1 ^ b1; | |
} | |
function h$hs_and64(a1,a2,b1,b2) { | |
h$ret1 = a2 & b2; | |
return a1 & b1; | |
} | |
function h$hs_or64(a1,a2,b1,b2) { | |
h$ret1 = a2 | b2; | |
return a1 | b1; | |
} | |
function h$hs_eqInt64(a1,a2,b1,b2) { | |
return (a1 === b1 && a2 === b2) ? 1 : 0; | |
} | |
function h$hs_neInt64(a1,a2,b1,b2) { | |
return (a1 !== b1 || a2 !== b2) ? 1 : 0; | |
} | |
function h$hs_leInt64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s < b2s || (a2s === b2s && ((a2&1) <= (b2&1)))) ? 1 : 0; | |
} else { | |
return (a1 < b1) ? 1 : 0; | |
} | |
} | |
function h$hs_ltInt64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s < b2s || (a2s === b2s && ((a2&1) < (b2&1)))) ? 1 : 0; | |
} else { | |
return (a1 < b1) ? 1 : 0; | |
} | |
} | |
function h$hs_geInt64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s > b2s || (a2s === b2s && ((a2&1) >= (b2&1)))) ? 1 : 0; | |
} else { | |
return (a1 > b1) ? 1 : 0; | |
} | |
} | |
function h$hs_gtInt64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s > b2s || (a2s === b2s && ((a2&1) > (b2&1)))) ? 1 : 0; | |
} else { | |
return (a1 > b1) ? 1 : 0; | |
} | |
} | |
function h$hs_quotWord64(a1,a2,b1,b2) { | |
var a = h$bigFromWord64(a1,a2); | |
var b = h$bigFromWord64(b1,b2); | |
var c = a.divide(b); | |
h$ret1 = c.intValue(); | |
return c.shiftRight(32).intValue(); | |
} | |
function h$hs_timesInt64(a1,a2,b1,b2) { | |
var c = goog.math.Long.fromBits(a2,a1).multiply(goog.math.Long.fromBits(b2,b1)); | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
function h$hs_quotInt64(a1,a2,b1,b2) { | |
var c = goog.math.Long.fromBits(a2,a1).div(goog.math.Long.fromBits(b2,b1)); | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
function h$hs_remInt64(a1,a2,b1,b2) { | |
var c = goog.math.Long.fromBits(a2,a1).modulo(goog.math.Long.fromBits(b2,b1)); | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
function h$hs_plusInt64(a1,a2,b1,b2) { | |
var c = goog.math.Long.fromBits(a2,a1).add(goog.math.Long.fromBits(b2,b1)); | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
function h$hs_minusInt64(a1,a2,b1,b2) { | |
var c = goog.math.Long.fromBits(a2,a1).subtract(goog.math.Long.fromBits(b2,b1)); | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
function h$hs_leWord64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s < b2s || (a2s === b2s && ((a2&1) <= (b2&1)))) ? 1 : 0; | |
} else { | |
var a1s = a1 >>> 1; | |
var b1s = b1 >>> 1; | |
return (a1s < b1s || (a1s === b1s && ((a1&1) <= (b1&1)))) ? 1 : 0; | |
} | |
} | |
function h$hs_ltWord64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s < b2s || (a2s === b2s && ((a2&1) < (b2&1)))) ? 1 : 0; | |
} else { | |
var a1s = a1 >>> 1; | |
var b1s = b1 >>> 1; | |
return (a1s < b1s || (a1s === b1s && ((a1&1) < (b1&1)))) ? 1 : 0; | |
} | |
} | |
function h$hs_geWord64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s > b2s || (a2s === b2s && ((a2&1) >= (b2&1)))) ? 1 : 0; | |
} else { | |
var a1s = a1 >>> 1; | |
var b1s = b1 >>> 1; | |
return (a1s > b1s || (a1s === b1s && ((a1&1) >= (b1&1)))) ? 1 : 0; | |
} | |
} | |
function h$hs_gtWord64(a1,a2,b1,b2) { | |
if(a1 === b1) { | |
var a2s = a2 >>> 1; | |
var b2s = b2 >>> 1; | |
return (a2s > b2s || (a2s === b2s && ((a2&1) > (b2&1)))) ? 1 : 0; | |
} else { | |
var a1s = a1 >>> 1; | |
var b1s = b1 >>> 1; | |
return (a1s > b1s || (a1s === b1s && ((a1&1) > (b1&1)))) ? 1 : 0; | |
} | |
} | |
function h$hs_remWord64(a1,a2,b1,b2) { | |
var a = h$bigFromWord64(a1,a2); | |
var b = h$bigFromWord64(b1,b2); | |
var c = a.mod(b); | |
h$ret1 = c.intValue(); | |
return c.shiftRight(32).intValue(); | |
} | |
function h$hs_uncheckedIShiftL64(a1,a2,n) { | |
var num = new goog.math.Long(a2,a1).shiftLeft(n); | |
h$ret1 = num.getLowBits(); | |
return num.getHighBits(); | |
} | |
function h$hs_uncheckedIShiftRA64(a1,a2,n) { | |
var num = new goog.math.Long(a2,a1).shiftRight(n); | |
h$ret1 = num.getLowBits(); | |
return num.getHighBits(); | |
} | |
// always nonnegative n? | |
function h$hs_uncheckedShiftL64(a1,a2,n) { | |
n &= 63; | |
if(n == 0) { | |
h$ret1 = a2; | |
return a1; | |
} else if(n < 32) { | |
h$ret1 = a2 << n; | |
return (a1 << n) | (a2 >>> (32-n)); | |
} else { | |
h$ret1 = 0; | |
return ((a2 << (n-32))|0); | |
} | |
} | |
function h$hs_uncheckedShiftRL64(a1,a2,n) { | |
n &= 63; | |
if(n == 0) { | |
h$ret1 = a2; | |
return a1; | |
} else if(n < 32) { | |
h$ret1 = (a2 >>> n ) | (a1 << (32-n)); | |
return a1 >>> n; | |
} else { | |
h$ret1 = a1 >>> (n-32); | |
return 0; | |
} | |
} | |
// fixme this function appears to deoptimize a lot due to smallint overflows | |
function h$imul_shim(a, b) { | |
var ah = (a >>> 16) & 0xffff; | |
var al = a & 0xffff; | |
var bh = (b >>> 16) & 0xffff; | |
var bl = b & 0xffff; | |
// the shift by 0 fixes the sign on the high part | |
// the final |0 converts the unsigned value into a signed value | |
return (((al * bl)|0) + (((ah * bl + al * bh) << 16) >>> 0)|0); | |
} | |
var h$mulInt32 = Math.imul ? Math.imul : h$imul_shim; | |
// function h$mulInt32(a,b) { | |
// return goog.math.Long.fromInt(a).multiply(goog.math.Long.fromInt(b)).getLowBits(); | |
// } | |
// var hs_mulInt32 = h$mulInt32; | |
function h$mulWord32(a,b) { | |
return goog.math.Long.fromBits(a,0).multiply(goog.math.Long.fromBits(b,0)).getLowBits(); | |
} | |
function h$mul2Word32(a,b) { | |
var c = goog.math.Long.fromBits(a,0).multiply(goog.math.Long.fromBits(b,0)) | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
function h$quotWord32(a,b) { | |
return goog.math.Long.fromBits(a,0).div(goog.math.Long.fromBits(b,0)).getLowBits(); | |
} | |
function h$remWord32(a,b) { | |
return goog.math.Long.fromBits(a,0).modulo(goog.math.Long.fromBits(b,0)).getLowBits(); | |
} | |
function h$quotRem2Word32(a1,a2,b) { | |
var a = h$bigFromWord64(a1,a2); | |
var b = h$bigFromWord(b); | |
var d = a.divide(b); | |
h$ret1 = a.subtract(b.multiply(d)).intValue(); | |
return d.intValue(); | |
} | |
function h$wordAdd2(a,b) { | |
var c = goog.math.Long.fromBits(a,0).add(goog.math.Long.fromBits(b,0)); | |
h$ret1 = c.getLowBits(); | |
return c.getHighBits(); | |
} | |
// this does an unsigned shift, is that ok? | |
function h$uncheckedShiftRL64(a1,a2,n) { | |
if(n < 0) throw "unexpected right shift"; | |
n &= 63; | |
if(n == 0) { | |
h$ret1 = a2; | |
return a1; | |
} else if(n < 32) { | |
h$ret1 = (a2 >>> n) | (a1 << (32 - n)); | |
return (a1 >>> n); | |
} else { | |
h$ret1 = a2 >>> (n - 32); | |
return 0; | |
} | |
} | |
function h$isDoubleNegativeZero(d) { | |
; | |
return (d===0 && (1/d) === -Infinity) ? 1 : 0; | |
} | |
function h$isFloatNegativeZero(d) { | |
; | |
return (d===0 && (1/d) === -Infinity) ? 1 : 0; | |
} | |
function h$isDoubleInfinite(d) { | |
return (d === Number.NEGATIVE_INFINITY || d === Number.POSITIVE_INFINITY) ? 1 : 0; | |
} | |
function h$isFloatInfinite(d) { | |
return (d === Number.NEGATIVE_INFINITY || d === Number.POSITIVE_INFINITY) ? 1 : 0; | |
} | |
function h$isFloatFinite(d) { | |
return (d !== Number.NEGATIVE_INFINITY && d !== Number.POSITIVE_INFINITY && !isNaN(d)) ? 1 : 0; | |
} | |
function h$isDoubleFinite(d) { | |
return (d !== Number.NEGATIVE_INFINITY && d !== Number.POSITIVE_INFINITY && !isNaN(d)) ? 1 : 0; | |
} | |
function h$isDoubleNaN(d) { | |
return (isNaN(d)) ? 1 : 0; | |
} | |
function h$isFloatNaN(d) { | |
return (isNaN(d)) ? 1 : 0; | |
} | |
function h$isDoubleDenormalized(d) { | |
return (d !== 0 && Math.abs(d) < 2.2250738585072014e-308) ? 1 : 0; | |
} | |
function h$isFloatDenormalized(d) { | |
return (d !== 0 && Math.abs(d) < 2.2250738585072014e-308) ? 1 : 0; | |
} | |
var h$convertBuffer = new ArrayBuffer(8); | |
var h$convertDouble = new Float64Array(h$convertBuffer); | |
var h$convertFloat = new Float32Array(h$convertBuffer); | |
var h$convertInt = new Int32Array(h$convertBuffer); | |
// use direct inspection through typed array for decoding floating point numbers if this test gives | |
// the expected answer. fixme: does this test catch all non-ieee or weird endianness situations? | |
h$convertFloat[0] = 0.75; | |
// h$convertFloat[0] = 1/0; // to force using fallbacks | |
var h$decodeFloatInt = h$convertInt[0] === 1061158912 ? h$decodeFloatIntArray : h$decodeFloatIntFallback; | |
var h$decodeDouble2Int = h$convertInt[0] === 1061158912 ? h$decodeDouble2IntArray : h$decodeDouble2IntFallback; | |
function h$decodeFloatIntArray(d) { | |
; | |
if(isNaN(d)) { | |
h$ret1 = 105; | |
return -12582912; | |
} | |
h$convertFloat[0] = d; | |
var i = h$convertInt[0]; | |
var exp = (i&2139095040) >> 23; | |
var s = i&8388607; | |
if(exp === 0) { // zero or denormal | |
if(s === 0) { | |
; | |
h$ret1 = 0; | |
return 0; | |
} else { | |
h$convertFloat[0] = d*8388608; | |
i = h$convertInt[0]; | |
; | |
h$ret1 = ((i&2139095040) >> 23) - 173; | |
return (((i&8388607)<<7)|(i&2147483648))>>7; | |
} | |
} else { | |
; | |
h$ret1 = exp - 150; | |
return (((s|8388608)<<7)|(i&2147483648))>>7; | |
} | |
} | |
function h$decodeFloatIntFallback(d) { | |
; | |
if(isNaN(d)) { | |
h$ret1 = 105; | |
return -12582912; | |
} | |
var exponent = h$integer_cmm_decodeDoublezhFallback(d)+29; | |
var significand = h$ret1.shiftRight(28).add(h$bigOne).shiftRight(1).intValue(); | |
if(exponent > 105) { | |
exponent = 105; | |
significand = d > 0 ? 8388608 : -8388608; | |
} else if(exponent < -151 || significand === 0) { | |
significand = 0; | |
exponent = 0; | |
} | |
; | |
h$ret1 = exponent; | |
return significand; | |
} | |
function h$decodeDouble2IntArray(d) { | |
; | |
if(isNaN(d)) { | |
h$ret3 = 972; | |
h$ret2 = 0; | |
h$ret1 = -1572864; | |
return 1; | |
} | |
h$convertDouble[0] = d; | |
; | |
var i1 = h$convertInt[1]; | |
h$ret2 = h$convertInt[0]; | |
var exp = (i1&2146435072)>>>20; | |
if(exp === 0) { // denormal or zero | |
if((i1&2147483647) === 0 && h$ret2 === 0) { | |
h$ret1 = 0; | |
h$ret3 = 0; | |
} else { | |
h$convertDouble[0] = d*9007199254740992; | |
i1 = h$convertInt[1]; | |
h$ret1 = (i1&1048575)|1048576; | |
h$ret2 = h$convertInt[0]; | |
h$ret3 = ((i1&2146435072)>>>20)-1128; | |
} | |
} else { | |
h$ret3 = exp-1075; | |
h$ret1 = (i1&1048575)|1048576; | |
} | |
; | |
return i1<0?-1:1; | |
} | |
function h$decodeDouble2IntFallback(d) { | |
; | |
if(isNaN(d)) { | |
h$ret3 = 972; | |
h$ret2 = 0; | |
h$ret1 = -1572864; | |
return 1; | |
} | |
var exponent = h$integer_cmm_decodeDoublezhFallback(d); | |
var significand = h$ret1; | |
var sign = d<0?-1:1; | |
var s = significand.abs(); | |
h$decodeDouble2IntArray(d); | |
; | |
h$ret1 = s.shiftRight(32).intValue(); | |
h$ret2 = s.intValue(); | |
h$ret3 = exponent; | |
; | |
return sign; | |
} | |
// round .5 to nearest even number | |
function h$rintDouble(a) { | |
var rounda = Math.round(a); | |
if(a >= 0) { | |
if(a%1===0.5 && rounda%2===1) { // tie | |
return rounda-1; | |
} else { | |
return rounda; | |
} | |
} else { | |
if(a%1===-0.5 && rounda%2===-1) { // tie | |
return rounda-1; | |
} else { | |
return rounda; | |
} | |
} | |
} | |
var h$rintFloat = h$rintDouble; | |
function h$acos(d) { return Math.acos(d); } | |
function h$acosf(f) { return Math.acos(f); } | |
function h$asin(d) { return Math.asin(d); } | |
function h$asinf(f) { return Math.asin(f); } | |
function h$atan(d) { return Math.atan(d); } | |
function h$atanf(f) { return Math.atan(f); } | |
function h$atan2(x,y) { return Math.atan2(x,y); } | |
function h$atan2f(x,y) { return Math.atan2(x,y); } | |
function h$cos(d) { return Math.cos(d); } | |
function h$cosf(f) { return Math.cos(f); } | |
function h$sin(d) { return Math.sin(d); } | |
function h$sinf(f) { return Math.sin(f); } | |
function h$tan(d) { return Math.tan(d); } | |
function h$tanf(f) { return Math.tan(f); } | |
function h$cosh(d) { return (Math.exp(d)+Math.exp(-d))/2; } | |
function h$coshf(f) { return h$cosh(f); } | |
function h$sinh(d) { return (Math.exp(d)-Math.exp(-d))/2; } | |
function h$sinhf(f) { return h$sinh(f); } | |
function h$tanh(d) { return (Math.exp(2*d)-1)/(Math.exp(2*d)+1); } | |
function h$tanhf(f) { return h$tanh(f); } | |
var h$popCntTab = | |
[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]; | |
function h$popCnt32(x) { | |
return h$popCntTab[x&0xFF] + | |
h$popCntTab[(x>>>8)&0xFF] + | |
h$popCntTab[(x>>>16)&0xFF] + | |
h$popCntTab[(x>>>24)&0xFF] | |
} | |
function h$popCnt64(x1,x2) { | |
return h$popCntTab[x1&0xFF] + | |
h$popCntTab[(x1>>>8)&0xFF] + | |
h$popCntTab[(x1>>>16)&0xFF] + | |
h$popCntTab[(x1>>>24)&0xFF] + | |
h$popCntTab[x2&0xFF] + | |
h$popCntTab[(x2>>>8)&0xFF] + | |
h$popCntTab[(x2>>>16)&0xFF] + | |
h$popCntTab[(x2>>>24)&0xFF]; | |
} | |
function h$bswap64(x1,x2) { | |
h$ret1 = (x1 >>> 24) | (x1 << 24) | ((x1 & 0xFF00) << 8) | ((x1 & 0xFF0000) >> 8); | |
return (x2 >>> 24) | (x2 << 24) | ((x2 & 0xFF00) << 8) | ((x2 & 0xFF0000) >> 8); | |
} | |
// Unicode tables generated by ghcjs/utils/genUnicode.hs | |
var h$printRanges = "f|!-f=|/q'/+1$J|(mo'1q&')| 63Y--EO'|$9| ('| ?'|!9?| ?-| %'AZ'| JI| +|#U2'''O0$)+'5'''+3*','O-).+''O0&&&'$-+''))0+$1C9)4(N0&,'7(('@+';A)2'''O0&,'5''')3'+','G7'.))*)'$&)')));+-))*'.>M-+2(PB)3(*1'&/+'733(2(P6,'5(*1'1$+'7&?)2(u'3(,32+'C)1''F)S4$'1)*/$2/7');| =+^n'$''$'.+0( #''<('-$.'7'+d| Yk+rk@<n|$G$-&|(E*'1$*'v*'f*'1$*'A| :*'| O'd)W/| t9|.r)|! 1=09Q5K;=(&;|!+'7/7/?'7/| z3z-| U7b:+;+(x'-9| +W/9)| E'| K]'9/7/?'A| K| b+| #)|!W3| A)A)| /| I33r&/|%M/|&;'/'p'/'3 $a'| 3@>'/H')48-S1| +C''Y<)`GfA|#)/|-h-rU9M|H;'d'h);2| %| '| &|#<-| #$-&| 91'?S510000000|!4| CW| {;|$hW;+| I| u'|!=-v)|!+y-l;| '|$y} ^y7}%0j| /|9t)| 75|'fK|!+| {3|#3_''| S| 3+7/| 93| S5;/[+| r9`)| f8+f| 65?'7'|!=S[7/'/'/510| (+'|!#| %'7/}!e;;Q+| +}!'n|(/'|!Cp1;--W,$&&|!gE|(-C| I'| 5t?'W/?'jH*+-|#!+|$7)/'/'/'))10='';VH&@'?h|!f-)+| #)| v);+| &| %|!t^)| +A[+l;Y-z-`m+?x|#Q'7| vt3| 19|#4|&v5O73|#E/'$| &)&Q| X35| j[)Y-| H| 9/'| I+&-3(X+)+5351| Idr+;5| 5)^'Y-W1+;1| j| [|+tb|(U| f+`A| E*?U17/| 3>;r5| [+&9/K9Gy|!S| ?-71)2'''O0&,'5''')5,1'1)-|%x| Y37|#b| 5'G| 5| S97p| 937|*K| p;|)y| ;|<Y|4M|!=|!M,|b`|7l}#8j|,^1b6+'|!/`'/7| U770L-I|3U| S9| 'CE}$&7'|e7|!E-=)517'+} 47|%M7r'| ^3|!5h| U|$/| x5G|#1| t| V&'&''+:$0| J*'30Z*,$)1|'T'|&O'| -} %|$E'C|=C+X&$'$7* #/* $)&$' &'$'+0**$6D-),D| 1'|&#| +|!7;A'A@m7=)b| @+z| `^=z-51'|#r| #)| f'| h-l3|%`| _-xu|#P'|#+C=)+;|!W;| tz;+| 937/t3`|I^}*Q/v} !59|$x}$#I|,'|G1|%A"; | |
var h$alnumRanges = "| +71W/W| '0'$)'(Pa|*2+;?-1$D|!Y&'+$/$)$J| o|#*|#oo'0r5| #$&&$3Y-)^9-| ^+|!;2'7H'B| ?'|!9?| 5+,| %G[| QI| +|!p'7H2'''O0$)+'5'''+3*',';'/1).+''O0&&&'$-+''))0+$1C9)4(N0&,'7(('@+'7E)2'''O0&,'5''')3'+','707'.))*)'$&)')));+-))*'.>==+2(PB)3(*1'&/+'731')2(P6,'5(*1'1$+'7&?)2(u'3(,32+'C+/''F)S4$'1)*/$2/7''=| =-A6r'$''$'.+0( #''<('-$.'7'+dP'/K $+7k+KFk5| :| ^/| f'p$-&z|'F*'1$*'v*'f*'1$*'A| :*'| O')5K)CC| t;|-j'EV-| `)91=09M9K;=(&;| r)*''7/7E)'7/| z3z-| U7b:+;7t'-9| +W/9n[+| G]'9/7=2A| K| b+7E5;|!W;| 937)| +| n)i&/|%M/|&;'/'p'/'3 $a'| 30$))0)+'/+=-)0|!U''/-9/=| /fE*&7$)-/ $+8'+--+$| =|0/| A| fO|.#`|91| '| &|!y/55&p$-&| 91@S510000000c| '|*H)UA,'-+| v''')|!!*-v)|!+)+7Y| 3Cd7`3@d7rA|'-} X;| ^}%/C| /|9t| O| %'|& )[K| /6a| on5'|!='+_''| S| +3/7| 1;| S97/S)*| %'l;^)| K?9/b| 65?'7/Q)| [S)'C'-7/'/'/510y*+'|!#z&'7/}!e;;Q+| +}!'n|(/'|!Cp1;--;<,$&&|!Ff|()G| I'| 5t;+CC?| M-|#!I71W/W9|! )/'/'/')j;VH&@'?h|!f;| #;| ;E'|!Q|!s^)| +A[+l;Y-z-`'l+3,x|#Q'7| vt3| 1|#M|&v5O73|#E/'$| &)&Q'b'p35| j[+W| U| 9/'| I+&-3(X+)+5Sbcd3_+-C| 57O'Y-WQ1| j| [|+tb|(U| W9`A| AMU17/| 36Cl'4| S99/K9Gm|!`| ?-71)2'''O0&,'5''')5,1'1)-|%x| U$37|#b| 5'5| G| K)87p| 937|*K| p;|)y| ;|<Y|4M|!=|!M|bl|7l}#8j|,^1b6|!;`'-9| 75+;70L-I|3U| S9| 'CE}$&7'|e7|!E-=)517)'} <3-)/33'1`+|#=)|&=G|#1| t| V&'&''+:$0| J*'30Z*,$)1|'T'UTaTaTaTaT2'| -} %|$E'C|=C+X&$'$7* #/* $)&$' &'$'+0**$6D-),D|,t=|v'}*Q/v} !59|$x}$#I|,'|G1|%A"; | |
var h$lowerRanges = "|!3W| =uS2 <& (& 8' #)'$&('+&()'& #&$'$'($&'')/&& )' )&'$( >1'&'$+ %| SX|$=$(()GXj&)) ,,$'&'| /| ) 25 ;& '' Q| +r} KQ| | G=g|!; l5 Q43/73333/73333?'333333-&/()&3+''337)&|&+(')X**&'3++| 2|]a| ''(' $+$'.- R'1$*:p$-}'Zi 7H .|#! ') @2 #' %*$&$) +| j|28z5'}%!p1;-|7`W|;?t} :;d}+l-WW1FWWW+$08WWWWWWWWWWWWWWWWW[[U.WU.WU.WU.WU.$"; | |
var h$upperRanges = "| MW|!9Q0f <& (& 8' #)'$&('+&()'& #&$'$'($&)0'&& )' )&'$( >1'&'$+ %|&I$(2.$)$&D4j&)) ,,&$''| /| ) 14 <' '' P&p|a5p$-|l( l4 Q433/73333/9 $23S333333-9-9+;-9-|%l*()')'(-/ $+'+7'-| B|[]| '| +$)' $+$'2) R3$*}']( 7H .|#! '( ?6 #' %+$&$( ++''}%OGW|;/t} :Kd}+l9WWWWWW$''&''+2WWW'*'30Y'*,$)1YWWWWWWWWWWW`UfUfUfUfUf%"; | |
var h$alphaRanges = "| MW/W| '6*,Qa|*2+;?-1$|!q-&'+$/$)$J| o|#*3|#bo'0r| YY-)| #zj'|!4$A'1'7)'B$`^|! 9Rf5'+,O+4(PU| WI| l| 5)F07AC+3'''O0$)+)B<'(?'I/+''O0&&&b+$I)C5(N0&,)F@'j3'''O0&,)_'(AD$/))*)'$&)')));O| 03(PB)V'/'j3(P6,)c$'A'G3(u'BD'S/-G)S4$'1| =| )&;1| ='$''$'.+0( #''*&5&-$M+d| F3kY-|!UzKB/++)('1)+=;Dp$-&z|'F*'1$*'v*'f*'1$*'A| :*'| OnCC| t;|-j'EV-| `/31=*?G?G?=(A| 1j*| N| z3v$-| U7b| +`'-9| M1| 9Q5| 3| n|!(| 'E1| 7`='7| Wlv)7l|!E+*)'5|$;| I|&3'/'p'/'3 $a'| 30$))0)+'/+=-)0|!W<B=|!9*&7$)-/ $+8'+--+| 0'|[[| '| &|!y/+)';p$-&| 91BQ510000000| j|*H'x--'+| v/)|!!*-v)|!+EY| 3C|+E} X;| ^}%/C| /|9t| O| %'|& )C7'K| 'Cb'| U| +5'|!='+_''| S9(*P^| 1?| -| E/)>[7QU^1| '[B-67-uQ)2KQ)(| -$)''-'$R)'91);/'/'/510y*+'|!#j^}!e;;Q+| +}!'n|(/'|!Cp1;--$7<,$&&|!Ff|()G| I'| 5t;|!W-|#!lW/W9|! )/'/'/')j;VH&@'?h|!f|(^^)| +| 'dCE2/p7`'l+3| )|#Q|!3t3| 1|#M|&v5O73|#E/'$| &)&Q7Q5b|!1O7W| U| 9/'| I@+(X| ^)^j3ZY| 57O7I=G|!K| [|55| 3| `| #dUWlvj):| )?+MmGT|!x| 'p3'''O0&,)a-|&C| )K'$|$+| '| l| )K| >z|+/| Ib|)y| ;|<Y|4M|gU|7l}#8j|,^1b|!Q`G| )C+bM-I|3U| S9| L=}$&7'|e7|!E-=)517} K-| t| V&'&''+:$0| J*'30Z*,$)1|'T'UTaTaTaTaT2} !3|$E|=h+X&$'$7* #/* $)&$' &'$'+0**$6D-),D} (7}*Q/v} !59|$x}$#I|,'"; | |
var h$toLowerMapping = "| K Wb|!9 Qb!1bf 9# !|$F ## &' (# &' 8# !|!_# # #) !|$^# ! # ! |$U !# '|$S&' !| f|$M !|$O# ! |$S !|$W !|$`|$[&) !|$`|$d ! |$f $# !|$n# ! |$n' !# !|$n#!'|$l ## !|$p#) &1 !%# ! % !# !%# ) #' )# &' !%# ! # ! |!. !| 6# 4 # ! |!q * #1 !}![r# ! |#X}%=]' !# !|$>| Q !| U# % #|&I !# &) &3 |%0/ !n )l ! | G!'| E!Eb!5bj B3 ,# &- |!]' !# !.#' )|!qC| hdb| ) 1# &5 <# !?# ' #' P# &' p| '|a5 p} hG ! } hG- }#To|l) l# &5 !} p4 P# &5 303 /07 303 303 /09 $0 @3 30S 303 303 303 '0'| ZD9 +| sD9 '0'|!4; '0'|!L<9 '|!m'|!iD|&Y }#a() !}!&:}!#V/ | 8| # CAI &|23 WU|Ht | '| '| + !# !}!Zc|ue}%:e' $# !}![R}!Zo !}![X}![V ! #' &3 '}!]> R# &3 !# &+ &}']) 7# &I .# &|## '# &) ?# &7 ## !}(b.# % #+ !# }4p*' !# &) +# !}*H0}*HF !}*H>}*H*' !}*G&}*GV}%OG Wb|;/ tr} :K db}p? "; | |
var h$toUpperMapping = "|!1 Wa| = |A$x Qa!1a !|!` 9! !|%. #! $' (! $' 7! $' #! !!|&]|(_' !! $' $) $- $' |$>) !!|#Y) |%i' #! $' $+ $' $) !! $' $) !! |!N- !!$ ! ! !$ !!$ ) ! !| e )! $' !!$ ! !) 4! $) )! $3 $' '}!]? ! !+ %! !!}![Y !}![S}![W !|$]|$T!'|$R ! |$L ! |$N}4qo) !|$R}*H? ! |$V ! }*GS !}*H1 !|$Z|$_ ! }!Zd}4q6' !|$_ !}!Zp|$c' |)N1 }%:g' |)_' |)_) !}*GW|$m|#&'|$k|#.- |)c9 }4o.|#b |#ez !! $) $) )|!r| % | _)k!Ea| B5a|!m'| D ! | B|!P) !| $| 2 !0 ,! !!| s !| g/ !|!T |$8' $' $| 1 daC| g 2 !5 ;! $' '! !!> Q !| + p| &} N7 }1H>) } pP|!v l! $- |!X- P! $313 /17 313 313 /19 $1 B3 313 '| [+| t'|!5'|!n'|!M'|!j' 313 313 313 '1 ! 37 }#R4+ F; '1? '1) >= F|'b | 6f C@+ $|2f WT|IE | '| &' $) !}![q}![k $ !/ $' $7 R! $3 !! $+ $; p} hF ! } hF- }#Tm}'Zj 7! $I .! $|## '! $) ?! $7 !! $' %! $+ $+ !! $) *! $}%P= Wa|;? tq} :; da}p>; "; | |
var h$catMapping = "d;P)3J)3 !/0 !34 !3.'37*'3)4'3W! !/3 !06 !-6W# !/4 !04f; !83+5 !73 !67 !&1 !4< !76 !74', !6#'3 !6, !&2),FQ!H1!S#H3# <!#$'# (!#$'# 8!#'! ##!)#'! !#!&'!&)!'#+!&'!&)!)#'!&'! ##!&'! !#!'# !!#'!&)! !#!&'!'# !&!)#+& !!$ !#! !$# !!$ )#!'# )!#$'# !!$ !#!&)! >#!1#'!&'!'# !!#+! %#!| S#,Y#G%+6;%?6-%16 !%6*E6|!O' #!# !%6 !!#' *)# !3!+ '6 !!3)! ! !!'!&E!!5!j#$'#)!)# ,!#$-# !!# !4!&'!'#| /!| )# 2!#N-'') <!#'! '#!'# Q!#!p!' */3!r# ! 3<' '7 !5 | #' !.'F''F'' !3'3 Y&- )&'39 /<)4'3J'3'79' !3<!'3d&*7&M'7*+3'&.|!5& !3&1' !<7/''%''N+''&7*)&'7,?3 ! < !&'`&Y'' |! &9',? 7*f&5''%N)3*- O&+'*5'*)'*-'' A3!U&)'' F| K I&| + b'0| 5& !'( !'&)(3'+(.'(,1'7&'''37* !3%A&.'(!3&' '&' O&!1& ! &) +&' !'&)(+'' '(' '( !'&3 0+ '&!)&''' 7*'&'5/, !75- '' !( /&+ '&' O&!1&!'&!'&!'&' !' )(''+ ''' )') .1 +& ! &1 7*'')&.9 '' !( 5&!)&!O&!1&!'&!-&' !'&)(-'!'' !( '(.' ,A '&''' 7* !35A .'(!3&' '&' O&!1&!'&!-&' !'& !('0+'' '(' '(.3 !'(+ '&!)&''' 7* !7&/,7 !'&!/&) )&!+&) '& ! &!'&) '&) )&) ;&+ '(.'() )(!)(.' ,/ 0? 7*),/7 !57- .)(!3&!)&!Q&!C&) ,)'+(!)'!+'1 ''!'&/ '&''' 7*3 1, !7 .'(!3&!)&!Q&!7&!-&' !'& !('-( ! ''(!'(''1 '(1 !& '&''' 7*!'&? .'(!3&!)&!v&' ,)(+'!)(!)( !'&3 03 '&''' 7*/,) N/&' '(!G&) S&!5& ! &' 1&) .+ )()' ! '!3(/ 7*' '(F; | )&.'&1'+ J/&*3'F7*'3n '& ! &' '& ! &' ,/ +&!1&!)& # &' '&!+&.'&/'!'',' -& ! %!/'' 7*' +&d ,)7A3 !73)7''/77*7, $7' #/0'(3&!l&+ ?'0-'F''-&9'!l'!37./7!'7-3+7'3n z&'(+'0/'0'''('',7*/3/&'(''+&)',)('&1()&+'=&.'(''/( !'&07*)(.'7p! ! !- $' z& !3%|'E&!+&' 1& ! &!+&' v&!+&' f&!+&' 1& ! &!+&' A&!| ;&!+&' | O&' )'53K,) C&77/ | t&9 <|-j&'3E&PW& !/0) | `&)3)+3&1 =&!+&)'9 G&)''35 G&''; =&!)&!''; | 1&''01'3(.'(9')3*)3 !5&.' 7*/ 7,/ /3<+3)' !< 7*/ j&*| 1&3 v& !'&- | U&7 b&!)'+('')(+ '(./()'+ N) '37*`&' -&9 | &+ E(1&'(/ 7*8) h7Q&'''(.' '3| 3& !('01' ! ' !(''(3'/(7'' .7*/ 7*/ 13*/3' ?'2| K +'0| '& !'(-' !('-(.'(1&+ 7*13775'57) ''0`&0+''(''0)''&7*| & !'('')( !'()''(3 +3l&3(3''('') -37*) )&7*`&/%'3| I 333 )'F='01'+&.+&'(.'&!''/ | #| G%=#*h#n%| 5'/ +' l!#$5# Q!#$5#3!/#' /!' 3#3!3#3!/#' /!' 3# % !3#3!?#' 3#3$3#3$3#3$-#!'#+! !$6&)6)#!'#+!()6+#' '#+!!)63#-!)6' )#!'#+!('6!98-</.'3 !12>'1 !2/B33 !9:-<P53 !12+3'-)3 !4/@93 !43:73P-<!7< !,%' /,)4 !/0*7,)4 !/0!=%) `5G ='+).));'A '7$+7$'7&)!'#)! !#7$'7H-!/7 $!7+! !7#+!&+&&'7'#'!-4$+# !74'7 !#7C,j+ !!#++8/ -4-7'4+7H'7H'7H17Hb7'4'7 !47Hb7|%z437 #/0K7'417 !/0| l7H`7U4t7/4U7- r7U 97M | A,| f7O,|$)7H57H| 5734|!M7H|%Q7 (/0`,| 7-4 !/0b4 &/0C4|%b7|!v4 ,/0| G4 #/0d4 !/0|%f4| )7M4'7/4r7' d7' h7) ;7!37| % | '!!| '# ! !&)!'# $!#+! !#!'#$/#'%)! R#!'#/7 #!#)' !!#- +38'3p# ! #- &' | 9&1 !%3? .Q&5 1&!1&!1&!1&!1&!1&!1&!1&!d''3 #12)3 !12 !31D53<'3 !.3 !12'3 !12 %/0-3*73'.+3 !.3>| C W7!|! 7; |$h7W ;7+ P)3 !7% !&+ &/0'7 %/0 !./'0N5++''(<-%'7)+ !%&F'7!| v&' '''6'% !&.|!#&F)%,- v&) |!+&!'7+,77Y&- l7; C&b7!7,`73,NA,d77,r7A,| G7!|%b7} X;&7 | I7}%/C&| / M&*|9G&) | 775 t&/%'3|%z&*)3C&7*'&K 8!# !&'))F7' !3% /!#'% ! '| U&7+''/33 Q65%'6 '!#$)# @!#*3# #!#'! %#! !#%'6 #!# ! ! !#!)# +!#+!' '!| S ,'%&1&.)&.+&.Q&'(''0+7+ /,'7 !57/ | 1&+33 '(| -&C(.5 '37*/ G'/&)3,+ 7*[&3''3Q&9''(9 F^&) )'0| '&.'(+''(.+(=3 ! %7*+ '3-& !'%5&7*-&!v&/''('''(''5 )&.3& !'(' 7*' +3C&*/&)7 !&( !'(| -& !'&)''&''-&'' !&',S '&*'39&0'''('3,'% !('7 /&' /&' /&5 1&!1&!z#L+%+ '#|!# j&'(.'(.'( !3(.' 7*/ }!e;&; Q&+ | +&+ |MQ=} T7 |(/&' |!C&p 1#; -#- !&'7&H=&!-& ! &!'&!'&!|!G&C6E |()& !0/C | I&' | 5&t ;& !57' C'13 !/0F/ ?'' F'.'- )/0'3 !/0+3)-)3!+3 !./ #0/@)3 !4.)4 ! 3J'3+ -&!|##&' !< )3J)3 !/0 !34 !3.'37*'3)4'3W! !/3 !06 !-6W# !/4 !04 !/0 !3/@'37&*| #&'%b&) /&' /&' /&' )&) '5 !46N'5 ! 7+4'77 )<'7' ;&!W&!I&!'&!A&' ?&h |!f&- )3+ | #,) 57| 3++,E7',N) ;7+ N| ' | #7.|!t ^&) | +&A .Y,+ d&+,; E&63&6- p&-'- `& ! 3l&+ 3&F-+x t!t#| f&' 7*| v t&3 | 1&9 F|#5 |&v&5 O&7 3&|#E /&' !& | &!'&) ,' Q& ! 33,Q&'71,b&3 5,| j O&/,) FW&- F| I | 9&/ '&| I ,)'!''- +'+&!)&!Y&+ )'+ .3,3 531 ^&',F^&),d 3&N[&''+ -,135 | 5&) 13O&' 3,I&- 3,G&1 +3; 1,| j | [&|+t b,|(U !('0| 3&A'13+ K,7*A )'0| #&)(+''('''3X+3? U&1 7*/ )'l&-'03'!7*+3; j&.'3,5 ''0| )&)(5''(+&+3+ F' 7*,/ K,9 G&!U&)()''( !'(''/3|!S | '&.)(3'- 7*1 .'(!3&' '&' O&!1&!'&!-&' !'&'(.+(' '(' )(5 0- -&'(' 1') -'|%x | )&)(/' !('+(''0'''& !3&3 7*|#b | '&)(+'' +(''0''53| 5 | )&)(3''( !'('')3,9 7*p z& !'(.'(/' !('3 7*|*K d!d#7*5,; ,|)z | ;&|<Y |4M&|!= |!M+!-3|b` |7l&}#8j |,^&1 b&!7*+ '3|!/ `&' -'F7 | )&1'-3+7+% !377 7*!1,!M&- I&|3U | S&9 ,| %(C +'=%}$&7 '&|e7 |!E&- =&) 5&1 7&' N''F+<} 4/ |%M77 r7' | A7'()')7/(3<3''71'`7+'| )7h | M7)'N|$/ | x75 G,|#1 W!W#W!1#!G#W!W# !! '!' $' '!' +!!3!+# ! #!1#!9#W!W#'!!+!' 3!!1!!W#'!!+!!-! ! !) 1!!W#W!W#W!W#W!W#W!W#W!W#W![#' U!HU#H/#U!HU#H/#U!HU#H/#U!HU#H/#U!HU#H/# !!#' | -*} % |$E&' 5,1'|=C +&!Y&!'& ! &' !& 7&!+& # &/ ,+ $& )&!'& ! &' && '& ! &' +&!1&!+&!+& ! &!7&!E&- )&!-&!E&| 1 '4|&# | 7+ |!77; A7' A7!A7!n77 =,) b7!| A7+ z7| ` ^7= z7- 571 '7|#r | #7) | f7' | h7- l73 |%`7!| `7- x7!v7!|#Q7' |#+7C =7) +7; |!W7; | t7z ;7+ | 973 77/ t73 `7|I^ }*Q/&v } !5&9 |$x&}$#I |,'&|AO X` |!/<|!p |%A'}PF' "; | |
// encode a string constant | |
function h$str(s) { | |
var enc = null; | |
return function() { | |
if(enc === null) { | |
enc = h$encodeUtf8(s); | |
} | |
return enc; | |
} | |
} | |
// encode a raw string from bytes | |
function h$rstr(d) { | |
var enc = null; | |
return function() { | |
if(enc === null) { | |
enc = h$rawStringData(d); | |
} | |
return enc; | |
} | |
} | |
// these aren't added to the CAFs, so the list stays in mem indefinitely, is that a problem? | |
function h$strt(str) { return h$c1(h$lazy_e, function() { return h$toHsString(str); }); } | |
function h$strta(str) { return h$c1(h$lazy_e, function() { return h$toHsStringA(str); }); } | |
function h$strtb(arr) { return h$c1(h$lazy_e, function() { return h$toHsStringMU8(arr); }); } | |
// unpack strings without thunks | |
function h$ustra(str) { return h$toHsStringA(str); } | |
function h$ustr(str) { return h$toHsString(str); } | |
function h$urstra(arr) { return h$toHsList(arr); } | |
function h$urstr(arr) { return h$toHsStringMU8(arr); } | |
function h$caseMapping(x) { | |
return (x%2)?-((x+1)>>1):(x>>1); | |
} | |
var h$toUpper = null; | |
function h$u_towupper(ch) { | |
if(h$toUpper == null) { h$toUpper = h$decodeMapping(h$toUpperMapping, h$caseMapping); } | |
return ch+(h$toUpper[ch]|0); | |
} | |
var h$toLower = null; | |
function h$u_towlower(ch) { | |
if(h$toLower == null) { h$toLower = h$decodeMapping(h$toLowerMapping, h$caseMapping); } | |
return ch+(h$toLower[ch]|0); | |
} | |
var h$alpha = null; | |
function h$u_iswalpha(a) { | |
if(h$alpha == null) { h$alpha = h$decodeRLE(h$alphaRanges); } | |
return h$alpha[a]|0; | |
} | |
var h$alnum = null; | |
function h$u_iswalnum(a) { | |
if(h$alnum == null) { h$alnum = h$decodeRLE(h$alnumRanges); } | |
return h$alnum[a] == 1 ? 1 : 0; | |
} | |
function h$u_iswspace(a) { | |
return '\t\n\v\f\r \u0020\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000' | |
.indexOf(String.fromCharCode(a)) !== -1 ? 1 : 0; | |
} | |
var h$lower = null; | |
function h$u_iswlower(a) { | |
if(h$lower == null) { h$lower = h$decodeRLE(h$lowerRanges); } | |
if(a < 0x30000) return h$lower[a]|0; | |
if(a < 0xE0000) return 0; | |
return h$lower[a-0xB0000]|0; | |
} | |
var h$upper = null; | |
function h$u_iswupper(a) { | |
if(h$upper == null) { h$upper = h$decodeRLE(h$upperRanges); } | |
if(a < 0x30000) return h$upper[a]|0; | |
if(a < 0xE0000) return 0; | |
return h$upper[a-0xB0000]|0; | |
} | |
var h$cntrlChars = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159]; | |
var h$cntrl = null; | |
function h$u_iswcntrl(a) { | |
if(h$cntrl === null) { | |
h$cntrl = []; | |
for(var i=0;i<=159;i++) h$cntrl[i] = (h$cntrlChars.indexOf(i) !== -1) ? 1 : 0; | |
} | |
return a <= 159 ? h$cntrl[a] : 0; | |
} | |
var h$print = null; | |
function h$u_iswprint(a) { | |
if(h$print == null) { h$print = h$decodeRLE(h$printRanges); } | |
if(a < 0x30000) return h$print[a]|0; | |
if(a < 0xE0000) return 0; | |
return h$print[a-0xB0000]|0; | |
} | |
// decode a packed string (Compactor encoding method) to an array of numbers | |
function h$decodePacked(s) { | |
function f(o) { | |
var c = s.charCodeAt(o); | |
return c<34?c-32:c<92?c-33:c-34; | |
} | |
var r=[], i=0; | |
while(i < s.length) { | |
var c = s.charCodeAt(i); | |
if(c < 124) r.push(f(i++)); | |
else if(c === 124) { | |
i += 3; r.push(90+90*f(i-2)+f(i-1)); | |
} else if(c === 125) { | |
i += 4; | |
r.push(8190+8100*f(i-3)+90*f(i-2)+f(i-1)); | |
} else throw ("h$decodePacked: invalid: " + c); | |
} | |
return r; | |
} | |
// decode string with encoded character ranges | |
function h$decodeRLE(str) { | |
var r = [], x = 0, i = 0, j = 0, v, k, a = h$decodePacked(str); | |
while(i < a.length) { | |
v = a[i++]; | |
if(v === 0) { // alternating | |
k = a[i++]; | |
while(k--) { | |
r[j++] = x; | |
r[j++] = 1-x; | |
} | |
} else { | |
if(v <= 2) { | |
k = (a[i]<<16)+a[i+1]; | |
i+=2; | |
} else k = (v-1)>>1; | |
if(v%2) { | |
r[j++] = x; | |
x = 1-x; | |
} | |
while(k--) r[j++] = x; | |
x = 1-x; | |
} | |
} | |
r.shift(); | |
return r; | |
} | |
function h$decodeMapping(str, f) { | |
var r = [], i = 0, j = 0, k, v, v2, a = h$decodePacked(str); | |
while(i < a.length) { | |
v = a[i++]; | |
if(v === 0) { // alternating | |
k = a[i]; | |
v = f(a[i+1]); | |
v2 = f(a[i+2]); | |
while(k--) { | |
r[j++] = v; | |
r[j++] = v2; | |
} | |
i+=3; | |
} else { | |
if(v === 2) { | |
k = (a[i] << 16) + a[i+1]; | |
v = a[i+2]; | |
i += 3; | |
} else if(v%2) { | |
k = 1; | |
v = v>>1; | |
} else { | |
k = (v>>1)-1; | |
v = a[i++]; | |
} | |
v = f(v); | |
while(k--) r[j++] = v; | |
} | |
} | |
return r; | |
} | |
var h$unicodeCat = null; | |
function h$u_gencat(a) { | |
if(h$unicodeCat == null) h$unicodeCat = h$decodeMapping(h$catMapping, function(x) { return x; }); | |
// private use | |
if(a >= 0xE000 && a <= 0xF8FF || a >= 0xF0000 & a <= 0xFFFFD || a >= 0x100000 && a <= 0x10FFFD) return 28; | |
var c = a < 0x30000 ? (h$unicodeCat[a]|0) : | |
(a < 0xE0000 ? 0 : (h$unicodeCat[a-0xB0000]|0)); | |
return c?c-1:29; | |
} | |
function h$localeEncoding() { | |
// h$log("### localeEncoding"); | |
h$ret1 = 0; // offset 0 | |
return h$encodeUtf8("UTF-8"); | |
} | |
function h$rawStringData(str) { | |
var v = h$newByteArray(str.length+1); | |
var u8 = v.u8; | |
for(var i=0;i<str.length;i++) { | |
u8[i] = str[i]; | |
} | |
u8[str.length] = 0; | |
return v; | |
} | |
// encode a javascript string to a zero terminated utf8 byte array | |
function h$encodeUtf8(str) { | |
var i, low; | |
var n = 0; | |
for(i=0;i<str.length;i++) { | |
// non-BMP encoded as surrogate pair in JavaScript string, get actual codepoint | |
var c = str.charCodeAt(i); | |
if (0xD800 <= c && c <= 0xDBFF) { | |
low = str.charCodeAt(i+1); | |
c = ((c - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; | |
i++; | |
} | |
if(c <= 0x7F) { | |
n++; | |
} else if(c <= 0x7FF) { | |
n+=2; | |
} else if(c <= 0xFFFF) { | |
n+=3; | |
} else if(c <= 0x1FFFFF) { | |
n+=4; | |
} else if(c <= 0x3FFFFFF) { | |
n+=5; | |
} else { | |
n+=6; | |
} | |
} | |
var v = h$newByteArray(n+1); | |
var u8 = v.u8; | |
n = 0; | |
for(i=0;i<str.length;i++) { | |
var c = str.charCodeAt(i); | |
// non-BMP encoded as surrogate pair in JavaScript string, get actual codepoint | |
if (0xD800 <= c && c <= 0xDBFF) { | |
low = str.charCodeAt(i+1); | |
c = ((c - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; | |
i++; | |
} | |
// h$log("### encoding char " + c + " to UTF-8: " + String.fromCodePoint(c)); | |
if(c <= 0x7F) { | |
u8[n] = c; | |
n++; | |
} else if(c <= 0x7FF) { | |
u8[n] = (c >> 6) | 0xC0; | |
u8[n+1] = (c & 0x3F) | 0x80; | |
n+=2; | |
} else if(c <= 0xFFFF) { | |
u8[n] = (c >> 12) | 0xE0; | |
u8[n+1] = ((c >> 6) & 0x3F) | 0x80; | |
u8[n+2] = (c & 0x3F) | 0x80; | |
n+=3; | |
} else if(c <= 0x1FFFFF) { | |
u8[n] = (c >> 18) | 0xF0; | |
u8[n+1] = ((c >> 12) & 0x3F) | 0x80; | |
u8[n+2] = ((c >> 6) & 0x3F) | 0x80; | |
u8[n+3] = (c & 0x3F) | 0x80; | |
n+=4; | |
} else if(c <= 0x3FFFFFF) { | |
u8[n] = (c >> 24) | 0xF8; | |
u8[n+1] = ((c >> 18) & 0x3F) | 0x80; | |
u8[n+2] = ((c >> 12) & 0x3F) | 0x80; | |
u8[n+3] = ((c >> 6) & 0x3F) | 0x80; | |
u8[n+4] = (c & 0x3F) | 0x80; | |
n+=5; | |
} else { | |
u8[n] = (c >>> 30) | 0xFC; | |
u8[n+1] = ((c >> 24) & 0x3F) | 0x80; | |
u8[n+2] = ((c >> 18) & 0x3F) | 0x80; | |
u8[n+3] = ((c >> 12) & 0x3F) | 0x80; | |
u8[n+4] = ((c >> 6) & 0x3F) | 0x80; | |
u8[n+5] = (c & 0x3F) | 0x80; | |
n+=6; | |
} | |
} | |
u8[v.len-1] = 0; // terminator | |
// h$log("### encodeUtf8: " + str); | |
// h$log(v); | |
return v; | |
} | |
// encode a javascript string to a zero terminated utf16 byte array | |
function h$encodeUtf16(str) { | |
var n = 0; | |
var i; | |
for(i=0;i<str.length;i++) { | |
var c = str.charCodeAt(i); | |
if(c <= 0xFFFF) { | |
n += 2; | |
} else { | |
n += 4; | |
} | |
} | |
var v = h$newByteArray(n+1); | |
var dv = v.dv; | |
n = 0; | |
for(i=0;i<str.length;i++) { | |
var c = str.charCodeAt(i); | |
if(c <= 0xFFFF) { | |
dv.setUint16(n, c, true); | |
n+=2; | |
} else { | |
var c0 = c - 0x10000; | |
dv.setUint16(n, c0 >> 10, true); | |
dv.setUint16(n+2, c0 & 0x3FF, true); | |
n+=4; | |
} | |
} | |
dv.setUint8(v.len-1,0); // terminator | |
return v; | |
} | |
// convert a string to a buffer, set second field in | |
// Addr# to length | |
function h$fromStr(s) { | |
var l = s.length; | |
var b = h$newByteArray(l * 2); | |
var dv = b.dv; | |
for(var i=l-1;i>=0;i--) { | |
dv.setUint16(i<<1, s.charCodeAt(i), true); | |
} | |
h$ret1 = l; | |
return b; | |
} | |
// convert a Data.Text buffer with offset/length to a | |
// JS string | |
function h$toStr(b,o,l) { | |
var a = []; | |
var end = 2*(o+l); | |
var k = 0; | |
var dv = b.dv; | |
var s = ''; | |
for(var i=2*o;i<end;i+=2) { | |
var cc = dv.getUint16(i,true); | |
a[k++] = cc; | |
if(k === 60000) { | |
s += String.fromCharCode.apply(this, a); | |
k = 0; | |
a = []; | |
} | |
} | |
return s + String.fromCharCode.apply(this, a); | |
} | |
/* | |
function h$encodeUtf16(str) { | |
var b = new DataView(new ArrayBuffer(str.length * 2)); | |
for(var i=str.length-1;i>=0;i--) { | |
b.setUint16(i<<1, str.charCodeAt(i)); | |
} | |
h$ret1 = 0; | |
return b; | |
} | |
var h$eU16 = h$encodeUtf16; | |
function h$decodeUtf16(v,start) { | |
return h$decodeUtf16(v, v.byteLength - start, start); | |
} | |
function h$decodeUtf16z(v,start) { | |
var len = v.byteLength - start; | |
for(var i=start;i<l;i+=2) { | |
if(v.getUint16(i) === 0) { | |
len = i; | |
break; | |
} | |
} | |
return h$decodeUtf16l(v,l,start) | |
} | |
*/ | |
function h$decodeUtf16l(v, byteLen, start) { | |
// perhaps we can apply it with an Uint16Array view, but that might give us endianness problems | |
var a = []; | |
for(var i=0;i<byteLen;i+=2) { | |
a[i>>1] = v.dv.getUint16(i+start,true); | |
} | |
return String.fromCharCode.apply(this, a); | |
} | |
var h$dU16 = h$decodeUtf16; | |
// decode a buffer with UTF-8 chars to a JS string | |
// stop at the first zero | |
function h$decodeUtf8z(v,start) { | |
// h$log("h$decodeUtf8z"); | |
var n = start; | |
var max = v.len; | |
while(n < max) { | |
// h$log("### " + n + " got char: " + v.u8[n]); | |
if(v.u8[n] === 0) { break; } | |
n++; | |
} | |
return h$decodeUtf8(v,n,start); | |
} | |
// decode a buffer with Utf8 chars to a JS string | |
// invalid characters are ignored | |
function h$decodeUtf8(v,n0,start) { | |
// h$log("### decodeUtf8"); | |
// h$log(v); | |
var n = n0 || v.len; | |
var arr = []; | |
var i = start || 0; | |
var code; | |
var u8 = v.u8; | |
// h$log("### decoding, starting at: " + i); | |
while(i < n) { | |
var c = u8[i]; | |
while((c & 0xC0) === 0x80) { | |
c = u8[++i]; | |
} | |
// h$log("### lead char: " + c); | |
if((c & 0x80) === 0) { | |
code = (c & 0x7F); | |
i++; | |
} else if((c & 0xE0) === 0xC0) { | |
code = ( ((c & 0x1F) << 6) | |
| (u8[i+1] & 0x3F) | |
); | |
i+=2; | |
} else if((c & 0xF0) === 0xE0) { | |
code = ( ((c & 0x0F) << 12) | |
| ((u8[i+1] & 0x3F) << 6) | |
| (u8[i+2] & 0x3F) | |
); | |
i+=3; | |
} else if ((c & 0xF8) === 0xF0) { | |
code = ( ((c & 0x07) << 18) | |
| ((u8[i+1] & 0x3F) << 12) | |
| ((u8[i+2] & 0x3F) << 6) | |
| (u8[i+3] & 0x3F) | |
); | |
i+=4; | |
} else if((c & 0xFC) === 0xF8) { | |
code = ( ((c & 0x03) << 24) | |
| ((u8[i+1] & 0x3F) << 18) | |
| ((u8[i+2] & 0x3F) << 12) | |
| ((u8[i+3] & 0x3F) << 6) | |
| (u8[i+4] & 0x3F) | |
); | |
i+=5; | |
} else { | |
code = ( ((c & 0x01) << 30) | |
| ((u8[i+1] & 0x3F) << 24) | |
| ((u8[i+2] & 0x3F) << 18) | |
| ((u8[i+3] & 0x3F) << 12) | |
| ((u8[i+4] & 0x3F) << 6) | |
| (u8[i+5] & 0x3F) | |
); | |
i+=6; | |
} | |
// h$log("### decoded codePoint: " + code + " - " + String.fromCharCode(code)); // String.fromCodePoint(code)); | |
// need to deal with surrogate pairs | |
if(code > 0xFFFF) { | |
var offset = code - 0x10000; | |
arr.push(0xD800 + (offset >> 10), 0xDC00 + (offset & 0x3FF)); | |
} else { | |
arr.push(code); | |
} | |
} | |
return String.fromCharCode.apply(this, arr); | |
} | |
// fixme what if terminator, then we read past end | |
function h$decodeUtf16(v) { | |
var n = v.len; | |
var arr = []; | |
var dv = v.dv; | |
for(var i=0;i<n;i+=2) { | |
arr.push(dv.getUint16(i,true)); | |
} | |
return String.fromCharCode.apply(this, arr); | |
} | |
function h$hs_iconv_open(to,to_off,from,from_off) { | |
h$errno = h$EINVAL; // no encodings supported | |
return -1; | |
// var fromStr = decodeUtf8(from, from_off); | |
// var toStr = decodeUtf8(to, to_off); | |
// h$log("#### hs_iconv_open: " + fromStr + " -> " + toStr); | |
// return 1; // fixme? | |
} | |
function h$hs_iconv_close(iconv) { | |
return 0; | |
} | |
// ptr* -> ptr (array) | |
function h$derefPtrA(ptr, ptr_off) { | |
return ptr.arr[ptr_off][0]; | |
} | |
// ptr* -> ptr (offset) | |
function h$derefPtrO(ptr, ptr_off) { | |
return ptr.arr[ptr_off][1]; | |
} | |
// word** -> word ptr[x][y] | |
function h$readPtrPtrU32(ptr, ptr_off, x, y) { | |
x = x || 0; | |
y = y || 0; | |
var arr = ptr.arr[ptr_off + 4 * x]; | |
return arr[0].dv.getInt32(arr[1] + 4 * y, true); | |
} | |
// char** -> char ptr[x][y] | |
function h$readPtrPtrU8(ptr, ptr_off, x, y) { | |
x = x || 0; | |
y = y || 0; | |
var arr = ptr.arr[ptr_off + 4 * x]; | |
return arr[0].dv.getUint8(arr[1] + y); | |
} | |
// word** ptr[x][y] = v | |
function h$writePtrPtrU32(ptr, ptr_off, v, x, y) { | |
x = x || 0; | |
y = y || 0; | |
var arr = ptr.arr[ptr_off + 4 * x]; | |
arr[0].dv.putInt32(arr[1] + y, v); | |
} | |
// unsigned char** ptr[x][y] = v | |
function h$writePtrPtrU8(ptr, ptr_off, v, x, y) { | |
x = x || 0; | |
y = y || 0; | |
var arr = ptr.arr[ptr_off+ 4 * x]; | |
arr[0].dv.putUint8(arr[1] + y, v); | |
} | |
// convert JavaScript String to a Haskell String | |
function h$toHsString(str) { | |
if(typeof str !== 'string') return h$ghczmprimZCGHCziTypesziZMZN; | |
var i = str.length - 1; | |
var r = h$ghczmprimZCGHCziTypesziZMZN; | |
while(i>=0) { | |
var cp = str.charCodeAt(i); | |
if(cp >= 0xDC00 && cp <= 0xDFFF && i > 0) { | |
--i; | |
cp = (cp - 0xDC00) + (str.charCodeAt(i) - 0xD800) * 1024 + 0x10000; | |
} | |
r = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, cp, r); | |
--i; | |
} | |
return r; | |
} | |
// string must have been completely forced first | |
function h$fromHsString(str) { | |
var xs = ''; | |
while(str.f.a === 2) { | |
if(typeof str.d1 === 'number') { | |
xs += String.fromCharCode(str.d1); | |
} else { | |
xs += String.fromCharCode(str.d1.d1); // unbox_e | |
} | |
str = str.d2; | |
} | |
return xs; | |
} | |
// list of JSRef to array, list must have been completely forced first | |
function h$fromHsListJSRef(xs) { | |
var arr = []; | |
while(xs.f.a === 2) { | |
arr.push(xs.d1.d1); | |
xs = xs.d2; | |
} | |
return arr; | |
} | |
// ascii only version of the above | |
function h$toHsStringA(str) { | |
if(typeof str !== 'string') return h$ghczmprimZCGHCziTypesziZMZN; | |
var i = str.length - 1; | |
var r = h$ghczmprimZCGHCziTypesziZMZN; | |
while(i>=0) { | |
r = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, str.charCodeAt(i), r); | |
--i; | |
} | |
return r; | |
} | |
// convert array with modified UTF-8 encoded text | |
function h$toHsStringMU8(arr) { | |
var accept = false, b, n = 0, cp = 0, r = h$ghczmprimZCGHCziTypesziZMZN, i = arr.length - 1; | |
while(i >= 0) { | |
b = arr[i]; | |
if(!(b & 128)) { | |
cp = b; | |
accept = true; | |
} else if((b & 192) === 128) { | |
cp += (b & 32) * Math.pow(64, n) | |
} else { | |
cp += (b&((1<<(6-n))-1)) * Math.pow(64, n); | |
accept = true; | |
} | |
if(accept) { | |
r = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, cp, r); | |
cp = 0 | |
n = 0; | |
} else { | |
n++; | |
} | |
accept = false; | |
i--; | |
} | |
return r; | |
} | |
function h$toHsList(arr) { | |
var r = h$ghczmprimZCGHCziTypesziZMZN; | |
for(var i=arr.length-1;i>=0;i--) { | |
r = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, arr[i], r); | |
} | |
return r; | |
} | |
// array of JS values to Haskell list of JSRef | |
function h$toHsListJSRef(arr) { | |
var r = h$ghczmprimZCGHCziTypesziZMZN; | |
for(var i=arr.length-1;i>=0;i--) { | |
r = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$mkJSRef(arr[i]), r); | |
} | |
return r; | |
} | |
// unpack ascii string, append to existing Haskell string | |
function h$appendToHsStringA(str, appendTo) { | |
var i = str.length - 1; | |
var r = appendTo; | |
while(i>=0) { | |
r = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, str.charCodeAt(i), r); | |
--i; | |
} | |
return r; | |
} | |
// throw e wrapped in a GHCJS.Prim.JSException in the current thread | |
function h$throwJSException(e) { | |
// a GHCJS.Prim.JSException | |
var jsE = h$c2(h$ghcjszmprimZCGHCJSziPrimziJSException_con_e,e,h$toHsString(e.toString())); | |
// wrap it in a SomeException, adding the Exception dictionary | |
var someE = h$c2(h$baseZCGHCziExceptionziSomeException_con_e, | |
h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSException, jsE); | |
return h$throw(someE, true); | |
} | |
/* | |
Integer and integer-gmp support | |
partial GMP emulation | |
note: sign behaves different from real gmp sign, | |
value is always zero, don't use it for comparisons | |
*/ | |
var h$bigZero = h$nbv(0); | |
var h$bigOne = h$nbv(1); | |
var h$bigCache = []; | |
(function() { | |
for(var i=0;i<=100;i++) { | |
h$bigCache.push(h$nbv(i)); | |
} | |
})(); | |
// convert a value to a BigInt | |
function h$bigFromInt(v) { | |
; | |
var v0 = v|0; | |
if(v0 >= 0) { | |
if(v0 <= 100) { | |
return h$bigCache[v0]; | |
} else if(v0 < 268435456) { // 67108864) { // guaranteed to fit in one digit | |
return h$nbv(v0); | |
} | |
var r1 = h$nbv(v0 >>> 16); | |
var r2 = h$nbi(); | |
r1.lShiftTo(16,r2); | |
r1.fromInt(v0 & 0xffff); | |
var r3 = r1.or(r2); | |
; | |
return r3; | |
} else { | |
v0 = -v0; | |
if(v0 < 268435456) { // 67108864) { | |
return h$nbv(v0).negate(); | |
} | |
var r1 = h$nbv(v0 >>> 16); | |
var r2 = h$nbi(); | |
r1.lShiftTo(16,r2); | |
r1.fromInt(v0 & 0xffff); | |
var r3 = r1.or(r2); | |
BigInteger.ZERO.subTo(r3,r2); | |
; | |
return r2; | |
} | |
} | |
function h$bigFromWord(v) { | |
var v0 = v|0; | |
if(v0 >= 0) { | |
if(v0 <= 100) { | |
return h$bigCache[v0]; | |
} else if(v0 < 268435456) { // 67108864) { // guaranteed to fit in one digit | |
return h$nbv(v0); | |
} | |
} | |
var r1 = h$nbv(v0 >>> 16); | |
var r2 = h$nbv(0); | |
r1.lShiftTo(16,r2); | |
r1.fromInt(v0 & 0xffff); | |
return r1.or(r2); | |
} | |
function h$bigFromInt64(v1,v2) { | |
; | |
var v10 = v1|0; | |
var v20 = v2|0; | |
var r = new BigInteger([ v10 >> 24, (v10 & 0xff0000) >> 16, (v10 & 0xff00) >> 8, v10 & 0xff | |
, v20 >>> 24, (v20 & 0xff0000) >> 16, (v20 & 0xff00) >> 8, v20 & 0xff | |
]); | |
; | |
return r; | |
} | |
function h$bigFromWord64(v1,v2) { | |
; | |
var v10 = v1|0; | |
var v20 = v2|0; | |
var arr = [ 0, v10 >>> 24, (v10 & 0xff0000) >> 16, (v10 & 0xff00) >> 8, v10 & 0xff | |
, v20 >>> 24, (v20 & 0xff0000) >> 16, (v20 & 0xff00) >> 8, v20 & 0xff | |
]; | |
; | |
var r = new BigInteger([ 0, v10 >>> 24, (v10 & 0xff0000) >> 16, (v10 & 0xff00) >> 8, v10 & 0xff | |
, v20 >>> 24, (v20 & 0xff0000) >> 16, (v20 & 0xff00) >> 8, v20 & 0xff | |
]); | |
; | |
return r; | |
} | |
function h$bigFromNumber(n) { | |
var ra = []; | |
var s = 0; | |
if(n < 0) { | |
n = -n; | |
s = -1; | |
} | |
var b = 1; | |
while(n >= b) { | |
ra.unshift((n/b)&0xff); | |
b *= 256; | |
} | |
ra.unshift(s); | |
return new BigInteger(ra); | |
} | |
function h$encodeNumber(big,e) { | |
var m = Math.pow(2,e); | |
if(m === Infinity) { | |
switch(big.signum()) { | |
case 1: return Infinity; | |
case 0: return 0; | |
default: return -Infinity; | |
} | |
} | |
var b = big.toByteArray(); | |
var l = b.length; | |
var r = 0; | |
; | |
for(var i=l-1;i>=1;i--) { | |
; | |
r += m * Math.pow(2,(l-i-1)*8) * (b[i] & 0xff); | |
; | |
} | |
// last one signed | |
if(b[0] != 0) { | |
r += m * Math.pow(2,(l-1)*8) * b[0]; | |
} | |
; | |
return r; | |
} | |
function h$integer_cmm_cmpIntegerzh(sa, abits, sb, bbits) { | |
; | |
var c = abits.compareTo(bbits); | |
return c == 0 ? 0 : c > 0 ? 1 : -1; | |
} | |
function h$integer_cmm_cmpIntegerIntzh(sa, abits, b) { | |
; | |
var c = abits.compareTo(h$bigFromInt(b)); | |
return c == 0 ? 0 : c > 0 ? 1 : -1; | |
} | |
function h$integer_cmm_plusIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.add(bbits); | |
} | |
function h$integer_cmm_plusIntegerIntzh(sa, abits, b) { | |
; | |
return abits.add(h$bigFromInt(b)); | |
} | |
function h$integer_cmm_minusIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.subtract(bbits); | |
} | |
function h$integer_cmm_minusIntegerIntzh(sa, abits, b) { | |
; | |
return abits.subtract(h$bigFromInt(b)); | |
} | |
function h$integer_cmm_timesIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.multiply(bbits); | |
} | |
function h$integer_cmm_timesIntegerIntzh(sa, abits, b) { | |
; | |
return abits.multiply(h$bigFromInt(b)); | |
} | |
// fixme make more efficient, divideRemainder | |
function h$integer_cmm_quotRemIntegerzh(sa, abits, sb, bbits) { | |
; | |
var q = abits.divide(bbits); | |
; | |
var r = abits.subtract(q.multiply(bbits)); | |
; | |
h$ret1 = r; | |
return q; | |
} | |
function h$integer_cmm_quotRemIntegerWordzh(sa, abits, b) { | |
var bbits = h$bigFromWord(b); | |
; | |
var q = abits.divide(bbits); | |
h$ret1 = abits.subtract(q.multiply(bbits)); | |
return q; | |
} | |
function h$integer_cmm_quotIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.divide(bbits); | |
} | |
function h$integer_cmm_quotIntegerWordzh(sa, abits, b) { | |
; | |
return abits.divide(h$bigFromWord(b)); | |
} | |
function h$integer_cmm_remIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.subtract(bbits.multiply(abits.divide(bbits))); | |
} | |
function h$integer_cmm_remIntegerWordzh(sa, abits, b) { | |
; | |
var bbits = h$bigFromWord(b); | |
return abits.subtract(bbits.multiply(abits.divide(bbits))); | |
} | |
function h$integer_cmm_divModIntegerzh(sa, abits, sb, bbits) { | |
; | |
var d = abits.divide(bbits); | |
var m = abits.subtract(d.multiply(bbits)); | |
if(abits.signum()!==bbits.signum() && m.signum() !== 0) { | |
d = d.subtract(h$bigOne); | |
m.addTo(bbits, m); | |
} | |
h$ret1 = m; | |
return d; | |
} | |
function h$integer_cmm_divModIntegerWordzh(sa, abits, b) { | |
; | |
return h$integer_cmm_divModIntegerzh(sa, abits, 0, h$bigFromWord(b)); | |
} | |
function h$integer_cmm_divIntegerzh(sa, abits, sb, bbits) { | |
; | |
var d = abits.divide(bbits); | |
var m = abits.subtract(d.multiply(bbits)); | |
if(abits.signum()!==bbits.signum() && m.signum() !== 0) { | |
d = d.subtract(h$bigOne); | |
} | |
return d; | |
} | |
function h$integer_cmm_divIntegerWordzh(sa, abits, b) { | |
; | |
return h$integer_cmm_divIntegerzh(sa, abits, 0, h$bigFromWord(b)); | |
} | |
function h$integer_cmm_modIntegerzh(sa, abits, sb, bbits) { | |
; | |
var d = abits.divide(bbits); | |
var m = abits.subtract(d.multiply(bbits)); | |
if(abits.signum()!==bbits.signum() && m.signum() !== 0) { | |
m.addTo(bbits, m); | |
} | |
return m; | |
} | |
function h$integer_cmm_modIntegerWordzh(sa, abits, b) { | |
; | |
return h$integer_cmm_modIntegerzh(sa, abits, 0, h$bigFromWord(b)); | |
} | |
function h$integer_cmm_divExactIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.divide(bbits); | |
} | |
function h$integer_cmm_divExactIntegerWordzh(sa, abits, b) { | |
; | |
return abits.divide(h$bigFromWord(b)); | |
} | |
function h$gcd(a, b) { | |
var x = a.abs(); | |
var y = b.abs(); | |
var big, small; | |
if(x.compareTo(y) < 0) { | |
small = x; | |
big = y; | |
} else { | |
small = y; | |
big = x; | |
} | |
while(small.signum() !== 0) { | |
var q = big.divide(small); | |
var r = big.subtract(q.multiply(small)); | |
big = small; | |
small = r; | |
} | |
return big; | |
} | |
function h$integer_cmm_gcdIntegerzh(sa, abits, sb, bbits) { | |
; | |
return h$gcd(abits, bbits); | |
} | |
function h$integer_cmm_gcdIntegerIntzh(sa, abits, b) { | |
; | |
var r = h$gcd(abits, h$bigFromInt(b)); | |
return r.intValue(); | |
} | |
function h$integer_cmm_gcdIntzh(a, b) { | |
var x = a<0 ? -a : a; | |
var y = b<0 ? -b : b; | |
var big, small; | |
if(x<y) { | |
small = x; | |
big = y; | |
} else { | |
small = y; | |
big = x; | |
} | |
while(small!==0) { | |
var r = big % small; | |
big = small; | |
small = r; | |
} | |
return big; | |
} | |
function h$integer_cmm_powIntegerzh(sa, abits, b) { | |
; | |
if(b >= 0) { | |
return abits.pow(b); | |
} else { | |
return abits.pow(b + 2147483648); | |
} | |
} | |
// (a ^ b) % c | |
function h$integer_cmm_powModIntegerzh(sa, abits, sb, bbits, sc, cbits) { | |
; | |
return abits.modPow(bbits, cbits); | |
} | |
// warning, there is no protection against side-channel attacks here | |
function h$integer_cmm_powModSecIntegerzh(sa, abits, sb, bbits, sc, cbits) { | |
; | |
return h$integer_cmm_powModIntegerzh(sa, abits, sb, bbits, sc, cbits); | |
} | |
function h$integer_cmm_recipModIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.modInverse(bbits); | |
} | |
function h$integer_cmm_nextPrimeIntegerzh(sa, abits) { | |
; | |
var n = abits.add(BigInteger.ONE); | |
while(true) { | |
if(n.isProbablePrime(50)) return n; | |
n.addTo(BigInteger.ONE, n); | |
} | |
} | |
function h$integer_cmm_testPrimeIntegerzh(sa, abits, b) { | |
; | |
return abits.isProbablePrime(b) ? 1 : 0; | |
} | |
function h$integer_cmm_sizeInBasezh(sa, abits, b) { | |
; | |
return Math.ceil(abits.bitLength() * Math.log(2) / Math.log(b)); | |
} | |
var h$oneOverLog2 = 1 / Math.log(2); | |
function h$integer_cmm_decodeDoublezh(x) { | |
; | |
var sgn = h$decodeDouble2Int(x); | |
var b = h$bigFromInt(h$ret1).shiftLeft(32).add(h$bigFromWord(h$ret2)); | |
h$ret1 = (!isNaN(x) && sgn < 0) ? b.negate() : b; | |
; | |
return h$ret3; // exponent | |
} | |
function h$integer_cmm_decodeDoublezhFallback(x) { | |
; | |
if(isNaN(x)) { | |
h$ret1 = h$bigFromInt(3).shiftLeft(51).negate(); | |
return 972; | |
} | |
if( x < 0 ) { | |
var result = h$integer_cmm_decodeDoublezh(-x); | |
h$ret1 = h$ret1.negate(); | |
return result; | |
} | |
if(x === Number.POSITIVE_INFINITY) { | |
h$ret1 = h$bigOne.shiftLeft(52); | |
return 972; | |
} | |
var exponent = (Math.floor(Math.log(x) * h$oneOverLog2)-52)|0; | |
var n; | |
// prevent overflow | |
if(exponent < -1000) { | |
n = x * Math.pow(2,-exponent-128) * Math.pow(2,128); | |
} else if(exponent > 900) { | |
n = x * Math.pow(2,-exponent+128) * Math.pow(2,-128); | |
} else { | |
n = x * Math.pow(2,-exponent); | |
} | |
// fixup precision, do we also need the other way (exponent++) ? | |
if(Math.abs(n - Math.floor(n) - 0.5) < 0.0001) { | |
exponent--; | |
n *= 2; | |
} | |
h$ret1 = h$bigFromNumber(n); | |
; | |
return exponent; | |
} | |
function h$integer_cmm_int2Integerzh(i) { | |
; | |
h$ret1 = h$bigFromInt(i); | |
return 0; | |
} | |
function h$integer_cmm_word2Integerzh(i) { | |
; | |
h$ret1 = h$bigFromWord(i); | |
return 0; | |
} | |
function h$integer_cmm_andIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.and(bbits); | |
} | |
function h$integer_cmm_orIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.or(bbits); | |
} | |
function h$integer_cmm_xorIntegerzh(sa, abits, sb, bbits) { | |
; | |
return abits.xor(bbits); | |
} | |
function h$integer_cmm_testBitIntegerzh(sa, abits, bit) { | |
return abits.testBit(bit)?1:0; | |
} | |
function h$integer_cmm_mul2ExpIntegerzh(sa, abits, b) { | |
; | |
return abits.shiftLeft(b); | |
} | |
function h$integer_cmm_fdivQ2ExpIntegerzh(sa, abits, b) { | |
; | |
return abits.shiftRight(b); | |
} | |
function h$integer_cmm_complementIntegerzh(sa, abits) { | |
; | |
return abits.not(); | |
} | |
function h$integer_cmm_int64ToIntegerzh(a0, a1) { | |
; | |
h$ret1 = h$bigFromInt64(a0,a1); | |
return 0; | |
} | |
function h$integer_cmm_word64ToIntegerzh(a0, a1) { | |
; | |
h$ret1 = h$bigFromWord64(a0,a1); | |
return 0; | |
} | |
function h$hs_integerToInt64(as, abits) { | |
; | |
h$ret1 = abits.intValue(); | |
return abits.shiftRight(32).intValue(); | |
} | |
function h$hs_integerToWord64(as, abits) { | |
; | |
h$ret1 = abits.intValue(); | |
return abits.shiftRight(32).intValue(); | |
} | |
function h$integer_cmm_integer2Intzh(as, abits) { | |
; | |
return abits.intValue(); | |
} | |
function h$integer_cbits_encodeDouble(as,abits,e) { | |
; | |
return h$encodeNumber(abits,e); | |
} | |
function h$integer_cbits_encodeFloat(as,abits,e) { | |
; | |
return h$encodeNumber(abits,e); | |
} | |
function h$__int_encodeDouble(i,e) { | |
return i * Math.pow(2,e); | |
} | |
function h$__int_encodeFloat(i,e) { | |
return i * Math.pow(2,e); | |
} | |
var h$integer_clz32 = Math.clz32 || function(x) { | |
if (x < 0) return 0; | |
if (x === 0) return 32; | |
return 31 - ((Math.log(x) / Math.LN2) | 0); | |
} | |
function h$integer_wordLog2(w) { | |
; | |
return 31 - h$integer_clz32(w); | |
} | |
function h$integer_integerLog2(i) { | |
; | |
return i.bitLength()-1; | |
} | |
function h$integer_integerLog2IsPowerOf2(i) { | |
; | |
var b = i.bitLength(); | |
h$ret1 = (b === 0 || i.getLowestSetBit() !== b) ? 1 : 0; | |
; | |
return b-1; | |
} | |
function h$integer_intLog2IsPowerOf2(i) { | |
; | |
var l = 31 - h$integer_clz32(i); | |
h$ret1 = (i !== (1 << l)) ? 1 : 0; | |
; | |
return l; | |
} | |
function h$integer_roundingMode(i,j) { | |
; | |
return 1; // round to even, is that correct? | |
} | |
function h$integer_mkBigInt(i) { | |
return h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, i); | |
} | |
function h$integer_mkSmallInt(i) { | |
return h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, i); | |
} | |
function h$integer_smartJ(i) { | |
; | |
if(i.bitLength() >= 32) return h$integer_mkBigInt(i); | |
return h$integer_mkSmallInt(i.intValue()|0) | |
} | |
function h$integer_mpzToInteger(i) { | |
; | |
if(typeof i === 'number') return h$integer_mkSmallInt(i); | |
return h$integer_smartJ(i); | |
} | |
var h$integer_negTwoThirtyOne = h$integer_mkBigInt(h$bigFromInt(-2147483648).negate()); | |
function h$integer_mpzNeg(i) { | |
; | |
if(typeof i === 'number') { | |
return (i === -2147483648) ? h$integer_negTwoThirtyOne : -i; | |
} | |
return i.negate(); | |
} | |
function h$integer_absInteger(i) { | |
; | |
return i.abs(); | |
} | |
function h$integer_negateInteger(i) { | |
; | |
return i.negate(); | |
} | |
// set up debug logging for the current JS environment/engine | |
// browser also logs to <div id="output"> if jquery is detected | |
// the various debug tracing options use h$log | |
var h$glbl; | |
function h$getGlbl() { h$glbl = this; } | |
h$getGlbl(); | |
function h$log() { | |
if(h$glbl) { | |
if(h$glbl.console && h$glbl.console.log) { | |
h$glbl.console.log.apply(h$glbl.console,arguments); | |
} else { | |
h$glbl.print.apply(this,arguments); | |
} | |
} else { | |
if(typeof console !== 'undefined') { | |
console.log.apply(console, arguments); | |
} else if(typeof print !== 'undefined') { | |
print.apply(null, arguments); | |
} | |
} | |
} | |
function h$collectProps(o) { | |
var props = []; | |
for(var p in o) { props.push(p); } | |
return("{"+props.join(",")+"}"); | |
} | |
// load the command line arguments in h$programArgs | |
// the first element is the program name | |
var h$programArgs; | |
if(h$isNode) { | |
h$programArgs = process.argv.slice(1); | |
} else if(h$isJsShell && typeof h$getGlobal(this).scriptArgs !== 'undefined') { | |
h$programArgs = h$getGlobal(this).scriptArgs.slice(0); | |
h$programArgs.unshift("a.js"); | |
} else if((h$isJsShell || h$isJsCore) && typeof h$getGlobal(this).arguments !== 'undefined') { | |
h$programArgs = h$getGlobal(this).arguments.slice(0); | |
h$programArgs.unshift("a.js"); | |
} else { | |
h$programArgs = [ "a.js" ]; | |
} | |
function h$getProgArgv(argc_v,argc_off,argv_v,argv_off) { | |
; | |
var c = h$programArgs.length; | |
if(c === 0) { | |
argc_v.dv.setInt32(argc_off, 0, true); | |
} else { | |
argc_v.dv.setInt32(argc_off, c, true); | |
var argv = h$newByteArray(4*c); | |
argv.arr = []; | |
for(var i=0;i<h$programArgs.length;i++) { | |
argv.arr[4*i] = [ h$encodeUtf8(h$programArgs[i]), 0 ]; | |
} | |
if(!argv_v.arr) { argv_v.arr = []; } | |
argv_v.arr[argv_off] = [argv, 0]; | |
} | |
} | |
function h$setProgArgv(n, ptr_d, ptr_o) { | |
args = []; | |
for(var i=0;i<n;i++) { | |
var p = ptr_d.arr[ptr_o+4*i]; | |
var arg = h$decodeUtf8z(p[0], p[1]); | |
args.push(arg); | |
} | |
h$programArgs = args; | |
} | |
function h$getpid() { | |
if(h$isNode) return process.id; | |
return 0; | |
} | |
function h$__hscore_environ() { | |
; | |
h$ret1 = 0; | |
if(h$isNode) { | |
var env = [], i; | |
for(i in process.env) env.push(i + '=' + process.env[i]); | |
if(env.length === 0) return null; | |
var p = h$newByteArray(4*env.length+1); | |
p.arr = []; | |
for(i=0;i<env.length;i++) p.arr[4*i] = [h$encodeUtf8(env[i]), 0]; | |
p.arr[4*env.length] = [null, 0]; | |
return p; | |
} | |
return null; | |
} | |
function h$getenv(name, name_off) { | |
; | |
h$ret1 = 0; | |
if(h$isNode) { | |
var n = h$decodeUtf8z(name, name_off); | |
if(typeof process.env[n] !== 'undefined') | |
return h$encodeUtf8(process.env[n]); | |
} | |
return null; | |
} | |
function h$errorBelch() { | |
h$log("### errorBelch: do we need to handle a vararg function here?"); | |
} | |
function h$errorBelch2(buf1, buf_offset1, buf2, buf_offset2) { | |
// log("### errorBelch2"); | |
h$errorMsg(h$decodeUtf8z(buf1, buf_offset1), h$decodeUtf8z(buf2, buf_offset2)); | |
} | |
function h$debugBelch2(buf1, buf_offset1, buf2, buf_offset2) { | |
h$errorMsg(h$decodeUtf8z(buf1, buf_offset1), h$decodeUtf8z(buf2, buf_offset2)); | |
} | |
function h$errorMsg(pat) { | |
function stripTrailingNewline(xs) { | |
return xs.replace(/\r?\n$/, ""); | |
} | |
// poor man's vprintf | |
var str = pat; | |
for(var i=1;i<arguments.length;i++) { | |
str = str.replace(/%s/, arguments[i]); | |
} | |
if(h$isNode) { | |
process.stderr.write(str); | |
} else if (h$isJsShell && typeof printErr !== 'undefined') { | |
if(str.length) printErr(stripTrailingNewline(str)); | |
} else if (h$isJsShell && typeof putstr !== 'undefined') { | |
putstr(str); | |
} else if (h$isJsCore) { | |
if(str.length) { | |
if(h$base_stderrLeftover.val !== null) { | |
debug(h$base_stderrLeftover.val + stripTrailingNewline(str)); | |
h$base_stderrLeftover.val = null; | |
} else { | |
debug(stripTrailingNewline(str)); | |
} | |
} | |
} else { | |
if(typeof console !== 'undefined') { | |
console.log(str); | |
} | |
} | |
} | |
// this needs to be imported with foreign import ccall safe/interruptible | |
function h$performMajorGC() { | |
// save current thread state so we can enter the GC | |
var t = h$currentThread, err = null; | |
t.sp = h$sp; | |
h$currentThread = null; | |
try { | |
h$gc(t); | |
} catch(e) { | |
err = e; | |
} | |
// restore thread state | |
h$currentThread = t; | |
h$sp = t.sp; | |
h$stack = t.stack; | |
if(err) throw err; | |
} | |
function h$baseZCSystemziCPUTimeZCgetrusage() { | |
return 0; | |
} | |
function h$getrusage() { | |
return 0; | |
} | |
// fixme need to fix these struct locations | |
function h$gettimeofday(tv_v,tv_o,tz_v,tz_o) { | |
var now = Date.now(); | |
tv_v.dv.setInt32(tv_o, (now / 1000)|0, true); | |
tv_v.dv.setInt32(tv_o + 4, ((now % 1000) * 1000)|0, true); | |
if(tv_v.len >= tv_o + 12) { | |
tv_v.dv.setInt32(tv_o + 8, ((now % 1000) * 1000)|0, true); | |
} | |
return 0; | |
} | |
function h$traceEvent(ev_v,ev_o) { | |
h$errorMsg(h$decodeUtf8z(ev_v, ev_o)); | |
} | |
function h$traceMarker(ev_v,ev_o) { | |
h$errorMsg(h$decodeUtf8z(ev_v, ev_o)); | |
} | |
var h$__hscore_gettimeofday = h$gettimeofday; | |
var h$myTimeZone = h$encodeUtf8("UTC"); | |
function h$localtime_r(timep_v, timep_o, result_v, result_o) { | |
var t = timep_v.i3[timep_o]; | |
var d = new Date(t * 1000); | |
result_v.dv.setInt32(result_o , d.getSeconds(), true); | |
result_v.dv.setInt32(result_o + 4 , d.getMinutes(), true); | |
result_v.dv.setInt32(result_o + 8 , d.getHours(), true); | |
result_v.dv.setInt32(result_o + 12, d.getDate(), true); | |
result_v.dv.setInt32(result_o + 16, d.getMonth(), true); | |
result_v.dv.setInt32(result_o + 20, d.getFullYear()-1900, true); | |
result_v.dv.setInt32(result_o + 24, d.getDay(), true); | |
result_v.dv.setInt32(result_o + 28, 0, true); // fixme yday 1-365 (366?) | |
result_v.dv.setInt32(result_o + 32, -1, true); // dst information unknown | |
result_v.dv.setInt32(result_o + 40, 0, true); // gmtoff? | |
if(!result_v.arr) result_v.arr = []; | |
result_v.arr[result_o + 40] = [h$myTimeZone, 0]; | |
result_v.arr[result_o + 48] = [h$myTimeZone, 0]; | |
h$ret1 = result_o; | |
return result_v; | |
} | |
var h$__hscore_localtime_r = h$localtime_r; | |
// some Enum conversion things | |
// an array of generic enums | |
var h$enums = []; | |
function h$initEnums() { | |
for(var i=0;i<256;i++) { | |
h$enums[i] = h$makeEnum(i); | |
} | |
} | |
h$initStatic.push(h$initEnums); | |
function h$makeEnum(tag) { | |
var f = function() { | |
return h$stack[h$sp]; | |
} | |
h$setObjInfo(f, 2, "Enum", [], tag+1, 0, [1], null); | |
return h$c0(f); | |
} | |
// used for all non-Bool enums | |
function h$tagToEnum(tag) { | |
if(tag >= h$enums.length) { | |
return h$makeEnum(tag); | |
} else { | |
return h$enums[tag]; | |
} | |
} | |
function h$dataTag(e) { | |
return (e===true)?1:((typeof e !== 'object')?0:(e.f.a-1)); | |
} | |
// weak reference support | |
// contains all pending finalizers | |
var h$finalizers = new h$Set(); | |
// filled at scan time, weak refs with possible work to do | |
var h$scannedWeaks = []; | |
// called by the GC after marking the heap | |
function h$finalizeWeaks() { | |
var mark = h$gcMark; | |
; | |
var i, w, toFinalize = []; | |
var iter = h$finalizers.iter(); | |
while((w = iter.next()) !== null) { | |
; | |
; | |
if((w.m.m&3) !== mark) { | |
iter.remove(); | |
toFinalize.push(w); | |
; | |
} | |
} | |
; | |
// start a finalizer thread if any finalizers need to be run | |
if(toFinalize.length > 0) { | |
var t = new h$Thread(); | |
for(i=0;i<toFinalize.length;i++) { | |
w = toFinalize[i]; | |
t.sp += 6; | |
t.stack[t.sp-5] = 0; // mask | |
t.stack[t.sp-4] = h$noop; // handler, dummy | |
t.stack[t.sp-3] = h$catch_e; | |
t.stack[t.sp-2] = h$ap_1_0; | |
t.stack[t.sp-1] = w.finalizer; | |
t.stack[t.sp] = h$return; | |
w.finalizer = null; | |
} | |
h$wakeupThread(t); | |
} | |
return toFinalize; | |
} | |
// clear references for reachable weak refs with unreachable keys | |
function h$clearWeaks() { | |
var mark = h$gcMark; | |
; | |
for(var i=h$scannedWeaks.length-1;i>=0;i--) { | |
var w = h$scannedWeaks[i]; | |
if(w.keym.m !== mark && w.val !== null) { | |
; | |
w.val = null; | |
} | |
} | |
} | |
var h$weakFinalizerN = 0; | |
/** @constructor */ | |
function h$Weak(key, val, finalizer) { | |
if(typeof key !== 'object') { | |
// can't attach a StableName to objects with unboxed storage | |
// our weak ref will be finalized soon. | |
; | |
this.keym = new h$StableName(0); | |
} else { | |
if(typeof key.m !== 'object') key.m = new h$StableName(key.m); | |
this.keym = key.m; | |
} | |
; | |
this.keym = key.m; | |
this.val = val; | |
this.finalizer = null; | |
if(finalizer !== null) { | |
var fin = { m: this.keym, finalizer: finalizer, _key: ++h$weakFinalizerN }; | |
h$finalizers.add(fin); | |
this.finalizer = fin; | |
} | |
this.m = 0; | |
// h$scannedWeaks.push(this); // fixme debug | |
} | |
function h$makeWeak(key, val, fin) { | |
; | |
return new h$Weak(key, val, fin) | |
} | |
function h$makeWeakNoFinalizer(key, val) { | |
; | |
return new h$Weak(key, val, null); | |
} | |
function h$finalizeWeak(w) { | |
; | |
w.val = null; | |
if(w.finalizer === null || w.finalizer.finalizer === null) { | |
h$ret1 = 0; | |
return null; | |
} else { | |
var r = w.finalizer.finalizer; | |
h$finalizers.remove(w.finalizer); | |
w.finalizer = null; | |
h$ret1 = 1; | |
return r; | |
} | |
} | |
// preemptive threading support | |
// run gc when this much time has passed (ms) | |
// preempt threads after the scheduling quantum (ms) | |
// check sched quantum after 10*GHCJS_SCHED_CHECK calls | |
// yield to js after running haskell for GHCJS_BUSY_YIELD ms | |
// thread status | |
var h$threadRunning = 0; | |
var h$threadBlocked = 1; | |
var h$threadFinished = 16; | |
var h$threadDied = 17; | |
var h$threadIdN = 0; | |
// all threads except h$currentThread | |
// that are not finished/died can be found here | |
var h$threads = new h$Queue(); | |
var h$blocked = new h$Set(); | |
/** @constructor */ | |
function h$Thread() { | |
this.tid = ++h$threadIdN; | |
this.status = h$threadRunning; | |
this.stack = [h$done, 0, h$baseZCGHCziConcziSynczireportError, h$catch_e]; | |
this.sp = 3; | |
this.mask = 0; // async exceptions masked (0 unmasked, 1: uninterruptible, 2: interruptible) | |
this.interruptible = false; // currently in an interruptible operation | |
this.excep = []; // async exceptions waiting for unmask of this thread | |
this.delayed = false; // waiting for threadDelay | |
this.blockedOn = null; // object on which thread is blocked | |
this.retryInterrupted = null; // how to retry blocking operation when interrupted | |
this.transaction = null; // for STM | |
this.isSynchronous = false; | |
this.continueAsync = false; | |
this.m = 0; // gc mark | |
this._key = this.tid; // for storing in h$Set / h$Map | |
} | |
function h$rts_getThreadId(t) { | |
return t.tid; | |
} | |
function h$cmp_thread(t1,t2) { | |
if(t1.tid < t2.tid) return -1; | |
if(t1.tid > t2.tid) return 1; | |
return 0; | |
} | |
// description of the thread, if unlabeled then just the thread id | |
function h$threadString(t) { | |
if(t === null) { | |
return "<no thread>"; | |
} else if(t.label) { | |
var str = h$decodeUtf8z(t.label[0], t.label[1]); | |
return str + " (" + t.tid + ")"; | |
} else { | |
return (""+t.tid); | |
} | |
} | |
function h$fork(a, inherit) { | |
var t = new h$Thread(); | |
; | |
if(inherit && h$currentThread) { | |
t.mask = h$currentThread.mask; | |
} | |
// TRACE_SCHEDULER("sched: action forked: " + a.f.n); | |
t.stack[4] = h$ap_1_0; | |
t.stack[5] = a; | |
t.stack[6] = h$return; | |
t.sp = 6; | |
h$wakeupThread(t); | |
return t; | |
} | |
function h$threadStatus(t) { | |
h$ret1 = 1; // capability | |
h$ret2 = 0; // locked | |
return t.status; | |
} | |
function h$waitRead(fd) { | |
h$fds[fd].waitRead.push(h$currentThread); | |
h$currentThread.interruptible = true; | |
h$blockThread(h$currentThread,fd,[h$waitRead,fd]); | |
return h$reschedule; | |
} | |
function h$waitWrite(fd) { | |
h$fds[fd].waitWrite.push(h$currentThread); | |
h$currentThread.interruptible = true; | |
h$blockThread(h$currentThread,fd,[h$waitWrite,fd]); | |
return h$reschedule; | |
} | |
// threadDelay support: | |
var h$delayed = new h$HeapSet(); | |
function h$wakeupDelayed(now) { | |
while(h$delayed.size() > 0 && h$delayed.peekPrio() < now) { | |
var t = h$delayed.pop(); | |
; | |
// might have been woken up early, don't wake up again in that case | |
if(t.delayed) { | |
t.delayed = false; | |
h$wakeupThread(t); | |
} | |
} | |
} | |
function h$delayThread(time) { | |
var now = Date.now(); | |
var ms = time/1000; // we have no microseconds in JS | |
; | |
h$delayed.add(now+ms, h$currentThread); | |
h$currentThread.delayed = true; | |
h$blockThread(h$currentThread, h$delayed,[h$resumeDelayThread]); | |
return h$reschedule; | |
} | |
function h$resumeDelayThread() { | |
h$r1 = false; | |
return h$stack[h$sp]; | |
} | |
function h$yield() { | |
h$sp += 2; | |
h$stack[h$sp-1] = h$r1; | |
h$stack[h$sp] = h$return; | |
h$currentThread.sp = h$sp; | |
return h$reschedule; | |
} | |
// raise the async exception in the thread if not masked | |
function h$killThread(t, ex) { | |
; | |
if(t === h$currentThread) { | |
// if target is self, then throw even if masked | |
h$sp += 2; | |
h$stack[h$sp-1] = h$r1; | |
h$stack[h$sp] = h$return; | |
return h$throw(ex,true); | |
} else { | |
; | |
if(t.mask === 0 || (t.mask === 2 && t.interruptible)) { | |
if(t.stack) { // finished threads don't have a stack anymore | |
h$forceWakeupThread(t); | |
t.sp += 2; | |
t.stack[t.sp-1] = ex; | |
t.stack[t.sp] = h$raiseAsync_frame; | |
} | |
return h$stack ? h$stack[h$sp] : null; | |
} else { | |
t.excep.push([h$currentThread,ex]); | |
h$blockThread(h$currentThread,t,null); | |
h$currentThread.interruptible = true; | |
h$sp += 2; | |
h$stack[h$sp-1] = h$r1; | |
h$stack[h$sp] = h$return; | |
return h$reschedule; | |
} | |
} | |
} | |
function h$maskStatus() { | |
; | |
return h$currentThread.mask; | |
} | |
function h$maskAsync(a) { | |
; | |
if(h$currentThread.mask !== 2) { | |
if(h$currentThread.mask === 0 && h$stack[h$sp] !== h$maskFrame && h$stack[h$sp] !== h$maskUnintFrame) { | |
h$stack[++h$sp] = h$unmaskFrame; | |
} | |
if(h$currentThread.mask === 1) { | |
h$stack[++h$sp] = h$maskUnintFrame; | |
} | |
h$currentThread.mask = 2; | |
} | |
h$r1 = a; | |
return h$ap_1_0_fast(); | |
} | |
function h$maskUnintAsync(a) { | |
; | |
if(h$currentThread.mask !== 1) { | |
if(h$currentThread.mask === 2) { | |
h$stack[++h$sp] = h$maskFrame; | |
} else { | |
h$stack[++h$sp] = h$unmaskFrame; | |
} | |
h$currentThread.mask = 1; | |
} | |
h$r1 = a; | |
return h$ap_1_0_fast(); | |
} | |
function h$unmaskAsync(a) { | |
; | |
if(h$currentThread.excep.length > 0) { | |
h$currentThread.mask = 0; | |
h$sp += 3; | |
h$stack[h$sp-2] = h$ap_1_0; | |
h$stack[h$sp-1] = a; | |
h$stack[h$sp] = h$return; | |
return h$reschedule; | |
} | |
if(h$currentThread.mask !== 0) { | |
if(h$stack[h$sp] !== h$unmaskFrame) { | |
if(h$currentThread.mask === 2) { | |
h$stack[++h$sp] = h$maskFrame; | |
} else { | |
h$stack[++h$sp] = h$maskUnintFrame; | |
} | |
} | |
h$currentThread.mask = 0; | |
} | |
h$r1 = a; | |
return h$ap_1_0_fast(); | |
} | |
function h$pendingAsync() { | |
var t = h$currentThread; | |
return (t.excep.length > 0 && (t.mask === 0 || (t.mask === 2 && t.interruptible))); | |
} | |
// post the first of the queued async exceptions to | |
// this thread, restore frame is in thread if alreadySuspended | |
function h$postAsync(alreadySuspended,next) { | |
var t = h$currentThread; | |
var v = t.excep.shift(); | |
; | |
var tposter = v[0]; // posting thread, blocked | |
var ex = v[1]; // the exception | |
if(v !== null && tposter !== null) { | |
h$wakeupThread(tposter); | |
} | |
if(!alreadySuspended) { | |
h$suspendCurrentThread(next); | |
} | |
h$sp += 2; | |
h$stack[h$sp-1] = ex; | |
h$stack[h$sp] = h$raiseAsync_frame; | |
t.sp = h$sp; | |
} | |
// wakeup thread, thread has already been removed | |
// from any queues it was blocked on | |
function h$wakeupThread(t) { | |
; | |
if(t.status === h$threadBlocked) { | |
t.blockedOn = null; | |
t.status = h$threadRunning; | |
h$blocked.remove(t); | |
} | |
t.interruptible = false; | |
t.retryInterrupted = null; | |
h$threads.enqueue(t); | |
h$startMainLoop(); | |
} | |
// force wakeup, remove this thread from any | |
// queue it's blocked on | |
function h$forceWakeupThread(t) { | |
; | |
if(t.status === h$threadBlocked) { | |
h$removeThreadBlock(t); | |
h$wakeupThread(t); | |
} | |
} | |
function h$removeThreadBlock(t) { | |
if(t.status === h$threadBlocked) { | |
var o = t.blockedOn; | |
if(o === null || o === undefined) { | |
throw ("h$removeThreadBlock: blocked on null or undefined: " + h$threadString(t)); | |
} else if(o === h$delayed) { | |
// thread delayed | |
h$delayed.remove(t); | |
t.delayed = false; | |
} else if(o instanceof h$MVar) { | |
; | |
; | |
// fixme this is rather inefficient | |
var r, rq = new h$Queue(); | |
while((r = o.readers.dequeue()) !== null) { | |
if(r !== t) rq.enqueue(r); | |
} | |
var w, wq = new h$Queue(); | |
while ((w = o.writers.dequeue()) !== null) { | |
if(w[0] !== t) wq.enqueue(w); | |
} | |
o.readers = rq; | |
o.writers = wq; | |
; | |
/* } else if(o instanceof h$Fd) { | |
TRACE_SCHEDULER("blocked on fd"); | |
h$removeFromArray(o.waitRead,t); | |
h$removeFromArray(o.waitWrite,t); */ | |
} else if(o instanceof h$Thread) { | |
; | |
// set thread (first in pair) to null, exception will still be delivered | |
// but this thread not woken up again | |
// fixme: are these the correct semantics? | |
for(var i=0;i<o.excep.length;i++) { | |
if(o.excep[i][0] === t) { | |
o.excep[i][0] = null; | |
break; | |
} | |
} | |
} else if (o instanceof h$TVarsWaiting) { | |
h$stmRemoveBlockedThread(o, t) | |
} else if(o.f && o.f.t === h$BLACKHOLE_CLOSURE) { | |
; | |
h$removeFromArray(o.d2,t); | |
} else { | |
throw ("h$removeThreadBlock: blocked on unknown object: " + h$collectProps(o)); | |
} | |
if(t.retryInterrupted) { | |
t.sp+=2; | |
t.stack[t.sp-1] = t.retryInterrupted; | |
t.stack[t.sp] = h$retryInterrupted; | |
} | |
} | |
} | |
function h$removeFromArray(a,o) { | |
var i; | |
while((i = a.indexOf(o)) !== -1) { | |
a.splice(i,1); | |
} | |
} | |
function h$finishThread(t) { | |
; | |
t.status = h$threadFinished; | |
h$blocked.remove(t); | |
t.stack = null; | |
t.mask = 0; | |
for(var i=0;i<t.excep.length;i++) { | |
var v = t.excep[i]; | |
var tposter = v[0]; | |
if(v !== null && tposter !== null) { | |
h$wakeupThread(tposter); | |
} | |
} | |
t.excep = []; | |
} | |
function h$blockThread(t,o,resume) { | |
; | |
if(o === undefined || o === null) { | |
throw ("h$blockThread, no block object: " + h$threadString(t)); | |
} | |
t.status = h$threadBlocked; | |
t.blockedOn = o; | |
t.retryInterrupted = resume; | |
t.sp = h$sp; | |
h$blocked.add(t); | |
} | |
// the main scheduler, called from h$mainLoop | |
// returns null if nothing to do, otherwise | |
// the next function to run | |
var h$lastGc = Date.now(); | |
var h$gcInterval = 1000; // ms | |
function h$scheduler(next) { | |
; | |
var now = Date.now(); | |
h$wakeupDelayed(now); | |
// find the next runnable thread in the run queue | |
// remove non-runnable threads | |
if(h$currentThread && h$pendingAsync()) { | |
; | |
if(h$currentThread.status !== h$threadRunning) { | |
h$forceWakeupThread(h$currentThread); | |
h$currentThread.status = h$threadRunning; | |
} | |
h$postAsync(next === h$reschedule, next); | |
return h$stack[h$sp]; | |
} | |
var t; | |
while(t = h$threads.dequeue()) { | |
if(t.status === h$threadRunning) { break; } | |
} | |
// if no other runnable threads, just continue current (if runnable) | |
if(t === null) { | |
; | |
if(h$currentThread && h$currentThread.status === h$threadRunning) { | |
// do gc after a while | |
if(now - h$lastGc > h$gcInterval) { | |
// save active data for the thread on its stack | |
if(next !== h$reschedule && next !== null) { | |
h$suspendCurrentThread(next); | |
next = h$stack[h$sp]; | |
} | |
var ct = h$currentThread; | |
h$currentThread = null; | |
h$gc(ct); | |
h$currentThread = ct; | |
// gc might replace the stack of a thread, so reload it | |
h$stack = h$currentThread.stack; | |
h$sp = h$currentThread.sp | |
} | |
; | |
return (next===h$reschedule || next === null)?h$stack[h$sp]:next; // just continue | |
} else { | |
; | |
h$currentThread = null; | |
// We could set a timer here so we do a gc even if Haskell pauses for a long time. | |
// However, currently this isn't necessary because h$mainLoop always sets a timer | |
// before it pauses. | |
if(now - h$lastGc > h$gcInterval) | |
h$gc(null); | |
return null; // pause the haskell runner | |
} | |
} else { // runnable thread in t, switch to it | |
; | |
if(h$currentThread !== null) { | |
if(h$currentThread.status === h$threadRunning) { | |
h$threads.enqueue(h$currentThread); | |
} | |
// if h$reschedule called, thread takes care of suspend | |
if(next !== h$reschedule && next !== null) { | |
; | |
// suspend thread: push h$restoreThread stack frame | |
h$suspendCurrentThread(next); | |
} else { | |
; | |
h$currentThread.sp = h$sp; | |
} | |
if(h$pendingAsync()) h$postAsync(true, next); | |
} else { | |
; | |
} | |
// gc if needed | |
if(now - h$lastGc > h$gcInterval) { | |
h$currentThread = null; | |
h$gc(t); | |
} | |
// schedule new one | |
h$currentThread = t; | |
h$stack = t.stack; | |
h$sp = t.sp; | |
; | |
// TRACE_SCHEDULER("sp thing: " + h$stack[h$sp].n); | |
// h$dumpStackTop(h$stack,0,h$sp); | |
return h$stack[h$sp]; | |
} | |
} | |
function h$scheduleMainLoop() { | |
; | |
if(h$mainLoopImmediate) return; | |
h$clearScheduleMainLoop(); | |
if(h$delayed.size() === 0) { | |
if(typeof setTimeout !== 'undefined') { | |
; | |
h$mainLoopTimeout = setTimeout(h$mainLoop, h$gcInterval); | |
} | |
return; | |
} | |
var now = Date.now(); | |
var delay = Math.min(Math.max(h$delayed.peekPrio()-now, 0), h$gcInterval); | |
if(typeof setTimeout !== 'undefined') { | |
if(delay >= 1) { | |
; | |
// node.js 0.10.30 has trouble with non-integral delays | |
h$mainLoopTimeout = setTimeout(h$mainLoop, Math.round(delay)); | |
} else { | |
h$mainLoopImmediate = setImmediate(h$mainLoop); | |
} | |
} | |
} | |
var h$animationFrameMainLoop = false; | |
function h$clearScheduleMainLoop() { | |
if(h$mainLoopTimeout) { | |
clearTimeout(h$mainLoopTimeout); | |
h$mainLoopTimeout = null; | |
} | |
if(h$mainLoopImmediate) { | |
clearImmediate(h$mainLoopImmediate); | |
h$mainLoopImmediate = null; | |
} | |
if(h$mainLoopFrame) { | |
cancelAnimationFrame(h$mainLoopFrame); | |
h$mainLoopFrame = null; | |
} | |
} | |
function h$startMainLoop() { | |
; | |
if(h$running) return; | |
if(typeof setTimeout !== 'undefined') { | |
if(!h$mainLoopImmediate) { | |
h$clearScheduleMainLoop(); | |
h$mainLoopImmediate = setImmediate(h$mainLoop); | |
} | |
} else { | |
while(true) h$mainLoop(); | |
} | |
} | |
var h$busyYield = 500; | |
var h$schedQuantum = 25; | |
var h$mainLoopImmediate = null; // immediate id if main loop has been scheduled immediately | |
var h$mainLoopTimeout = null; // timeout id if main loop has been scheduled with a timeout | |
var h$mainLoopFrame = null; // timeout id if main loop has been scheduled with an animation frame | |
var h$running = false; | |
var h$next = null; | |
function h$mainLoop() { | |
if(h$running) return; | |
h$clearScheduleMainLoop(); | |
if(h$currentThread) { | |
h$scheduleMainLoop(); | |
return; | |
} | |
h$running = true; | |
h$runInitStatic(); | |
h$currentThread = h$next; | |
if(h$next !== null) { | |
h$stack = h$currentThread.stack; | |
h$sp = h$currentThread.sp; | |
} | |
var c = null; | |
var count; | |
var start = Date.now(); | |
do { | |
c = h$scheduler(c); | |
var scheduled = Date.now(); | |
if(c === null) { // no running threads | |
h$next = null; | |
h$running = false; | |
h$currentThread = null; | |
h$scheduleMainLoop(); | |
return; | |
} | |
// yield to js after h$busyYield (default value GHCJS_BUSY_YIELD) | |
if(Date.now() - start > h$busyYield) { | |
; | |
if(c !== h$reschedule) h$suspendCurrentThread(c); | |
h$next = h$currentThread; | |
h$currentThread = null; | |
h$running = false; | |
if(h$animationFrameMainLoop) { | |
h$mainLoopFrame = requestAnimationFrame(h$mainLoop); | |
} else { | |
h$mainLoopImmediate = setImmediate(h$mainLoop); | |
} | |
return; | |
} | |
// preemptively schedule threads after 10*GHCJS_SCHED_CHECK calls | |
// but not before the end of the scheduling quantum | |
try { | |
while(c !== h$reschedule && Date.now() - scheduled < h$schedQuantum) { | |
count = 0; | |
while(c !== h$reschedule && ++count < 1000) { | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
} | |
} | |
} catch(e) { | |
// uncaught exception in haskell code, kill thread | |
// fixme: would we ever need to remove the thread from queues? | |
h$currentThread.status = h$threadDied; | |
h$currentThread.stack = null; | |
h$currentThread = null; | |
c = null; | |
if(h$stack && h$stack[0] === h$doneMain) { | |
h$stack = null; | |
h$reportMainLoopException(e, true); | |
h$doneMain(); | |
return; | |
} else { | |
h$stack = null; | |
h$reportMainLoopException(e, false); | |
} | |
} | |
} while(true); | |
} | |
function h$reportMainLoopException(e, isMainThread) { | |
var main = isMainThread ? " main" : ""; | |
h$log("uncaught exception in Haskell" + main + " thread: " + e.toString()); | |
if(e.stack) h$log(e.stack) | |
} | |
// run the supplied IO action in a new thread | |
// returns immediately, thread is started in background | |
function h$run(a) { | |
; | |
var t = h$fork(a, false); | |
h$startMainLoop(); | |
return t; | |
} | |
// try to run the supplied IO action synchronously, running the | |
// thread to completion, unless it blocks, | |
// for example by taking an MVar or threadDelay | |
// returns the thing the thread blocked on, null if the thread ran to completion | |
// cont :: bool, continue thread asynchronously after h$runSync returns | |
function h$runSync(a, cont) { | |
h$runInitStatic(); | |
var c = h$return; | |
var t = new h$Thread(); | |
t.isSynchronous = true; | |
t.continueAsync = cont; | |
var ct = h$currentThread; | |
var csp = h$sp; | |
var cr1 = h$r1; // do we need to save more than this? | |
t.stack[4] = h$ap_1_0; | |
t.stack[5] = a; | |
t.stack[6] = h$return; | |
t.sp = 6; | |
t.status = h$threadRunning; | |
var excep = null; | |
var blockedOn = null; | |
h$currentThread = t; | |
h$stack = t.stack; | |
h$sp = t.sp; | |
try { | |
while(true) { | |
; | |
while(c !== h$reschedule) { | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
} | |
; | |
if(t.status === h$threadFinished) { | |
; | |
break; | |
} else { | |
; | |
} | |
var b = t.blockedOn; | |
if(typeof b === 'object' && b && b.f && b.f.t === h$BLACKHOLE_CLOSURE) { | |
var bhThread = b.d1; | |
if(bhThread === ct || bhThread === t) { // hit a blackhole from running thread or ourselves | |
; | |
c = h$throw(h$baseZCControlziExceptionziBasezinonTermination, false); | |
} else { // blackhole from other thread, steal it if thread is running | |
// switch to that thread | |
if(h$runBlackholeThreadSync(b)) { | |
; | |
c = h$stack[h$sp]; | |
} else { | |
; | |
blockedOn = b; | |
throw false; | |
} | |
} | |
} else { | |
; | |
blockedOn = b; | |
throw false; | |
} | |
} | |
} catch(e) { excep = e; } | |
if(ct !== null) { | |
h$currentThread = ct; | |
h$stack = ct.stack; | |
h$sp = csp; | |
h$r1 = cr1; | |
} else { | |
h$currentThread = null; | |
h$stack = null; | |
} | |
if(t.status !== h$threadFinished && !cont) { | |
h$removeThreadBlock(t); | |
h$finishThread(t); | |
} | |
if(excep) { | |
throw excep; | |
} | |
return blockedOn; | |
; | |
} | |
// run other threads synchronously until the blackhole is 'freed' | |
// returns true for success, false for failure, a thread blocks | |
function h$runBlackholeThreadSync(bh) { | |
; | |
var ct = h$currentThread; | |
var sp = h$sp; | |
var success = false; | |
var bhs = []; | |
var currentBh = bh; | |
// we don't handle async exceptions here, don't run threads with pending exceptions | |
if(bh.d1.excep.length > 0) { | |
return false; | |
} | |
h$currentThread = bh.d1; | |
h$stack = h$currentThread.stack; | |
h$sp = h$currentThread.sp; | |
var c = (h$currentThread.status === h$threadRunning)?h$stack[h$sp]:h$reschedule; | |
; | |
try { | |
while(true) { | |
while(c !== h$reschedule && currentBh.f.t === h$BLACKHOLE_CLOSURE) { | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
c = c(); | |
} | |
if(c === h$reschedule) { // perhaps new blackhole, then continue with that thread, otherwise fail | |
if(typeof h$currentThread.blockedOn === 'object' && | |
h$currentThread.blockedOn.f && | |
h$currentThread.blockedOn.f.t === h$BLACKHOLE_CLOSURE) { | |
; | |
bhs.push(currentBh); | |
currentBh = h$currentThread.blockedOn; | |
h$currentThread = h$currentThread.blockedOn.d1; | |
if(h$currentThread.excep.length > 0) { | |
break; | |
} | |
h$stack = h$currentThread.stack; | |
h$sp = h$currentThread.sp; | |
c = (h$currentThread.status === h$threadRunning)?h$stack[h$sp]:h$reschedule; | |
} else { | |
; | |
break; | |
} | |
} else { // blackhole updated: suspend thread and pick up the old one | |
; | |
; | |
h$suspendCurrentThread(c); | |
if(bhs.length > 0) { | |
; | |
currentBh = bhs.pop(); | |
h$currentThread = currentBh.d1; | |
h$stack = h$currentThread.stack; | |
h$sp = h$currentThread.sp; | |
} else { | |
; | |
success = true; | |
break; | |
} | |
} | |
} | |
} catch(e) { } | |
// switch back to original thread | |
h$sp = sp; | |
h$stack = ct.stack; | |
h$currentThread = ct; | |
return success; | |
} | |
function h$syncThreadState(tid) { | |
return (tid.isSynchronous ? 1 : 0) | | |
(tid.continueAsync ? 2 : 0); | |
} | |
// run the supplied IO action in a main thread | |
// (program exits when this thread finishes) | |
function h$main(a) { | |
var t = new h$Thread(); | |
//TRACE_SCHEDULER("sched: starting main thread"); | |
t.stack[0] = h$doneMain; | |
if(!h$isBrowser) { | |
t.stack[2] = h$baseZCGHCziTopHandlerzitopHandler; | |
} | |
t.stack[4] = h$ap_1_0; | |
t.stack[5] = h$flushStdout; | |
t.stack[6] = h$return; | |
t.stack[7] = h$ap_1_0; | |
t.stack[8] = a; | |
t.stack[9] = h$return; | |
t.sp = 9; | |
t.label = [h$encodeUtf8("main"), 0]; | |
h$wakeupThread(t); | |
h$startMainLoop(); | |
return t; | |
} | |
// MVar support | |
var h$mvarId = 0; | |
/** @constructor */ | |
function h$MVar() { | |
; | |
this.val = null; | |
this.readers = new h$Queue(); | |
this.writers = new h$Queue(); | |
this.waiters = null; // waiting for a value in the MVar with ReadMVar | |
this.m = 0; // gc mark | |
this.id = ++h$mvarId; | |
} | |
// set the MVar to empty unless there are writers | |
function h$notifyMVarEmpty(mv) { | |
var w = mv.writers.dequeue(); | |
if(w !== null) { | |
var thread = w[0]; | |
var val = w[1]; | |
; | |
mv.val = val; | |
// thread is null if some JavaScript outside Haskell wrote to the MVar | |
if(thread !== null) { | |
h$wakeupThread(thread); | |
} | |
} else { | |
; | |
mv.val = null; | |
} | |
; | |
} | |
// set the MVar to val unless there are readers | |
function h$notifyMVarFull(mv,val) { | |
if(mv.waiters && mv.waiters.length > 0) { | |
for(var i=0;i<mv.waiters.length;i++) { | |
var w = mv.waiters[i]; | |
w.sp += 2; | |
w.stack[w.sp-1] = val; | |
w.stack[w.sp] = h$return; | |
h$wakeupThread(w); | |
} | |
mv.waiters = null; | |
} | |
var r = mv.readers.dequeue(); | |
if(r !== null) { | |
; | |
r.sp += 2; | |
r.stack[r.sp-1] = val; | |
r.stack[r.sp] = h$return; | |
h$wakeupThread(r); | |
mv.val = null; | |
} else { | |
; | |
mv.val = val; | |
} | |
; | |
} | |
function h$takeMVar(mv) { | |
; | |
if(mv.val !== null) { | |
h$r1 = mv.val; | |
h$notifyMVarEmpty(mv); | |
return h$stack[h$sp]; | |
} else { | |
mv.readers.enqueue(h$currentThread); | |
h$currentThread.interruptible = true; | |
h$blockThread(h$currentThread,mv,[h$takeMVar,mv]); | |
return h$reschedule; | |
} | |
} | |
function h$tryTakeMVar(mv) { | |
; | |
if(mv.val === null) { | |
h$ret1 = null; | |
return 0; | |
} else { | |
h$ret1 = mv.val; | |
h$notifyMVarEmpty(mv); | |
return 1; | |
} | |
} | |
function h$readMVar(mv) { | |
; | |
if(mv.val === null) { | |
if(mv.waiters) { | |
mv.waiters.push(h$currentThread); | |
} else { | |
mv.waiters = [h$currentThread]; | |
} | |
h$currentThread.interruptible = true; | |
h$blockThread(h$currentThread,mv,[h$readMVar,mv]); | |
return h$reschedule; | |
} else { | |
h$r1 = mv.val; | |
return h$stack[h$sp]; | |
} | |
} | |
function h$putMVar(mv,val) { | |
; | |
if(mv.val !== null) { | |
mv.writers.enqueue([h$currentThread,val]); | |
h$currentThread.interruptible = true; | |
h$blockThread(h$currentThread,mv,[h$putMVar,mv,val]); | |
return h$reschedule; | |
} else { | |
h$notifyMVarFull(mv,val); | |
return h$stack[h$sp]; | |
} | |
} | |
function h$tryPutMVar(mv,val) { | |
; | |
if(mv.val !== null) { | |
return 0; | |
} else { | |
h$notifyMVarFull(mv,val); | |
return 1; | |
} | |
} | |
// box up a JavaScript value and write it to the MVar synchronously | |
function h$writeMVarJs1(mv,val) { | |
var v = h$c1(h$data1_e, val); | |
if(mv.val !== null) { | |
; | |
mv.writers.enqueue([null,v]); | |
} else { | |
; | |
h$notifyMVarFull(mv,v); | |
} | |
} | |
function h$writeMVarJs2(mv,val1,val2) { | |
var v = h$c2(h$data1_e, val1, val2); | |
if(mv.val !== null) { | |
; | |
mv.writers.enqueue([null,v]); | |
} else { | |
; | |
h$notifyMVarFull(mv,v); | |
} | |
} | |
// IORef support | |
/** @constructor */ | |
function h$MutVar(v) { | |
this.val = v; | |
this.m = 0; | |
} | |
function h$atomicModifyMutVar(mv, fun) { | |
var thunk = h$c2(h$ap1_e, fun, mv.val); | |
mv.val = h$c1(h$select1_e, thunk); | |
return h$c1(h$select2_e, thunk); | |
} | |
// Black holes and updates | |
// caller must save registers on stack | |
function h$blockOnBlackhole(c) { | |
; | |
if(c.d1 === h$currentThread) { | |
; | |
return h$throw(h$baseZCControlziExceptionziBasezinonTermination, false); // is this an async exception? | |
} | |
; | |
if(c.d2 === null) { | |
c.d2 = [h$currentThread]; | |
} else { | |
c.d2.push(h$currentThread); | |
} | |
h$blockThread(h$currentThread,c,[h$resumeBlockOnBlackhole,c]); | |
return h$reschedule; | |
} | |
function h$resumeBlockOnBlackhole(c) { | |
h$r1 = c; | |
return h$ap_0_0_fast(); | |
} | |
// async exception happened in a black hole, make a thunk | |
// to resume the computation | |
// var h$debugResumableId = 0; | |
function h$makeResumable(bh,start,end,extra) { | |
var s = h$stack.slice(start,end+1); | |
if(extra) { | |
s = s.concat(extra); | |
} | |
// TRACE_SCHEDULER("making resumable " + (h$debugResumableId+1) + ", stack: "); | |
// h$dumpStackTop(s,0,s.length-1); | |
bh.f = h$resume_e; | |
bh.d1 = s; | |
bh.d2 = null; | |
// bh.d2 = ++h$debugResumableId; | |
} | |
var h$enabled_capabilities = h$newByteArray(4); | |
h$enabled_capabilities.i3[0] = 1; | |
function h$rtsSupportsBoundThreads() { | |
return 0; | |
} | |
// async foreign calls | |
function h$mkForeignCallback(x) { | |
return function() { | |
if(x.mv === null) { // callback called synchronously | |
x.mv = arguments; | |
} else { | |
h$notifyMVarFull(x.mv, h$c1(h$data1_e, arguments)); | |
h$mainLoop(); | |
} | |
} | |
} | |
// event listeners through MVar | |
function h$makeMVarListener(mv, stopProp, stopImmProp, preventDefault) { | |
var f = function(event) { | |
; | |
h$writeMVarJs1(mv,event); | |
if(stopProp) { event.stopPropagation(); } | |
if(stopImmProp) { event.stopImmediatePropagation(); } | |
if(preventDefault) { event.preventDefault(); } | |
} | |
f.root = mv; | |
return f; | |
} | |
// software transactional memory | |
var h$stmTransactionActive = 0; | |
var h$stmTransactionWaiting = 4; | |
/** @constructor */ | |
function h$Transaction(o, parent) { | |
; | |
this.action = o; | |
// h$TVar -> h$WrittenTVar, transaction-local changed values | |
this.tvars = new h$Map(); | |
// h$TVar -> h$LocalTVar, all local tvars accessed anywhere in the transaction | |
this.accessed = parent===null?new h$Map():parent.accessed; | |
// nonnull while running a check, contains read variables in this part of the transaction | |
this.checkRead = parent===null?null:parent.checkRead; | |
this.parent = parent; | |
this.state = h$stmTransactionActive; | |
this.invariants = []; // invariants added in this transaction | |
this.m = 0; // gc mark | |
} | |
var h$stmInvariantN = 0; | |
/** @constructor */ | |
function h$StmInvariant(a) { | |
this.action = a; | |
this._key = ++h$stmInvariantN; | |
} | |
/** @constructor */ | |
function h$WrittenTVar(tv,v) { | |
this.tvar = tv; | |
this.val = v; | |
} | |
var h$TVarN = 0; | |
/** @constructor */ | |
function h$TVar(v) { | |
; | |
this.val = v; // current value | |
this.blocked = new h$Set(); // threads that get woken up if this TVar is updated | |
this.invariants = null; // invariants that use this TVar (h$Set) | |
this.m = 0; // gc mark | |
this._key = ++h$TVarN; // for storing in h$Map/h$Set | |
} | |
/** @constructor */ | |
function h$TVarsWaiting(s) { | |
this.tvars = s; // h$Set of TVars we're waiting on | |
} | |
/** @constructor */ | |
function h$LocalInvariant(o) { | |
this.action = o; | |
this.dependencies = new h$Set(); | |
} | |
// local view of a TVar | |
/** @constructor */ | |
function h$LocalTVar(v) { | |
; | |
this.readVal = v.val; // the value when read from environment | |
this.val = v.val; // the current uncommitted value | |
this.tvar = v; | |
} | |
function h$atomically(o) { | |
h$p3(o, h$atomically_e, h$checkInvariants_e); | |
return h$stmStartTransaction(o); | |
} | |
function h$stmStartTransaction(o) { | |
; | |
var t = new h$Transaction(o, null); | |
h$currentThread.transaction = t; | |
h$r1 = o; | |
return h$ap_1_0_fast(); | |
} | |
function h$stmUpdateInvariantDependencies(inv) { | |
var ii, iter = h$currentThread.transaction.checkRead.iter(); | |
if(inv instanceof h$LocalInvariant) { | |
while((ii = iter.next()) !== null) inv.dependencies.add(ii); | |
} else { | |
while((ii = iter.next()) !== null) h$stmAddTVarInvariant(ii, inv); | |
} | |
} | |
function h$stmAddTVarInvariant(tv, inv) { | |
if(tv.invariants === null) tv.invariants = new h$Set(); | |
tv.invariants.add(inv); | |
} | |
// commit current transaction, | |
// if it's top-level, commit the TVars, otherwise commit to parent | |
function h$stmCommitTransaction() { | |
var t = h$currentThread.transaction; | |
var tvs = t.tvars; | |
var wtv, i = tvs.iter(); | |
if(t.parent === null) { // top-level commit | |
; | |
// write new value to TVars and collect blocked threads | |
var thread, threadi, blockedThreads = new h$Set(); | |
while((wtv = i.nextVal()) !== null) { | |
h$stmCommitTVar(wtv.tvar, wtv.val, blockedThreads); | |
} | |
// wake up all blocked threads | |
threadi = blockedThreads.iter(); | |
while((thread = threadi.next()) !== null) { | |
h$stmRemoveBlockedThread(thread.blockedOn, thread); | |
h$wakeupThread(thread); | |
} | |
// commit our new invariants | |
for(var j=0;j<t.invariants.length;j++) { | |
h$stmCommitInvariant(t.invariants[j]); | |
} | |
} else { // commit subtransaction | |
; | |
var tpvs = t.parent.tvars; | |
while((wtv = i.nextVal()) !== null) tpvs.put(wtv.tvar, wtv); | |
t.parent.invariants = t.parent.invariants.concat(t.invariants); | |
} | |
h$currentThread.transaction = t.parent; | |
} | |
function h$stmValidateTransaction() { | |
var ltv, i = h$currentThread.transaction.accessed.iter(); | |
while((ltv = i.nextVal()) !== null) { | |
if(ltv.readVal !== ltv.tvar.val) return false; | |
} | |
return true; | |
} | |
function h$stmAbortTransaction() { | |
h$currentThread.transaction = h$currentThread.transaction.parent; | |
} | |
// add an invariant | |
function h$stmCheck(o) { | |
h$currentThread.transaction.invariants.push(new h$LocalInvariant(o)); | |
return false; | |
} | |
function h$stmRetry() { | |
// unwind stack to h$atomically_e or h$stmCatchRetry_e frame | |
while(h$sp > 0) { | |
var f = h$stack[h$sp]; | |
if(f === h$atomically_e || f === h$stmCatchRetry_e) { | |
break; | |
} | |
var size; | |
if(f === h$ap_gen) { | |
size = ((h$stack[h$sp-1] >> 8) + 2); | |
} else { | |
var tag = f.gtag; | |
if(tag < 0) { // dynamic size | |
size = h$stack[h$sp-1]; | |
} else { | |
size = (tag & 0xff) + 1; | |
} | |
} | |
h$sp -= size; | |
} | |
// either h$sp == 0 or at a handler | |
if(h$sp > 0) { | |
if(f === h$atomically_e) { | |
return h$stmSuspendRetry(); | |
} else { // h$stmCatchRetry_e | |
var b = h$stack[h$sp-1]; | |
h$stmAbortTransaction(); | |
h$sp -= 2; | |
h$r1 = b; | |
return h$ap_1_0_fast(); | |
} | |
} else { | |
throw "h$stmRetry: STM retry outside a transaction"; | |
} | |
} | |
function h$stmSuspendRetry() { | |
var tv, i = h$currentThread.transaction.accessed.iter(); | |
var tvs = new h$Set(); | |
while((tv = i.next()) !== null) { | |
; | |
tv.blocked.add(h$currentThread); | |
tvs.add(tv); | |
} | |
var waiting = new h$TVarsWaiting(tvs); | |
h$currentThread.interruptible = true; | |
h$blockThread(h$currentThread, waiting); | |
h$p2(waiting, h$stmResumeRetry_e); | |
return h$reschedule; | |
} | |
function h$stmCatchRetry(a,b) { | |
h$currentThread.transaction = new h$Transaction(b, h$currentThread.transaction); | |
h$p2(b, h$stmCatchRetry_e); | |
h$r1 = a; | |
return h$ap_1_0_fast(); | |
} | |
function h$catchStm(a,handler) { | |
h$p4(h$currentThread.transaction, h$currentThread.mask, handler, h$catchStm_e); | |
h$r1 = a; | |
return h$ap_1_0_fast(); | |
} | |
function h$newTVar(v) { | |
return new h$TVar(v); | |
} | |
function h$readTVar(tv) { | |
return h$readLocalTVar(h$currentThread.transaction,tv); | |
} | |
function h$readTVarIO(tv) { | |
return tv.val; | |
} | |
function h$writeTVar(tv, v) { | |
h$setLocalTVar(h$currentThread.transaction, tv, v); | |
} | |
function h$sameTVar(tv1, tv2) { | |
return tv1 === tv2; | |
} | |
// get the local value of the TVar in the transaction t | |
// tvar is added to the read set | |
function h$readLocalTVar(t, tv) { | |
if(t.checkRead !== null) { | |
t.checkRead.add(tv); | |
} | |
var t0 = t; | |
while(t0 !== null) { | |
var v = t0.tvars.get(tv); | |
if(v !== null) { | |
; | |
return v.val; | |
} | |
t0 = t0.parent; | |
} | |
var lv = t.accessed.get(tv); | |
if(lv !== null) { | |
; | |
return lv.val; | |
} else { | |
; | |
t.accessed.put(tv, new h$LocalTVar(tv)); | |
return tv.val; | |
} | |
} | |
function h$setLocalTVar(t, tv, v) { | |
if(!t.accessed.has(tv)) t.accessed.put(tv, new h$LocalTVar(tv)); | |
if(t.tvars.has(tv)) { | |
t.tvars.get(tv).val = v; | |
} else { | |
t.tvars.put(tv, new h$WrittenTVar(tv, v)) | |
} | |
} | |
function h$stmCheckInvariants() { | |
var t = h$currentThread.transaction; | |
function addCheck(inv) { | |
h$p5(inv, h$stmCheckInvariantResult_e, t, inv, h$stmCheckInvariantStart_e); | |
} | |
h$p2(h$r1, h$return); | |
var wtv, i = t.tvars.iter(); | |
while((wtv = i.nextVal()) !== null) { | |
; | |
var ii = wtv.tvar.invariants; | |
if(ii) { | |
var iv, iii = ii.iter(); | |
while((iv = iii.next()) !== null) addCheck(iv); | |
} | |
} | |
for(var j=0;j<t.invariants.length;j++) { | |
addCheck(t.invariants[j]); | |
} | |
return h$stack[h$sp]; | |
} | |
function h$stmCommitTVar(tv, v, threads) { | |
; | |
if(v !== tv.val) { | |
var thr, iter = tv.blocked.iter(); | |
while((thr = iter.next()) !== null) threads.add(thr); | |
tv.blocked.clear(); | |
tv.val = v; | |
} | |
} | |
// remove the thread from the queues of the TVars in s | |
function h$stmRemoveBlockedThread(s, thread) { | |
var tv, i = s.tvars.iter(); | |
while((tv = i.next()) !== null) { | |
tv.blocked.remove(thread); | |
} | |
} | |
function h$stmCommitInvariant(localInv) { | |
var inv = new h$StmInvariant(localInv.action); | |
var dep, i = localInv.dependencies.iter(); | |
while((dep = i.next()) !== null) { | |
h$stmAddTVarInvariant(dep, inv); | |
} | |
} | |
// static pointers | |
var h$static_pointer_table = null; | |
var h$static_pointer_table_keys = null; | |
function h$hs_spt_insert(key1,key2,key3,key4,ref) { | |
if(!h$static_pointer_table) { | |
h$static_pointer_table = []; | |
h$static_pointer_table_keys = []; | |
} | |
if(!h$hs_spt_lookup_key(key1,key2,key3,key4)) { | |
var ba = h$newByteArray(16); | |
ba.i3[0] = key1; | |
ba.i3[1] = key2; | |
ba.i3[2] = key3; | |
ba.i3[3] = key4; | |
h$static_pointer_table_keys.push([ba,0]); | |
} | |
var s = h$static_pointer_table; | |
if(!s[key1]) s[key1] = []; | |
if(!s[key1][key2]) s[key1][key2] = []; | |
if(!s[key1][key2][key3]) s[key1][key2][key3] = []; | |
s[key1][key2][key3][key4] = ref; | |
} | |
function h$hs_spt_key_count() { | |
return h$static_pointer_table_keys ? | |
h$static_pointer_table_keys.length : 0; | |
} | |
function h$hs_spt_keys(tgt_d, tgt_o, n) { | |
var ks = h$static_pointer_table_keys; | |
if(!tgt_d.arr) tgt_d.arr = []; | |
for(var i=0;(i<n&&i<ks.length);i++) tgt_d.arr[tgt_o+4*i] = ks[i]; | |
return Math.min(n,ks.length); | |
} | |
function h$hs_spt_lookup(key_d, key_o) { | |
var i3 = key_d.i3, o = key_o >> 2; | |
h$ret1 = 0; | |
return h$hs_spt_lookup_key(i3[o],i3[o+1],i3[o+2],i3[o+3]); | |
} | |
function h$hs_spt_lookup_key(key1,key2,key3,key4) { | |
var s = h$static_pointer_table; | |
if(s && s[key1] && s[key1][key2] && s[key1][key2][key3] && | |
s[key1][key2][key3][key4]) return s[key1][key2][key3][key4]; | |
return null; | |
} | |
function h$c(f) | |
{ | |
var h$RTS_0 = { d1: null, d2: null, f: f, m: 0 | |
}; | |
return h$RTS_0; | |
}; | |
function h$c0(f) | |
{ | |
var h$RTS_1 = { d1: null, d2: null, f: f, m: 0 | |
}; | |
return h$RTS_1; | |
}; | |
function h$c1(f, x1) | |
{ | |
var h$RTS_2 = { d1: x1, d2: null, f: f, m: 0 | |
}; | |
return h$RTS_2; | |
}; | |
function h$c2(f, x1, x2) | |
{ | |
var h$RTS_3 = { d1: x1, d2: x2, f: f, m: 0 | |
}; | |
return h$RTS_3; | |
}; | |
function h$c3(f, x1, x2, x3) | |
{ | |
var h$RTS_4 = { d1: x1, d2: { d1: x2, d2: x3 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_4; | |
}; | |
function h$c4(f, x1, x2, x3, x4) | |
{ | |
var h$RTS_5 = { d1: x1, d2: { d1: x2, d2: x3, d3: x4 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_5; | |
}; | |
function h$c5(f, x1, x2, x3, x4, x5) | |
{ | |
var h$RTS_6 = { d1: x1, d2: { d1: x2, d2: x3, d3: x4, d4: x5 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_6; | |
}; | |
function h$c6(f, x1, x2, x3, x4, x5, x6) | |
{ | |
var h$RTS_7 = { d1: x1, d2: { d1: x2, d2: x3, d3: x4, d4: x5, d5: x6 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_7; | |
}; | |
function h$c7(f, x1, x2, x3, x4, x5, x6, x7) | |
{ | |
var h$RTS_8 = { d1: x1, d2: { d1: x2, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_8; | |
}; | |
function h$c8(f, x1, x2, x3, x4, x5, x6, x7, x8) | |
{ | |
var h$RTS_9 = { d1: x1, d2: { d1: x2, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_9; | |
}; | |
function h$c9(f, x1, x2, x3, x4, x5, x6, x7, x8, x9) | |
{ | |
var h$RTS_10 = { d1: x1, d2: { d1: x2, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_10; | |
}; | |
function h$c10(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) | |
{ | |
var h$RTS_11 = { d1: x1, d2: { d1: x2, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_11; | |
}; | |
function h$c11(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) | |
{ | |
var h$RTS_12 = { d1: x1, d2: { d1: x2, d10: x11, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_12; | |
}; | |
function h$c12(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) | |
{ | |
var h$RTS_13 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, | |
d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_13; | |
}; | |
function h$c13(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) | |
{ | |
var h$RTS_14 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, | |
d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_14; | |
}; | |
function h$c14(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) | |
{ | |
var h$RTS_15 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, | |
d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_15; | |
}; | |
function h$c15(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) | |
{ | |
var h$RTS_16 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d2: x3, d3: x4, d4: x5, d5: x6, | |
d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_16; | |
}; | |
function h$c16(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) | |
{ | |
var h$RTS_17 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d2: x3, d3: x4, | |
d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_17; | |
}; | |
function h$c17(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) | |
{ | |
var h$RTS_18 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d2: x3, | |
d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_18; | |
}; | |
function h$c18(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) | |
{ | |
var h$RTS_19 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d17: x18, | |
d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_19; | |
}; | |
function h$c19(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) | |
{ | |
var h$RTS_20 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d17: x18, | |
d18: x19, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_20; | |
}; | |
function h$c20(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) | |
{ | |
var h$RTS_21 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d17: x18, | |
d18: x19, d19: x20, d2: x3, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_21; | |
}; | |
function h$c21(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) | |
{ | |
var h$RTS_22 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d17: x18, | |
d18: x19, d19: x20, d2: x3, d20: x21, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_22; | |
}; | |
function h$c22(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) | |
{ | |
var h$RTS_23 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d17: x18, | |
d18: x19, d19: x20, d2: x3, d20: x21, d21: x22, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_23; | |
}; | |
function h$c23(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, | |
x23) | |
{ | |
var h$RTS_24 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d17: x18, | |
d18: x19, d19: x20, d2: x3, d20: x21, d21: x22, d22: x23, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_24; | |
}; | |
function h$c24(f, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, | |
x23, x24) | |
{ | |
var h$RTS_25 = { d1: x1, d2: { d1: x2, d10: x11, d11: x12, d12: x13, d13: x14, d14: x15, d15: x16, d16: x17, d17: x18, | |
d18: x19, d19: x20, d2: x3, d20: x21, d21: x22, d22: x23, d23: x24, d3: x4, d4: x5, d5: x6, d6: x7, d7: x8, d8: x9, | |
d9: x10 | |
}, f: f, m: 0 | |
}; | |
return h$RTS_25; | |
}; | |
function h$d1(d1) | |
{ | |
return { d1: d1 | |
}; | |
}; | |
function h$d2(d1, d2) | |
{ | |
return { d1: d1, d2: d2 | |
}; | |
}; | |
function h$d3(d1, d2, d3) | |
{ | |
return { d1: d1, d2: d2, d3: d3 | |
}; | |
}; | |
function h$d4(d1, d2, d3, d4) | |
{ | |
return { d1: d1, d2: d2, d3: d3, d4: d4 | |
}; | |
}; | |
function h$d5(d1, d2, d3, d4, d5) | |
{ | |
return { d1: d1, d2: d2, d3: d3, d4: d4, d5: d5 | |
}; | |
}; | |
function h$d6(d1, d2, d3, d4, d5, d6) | |
{ | |
return { d1: d1, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6 | |
}; | |
}; | |
function h$d7(d1, d2, d3, d4, d5, d6, d7) | |
{ | |
return { d1: d1, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7 | |
}; | |
}; | |
function h$d8(d1, d2, d3, d4, d5, d6, d7, d8) | |
{ | |
return { d1: d1, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8 | |
}; | |
}; | |
function h$d9(d1, d2, d3, d4, d5, d6, d7, d8, d9) | |
{ | |
return { d1: d1, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d10(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10) | |
{ | |
return { d1: d1, d10: d10, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d11(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d12(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d13(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d14(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, | |
d8: d8, d9: d9 | |
}; | |
}; | |
function h$d15(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, | |
d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d16(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d2: d2, d3: d3, d4: d4, d5: d5, | |
d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d17(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d2: d2, d3: d3, d4: d4, | |
d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d18(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d18: d18, d2: d2, | |
d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d19(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d18: d18, d19: d19, | |
d2: d2, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d20(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d18: d18, d19: d19, | |
d2: d2, d20: d20, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d21(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20, d21) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d18: d18, d19: d19, | |
d2: d2, d20: d20, d21: d21, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d22(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20, d21, d22) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d18: d18, d19: d19, | |
d2: d2, d20: d20, d21: d21, d22: d22, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d23(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20, d21, d22, d23) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d18: d18, d19: d19, | |
d2: d2, d20: d20, d21: d21, d22: d22, d23: d23, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$d24(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20, d21, d22, d23, | |
d24) | |
{ | |
return { d1: d1, d10: d10, d11: d11, d12: d12, d13: d13, d14: d14, d15: d15, d16: d16, d17: d17, d18: d18, d19: d19, | |
d2: d2, d20: d20, d21: d21, d22: d22, d23: d23, d24: d24, d3: d3, d4: d4, d5: d5, d6: d6, d7: d7, d8: d8, d9: d9 | |
}; | |
}; | |
function h$resetRegisters() | |
{ | |
h$r1 = null; | |
h$r2 = null; | |
h$r3 = null; | |
h$r4 = null; | |
h$r5 = null; | |
h$r6 = null; | |
h$r7 = null; | |
h$r8 = null; | |
h$r9 = null; | |
h$r10 = null; | |
h$r11 = null; | |
h$r12 = null; | |
h$r13 = null; | |
h$r14 = null; | |
h$r15 = null; | |
h$r16 = null; | |
h$r17 = null; | |
h$r18 = null; | |
h$r19 = null; | |
h$r20 = null; | |
h$r21 = null; | |
h$r22 = null; | |
h$r23 = null; | |
h$r24 = null; | |
h$r25 = null; | |
h$r26 = null; | |
h$r27 = null; | |
h$r28 = null; | |
h$r29 = null; | |
h$r30 = null; | |
h$r31 = null; | |
h$r32 = null; | |
h$regs[0] = null; | |
h$regs[1] = null; | |
h$regs[2] = null; | |
h$regs[3] = null; | |
h$regs[4] = null; | |
h$regs[5] = null; | |
h$regs[6] = null; | |
h$regs[7] = null; | |
h$regs[8] = null; | |
h$regs[9] = null; | |
h$regs[10] = null; | |
h$regs[11] = null; | |
h$regs[12] = null; | |
h$regs[13] = null; | |
h$regs[14] = null; | |
h$regs[15] = null; | |
h$regs[16] = null; | |
h$regs[17] = null; | |
h$regs[18] = null; | |
h$regs[19] = null; | |
h$regs[20] = null; | |
h$regs[21] = null; | |
h$regs[22] = null; | |
h$regs[23] = null; | |
h$regs[24] = null; | |
h$regs[25] = null; | |
h$regs[26] = null; | |
h$regs[27] = null; | |
h$regs[28] = null; | |
h$regs[29] = null; | |
h$regs[30] = null; | |
h$regs[31] = null; | |
h$regs[32] = null; | |
h$regs[33] = null; | |
h$regs[34] = null; | |
h$regs[35] = null; | |
h$regs[36] = null; | |
h$regs[37] = null; | |
h$regs[38] = null; | |
h$regs[39] = null; | |
h$regs[40] = null; | |
h$regs[41] = null; | |
h$regs[42] = null; | |
h$regs[43] = null; | |
h$regs[44] = null; | |
h$regs[45] = null; | |
h$regs[46] = null; | |
h$regs[47] = null; | |
h$regs[48] = null; | |
h$regs[49] = null; | |
h$regs[50] = null; | |
h$regs[51] = null; | |
h$regs[52] = null; | |
h$regs[53] = null; | |
h$regs[54] = null; | |
h$regs[55] = null; | |
h$regs[56] = null; | |
h$regs[57] = null; | |
h$regs[58] = null; | |
h$regs[59] = null; | |
h$regs[60] = null; | |
h$regs[61] = null; | |
h$regs[62] = null; | |
h$regs[63] = null; | |
h$regs[64] = null; | |
h$regs[65] = null; | |
h$regs[66] = null; | |
h$regs[67] = null; | |
h$regs[68] = null; | |
h$regs[69] = null; | |
h$regs[70] = null; | |
h$regs[71] = null; | |
h$regs[72] = null; | |
h$regs[73] = null; | |
h$regs[74] = null; | |
h$regs[75] = null; | |
h$regs[76] = null; | |
h$regs[77] = null; | |
h$regs[78] = null; | |
h$regs[79] = null; | |
h$regs[80] = null; | |
h$regs[81] = null; | |
h$regs[82] = null; | |
h$regs[83] = null; | |
h$regs[84] = null; | |
h$regs[85] = null; | |
h$regs[86] = null; | |
h$regs[87] = null; | |
h$regs[88] = null; | |
h$regs[89] = null; | |
h$regs[90] = null; | |
h$regs[91] = null; | |
h$regs[92] = null; | |
h$regs[93] = null; | |
h$regs[94] = null; | |
h$regs[95] = null; | |
}; | |
function h$resetResultVars() | |
{ | |
h$ret1 = null; | |
h$ret2 = null; | |
h$ret3 = null; | |
h$ret4 = null; | |
h$ret5 = null; | |
h$ret6 = null; | |
h$ret7 = null; | |
h$ret8 = null; | |
h$ret9 = null; | |
h$ret10 = null; | |
}; | |
function h$p1(x1) | |
{ | |
++h$sp; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$p2(x1, x2) | |
{ | |
h$sp += 2; | |
h$stack[(h$sp - 1)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$p3(x1, x2, x3) | |
{ | |
h$sp += 3; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$p4(x1, x2, x3, x4) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$p5(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$p6(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$p7(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 1)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$p8(x1, x2, x3, x4, x5, x6, x7, x8) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 3)] = x5; | |
h$stack[(h$sp - 2)] = x6; | |
h$stack[(h$sp - 1)] = x7; | |
h$stack[(h$sp - 0)] = x8; | |
}; | |
function h$p9(x1, x2, x3, x4, x5, x6, x7, x8, x9) | |
{ | |
h$sp += 9; | |
h$stack[(h$sp - 8)] = x1; | |
h$stack[(h$sp - 7)] = x2; | |
h$stack[(h$sp - 6)] = x3; | |
h$stack[(h$sp - 5)] = x4; | |
h$stack[(h$sp - 4)] = x5; | |
h$stack[(h$sp - 3)] = x6; | |
h$stack[(h$sp - 2)] = x7; | |
h$stack[(h$sp - 1)] = x8; | |
h$stack[(h$sp - 0)] = x9; | |
}; | |
function h$p10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) | |
{ | |
h$sp += 10; | |
h$stack[(h$sp - 9)] = x1; | |
h$stack[(h$sp - 8)] = x2; | |
h$stack[(h$sp - 7)] = x3; | |
h$stack[(h$sp - 6)] = x4; | |
h$stack[(h$sp - 5)] = x5; | |
h$stack[(h$sp - 4)] = x6; | |
h$stack[(h$sp - 3)] = x7; | |
h$stack[(h$sp - 2)] = x8; | |
h$stack[(h$sp - 1)] = x9; | |
h$stack[(h$sp - 0)] = x10; | |
}; | |
function h$p11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) | |
{ | |
h$sp += 11; | |
h$stack[(h$sp - 10)] = x1; | |
h$stack[(h$sp - 9)] = x2; | |
h$stack[(h$sp - 8)] = x3; | |
h$stack[(h$sp - 7)] = x4; | |
h$stack[(h$sp - 6)] = x5; | |
h$stack[(h$sp - 5)] = x6; | |
h$stack[(h$sp - 4)] = x7; | |
h$stack[(h$sp - 3)] = x8; | |
h$stack[(h$sp - 2)] = x9; | |
h$stack[(h$sp - 1)] = x10; | |
h$stack[(h$sp - 0)] = x11; | |
}; | |
function h$p12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) | |
{ | |
h$sp += 12; | |
h$stack[(h$sp - 11)] = x1; | |
h$stack[(h$sp - 10)] = x2; | |
h$stack[(h$sp - 9)] = x3; | |
h$stack[(h$sp - 8)] = x4; | |
h$stack[(h$sp - 7)] = x5; | |
h$stack[(h$sp - 6)] = x6; | |
h$stack[(h$sp - 5)] = x7; | |
h$stack[(h$sp - 4)] = x8; | |
h$stack[(h$sp - 3)] = x9; | |
h$stack[(h$sp - 2)] = x10; | |
h$stack[(h$sp - 1)] = x11; | |
h$stack[(h$sp - 0)] = x12; | |
}; | |
function h$p13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) | |
{ | |
h$sp += 13; | |
h$stack[(h$sp - 12)] = x1; | |
h$stack[(h$sp - 11)] = x2; | |
h$stack[(h$sp - 10)] = x3; | |
h$stack[(h$sp - 9)] = x4; | |
h$stack[(h$sp - 8)] = x5; | |
h$stack[(h$sp - 7)] = x6; | |
h$stack[(h$sp - 6)] = x7; | |
h$stack[(h$sp - 5)] = x8; | |
h$stack[(h$sp - 4)] = x9; | |
h$stack[(h$sp - 3)] = x10; | |
h$stack[(h$sp - 2)] = x11; | |
h$stack[(h$sp - 1)] = x12; | |
h$stack[(h$sp - 0)] = x13; | |
}; | |
function h$p14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) | |
{ | |
h$sp += 14; | |
h$stack[(h$sp - 13)] = x1; | |
h$stack[(h$sp - 12)] = x2; | |
h$stack[(h$sp - 11)] = x3; | |
h$stack[(h$sp - 10)] = x4; | |
h$stack[(h$sp - 9)] = x5; | |
h$stack[(h$sp - 8)] = x6; | |
h$stack[(h$sp - 7)] = x7; | |
h$stack[(h$sp - 6)] = x8; | |
h$stack[(h$sp - 5)] = x9; | |
h$stack[(h$sp - 4)] = x10; | |
h$stack[(h$sp - 3)] = x11; | |
h$stack[(h$sp - 2)] = x12; | |
h$stack[(h$sp - 1)] = x13; | |
h$stack[(h$sp - 0)] = x14; | |
}; | |
function h$p15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) | |
{ | |
h$sp += 15; | |
h$stack[(h$sp - 14)] = x1; | |
h$stack[(h$sp - 13)] = x2; | |
h$stack[(h$sp - 12)] = x3; | |
h$stack[(h$sp - 11)] = x4; | |
h$stack[(h$sp - 10)] = x5; | |
h$stack[(h$sp - 9)] = x6; | |
h$stack[(h$sp - 8)] = x7; | |
h$stack[(h$sp - 7)] = x8; | |
h$stack[(h$sp - 6)] = x9; | |
h$stack[(h$sp - 5)] = x10; | |
h$stack[(h$sp - 4)] = x11; | |
h$stack[(h$sp - 3)] = x12; | |
h$stack[(h$sp - 2)] = x13; | |
h$stack[(h$sp - 1)] = x14; | |
h$stack[(h$sp - 0)] = x15; | |
}; | |
function h$p16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) | |
{ | |
h$sp += 16; | |
h$stack[(h$sp - 15)] = x1; | |
h$stack[(h$sp - 14)] = x2; | |
h$stack[(h$sp - 13)] = x3; | |
h$stack[(h$sp - 12)] = x4; | |
h$stack[(h$sp - 11)] = x5; | |
h$stack[(h$sp - 10)] = x6; | |
h$stack[(h$sp - 9)] = x7; | |
h$stack[(h$sp - 8)] = x8; | |
h$stack[(h$sp - 7)] = x9; | |
h$stack[(h$sp - 6)] = x10; | |
h$stack[(h$sp - 5)] = x11; | |
h$stack[(h$sp - 4)] = x12; | |
h$stack[(h$sp - 3)] = x13; | |
h$stack[(h$sp - 2)] = x14; | |
h$stack[(h$sp - 1)] = x15; | |
h$stack[(h$sp - 0)] = x16; | |
}; | |
function h$p17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) | |
{ | |
h$sp += 17; | |
h$stack[(h$sp - 16)] = x1; | |
h$stack[(h$sp - 15)] = x2; | |
h$stack[(h$sp - 14)] = x3; | |
h$stack[(h$sp - 13)] = x4; | |
h$stack[(h$sp - 12)] = x5; | |
h$stack[(h$sp - 11)] = x6; | |
h$stack[(h$sp - 10)] = x7; | |
h$stack[(h$sp - 9)] = x8; | |
h$stack[(h$sp - 8)] = x9; | |
h$stack[(h$sp - 7)] = x10; | |
h$stack[(h$sp - 6)] = x11; | |
h$stack[(h$sp - 5)] = x12; | |
h$stack[(h$sp - 4)] = x13; | |
h$stack[(h$sp - 3)] = x14; | |
h$stack[(h$sp - 2)] = x15; | |
h$stack[(h$sp - 1)] = x16; | |
h$stack[(h$sp - 0)] = x17; | |
}; | |
function h$p18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 17)] = x1; | |
h$stack[(h$sp - 16)] = x2; | |
h$stack[(h$sp - 15)] = x3; | |
h$stack[(h$sp - 14)] = x4; | |
h$stack[(h$sp - 13)] = x5; | |
h$stack[(h$sp - 12)] = x6; | |
h$stack[(h$sp - 11)] = x7; | |
h$stack[(h$sp - 10)] = x8; | |
h$stack[(h$sp - 9)] = x9; | |
h$stack[(h$sp - 8)] = x10; | |
h$stack[(h$sp - 7)] = x11; | |
h$stack[(h$sp - 6)] = x12; | |
h$stack[(h$sp - 5)] = x13; | |
h$stack[(h$sp - 4)] = x14; | |
h$stack[(h$sp - 3)] = x15; | |
h$stack[(h$sp - 2)] = x16; | |
h$stack[(h$sp - 1)] = x17; | |
h$stack[(h$sp - 0)] = x18; | |
}; | |
function h$p19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 18)] = x1; | |
h$stack[(h$sp - 17)] = x2; | |
h$stack[(h$sp - 16)] = x3; | |
h$stack[(h$sp - 15)] = x4; | |
h$stack[(h$sp - 14)] = x5; | |
h$stack[(h$sp - 13)] = x6; | |
h$stack[(h$sp - 12)] = x7; | |
h$stack[(h$sp - 11)] = x8; | |
h$stack[(h$sp - 10)] = x9; | |
h$stack[(h$sp - 9)] = x10; | |
h$stack[(h$sp - 8)] = x11; | |
h$stack[(h$sp - 7)] = x12; | |
h$stack[(h$sp - 6)] = x13; | |
h$stack[(h$sp - 5)] = x14; | |
h$stack[(h$sp - 4)] = x15; | |
h$stack[(h$sp - 3)] = x16; | |
h$stack[(h$sp - 2)] = x17; | |
h$stack[(h$sp - 1)] = x18; | |
h$stack[(h$sp - 0)] = x19; | |
}; | |
function h$p20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) | |
{ | |
h$sp += 20; | |
h$stack[(h$sp - 19)] = x1; | |
h$stack[(h$sp - 18)] = x2; | |
h$stack[(h$sp - 17)] = x3; | |
h$stack[(h$sp - 16)] = x4; | |
h$stack[(h$sp - 15)] = x5; | |
h$stack[(h$sp - 14)] = x6; | |
h$stack[(h$sp - 13)] = x7; | |
h$stack[(h$sp - 12)] = x8; | |
h$stack[(h$sp - 11)] = x9; | |
h$stack[(h$sp - 10)] = x10; | |
h$stack[(h$sp - 9)] = x11; | |
h$stack[(h$sp - 8)] = x12; | |
h$stack[(h$sp - 7)] = x13; | |
h$stack[(h$sp - 6)] = x14; | |
h$stack[(h$sp - 5)] = x15; | |
h$stack[(h$sp - 4)] = x16; | |
h$stack[(h$sp - 3)] = x17; | |
h$stack[(h$sp - 2)] = x18; | |
h$stack[(h$sp - 1)] = x19; | |
h$stack[(h$sp - 0)] = x20; | |
}; | |
function h$p21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) | |
{ | |
h$sp += 21; | |
h$stack[(h$sp - 20)] = x1; | |
h$stack[(h$sp - 19)] = x2; | |
h$stack[(h$sp - 18)] = x3; | |
h$stack[(h$sp - 17)] = x4; | |
h$stack[(h$sp - 16)] = x5; | |
h$stack[(h$sp - 15)] = x6; | |
h$stack[(h$sp - 14)] = x7; | |
h$stack[(h$sp - 13)] = x8; | |
h$stack[(h$sp - 12)] = x9; | |
h$stack[(h$sp - 11)] = x10; | |
h$stack[(h$sp - 10)] = x11; | |
h$stack[(h$sp - 9)] = x12; | |
h$stack[(h$sp - 8)] = x13; | |
h$stack[(h$sp - 7)] = x14; | |
h$stack[(h$sp - 6)] = x15; | |
h$stack[(h$sp - 5)] = x16; | |
h$stack[(h$sp - 4)] = x17; | |
h$stack[(h$sp - 3)] = x18; | |
h$stack[(h$sp - 2)] = x19; | |
h$stack[(h$sp - 1)] = x20; | |
h$stack[(h$sp - 0)] = x21; | |
}; | |
function h$p22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) | |
{ | |
h$sp += 22; | |
h$stack[(h$sp - 21)] = x1; | |
h$stack[(h$sp - 20)] = x2; | |
h$stack[(h$sp - 19)] = x3; | |
h$stack[(h$sp - 18)] = x4; | |
h$stack[(h$sp - 17)] = x5; | |
h$stack[(h$sp - 16)] = x6; | |
h$stack[(h$sp - 15)] = x7; | |
h$stack[(h$sp - 14)] = x8; | |
h$stack[(h$sp - 13)] = x9; | |
h$stack[(h$sp - 12)] = x10; | |
h$stack[(h$sp - 11)] = x11; | |
h$stack[(h$sp - 10)] = x12; | |
h$stack[(h$sp - 9)] = x13; | |
h$stack[(h$sp - 8)] = x14; | |
h$stack[(h$sp - 7)] = x15; | |
h$stack[(h$sp - 6)] = x16; | |
h$stack[(h$sp - 5)] = x17; | |
h$stack[(h$sp - 4)] = x18; | |
h$stack[(h$sp - 3)] = x19; | |
h$stack[(h$sp - 2)] = x20; | |
h$stack[(h$sp - 1)] = x21; | |
h$stack[(h$sp - 0)] = x22; | |
}; | |
function h$p23(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23) | |
{ | |
h$sp += 23; | |
h$stack[(h$sp - 22)] = x1; | |
h$stack[(h$sp - 21)] = x2; | |
h$stack[(h$sp - 20)] = x3; | |
h$stack[(h$sp - 19)] = x4; | |
h$stack[(h$sp - 18)] = x5; | |
h$stack[(h$sp - 17)] = x6; | |
h$stack[(h$sp - 16)] = x7; | |
h$stack[(h$sp - 15)] = x8; | |
h$stack[(h$sp - 14)] = x9; | |
h$stack[(h$sp - 13)] = x10; | |
h$stack[(h$sp - 12)] = x11; | |
h$stack[(h$sp - 11)] = x12; | |
h$stack[(h$sp - 10)] = x13; | |
h$stack[(h$sp - 9)] = x14; | |
h$stack[(h$sp - 8)] = x15; | |
h$stack[(h$sp - 7)] = x16; | |
h$stack[(h$sp - 6)] = x17; | |
h$stack[(h$sp - 5)] = x18; | |
h$stack[(h$sp - 4)] = x19; | |
h$stack[(h$sp - 3)] = x20; | |
h$stack[(h$sp - 2)] = x21; | |
h$stack[(h$sp - 1)] = x22; | |
h$stack[(h$sp - 0)] = x23; | |
}; | |
function h$p24(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24) | |
{ | |
h$sp += 24; | |
h$stack[(h$sp - 23)] = x1; | |
h$stack[(h$sp - 22)] = x2; | |
h$stack[(h$sp - 21)] = x3; | |
h$stack[(h$sp - 20)] = x4; | |
h$stack[(h$sp - 19)] = x5; | |
h$stack[(h$sp - 18)] = x6; | |
h$stack[(h$sp - 17)] = x7; | |
h$stack[(h$sp - 16)] = x8; | |
h$stack[(h$sp - 15)] = x9; | |
h$stack[(h$sp - 14)] = x10; | |
h$stack[(h$sp - 13)] = x11; | |
h$stack[(h$sp - 12)] = x12; | |
h$stack[(h$sp - 11)] = x13; | |
h$stack[(h$sp - 10)] = x14; | |
h$stack[(h$sp - 9)] = x15; | |
h$stack[(h$sp - 8)] = x16; | |
h$stack[(h$sp - 7)] = x17; | |
h$stack[(h$sp - 6)] = x18; | |
h$stack[(h$sp - 5)] = x19; | |
h$stack[(h$sp - 4)] = x20; | |
h$stack[(h$sp - 3)] = x21; | |
h$stack[(h$sp - 2)] = x22; | |
h$stack[(h$sp - 1)] = x23; | |
h$stack[(h$sp - 0)] = x24; | |
}; | |
function h$p25(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25) | |
{ | |
h$sp += 25; | |
h$stack[(h$sp - 24)] = x1; | |
h$stack[(h$sp - 23)] = x2; | |
h$stack[(h$sp - 22)] = x3; | |
h$stack[(h$sp - 21)] = x4; | |
h$stack[(h$sp - 20)] = x5; | |
h$stack[(h$sp - 19)] = x6; | |
h$stack[(h$sp - 18)] = x7; | |
h$stack[(h$sp - 17)] = x8; | |
h$stack[(h$sp - 16)] = x9; | |
h$stack[(h$sp - 15)] = x10; | |
h$stack[(h$sp - 14)] = x11; | |
h$stack[(h$sp - 13)] = x12; | |
h$stack[(h$sp - 12)] = x13; | |
h$stack[(h$sp - 11)] = x14; | |
h$stack[(h$sp - 10)] = x15; | |
h$stack[(h$sp - 9)] = x16; | |
h$stack[(h$sp - 8)] = x17; | |
h$stack[(h$sp - 7)] = x18; | |
h$stack[(h$sp - 6)] = x19; | |
h$stack[(h$sp - 5)] = x20; | |
h$stack[(h$sp - 4)] = x21; | |
h$stack[(h$sp - 3)] = x22; | |
h$stack[(h$sp - 2)] = x23; | |
h$stack[(h$sp - 1)] = x24; | |
h$stack[(h$sp - 0)] = x25; | |
}; | |
function h$p26(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26) | |
{ | |
h$sp += 26; | |
h$stack[(h$sp - 25)] = x1; | |
h$stack[(h$sp - 24)] = x2; | |
h$stack[(h$sp - 23)] = x3; | |
h$stack[(h$sp - 22)] = x4; | |
h$stack[(h$sp - 21)] = x5; | |
h$stack[(h$sp - 20)] = x6; | |
h$stack[(h$sp - 19)] = x7; | |
h$stack[(h$sp - 18)] = x8; | |
h$stack[(h$sp - 17)] = x9; | |
h$stack[(h$sp - 16)] = x10; | |
h$stack[(h$sp - 15)] = x11; | |
h$stack[(h$sp - 14)] = x12; | |
h$stack[(h$sp - 13)] = x13; | |
h$stack[(h$sp - 12)] = x14; | |
h$stack[(h$sp - 11)] = x15; | |
h$stack[(h$sp - 10)] = x16; | |
h$stack[(h$sp - 9)] = x17; | |
h$stack[(h$sp - 8)] = x18; | |
h$stack[(h$sp - 7)] = x19; | |
h$stack[(h$sp - 6)] = x20; | |
h$stack[(h$sp - 5)] = x21; | |
h$stack[(h$sp - 4)] = x22; | |
h$stack[(h$sp - 3)] = x23; | |
h$stack[(h$sp - 2)] = x24; | |
h$stack[(h$sp - 1)] = x25; | |
h$stack[(h$sp - 0)] = x26; | |
}; | |
function h$p27(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27) | |
{ | |
h$sp += 27; | |
h$stack[(h$sp - 26)] = x1; | |
h$stack[(h$sp - 25)] = x2; | |
h$stack[(h$sp - 24)] = x3; | |
h$stack[(h$sp - 23)] = x4; | |
h$stack[(h$sp - 22)] = x5; | |
h$stack[(h$sp - 21)] = x6; | |
h$stack[(h$sp - 20)] = x7; | |
h$stack[(h$sp - 19)] = x8; | |
h$stack[(h$sp - 18)] = x9; | |
h$stack[(h$sp - 17)] = x10; | |
h$stack[(h$sp - 16)] = x11; | |
h$stack[(h$sp - 15)] = x12; | |
h$stack[(h$sp - 14)] = x13; | |
h$stack[(h$sp - 13)] = x14; | |
h$stack[(h$sp - 12)] = x15; | |
h$stack[(h$sp - 11)] = x16; | |
h$stack[(h$sp - 10)] = x17; | |
h$stack[(h$sp - 9)] = x18; | |
h$stack[(h$sp - 8)] = x19; | |
h$stack[(h$sp - 7)] = x20; | |
h$stack[(h$sp - 6)] = x21; | |
h$stack[(h$sp - 5)] = x22; | |
h$stack[(h$sp - 4)] = x23; | |
h$stack[(h$sp - 3)] = x24; | |
h$stack[(h$sp - 2)] = x25; | |
h$stack[(h$sp - 1)] = x26; | |
h$stack[(h$sp - 0)] = x27; | |
}; | |
function h$p28(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28) | |
{ | |
h$sp += 28; | |
h$stack[(h$sp - 27)] = x1; | |
h$stack[(h$sp - 26)] = x2; | |
h$stack[(h$sp - 25)] = x3; | |
h$stack[(h$sp - 24)] = x4; | |
h$stack[(h$sp - 23)] = x5; | |
h$stack[(h$sp - 22)] = x6; | |
h$stack[(h$sp - 21)] = x7; | |
h$stack[(h$sp - 20)] = x8; | |
h$stack[(h$sp - 19)] = x9; | |
h$stack[(h$sp - 18)] = x10; | |
h$stack[(h$sp - 17)] = x11; | |
h$stack[(h$sp - 16)] = x12; | |
h$stack[(h$sp - 15)] = x13; | |
h$stack[(h$sp - 14)] = x14; | |
h$stack[(h$sp - 13)] = x15; | |
h$stack[(h$sp - 12)] = x16; | |
h$stack[(h$sp - 11)] = x17; | |
h$stack[(h$sp - 10)] = x18; | |
h$stack[(h$sp - 9)] = x19; | |
h$stack[(h$sp - 8)] = x20; | |
h$stack[(h$sp - 7)] = x21; | |
h$stack[(h$sp - 6)] = x22; | |
h$stack[(h$sp - 5)] = x23; | |
h$stack[(h$sp - 4)] = x24; | |
h$stack[(h$sp - 3)] = x25; | |
h$stack[(h$sp - 2)] = x26; | |
h$stack[(h$sp - 1)] = x27; | |
h$stack[(h$sp - 0)] = x28; | |
}; | |
function h$p29(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29) | |
{ | |
h$sp += 29; | |
h$stack[(h$sp - 28)] = x1; | |
h$stack[(h$sp - 27)] = x2; | |
h$stack[(h$sp - 26)] = x3; | |
h$stack[(h$sp - 25)] = x4; | |
h$stack[(h$sp - 24)] = x5; | |
h$stack[(h$sp - 23)] = x6; | |
h$stack[(h$sp - 22)] = x7; | |
h$stack[(h$sp - 21)] = x8; | |
h$stack[(h$sp - 20)] = x9; | |
h$stack[(h$sp - 19)] = x10; | |
h$stack[(h$sp - 18)] = x11; | |
h$stack[(h$sp - 17)] = x12; | |
h$stack[(h$sp - 16)] = x13; | |
h$stack[(h$sp - 15)] = x14; | |
h$stack[(h$sp - 14)] = x15; | |
h$stack[(h$sp - 13)] = x16; | |
h$stack[(h$sp - 12)] = x17; | |
h$stack[(h$sp - 11)] = x18; | |
h$stack[(h$sp - 10)] = x19; | |
h$stack[(h$sp - 9)] = x20; | |
h$stack[(h$sp - 8)] = x21; | |
h$stack[(h$sp - 7)] = x22; | |
h$stack[(h$sp - 6)] = x23; | |
h$stack[(h$sp - 5)] = x24; | |
h$stack[(h$sp - 4)] = x25; | |
h$stack[(h$sp - 3)] = x26; | |
h$stack[(h$sp - 2)] = x27; | |
h$stack[(h$sp - 1)] = x28; | |
h$stack[(h$sp - 0)] = x29; | |
}; | |
function h$p30(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29, x30) | |
{ | |
h$sp += 30; | |
h$stack[(h$sp - 29)] = x1; | |
h$stack[(h$sp - 28)] = x2; | |
h$stack[(h$sp - 27)] = x3; | |
h$stack[(h$sp - 26)] = x4; | |
h$stack[(h$sp - 25)] = x5; | |
h$stack[(h$sp - 24)] = x6; | |
h$stack[(h$sp - 23)] = x7; | |
h$stack[(h$sp - 22)] = x8; | |
h$stack[(h$sp - 21)] = x9; | |
h$stack[(h$sp - 20)] = x10; | |
h$stack[(h$sp - 19)] = x11; | |
h$stack[(h$sp - 18)] = x12; | |
h$stack[(h$sp - 17)] = x13; | |
h$stack[(h$sp - 16)] = x14; | |
h$stack[(h$sp - 15)] = x15; | |
h$stack[(h$sp - 14)] = x16; | |
h$stack[(h$sp - 13)] = x17; | |
h$stack[(h$sp - 12)] = x18; | |
h$stack[(h$sp - 11)] = x19; | |
h$stack[(h$sp - 10)] = x20; | |
h$stack[(h$sp - 9)] = x21; | |
h$stack[(h$sp - 8)] = x22; | |
h$stack[(h$sp - 7)] = x23; | |
h$stack[(h$sp - 6)] = x24; | |
h$stack[(h$sp - 5)] = x25; | |
h$stack[(h$sp - 4)] = x26; | |
h$stack[(h$sp - 3)] = x27; | |
h$stack[(h$sp - 2)] = x28; | |
h$stack[(h$sp - 1)] = x29; | |
h$stack[(h$sp - 0)] = x30; | |
}; | |
function h$p31(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29, x30, x31) | |
{ | |
h$sp += 31; | |
h$stack[(h$sp - 30)] = x1; | |
h$stack[(h$sp - 29)] = x2; | |
h$stack[(h$sp - 28)] = x3; | |
h$stack[(h$sp - 27)] = x4; | |
h$stack[(h$sp - 26)] = x5; | |
h$stack[(h$sp - 25)] = x6; | |
h$stack[(h$sp - 24)] = x7; | |
h$stack[(h$sp - 23)] = x8; | |
h$stack[(h$sp - 22)] = x9; | |
h$stack[(h$sp - 21)] = x10; | |
h$stack[(h$sp - 20)] = x11; | |
h$stack[(h$sp - 19)] = x12; | |
h$stack[(h$sp - 18)] = x13; | |
h$stack[(h$sp - 17)] = x14; | |
h$stack[(h$sp - 16)] = x15; | |
h$stack[(h$sp - 15)] = x16; | |
h$stack[(h$sp - 14)] = x17; | |
h$stack[(h$sp - 13)] = x18; | |
h$stack[(h$sp - 12)] = x19; | |
h$stack[(h$sp - 11)] = x20; | |
h$stack[(h$sp - 10)] = x21; | |
h$stack[(h$sp - 9)] = x22; | |
h$stack[(h$sp - 8)] = x23; | |
h$stack[(h$sp - 7)] = x24; | |
h$stack[(h$sp - 6)] = x25; | |
h$stack[(h$sp - 5)] = x26; | |
h$stack[(h$sp - 4)] = x27; | |
h$stack[(h$sp - 3)] = x28; | |
h$stack[(h$sp - 2)] = x29; | |
h$stack[(h$sp - 1)] = x30; | |
h$stack[(h$sp - 0)] = x31; | |
}; | |
function h$p32(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, | |
x24, x25, x26, x27, x28, x29, x30, x31, x32) | |
{ | |
h$sp += 32; | |
h$stack[(h$sp - 31)] = x1; | |
h$stack[(h$sp - 30)] = x2; | |
h$stack[(h$sp - 29)] = x3; | |
h$stack[(h$sp - 28)] = x4; | |
h$stack[(h$sp - 27)] = x5; | |
h$stack[(h$sp - 26)] = x6; | |
h$stack[(h$sp - 25)] = x7; | |
h$stack[(h$sp - 24)] = x8; | |
h$stack[(h$sp - 23)] = x9; | |
h$stack[(h$sp - 22)] = x10; | |
h$stack[(h$sp - 21)] = x11; | |
h$stack[(h$sp - 20)] = x12; | |
h$stack[(h$sp - 19)] = x13; | |
h$stack[(h$sp - 18)] = x14; | |
h$stack[(h$sp - 17)] = x15; | |
h$stack[(h$sp - 16)] = x16; | |
h$stack[(h$sp - 15)] = x17; | |
h$stack[(h$sp - 14)] = x18; | |
h$stack[(h$sp - 13)] = x19; | |
h$stack[(h$sp - 12)] = x20; | |
h$stack[(h$sp - 11)] = x21; | |
h$stack[(h$sp - 10)] = x22; | |
h$stack[(h$sp - 9)] = x23; | |
h$stack[(h$sp - 8)] = x24; | |
h$stack[(h$sp - 7)] = x25; | |
h$stack[(h$sp - 6)] = x26; | |
h$stack[(h$sp - 5)] = x27; | |
h$stack[(h$sp - 4)] = x28; | |
h$stack[(h$sp - 3)] = x29; | |
h$stack[(h$sp - 2)] = x30; | |
h$stack[(h$sp - 1)] = x31; | |
h$stack[(h$sp - 0)] = x32; | |
}; | |
function h$pp2(x1) | |
{ | |
h$sp += 2; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$pp4(x1) | |
{ | |
h$sp += 3; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$pp5(x1, x2) | |
{ | |
h$sp += 3; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp6(x1, x2) | |
{ | |
h$sp += 3; | |
h$stack[(h$sp - 1)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp8(x1) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$pp9(x1, x2) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp10(x1, x2) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp11(x1, x2, x3) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp12(x1, x2) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 1)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp13(x1, x2, x3) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp14(x1, x2, x3) | |
{ | |
h$sp += 4; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp16(x1) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$pp17(x1, x2) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp18(x1, x2) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp19(x1, x2, x3) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp20(x1, x2) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp21(x1, x2, x3) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp22(x1, x2, x3) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp23(x1, x2, x3, x4) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp24(x1, x2) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 1)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp25(x1, x2, x3) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp26(x1, x2, x3) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp27(x1, x2, x3, x4) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp28(x1, x2, x3) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp29(x1, x2, x3, x4) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp30(x1, x2, x3, x4) | |
{ | |
h$sp += 5; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp32(x1) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$pp33(x1, x2) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp34(x1, x2) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp35(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp36(x1, x2) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp37(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp38(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp39(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp40(x1, x2) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp41(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp42(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp43(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp44(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp45(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp46(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp47(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp48(x1, x2) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 1)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp49(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp50(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp51(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp52(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp53(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp54(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp55(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp56(x1, x2, x3) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp57(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp58(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp59(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp60(x1, x2, x3, x4) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp61(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp62(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp64(x1) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$pp65(x1, x2) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp66(x1, x2) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp67(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp68(x1, x2) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp69(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp70(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp71(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp72(x1, x2) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp73(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp74(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp75(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp76(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp77(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp78(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp79(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp80(x1, x2) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp81(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp82(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp83(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp84(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp85(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp86(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp87(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp88(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp89(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp90(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp91(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp92(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp93(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp94(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp95(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp96(x1, x2) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 1)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp97(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp98(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp99(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp100(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp101(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp102(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp103(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp104(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp105(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp106(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp107(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp108(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp109(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp110(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp111(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp112(x1, x2, x3) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp113(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp114(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp115(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp116(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp117(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp118(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp119(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp120(x1, x2, x3, x4) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp121(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp122(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp123(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp124(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp125(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp126(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 7; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp128(x1) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 0)] = x1; | |
}; | |
function h$pp129(x1, x2) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp130(x1, x2) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp131(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp132(x1, x2) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp133(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp134(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp135(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp136(x1, x2) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp137(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp138(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp139(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp140(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp141(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp142(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp143(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp144(x1, x2) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp145(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp146(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp147(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp148(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp149(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp150(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp151(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp152(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp153(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp154(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp155(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp156(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp157(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp158(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp159(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 3)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp160(x1, x2) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp161(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp162(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp163(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp164(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp165(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp166(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp167(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp168(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp169(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp170(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp171(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp172(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp173(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp174(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp175(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp176(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp177(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp178(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp179(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp180(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp181(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp182(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp183(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp184(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp185(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp186(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp187(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp188(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp189(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp190(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp191(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 3)] = x5; | |
h$stack[(h$sp - 2)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$pp192(x1, x2) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 1)] = x1; | |
h$stack[(h$sp - 0)] = x2; | |
}; | |
function h$pp193(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp194(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp195(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp196(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp197(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp198(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp199(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp200(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp201(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp202(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp203(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp204(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp205(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp206(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp207(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp208(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp209(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp210(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp211(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp212(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp213(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp214(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp215(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp216(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp217(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp218(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp219(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp220(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp221(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp222(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp223(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 3)] = x5; | |
h$stack[(h$sp - 1)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$pp224(x1, x2, x3) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 2)] = x1; | |
h$stack[(h$sp - 1)] = x2; | |
h$stack[(h$sp - 0)] = x3; | |
}; | |
function h$pp225(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp226(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp227(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp228(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp229(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp230(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp231(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp232(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp233(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp234(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp235(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp236(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp237(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp238(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp239(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 4)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 1)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$pp240(x1, x2, x3, x4) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 3)] = x1; | |
h$stack[(h$sp - 2)] = x2; | |
h$stack[(h$sp - 1)] = x3; | |
h$stack[(h$sp - 0)] = x4; | |
}; | |
function h$pp241(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp242(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp243(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp244(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp245(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp246(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp247(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 5)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 1)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$pp248(x1, x2, x3, x4, x5) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 4)] = x1; | |
h$stack[(h$sp - 3)] = x2; | |
h$stack[(h$sp - 2)] = x3; | |
h$stack[(h$sp - 1)] = x4; | |
h$stack[(h$sp - 0)] = x5; | |
}; | |
function h$pp249(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp250(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp251(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 6)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 1)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$pp252(x1, x2, x3, x4, x5, x6) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 5)] = x1; | |
h$stack[(h$sp - 4)] = x2; | |
h$stack[(h$sp - 3)] = x3; | |
h$stack[(h$sp - 2)] = x4; | |
h$stack[(h$sp - 1)] = x5; | |
h$stack[(h$sp - 0)] = x6; | |
}; | |
function h$pp253(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 7)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 1)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$pp254(x1, x2, x3, x4, x5, x6, x7) | |
{ | |
h$sp += 8; | |
h$stack[(h$sp - 6)] = x1; | |
h$stack[(h$sp - 5)] = x2; | |
h$stack[(h$sp - 4)] = x3; | |
h$stack[(h$sp - 3)] = x4; | |
h$stack[(h$sp - 2)] = x5; | |
h$stack[(h$sp - 1)] = x6; | |
h$stack[(h$sp - 0)] = x7; | |
}; | |
function h$bh() | |
{ | |
h$p2(h$r1, h$upd_frame); | |
h$r1.f = h$blackhole; | |
h$r1.d1 = h$currentThread; | |
h$r1.d2 = null; | |
}; | |
function h$bh_lne(h$RTS_26, h$RTS_27) | |
{ | |
var h$RTS_28 = h$stack[h$RTS_26]; | |
if(h$RTS_28) | |
{ | |
h$sp -= h$RTS_27; | |
if((h$RTS_28 === h$blackhole)) | |
{ | |
return h$throw(h$baseZCControlziExceptionziBasezinonTermination, false); | |
} | |
else | |
{ | |
h$r1 = h$RTS_28; | |
h$sp -= h$RTS_27; | |
return h$stack[h$sp]; | |
}; | |
} | |
else | |
{ | |
h$stack[h$RTS_26] = h$blackhole; | |
return null; | |
}; | |
}; | |
function h$blackhole() | |
{ | |
throw("oops: entered black hole"); | |
return 0; | |
}; | |
h$o(h$blackhole, 5, 0, 2, 0, null); | |
function h$blackholeTrap() | |
{ | |
throw("oops: entered multiple times"); | |
return 0; | |
}; | |
h$o(h$blackholeTrap, 0, 0, 2, 0, null); | |
function h$done(h$RTS_29) | |
{ | |
h$finishThread(h$currentThread); | |
return h$reschedule; | |
}; | |
h$o(h$done, (-1), 0, 0, 256, null); | |
function h$doneMain() | |
{ | |
if(((typeof process !== "undefined") && process.exit)) | |
{ | |
process.exit(0); | |
} | |
else | |
{ | |
if((typeof quit !== "undefined")) | |
{ | |
if((((typeof h$base_stdoutLeftover !== "undefined") && h$base_stdoutLeftover) && h$base_stdoutLeftover.val)) | |
{ | |
print(h$base_stdoutLeftover.val); | |
}; | |
if((((typeof h$base_stderrLeftover !== "undefined") && h$base_stderrLeftover) && h$base_stderrLeftover.val)) | |
{ | |
debug(h$base_stderrLeftover.val); | |
}; | |
quit(); | |
}; | |
}; | |
h$finishThread(h$currentThread); | |
return h$reschedule; | |
}; | |
h$o(h$doneMain, (-1), 0, 0, 256, null); | |
function h$false_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
h$o(h$false_e, 2, 1, 0, 256, null); | |
function h$true_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
h$o(h$true_e, 2, 2, 0, 256, null); | |
function h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
h$o(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, 2, 1, 1, 256, null); | |
function h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
h$o(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 2, 2, 2, 256, null); | |
function h$data1_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
h$o(h$data1_e, 2, 1, 1, 256, null); | |
function h$data2_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
h$o(h$data2_e, 2, 1, 2, 256, null); | |
function h$con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$catch(h$RTS_30, h$RTS_31) | |
{ | |
h$sp += 3; | |
h$stack[(h$sp - 2)] = h$currentThread.mask; | |
h$stack[(h$sp - 1)] = h$RTS_31; | |
h$stack[h$sp] = h$catch_e; | |
h$r1 = h$RTS_30; | |
return h$ap_1_0_fast(); | |
}; | |
function h$noop_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
h$o(h$noop_e, 1, 1, 0, 257, null); | |
var h$noop = h$c0(h$noop_e); | |
function h$catch_e() | |
{ | |
h$sp -= 3; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$catch_e, (-1), 0, 2, 256, null); | |
function h$ap1_e() | |
{ | |
var h$RTS_32 = h$r1.d1; | |
var h$RTS_33 = h$r1.d2; | |
h$bh(); | |
h$r1 = h$RTS_32; | |
h$r2 = h$RTS_33; | |
return h$ap_1_1_fast(); | |
}; | |
h$o(h$ap1_e, 0, 0, 2, 256, null); | |
function h$ap2_e() | |
{ | |
var h$RTS_34 = h$r1.d1; | |
var h$RTS_35 = h$r1.d2.d1; | |
var h$RTS_36 = h$r1.d2.d2; | |
h$bh(); | |
h$r1 = h$RTS_34; | |
h$r2 = h$RTS_35; | |
h$r3 = h$RTS_36; | |
return h$ap_2_2_fast(); | |
}; | |
h$o(h$ap2_e, 0, 0, 3, 256, null); | |
function h$ap3_e() | |
{ | |
var h$RTS_37 = h$r1.d1; | |
var h$RTS_38 = h$r1.d2.d1; | |
var h$RTS_39 = h$r1.d2.d2; | |
var h$RTS_40 = h$r1.d2.d3; | |
h$bh(); | |
h$r1 = h$RTS_37; | |
h$r2 = h$RTS_38; | |
h$r3 = h$RTS_39; | |
h$r4 = h$RTS_40; | |
return h$ap_3_3_fast(); | |
}; | |
h$o(h$ap3_e, 0, 0, 4, 256, null); | |
function h$select1_e() | |
{ | |
var h$RTS_41 = h$r1.d1; | |
h$sp += 3; | |
h$stack[(h$sp - 2)] = h$r1; | |
h$stack[(h$sp - 1)] = h$upd_frame; | |
h$stack[h$sp] = h$select1_ret; | |
h$r1.f = h$blackhole; | |
h$r1.d1 = h$currentThread; | |
h$r1.d2 = null; | |
h$r1 = h$RTS_41; | |
return h$ap_0_0_fast(); | |
}; | |
h$o(h$select1_e, 0, 0, 1, 256, null); | |
function h$select1_ret() | |
{ | |
h$r1 = h$r1.d1; | |
--h$sp; | |
return h$ap_0_0_fast(); | |
}; | |
h$o(h$select1_ret, (-1), 0, 0, 256, null); | |
function h$select2_e() | |
{ | |
var h$RTS_42 = h$r1.d1; | |
h$sp += 3; | |
h$stack[(h$sp - 2)] = h$r1; | |
h$stack[(h$sp - 1)] = h$upd_frame; | |
h$stack[h$sp] = h$select2_ret; | |
h$r1.f = h$blackhole; | |
h$r1.d1 = h$currentThread; | |
h$r1.d2 = null; | |
h$r1 = h$RTS_42; | |
return h$ap_0_0_fast(); | |
}; | |
h$o(h$select2_e, 0, 0, 1, 256, null); | |
function h$select2_ret() | |
{ | |
h$r1 = h$r1.d2; | |
--h$sp; | |
return h$ap_0_0_fast(); | |
}; | |
h$o(h$select2_ret, (-1), 0, 0, 256, null); | |
function h$throw(h$RTS_43, h$RTS_44) | |
{ | |
var h$RTS_45 = h$sp; | |
var h$RTS_46 = null; | |
var h$RTS_47; | |
while((h$sp > 0)) | |
{ | |
h$RTS_47 = h$stack[h$sp]; | |
if(((h$RTS_47 === null) || (h$RTS_47 === undefined))) | |
{ | |
throw("h$throw: invalid object while unwinding stack"); | |
}; | |
if((h$RTS_47 === h$catch_e)) | |
{ | |
break; | |
}; | |
if((h$RTS_47 === h$atomically_e)) | |
{ | |
if(h$RTS_44) | |
{ | |
h$currentThread.transaction = null; | |
} | |
else | |
{ | |
if(!h$stmValidateTransaction()) | |
{ | |
++h$sp; | |
h$stack[h$sp] = h$checkInvariants_e; | |
return h$stmStartTransaction(h$stack[(h$sp - 2)]); | |
}; | |
}; | |
}; | |
if(((h$RTS_47 === h$catchStm_e) && !h$RTS_44)) | |
{ | |
break; | |
}; | |
if((h$RTS_47 === h$upd_frame)) | |
{ | |
var h$RTS_48 = h$stack[(h$sp - 1)]; | |
var h$RTS_49 = h$RTS_48.d2; | |
if((h$RTS_49 !== null)) | |
{ | |
for(var h$RTS_50 = 0;(h$RTS_50 < h$RTS_49.length);(h$RTS_50++)) { | |
h$wakeupThread(h$RTS_49[h$RTS_50]); | |
}; | |
}; | |
if(h$RTS_44) | |
{ | |
if((h$RTS_46 === null)) | |
{ | |
h$makeResumable(h$RTS_48, (h$sp + 1), h$RTS_45, []); | |
} | |
else | |
{ | |
h$makeResumable(h$RTS_48, (h$sp + 1), (h$RTS_46 - 2), [h$ap_0_0, h$stack[(h$RTS_46 - 1)], h$return]); | |
}; | |
h$RTS_46 = h$sp; | |
} | |
else | |
{ | |
h$RTS_48.f = h$raise_e; | |
h$RTS_48.d1 = h$RTS_43; | |
h$RTS_48.d2 = null; | |
}; | |
}; | |
var h$RTS_51; | |
if((h$RTS_47 === h$ap_gen)) | |
{ | |
h$RTS_51 = ((h$stack[(h$sp - 1)] >> 8) + 2); | |
} | |
else | |
{ | |
var h$RTS_52 = h$RTS_47.size; | |
if((h$RTS_52 < 0)) | |
{ | |
h$RTS_51 = h$stack[(h$sp - 1)]; | |
} | |
else | |
{ | |
h$RTS_51 = ((h$RTS_52 & 255) + 1); | |
}; | |
}; | |
h$sp -= h$RTS_51; | |
}; | |
if((h$sp > 0)) | |
{ | |
var h$RTS_53 = h$stack[(h$sp - 2)]; | |
var h$RTS_54 = h$stack[(h$sp - 1)]; | |
if((h$RTS_47 === h$catchStm_e)) | |
{ | |
h$currentThread.transaction = h$stack[(h$sp - 3)]; | |
h$sp -= 4; | |
} | |
else | |
{ | |
if((h$sp > 3)) | |
{ | |
h$sp -= 3; | |
}; | |
}; | |
h$r1 = h$RTS_54; | |
h$r2 = h$RTS_43; | |
if((h$RTS_47 !== h$catchStm_e)) | |
{ | |
if((((h$RTS_53 === 0) && (h$stack[h$sp] !== h$maskFrame)) && (h$stack[h$sp] !== h$maskUnintFrame))) | |
{ | |
h$stack[(h$sp + 1)] = h$unmaskFrame; | |
++h$sp; | |
} | |
else | |
{ | |
if((h$RTS_53 === 1)) | |
{ | |
h$stack[(h$sp + 1)] = h$maskUnintFrame; | |
++h$sp; | |
}; | |
}; | |
h$currentThread.mask = 2; | |
}; | |
return h$ap_2_1_fast(); | |
} | |
else | |
{ | |
throw("unhandled exception in haskell thread"); | |
}; | |
}; | |
function h$raise_e() | |
{ | |
return h$throw(h$r1.d1, false); | |
}; | |
h$o(h$raise_e, 0, 0, 0, 256, null); | |
function h$raiseAsync_e() | |
{ | |
return h$throw(h$r1.d1, true); | |
}; | |
h$o(h$raiseAsync_e, 0, 0, 0, 256, null); | |
function h$raiseAsync_frame() | |
{ | |
var h$RTS_55 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$throw(h$RTS_55, true); | |
}; | |
h$o(h$raiseAsync_frame, (-1), 0, 1, 0, null); | |
function h$reduce() | |
{ | |
if((h$r1.f.t === 0)) | |
{ | |
return h$r1.f; | |
} | |
else | |
{ | |
--h$sp; | |
return h$stack[h$sp]; | |
}; | |
}; | |
h$o(h$reduce, (-1), 0, 0, 256, null); | |
var h$RTS_56 = 0; | |
function h$gc_check(h$RTS_57) | |
{ | |
if((++h$RTS_56 > 1000)) | |
{ | |
for(var h$RTS_58 = (h$sp + 1);(h$RTS_58 < h$stack.length);(h$RTS_58++)) { | |
h$stack[h$RTS_58] = null; | |
}; | |
h$RTS_56 = 0; | |
}; | |
return 0; | |
}; | |
function h$o(h$RTS_59, h$RTS_60, h$RTS_61, h$RTS_62, h$RTS_63, h$RTS_64) | |
{ | |
h$setObjInfo(h$RTS_59, h$RTS_60, "", [], h$RTS_61, h$RTS_62, h$RTS_63, h$RTS_64); | |
}; | |
function h$setObjInfo(h$RTS_65, h$RTS_66, h$RTS_67, h$RTS_68, h$RTS_69, h$RTS_70, h$RTS_71, h$RTS_72) | |
{ | |
h$RTS_65.t = h$RTS_66; | |
h$RTS_65.i = h$RTS_68; | |
h$RTS_65.n = h$RTS_67; | |
h$RTS_65.a = h$RTS_69; | |
h$RTS_65.r = h$RTS_71; | |
h$RTS_65.s = h$RTS_72; | |
h$RTS_65.m = 0; | |
h$RTS_65.size = h$RTS_70; | |
}; | |
function h$static_thunk(h$RTS_73) | |
{ | |
var h$RTS_74 = { d1: null, d2: null, f: h$RTS_73, m: 0 | |
}; | |
h$CAFs.push(h$RTS_74); | |
h$CAFsReset.push(h$RTS_73); | |
return h$RTS_74; | |
}; | |
function h$printcl(h$RTS_75) | |
{ | |
var h$RTS_76 = h$RTS_75.f; | |
var h$RTS_77 = h$RTS_75.d1; | |
var h$RTS_78 = ""; | |
switch (h$RTS_76.t) | |
{ | |
case (0): | |
h$RTS_78 += "thunk"; | |
break; | |
case (2): | |
h$RTS_78 += (("con[" + h$RTS_76.a) + "]"); | |
break; | |
case (3): | |
h$RTS_78 += (("pap[" + h$RTS_76.a) + "]"); | |
break; | |
case (1): | |
h$RTS_78 += (("fun[" + h$RTS_76.a) + "]"); | |
break; | |
default: | |
h$RTS_78 += "unknown closure type"; | |
break; | |
}; | |
h$RTS_78 += ((" :: " + h$RTS_76.n) + " ->"); | |
var h$RTS_79 = 1; | |
for(var h$RTS_80 = 0;(h$RTS_80 < h$RTS_76.i.length);(h$RTS_80++)) { | |
h$RTS_78 += " "; | |
switch (h$RTS_76.i[h$RTS_80]) | |
{ | |
case (0): | |
h$RTS_78 += (("[ Ptr :: " + h$RTS_77[("d" + h$RTS_79)].f.n) + "]"); | |
h$RTS_79++; | |
break; | |
case (1): | |
h$RTS_78 += "void"; | |
break; | |
case (2): | |
h$RTS_78 += (("(" + h$RTS_77[("d" + h$RTS_79)]) + " :: double)"); | |
h$RTS_79++; | |
break; | |
case (3): | |
h$RTS_78 += (("(" + h$RTS_77[("d" + h$RTS_79)]) + " :: int)"); | |
h$RTS_79++; | |
break; | |
case (4): | |
h$RTS_78 += (((("(" + h$RTS_77[("d" + h$RTS_79)]) + ",") + h$RTS_77[("d" + (h$RTS_79 + 1))]) + " :: long)"); | |
h$RTS_79 += 2; | |
break; | |
case (5): | |
h$RTS_78 += (((("(" + h$RTS_77[("d" + h$RTS_79)].length) + ",") + h$RTS_77[("d" + (h$RTS_79 + 1))]) + " :: ptr)"); | |
h$RTS_79 += 2; | |
break; | |
case (6): | |
h$RTS_78 += (("(" + h$RTS_77[("d" + h$RTS_79)].toString()) + " :: RTS object)"); | |
h$RTS_79++; | |
break; | |
default: | |
h$RTS_78 += ("unknown field: " + h$RTS_76.i[h$RTS_80]); | |
}; | |
}; | |
h$log(h$RTS_78); | |
}; | |
function h$init_closure(h$RTS_81, h$RTS_82) | |
{ | |
h$RTS_81.m = 0; | |
switch (h$RTS_82.length) | |
{ | |
case (0): | |
h$RTS_81.d1 = null; | |
h$RTS_81.d2 = null; | |
return h$RTS_81; | |
case (1): | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = null; | |
return h$RTS_81; | |
case (2): | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = h$RTS_82[1]; | |
return h$RTS_81; | |
case (3): | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = { d1: h$RTS_82[1], d2: h$RTS_82[2] | |
}; | |
return h$RTS_81; | |
case (4): | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = { d1: h$RTS_82[1], d2: h$RTS_82[2], d3: h$RTS_82[3] | |
}; | |
return h$RTS_81; | |
case (5): | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = { d1: h$RTS_82[1], d2: h$RTS_82[2], d3: h$RTS_82[3], d4: h$RTS_82[4] | |
}; | |
return h$RTS_81; | |
case (6): | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = { d1: h$RTS_82[1], d2: h$RTS_82[2], d3: h$RTS_82[3], d4: h$RTS_82[4], d5: h$RTS_82[5] | |
}; | |
return h$RTS_81; | |
case (7): | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = { d1: h$RTS_82[1], d2: h$RTS_82[2], d3: h$RTS_82[3], d4: h$RTS_82[4], d5: h$RTS_82[5], d6: h$RTS_82[6] | |
}; | |
return h$RTS_81; | |
default: | |
h$RTS_81.d1 = h$RTS_82[0]; | |
h$RTS_81.d2 = { d1: h$RTS_82[1], d2: h$RTS_82[2], d3: h$RTS_82[3], d4: h$RTS_82[4], d5: h$RTS_82[5], d6: h$RTS_82[6] | |
}; | |
for(var h$RTS_83 = 7;(h$RTS_83 < h$RTS_82.length);(h$RTS_83++)) { | |
h$RTS_81.d2[("d" + h$RTS_83)] = h$RTS_82[h$RTS_83]; | |
}; | |
return h$RTS_81; | |
}; | |
}; | |
function h$runInitStatic() | |
{ | |
if((h$initStatic.length == 0)) | |
{ | |
return undefined; | |
}; | |
for(var h$RTS_84 = (h$initStatic.length - 1);(h$RTS_84 >= 0);(h$RTS_84--)) { | |
h$initStatic[h$RTS_84](); | |
}; | |
h$initStatic = []; | |
}; | |
function h$checkStack(h$RTS_85) | |
{ | |
if((h$RTS_85.t === (-1))) | |
{ | |
h$stack[h$sp] = h$RTS_85; | |
}; | |
var h$RTS_86 = h$sp; | |
while((h$RTS_86 >= 0)) | |
{ | |
h$RTS_85 = h$stack[h$RTS_86]; | |
var h$RTS_87; | |
var h$RTS_88; | |
if((typeof h$RTS_85 === "function")) | |
{ | |
if((h$RTS_85 === h$ap_gen)) | |
{ | |
h$RTS_87 = ((h$stack[(h$RTS_86 - 1)] >> 8) + 2); | |
h$RTS_88 = 2; | |
} | |
else | |
{ | |
var h$RTS_89 = h$stack[h$RTS_86].size; | |
if((h$RTS_89 <= 0)) | |
{ | |
h$RTS_87 = h$stack[(h$RTS_86 - 1)]; | |
h$RTS_88 = 2; | |
} | |
else | |
{ | |
h$RTS_87 = ((h$RTS_89 & 255) + 1); | |
h$RTS_88 = 1; | |
}; | |
}; | |
h$RTS_86 -= h$RTS_87; | |
} | |
else | |
{ | |
h$dumpStackTop(h$stack, 0, h$sp); | |
throw(("invalid stack object at: " + h$RTS_86)); | |
}; | |
}; | |
}; | |
function h$printReg(h$RTS_90) | |
{ | |
if((h$RTS_90 === null)) | |
{ | |
return "null"; | |
} | |
else | |
{ | |
if(((((typeof h$RTS_90 === "object") && h$RTS_90.hasOwnProperty("f")) && h$RTS_90.hasOwnProperty("d1")) && h$RTS_90. | |
hasOwnProperty("d2"))) | |
{ | |
if((typeof h$RTS_90.f !== "function")) | |
{ | |
return "dodgy object"; | |
} | |
else | |
{ | |
if(((h$RTS_90.f.t === 5) && h$RTS_90.x)) | |
{ | |
return (("blackhole: -> " + h$printReg({ d: h$RTS_90.d1.x2, f: h$RTS_90.x.x1 | |
})) + ")"); | |
} | |
else | |
{ | |
return (((((((h$RTS_90.alloc ? (h$RTS_90.alloc + ": ") : "") + h$RTS_90.f.n) + " (") + h$closureTypeName(h$RTS_90.f. | |
t)) + ", ") + h$RTS_90.f.a) + ")"); | |
}; | |
}; | |
} | |
else | |
{ | |
if((typeof h$RTS_90 === "object")) | |
{ | |
var h$RTS_91 = h$collectProps(h$RTS_90); | |
if((h$RTS_91.length > 40)) | |
{ | |
return (h$RTS_91.substr(0, 40) + "..."); | |
} | |
else | |
{ | |
return h$RTS_91; | |
}; | |
} | |
else | |
{ | |
var h$RTS_92 = (new String(h$RTS_90) + ""); | |
if((h$RTS_92.length > 40)) | |
{ | |
return (h$RTS_92.substr(0, 40) + "..."); | |
} | |
else | |
{ | |
return h$RTS_92; | |
}; | |
}; | |
}; | |
}; | |
}; | |
function h$logStack() | |
{ | |
if((typeof h$stack[h$sp] === "undefined")) | |
{ | |
h$log("warning: invalid stack frame"); | |
return undefined; | |
}; | |
var h$RTS_93 = 0; | |
var h$RTS_94 = h$stack[h$sp].size; | |
if((h$RTS_94 === (-1))) | |
{ | |
h$RTS_93 = (h$stack[(h$sp - 1)] & 255); | |
} | |
else | |
{ | |
h$RTS_93 = (h$RTS_94 & 255); | |
}; | |
h$dumpStackTop(h$stack, ((h$sp - h$RTS_93) - 2), h$sp); | |
for(var h$RTS_95 = Math.max(0, ((h$sp - h$RTS_93) + 1));(h$RTS_95 <= h$sp);(h$RTS_95++)) { | |
if((typeof h$stack[h$RTS_95] === "undefined")) | |
{ | |
throw("undefined on stack"); | |
}; | |
}; | |
}; | |
function h$ap_1_0() | |
{ | |
var h$RTS_96 = h$r1.f; | |
switch (h$RTS_96.t) | |
{ | |
case (0): | |
return h$RTS_96; | |
case (1): | |
var h$RTS_98 = h$RTS_96.a; | |
var h$RTS_99 = (h$RTS_98 & 255); | |
if((1 === h$RTS_99)) | |
{ | |
--h$sp; | |
return h$RTS_96; | |
} | |
else | |
{ | |
if((1 > h$RTS_99)) | |
{ | |
var h$RTS_100 = (h$RTS_98 >> 8); | |
switch (h$RTS_100) | |
{ | |
default: | |
}; | |
h$sp -= h$RTS_100; | |
var h$RTS_101 = h$apply[((1 - h$RTS_99) | ((0 - h$RTS_100) << 8))]; | |
h$stack[h$sp] = h$RTS_101; | |
return h$RTS_96; | |
} | |
else | |
{ | |
var h$RTS_97 = h$c3(h$pap_0, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 0) - 1), null); | |
--h$sp; | |
h$r1 = h$RTS_97; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_103 = h$r1.d2.d1; | |
var h$RTS_104 = (h$RTS_103 & 255); | |
if((1 === h$RTS_104)) | |
{ | |
--h$sp; | |
return h$RTS_96; | |
} | |
else | |
{ | |
if((1 > h$RTS_104)) | |
{ | |
var h$RTS_105 = (h$RTS_103 >> 8); | |
switch (h$RTS_105) | |
{ | |
default: | |
}; | |
h$sp -= h$RTS_105; | |
var h$RTS_106 = h$apply[((1 - h$RTS_104) | ((0 - h$RTS_105) << 8))]; | |
h$stack[h$sp] = h$RTS_106; | |
return h$RTS_96; | |
} | |
else | |
{ | |
var h$RTS_102 = h$c3(h$pap_0, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 0) - 1), null); | |
--h$sp; | |
h$r1 = h$RTS_102; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_1_0, unexpected closure type: " + h$RTS_96.t)); | |
}; | |
}; | |
h$o(h$ap_1_0, (-1), 0, 0, 256, null); | |
function h$ap_1_1() | |
{ | |
var h$RTS_107 = h$r1.f; | |
switch (h$RTS_107.t) | |
{ | |
case (0): | |
return h$RTS_107; | |
case (1): | |
var h$RTS_109 = h$RTS_107.a; | |
var h$RTS_110 = (h$RTS_109 & 255); | |
if((1 === h$RTS_110)) | |
{ | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$RTS_107; | |
} | |
else | |
{ | |
if((1 > h$RTS_110)) | |
{ | |
var h$RTS_111 = (h$RTS_109 >> 8); | |
switch (h$RTS_111) | |
{ | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_111; | |
var h$RTS_112 = h$apply[((1 - h$RTS_110) | ((1 - h$RTS_111) << 8))]; | |
h$stack[h$sp] = h$RTS_112; | |
return h$RTS_107; | |
} | |
else | |
{ | |
var h$RTS_108 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 1), h$stack[(h$sp - 1)]); | |
h$sp -= 2; | |
h$r1 = h$RTS_108; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_114 = h$r1.d2.d1; | |
var h$RTS_115 = (h$RTS_114 & 255); | |
if((1 === h$RTS_115)) | |
{ | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$RTS_107; | |
} | |
else | |
{ | |
if((1 > h$RTS_115)) | |
{ | |
var h$RTS_116 = (h$RTS_114 >> 8); | |
switch (h$RTS_116) | |
{ | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_116; | |
var h$RTS_117 = h$apply[((1 - h$RTS_115) | ((1 - h$RTS_116) << 8))]; | |
h$stack[h$sp] = h$RTS_117; | |
return h$RTS_107; | |
} | |
else | |
{ | |
var h$RTS_113 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 1), h$stack[(h$sp - 1)]); | |
h$sp -= 2; | |
h$r1 = h$RTS_113; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_1_1, unexpected closure type: " + h$RTS_107.t)); | |
}; | |
}; | |
h$o(h$ap_1_1, (-1), 0, 1, 256, null); | |
function h$ap_1_2() | |
{ | |
var h$RTS_118 = h$r1.f; | |
switch (h$RTS_118.t) | |
{ | |
case (0): | |
return h$RTS_118; | |
case (1): | |
var h$RTS_120 = h$RTS_118.a; | |
var h$RTS_121 = (h$RTS_120 & 255); | |
if((1 === h$RTS_121)) | |
{ | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
return h$RTS_118; | |
} | |
else | |
{ | |
if((1 > h$RTS_121)) | |
{ | |
var h$RTS_122 = (h$RTS_120 >> 8); | |
switch (h$RTS_122) | |
{ | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_122; | |
var h$RTS_123 = h$apply[((1 - h$RTS_121) | ((2 - h$RTS_122) << 8))]; | |
h$stack[h$sp] = h$RTS_123; | |
return h$RTS_118; | |
} | |
else | |
{ | |
var h$RTS_119 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 1), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)]); | |
h$sp -= 3; | |
h$r1 = h$RTS_119; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_125 = h$r1.d2.d1; | |
var h$RTS_126 = (h$RTS_125 & 255); | |
if((1 === h$RTS_126)) | |
{ | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
return h$RTS_118; | |
} | |
else | |
{ | |
if((1 > h$RTS_126)) | |
{ | |
var h$RTS_127 = (h$RTS_125 >> 8); | |
switch (h$RTS_127) | |
{ | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_127; | |
var h$RTS_128 = h$apply[((1 - h$RTS_126) | ((2 - h$RTS_127) << 8))]; | |
h$stack[h$sp] = h$RTS_128; | |
return h$RTS_118; | |
} | |
else | |
{ | |
var h$RTS_124 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 1), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)]); | |
h$sp -= 3; | |
h$r1 = h$RTS_124; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_1_2, unexpected closure type: " + h$RTS_118.t)); | |
}; | |
}; | |
h$o(h$ap_1_2, (-1), 0, 2, 256, null); | |
function h$ap_2_1() | |
{ | |
var h$RTS_129 = h$r1.f; | |
switch (h$RTS_129.t) | |
{ | |
case (0): | |
return h$RTS_129; | |
case (1): | |
var h$RTS_131 = h$RTS_129.a; | |
var h$RTS_132 = (h$RTS_131 & 255); | |
if((2 === h$RTS_132)) | |
{ | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$RTS_129; | |
} | |
else | |
{ | |
if((2 > h$RTS_132)) | |
{ | |
var h$RTS_133 = (h$RTS_131 >> 8); | |
switch (h$RTS_133) | |
{ | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_133; | |
var h$RTS_134 = h$apply[((2 - h$RTS_132) | ((1 - h$RTS_133) << 8))]; | |
h$stack[h$sp] = h$RTS_134; | |
return h$RTS_129; | |
} | |
else | |
{ | |
var h$RTS_130 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 2), h$stack[(h$sp - 1)]); | |
h$sp -= 2; | |
h$r1 = h$RTS_130; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_136 = h$r1.d2.d1; | |
var h$RTS_137 = (h$RTS_136 & 255); | |
if((2 === h$RTS_137)) | |
{ | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$RTS_129; | |
} | |
else | |
{ | |
if((2 > h$RTS_137)) | |
{ | |
var h$RTS_138 = (h$RTS_136 >> 8); | |
switch (h$RTS_138) | |
{ | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_138; | |
var h$RTS_139 = h$apply[((2 - h$RTS_137) | ((1 - h$RTS_138) << 8))]; | |
h$stack[h$sp] = h$RTS_139; | |
return h$RTS_129; | |
} | |
else | |
{ | |
var h$RTS_135 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 2), h$stack[(h$sp - 1)]); | |
h$sp -= 2; | |
h$r1 = h$RTS_135; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_2_1, unexpected closure type: " + h$RTS_129.t)); | |
}; | |
}; | |
h$o(h$ap_2_1, (-1), 0, 1, 256, null); | |
function h$ap_2_2() | |
{ | |
var h$RTS_140 = h$r1.f; | |
switch (h$RTS_140.t) | |
{ | |
case (0): | |
return h$RTS_140; | |
case (1): | |
var h$RTS_142 = h$RTS_140.a; | |
var h$RTS_143 = (h$RTS_142 & 255); | |
if((2 === h$RTS_143)) | |
{ | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
return h$RTS_140; | |
} | |
else | |
{ | |
if((2 > h$RTS_143)) | |
{ | |
var h$RTS_144 = (h$RTS_142 >> 8); | |
switch (h$RTS_144) | |
{ | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_144; | |
var h$RTS_145 = h$apply[((2 - h$RTS_143) | ((2 - h$RTS_144) << 8))]; | |
h$stack[h$sp] = h$RTS_145; | |
return h$RTS_140; | |
} | |
else | |
{ | |
var h$RTS_141 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 2), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)]); | |
h$sp -= 3; | |
h$r1 = h$RTS_141; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_147 = h$r1.d2.d1; | |
var h$RTS_148 = (h$RTS_147 & 255); | |
if((2 === h$RTS_148)) | |
{ | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
return h$RTS_140; | |
} | |
else | |
{ | |
if((2 > h$RTS_148)) | |
{ | |
var h$RTS_149 = (h$RTS_147 >> 8); | |
switch (h$RTS_149) | |
{ | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_149; | |
var h$RTS_150 = h$apply[((2 - h$RTS_148) | ((2 - h$RTS_149) << 8))]; | |
h$stack[h$sp] = h$RTS_150; | |
return h$RTS_140; | |
} | |
else | |
{ | |
var h$RTS_146 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 2), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)]); | |
h$sp -= 3; | |
h$r1 = h$RTS_146; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_2_2, unexpected closure type: " + h$RTS_140.t)); | |
}; | |
}; | |
h$o(h$ap_2_2, (-1), 0, 2, 256, null); | |
function h$ap_2_3() | |
{ | |
var h$RTS_151 = h$r1.f; | |
switch (h$RTS_151.t) | |
{ | |
case (0): | |
return h$RTS_151; | |
case (1): | |
var h$RTS_153 = h$RTS_151.a; | |
var h$RTS_154 = (h$RTS_153 & 255); | |
if((2 === h$RTS_154)) | |
{ | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
return h$RTS_151; | |
} | |
else | |
{ | |
if((2 > h$RTS_154)) | |
{ | |
var h$RTS_155 = (h$RTS_153 >> 8); | |
switch (h$RTS_155) | |
{ | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_155; | |
var h$RTS_156 = h$apply[((2 - h$RTS_154) | ((3 - h$RTS_155) << 8))]; | |
h$stack[h$sp] = h$RTS_156; | |
return h$RTS_151; | |
} | |
else | |
{ | |
var h$RTS_152 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 2), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)]); | |
h$sp -= 4; | |
h$r1 = h$RTS_152; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_158 = h$r1.d2.d1; | |
var h$RTS_159 = (h$RTS_158 & 255); | |
if((2 === h$RTS_159)) | |
{ | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
return h$RTS_151; | |
} | |
else | |
{ | |
if((2 > h$RTS_159)) | |
{ | |
var h$RTS_160 = (h$RTS_158 >> 8); | |
switch (h$RTS_160) | |
{ | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_160; | |
var h$RTS_161 = h$apply[((2 - h$RTS_159) | ((3 - h$RTS_160) << 8))]; | |
h$stack[h$sp] = h$RTS_161; | |
return h$RTS_151; | |
} | |
else | |
{ | |
var h$RTS_157 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 2), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)]); | |
h$sp -= 4; | |
h$r1 = h$RTS_157; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_2_3, unexpected closure type: " + h$RTS_151.t)); | |
}; | |
}; | |
h$o(h$ap_2_3, (-1), 0, 3, 256, null); | |
function h$ap_2_4() | |
{ | |
var h$RTS_162 = h$r1.f; | |
switch (h$RTS_162.t) | |
{ | |
case (0): | |
return h$RTS_162; | |
case (1): | |
var h$RTS_164 = h$RTS_162.a; | |
var h$RTS_165 = (h$RTS_164 & 255); | |
if((2 === h$RTS_165)) | |
{ | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
return h$RTS_162; | |
} | |
else | |
{ | |
if((2 > h$RTS_165)) | |
{ | |
var h$RTS_166 = (h$RTS_164 >> 8); | |
switch (h$RTS_166) | |
{ | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_166; | |
var h$RTS_167 = h$apply[((2 - h$RTS_165) | ((4 - h$RTS_166) << 8))]; | |
h$stack[h$sp] = h$RTS_167; | |
return h$RTS_162; | |
} | |
else | |
{ | |
var h$RTS_163 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 2), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)]); | |
h$sp -= 5; | |
h$r1 = h$RTS_163; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_169 = h$r1.d2.d1; | |
var h$RTS_170 = (h$RTS_169 & 255); | |
if((2 === h$RTS_170)) | |
{ | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
return h$RTS_162; | |
} | |
else | |
{ | |
if((2 > h$RTS_170)) | |
{ | |
var h$RTS_171 = (h$RTS_169 >> 8); | |
switch (h$RTS_171) | |
{ | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_171; | |
var h$RTS_172 = h$apply[((2 - h$RTS_170) | ((4 - h$RTS_171) << 8))]; | |
h$stack[h$sp] = h$RTS_172; | |
return h$RTS_162; | |
} | |
else | |
{ | |
var h$RTS_168 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 2), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)]); | |
h$sp -= 5; | |
h$r1 = h$RTS_168; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_2_4, unexpected closure type: " + h$RTS_162.t)); | |
}; | |
}; | |
h$o(h$ap_2_4, (-1), 0, 4, 256, null); | |
function h$ap_3_2() | |
{ | |
var h$RTS_173 = h$r1.f; | |
switch (h$RTS_173.t) | |
{ | |
case (0): | |
return h$RTS_173; | |
case (1): | |
var h$RTS_175 = h$RTS_173.a; | |
var h$RTS_176 = (h$RTS_175 & 255); | |
if((3 === h$RTS_176)) | |
{ | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
return h$RTS_173; | |
} | |
else | |
{ | |
if((3 > h$RTS_176)) | |
{ | |
var h$RTS_177 = (h$RTS_175 >> 8); | |
switch (h$RTS_177) | |
{ | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_177; | |
var h$RTS_178 = h$apply[((3 - h$RTS_176) | ((2 - h$RTS_177) << 8))]; | |
h$stack[h$sp] = h$RTS_178; | |
return h$RTS_173; | |
} | |
else | |
{ | |
var h$RTS_174 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)]); | |
h$sp -= 3; | |
h$r1 = h$RTS_174; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_180 = h$r1.d2.d1; | |
var h$RTS_181 = (h$RTS_180 & 255); | |
if((3 === h$RTS_181)) | |
{ | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
return h$RTS_173; | |
} | |
else | |
{ | |
if((3 > h$RTS_181)) | |
{ | |
var h$RTS_182 = (h$RTS_180 >> 8); | |
switch (h$RTS_182) | |
{ | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_182; | |
var h$RTS_183 = h$apply[((3 - h$RTS_181) | ((2 - h$RTS_182) << 8))]; | |
h$stack[h$sp] = h$RTS_183; | |
return h$RTS_173; | |
} | |
else | |
{ | |
var h$RTS_179 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)]); | |
h$sp -= 3; | |
h$r1 = h$RTS_179; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_3_2, unexpected closure type: " + h$RTS_173.t)); | |
}; | |
}; | |
h$o(h$ap_3_2, (-1), 0, 2, 256, null); | |
function h$ap_3_3() | |
{ | |
var h$RTS_184 = h$r1.f; | |
switch (h$RTS_184.t) | |
{ | |
case (0): | |
return h$RTS_184; | |
case (1): | |
var h$RTS_186 = h$RTS_184.a; | |
var h$RTS_187 = (h$RTS_186 & 255); | |
if((3 === h$RTS_187)) | |
{ | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
return h$RTS_184; | |
} | |
else | |
{ | |
if((3 > h$RTS_187)) | |
{ | |
var h$RTS_188 = (h$RTS_186 >> 8); | |
switch (h$RTS_188) | |
{ | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_188; | |
var h$RTS_189 = h$apply[((3 - h$RTS_187) | ((3 - h$RTS_188) << 8))]; | |
h$stack[h$sp] = h$RTS_189; | |
return h$RTS_184; | |
} | |
else | |
{ | |
var h$RTS_185 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)]); | |
h$sp -= 4; | |
h$r1 = h$RTS_185; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_191 = h$r1.d2.d1; | |
var h$RTS_192 = (h$RTS_191 & 255); | |
if((3 === h$RTS_192)) | |
{ | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
return h$RTS_184; | |
} | |
else | |
{ | |
if((3 > h$RTS_192)) | |
{ | |
var h$RTS_193 = (h$RTS_191 >> 8); | |
switch (h$RTS_193) | |
{ | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_193; | |
var h$RTS_194 = h$apply[((3 - h$RTS_192) | ((3 - h$RTS_193) << 8))]; | |
h$stack[h$sp] = h$RTS_194; | |
return h$RTS_184; | |
} | |
else | |
{ | |
var h$RTS_190 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)]); | |
h$sp -= 4; | |
h$r1 = h$RTS_190; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_3_3, unexpected closure type: " + h$RTS_184.t)); | |
}; | |
}; | |
h$o(h$ap_3_3, (-1), 0, 3, 256, null); | |
function h$ap_3_4() | |
{ | |
var h$RTS_195 = h$r1.f; | |
switch (h$RTS_195.t) | |
{ | |
case (0): | |
return h$RTS_195; | |
case (1): | |
var h$RTS_197 = h$RTS_195.a; | |
var h$RTS_198 = (h$RTS_197 & 255); | |
if((3 === h$RTS_198)) | |
{ | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
return h$RTS_195; | |
} | |
else | |
{ | |
if((3 > h$RTS_198)) | |
{ | |
var h$RTS_199 = (h$RTS_197 >> 8); | |
switch (h$RTS_199) | |
{ | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_199; | |
var h$RTS_200 = h$apply[((3 - h$RTS_198) | ((4 - h$RTS_199) << 8))]; | |
h$stack[h$sp] = h$RTS_200; | |
return h$RTS_195; | |
} | |
else | |
{ | |
var h$RTS_196 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)]); | |
h$sp -= 5; | |
h$r1 = h$RTS_196; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_202 = h$r1.d2.d1; | |
var h$RTS_203 = (h$RTS_202 & 255); | |
if((3 === h$RTS_203)) | |
{ | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
return h$RTS_195; | |
} | |
else | |
{ | |
if((3 > h$RTS_203)) | |
{ | |
var h$RTS_204 = (h$RTS_202 >> 8); | |
switch (h$RTS_204) | |
{ | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_204; | |
var h$RTS_205 = h$apply[((3 - h$RTS_203) | ((4 - h$RTS_204) << 8))]; | |
h$stack[h$sp] = h$RTS_205; | |
return h$RTS_195; | |
} | |
else | |
{ | |
var h$RTS_201 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)]); | |
h$sp -= 5; | |
h$r1 = h$RTS_201; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_3_4, unexpected closure type: " + h$RTS_195.t)); | |
}; | |
}; | |
h$o(h$ap_3_4, (-1), 0, 4, 256, null); | |
function h$ap_3_5() | |
{ | |
var h$RTS_206 = h$r1.f; | |
switch (h$RTS_206.t) | |
{ | |
case (0): | |
return h$RTS_206; | |
case (1): | |
var h$RTS_208 = h$RTS_206.a; | |
var h$RTS_209 = (h$RTS_208 & 255); | |
if((3 === h$RTS_209)) | |
{ | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
return h$RTS_206; | |
} | |
else | |
{ | |
if((3 > h$RTS_209)) | |
{ | |
var h$RTS_210 = (h$RTS_208 >> 8); | |
switch (h$RTS_210) | |
{ | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_210; | |
var h$RTS_211 = h$apply[((3 - h$RTS_209) | ((5 - h$RTS_210) << 8))]; | |
h$stack[h$sp] = h$RTS_211; | |
return h$RTS_206; | |
} | |
else | |
{ | |
var h$RTS_207 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)]); | |
h$sp -= 6; | |
h$r1 = h$RTS_207; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_213 = h$r1.d2.d1; | |
var h$RTS_214 = (h$RTS_213 & 255); | |
if((3 === h$RTS_214)) | |
{ | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
return h$RTS_206; | |
} | |
else | |
{ | |
if((3 > h$RTS_214)) | |
{ | |
var h$RTS_215 = (h$RTS_213 >> 8); | |
switch (h$RTS_215) | |
{ | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_215; | |
var h$RTS_216 = h$apply[((3 - h$RTS_214) | ((5 - h$RTS_215) << 8))]; | |
h$stack[h$sp] = h$RTS_216; | |
return h$RTS_206; | |
} | |
else | |
{ | |
var h$RTS_212 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)]); | |
h$sp -= 6; | |
h$r1 = h$RTS_212; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_3_5, unexpected closure type: " + h$RTS_206.t)); | |
}; | |
}; | |
h$o(h$ap_3_5, (-1), 0, 5, 256, null); | |
function h$ap_3_6() | |
{ | |
var h$RTS_217 = h$r1.f; | |
switch (h$RTS_217.t) | |
{ | |
case (0): | |
return h$RTS_217; | |
case (1): | |
var h$RTS_219 = h$RTS_217.a; | |
var h$RTS_220 = (h$RTS_219 & 255); | |
if((3 === h$RTS_220)) | |
{ | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
return h$RTS_217; | |
} | |
else | |
{ | |
if((3 > h$RTS_220)) | |
{ | |
var h$RTS_221 = (h$RTS_219 >> 8); | |
switch (h$RTS_221) | |
{ | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_221; | |
var h$RTS_222 = h$apply[((3 - h$RTS_220) | ((6 - h$RTS_221) << 8))]; | |
h$stack[h$sp] = h$RTS_222; | |
return h$RTS_217; | |
} | |
else | |
{ | |
var h$RTS_218 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)]); | |
h$sp -= 7; | |
h$r1 = h$RTS_218; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_224 = h$r1.d2.d1; | |
var h$RTS_225 = (h$RTS_224 & 255); | |
if((3 === h$RTS_225)) | |
{ | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
return h$RTS_217; | |
} | |
else | |
{ | |
if((3 > h$RTS_225)) | |
{ | |
var h$RTS_226 = (h$RTS_224 >> 8); | |
switch (h$RTS_226) | |
{ | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_226; | |
var h$RTS_227 = h$apply[((3 - h$RTS_225) | ((6 - h$RTS_226) << 8))]; | |
h$stack[h$sp] = h$RTS_227; | |
return h$RTS_217; | |
} | |
else | |
{ | |
var h$RTS_223 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 3), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)]); | |
h$sp -= 7; | |
h$r1 = h$RTS_223; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_3_6, unexpected closure type: " + h$RTS_217.t)); | |
}; | |
}; | |
h$o(h$ap_3_6, (-1), 0, 6, 256, null); | |
function h$ap_4_3() | |
{ | |
var h$RTS_228 = h$r1.f; | |
switch (h$RTS_228.t) | |
{ | |
case (0): | |
return h$RTS_228; | |
case (1): | |
var h$RTS_230 = h$RTS_228.a; | |
var h$RTS_231 = (h$RTS_230 & 255); | |
if((4 === h$RTS_231)) | |
{ | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
return h$RTS_228; | |
} | |
else | |
{ | |
if((4 > h$RTS_231)) | |
{ | |
var h$RTS_232 = (h$RTS_230 >> 8); | |
switch (h$RTS_232) | |
{ | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_232; | |
var h$RTS_233 = h$apply[((4 - h$RTS_231) | ((3 - h$RTS_232) << 8))]; | |
h$stack[h$sp] = h$RTS_233; | |
return h$RTS_228; | |
} | |
else | |
{ | |
var h$RTS_229 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)]); | |
h$sp -= 4; | |
h$r1 = h$RTS_229; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_235 = h$r1.d2.d1; | |
var h$RTS_236 = (h$RTS_235 & 255); | |
if((4 === h$RTS_236)) | |
{ | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
return h$RTS_228; | |
} | |
else | |
{ | |
if((4 > h$RTS_236)) | |
{ | |
var h$RTS_237 = (h$RTS_235 >> 8); | |
switch (h$RTS_237) | |
{ | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_237; | |
var h$RTS_238 = h$apply[((4 - h$RTS_236) | ((3 - h$RTS_237) << 8))]; | |
h$stack[h$sp] = h$RTS_238; | |
return h$RTS_228; | |
} | |
else | |
{ | |
var h$RTS_234 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)]); | |
h$sp -= 4; | |
h$r1 = h$RTS_234; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_4_3, unexpected closure type: " + h$RTS_228.t)); | |
}; | |
}; | |
h$o(h$ap_4_3, (-1), 0, 3, 256, null); | |
function h$ap_4_4() | |
{ | |
var h$RTS_239 = h$r1.f; | |
switch (h$RTS_239.t) | |
{ | |
case (0): | |
return h$RTS_239; | |
case (1): | |
var h$RTS_241 = h$RTS_239.a; | |
var h$RTS_242 = (h$RTS_241 & 255); | |
if((4 === h$RTS_242)) | |
{ | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
return h$RTS_239; | |
} | |
else | |
{ | |
if((4 > h$RTS_242)) | |
{ | |
var h$RTS_243 = (h$RTS_241 >> 8); | |
switch (h$RTS_243) | |
{ | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_243; | |
var h$RTS_244 = h$apply[((4 - h$RTS_242) | ((4 - h$RTS_243) << 8))]; | |
h$stack[h$sp] = h$RTS_244; | |
return h$RTS_239; | |
} | |
else | |
{ | |
var h$RTS_240 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)]); | |
h$sp -= 5; | |
h$r1 = h$RTS_240; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_246 = h$r1.d2.d1; | |
var h$RTS_247 = (h$RTS_246 & 255); | |
if((4 === h$RTS_247)) | |
{ | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
return h$RTS_239; | |
} | |
else | |
{ | |
if((4 > h$RTS_247)) | |
{ | |
var h$RTS_248 = (h$RTS_246 >> 8); | |
switch (h$RTS_248) | |
{ | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_248; | |
var h$RTS_249 = h$apply[((4 - h$RTS_247) | ((4 - h$RTS_248) << 8))]; | |
h$stack[h$sp] = h$RTS_249; | |
return h$RTS_239; | |
} | |
else | |
{ | |
var h$RTS_245 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)]); | |
h$sp -= 5; | |
h$r1 = h$RTS_245; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_4_4, unexpected closure type: " + h$RTS_239.t)); | |
}; | |
}; | |
h$o(h$ap_4_4, (-1), 0, 4, 256, null); | |
function h$ap_4_5() | |
{ | |
var h$RTS_250 = h$r1.f; | |
switch (h$RTS_250.t) | |
{ | |
case (0): | |
return h$RTS_250; | |
case (1): | |
var h$RTS_252 = h$RTS_250.a; | |
var h$RTS_253 = (h$RTS_252 & 255); | |
if((4 === h$RTS_253)) | |
{ | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
return h$RTS_250; | |
} | |
else | |
{ | |
if((4 > h$RTS_253)) | |
{ | |
var h$RTS_254 = (h$RTS_252 >> 8); | |
switch (h$RTS_254) | |
{ | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_254; | |
var h$RTS_255 = h$apply[((4 - h$RTS_253) | ((5 - h$RTS_254) << 8))]; | |
h$stack[h$sp] = h$RTS_255; | |
return h$RTS_250; | |
} | |
else | |
{ | |
var h$RTS_251 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)]); | |
h$sp -= 6; | |
h$r1 = h$RTS_251; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_257 = h$r1.d2.d1; | |
var h$RTS_258 = (h$RTS_257 & 255); | |
if((4 === h$RTS_258)) | |
{ | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
return h$RTS_250; | |
} | |
else | |
{ | |
if((4 > h$RTS_258)) | |
{ | |
var h$RTS_259 = (h$RTS_257 >> 8); | |
switch (h$RTS_259) | |
{ | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_259; | |
var h$RTS_260 = h$apply[((4 - h$RTS_258) | ((5 - h$RTS_259) << 8))]; | |
h$stack[h$sp] = h$RTS_260; | |
return h$RTS_250; | |
} | |
else | |
{ | |
var h$RTS_256 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)]); | |
h$sp -= 6; | |
h$r1 = h$RTS_256; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_4_5, unexpected closure type: " + h$RTS_250.t)); | |
}; | |
}; | |
h$o(h$ap_4_5, (-1), 0, 5, 256, null); | |
function h$ap_4_6() | |
{ | |
var h$RTS_261 = h$r1.f; | |
switch (h$RTS_261.t) | |
{ | |
case (0): | |
return h$RTS_261; | |
case (1): | |
var h$RTS_263 = h$RTS_261.a; | |
var h$RTS_264 = (h$RTS_263 & 255); | |
if((4 === h$RTS_264)) | |
{ | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
return h$RTS_261; | |
} | |
else | |
{ | |
if((4 > h$RTS_264)) | |
{ | |
var h$RTS_265 = (h$RTS_263 >> 8); | |
switch (h$RTS_265) | |
{ | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_265; | |
var h$RTS_266 = h$apply[((4 - h$RTS_264) | ((6 - h$RTS_265) << 8))]; | |
h$stack[h$sp] = h$RTS_266; | |
return h$RTS_261; | |
} | |
else | |
{ | |
var h$RTS_262 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)]); | |
h$sp -= 7; | |
h$r1 = h$RTS_262; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_268 = h$r1.d2.d1; | |
var h$RTS_269 = (h$RTS_268 & 255); | |
if((4 === h$RTS_269)) | |
{ | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
return h$RTS_261; | |
} | |
else | |
{ | |
if((4 > h$RTS_269)) | |
{ | |
var h$RTS_270 = (h$RTS_268 >> 8); | |
switch (h$RTS_270) | |
{ | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_270; | |
var h$RTS_271 = h$apply[((4 - h$RTS_269) | ((6 - h$RTS_270) << 8))]; | |
h$stack[h$sp] = h$RTS_271; | |
return h$RTS_261; | |
} | |
else | |
{ | |
var h$RTS_267 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)]); | |
h$sp -= 7; | |
h$r1 = h$RTS_267; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_4_6, unexpected closure type: " + h$RTS_261.t)); | |
}; | |
}; | |
h$o(h$ap_4_6, (-1), 0, 6, 256, null); | |
function h$ap_4_7() | |
{ | |
var h$RTS_272 = h$r1.f; | |
switch (h$RTS_272.t) | |
{ | |
case (0): | |
return h$RTS_272; | |
case (1): | |
var h$RTS_274 = h$RTS_272.a; | |
var h$RTS_275 = (h$RTS_274 & 255); | |
if((4 === h$RTS_275)) | |
{ | |
h$r8 = h$stack[(h$sp - 7)]; | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
return h$RTS_272; | |
} | |
else | |
{ | |
if((4 > h$RTS_275)) | |
{ | |
var h$RTS_276 = (h$RTS_274 >> 8); | |
switch (h$RTS_276) | |
{ | |
case (7): | |
h$r8 = h$stack[(h$sp - 7)]; | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_276; | |
var h$RTS_277 = h$apply[((4 - h$RTS_275) | ((7 - h$RTS_276) << 8))]; | |
h$stack[h$sp] = h$RTS_277; | |
return h$RTS_272; | |
} | |
else | |
{ | |
var h$RTS_273 = h$c9(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1792) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)], | |
h$stack[(h$sp - 7)]); | |
h$sp -= 8; | |
h$r1 = h$RTS_273; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_279 = h$r1.d2.d1; | |
var h$RTS_280 = (h$RTS_279 & 255); | |
if((4 === h$RTS_280)) | |
{ | |
h$r8 = h$stack[(h$sp - 7)]; | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
return h$RTS_272; | |
} | |
else | |
{ | |
if((4 > h$RTS_280)) | |
{ | |
var h$RTS_281 = (h$RTS_279 >> 8); | |
switch (h$RTS_281) | |
{ | |
case (7): | |
h$r8 = h$stack[(h$sp - 7)]; | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_281; | |
var h$RTS_282 = h$apply[((4 - h$RTS_280) | ((7 - h$RTS_281) << 8))]; | |
h$stack[h$sp] = h$RTS_282; | |
return h$RTS_272; | |
} | |
else | |
{ | |
var h$RTS_278 = h$c9(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1792) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)], | |
h$stack[(h$sp - 7)]); | |
h$sp -= 8; | |
h$r1 = h$RTS_278; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_4_7, unexpected closure type: " + h$RTS_272.t)); | |
}; | |
}; | |
h$o(h$ap_4_7, (-1), 0, 7, 256, null); | |
function h$ap_4_8() | |
{ | |
var h$RTS_283 = h$r1.f; | |
switch (h$RTS_283.t) | |
{ | |
case (0): | |
return h$RTS_283; | |
case (1): | |
var h$RTS_285 = h$RTS_283.a; | |
var h$RTS_286 = (h$RTS_285 & 255); | |
if((4 === h$RTS_286)) | |
{ | |
h$r9 = h$stack[(h$sp - 8)]; | |
h$r8 = h$stack[(h$sp - 7)]; | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 9; | |
return h$RTS_283; | |
} | |
else | |
{ | |
if((4 > h$RTS_286)) | |
{ | |
var h$RTS_287 = (h$RTS_285 >> 8); | |
switch (h$RTS_287) | |
{ | |
case (8): | |
h$r9 = h$stack[(h$sp - 8)]; | |
case (7): | |
h$r8 = h$stack[(h$sp - 7)]; | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_287; | |
var h$RTS_288 = h$apply[((4 - h$RTS_286) | ((8 - h$RTS_287) << 8))]; | |
h$stack[h$sp] = h$RTS_288; | |
return h$RTS_283; | |
} | |
else | |
{ | |
var h$RTS_284 = h$c10(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 2048) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)], | |
h$stack[(h$sp - 7)], h$stack[(h$sp - 8)]); | |
h$sp -= 9; | |
h$r1 = h$RTS_284; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_290 = h$r1.d2.d1; | |
var h$RTS_291 = (h$RTS_290 & 255); | |
if((4 === h$RTS_291)) | |
{ | |
h$r9 = h$stack[(h$sp - 8)]; | |
h$r8 = h$stack[(h$sp - 7)]; | |
h$r7 = h$stack[(h$sp - 6)]; | |
h$r6 = h$stack[(h$sp - 5)]; | |
h$r5 = h$stack[(h$sp - 4)]; | |
h$r4 = h$stack[(h$sp - 3)]; | |
h$r3 = h$stack[(h$sp - 2)]; | |
h$r2 = h$stack[(h$sp - 1)]; | |
h$sp -= 9; | |
return h$RTS_283; | |
} | |
else | |
{ | |
if((4 > h$RTS_291)) | |
{ | |
var h$RTS_292 = (h$RTS_290 >> 8); | |
switch (h$RTS_292) | |
{ | |
case (8): | |
h$r9 = h$stack[(h$sp - 8)]; | |
case (7): | |
h$r8 = h$stack[(h$sp - 7)]; | |
case (6): | |
h$r7 = h$stack[(h$sp - 6)]; | |
case (5): | |
h$r6 = h$stack[(h$sp - 5)]; | |
case (4): | |
h$r5 = h$stack[(h$sp - 4)]; | |
case (3): | |
h$r4 = h$stack[(h$sp - 3)]; | |
case (2): | |
h$r3 = h$stack[(h$sp - 2)]; | |
case (1): | |
h$r2 = h$stack[(h$sp - 1)]; | |
default: | |
}; | |
h$sp -= h$RTS_292; | |
var h$RTS_293 = h$apply[((4 - h$RTS_291) | ((8 - h$RTS_292) << 8))]; | |
h$stack[h$sp] = h$RTS_293; | |
return h$RTS_283; | |
} | |
else | |
{ | |
var h$RTS_289 = h$c10(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 2048) - 4), h$stack[(h$sp - 1)], | |
h$stack[(h$sp - 2)], h$stack[(h$sp - 3)], h$stack[(h$sp - 4)], h$stack[(h$sp - 5)], h$stack[(h$sp - 6)], | |
h$stack[(h$sp - 7)], h$stack[(h$sp - 8)]); | |
h$sp -= 9; | |
h$r1 = h$RTS_289; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("panic: h$ap_4_8, unexpected closure type: " + h$RTS_283.t)); | |
}; | |
}; | |
h$o(h$ap_4_8, (-1), 0, 8, 256, null); | |
function h$ap_1_0_fast() | |
{ | |
var h$RTS_294 = h$r1.f; | |
switch (h$RTS_294.t) | |
{ | |
case (1): | |
var h$RTS_295 = h$RTS_294.a; | |
var h$RTS_297 = (h$RTS_295 & 255); | |
if((1 === h$RTS_297)) | |
{ | |
return h$RTS_294; | |
} | |
else | |
{ | |
if((1 > h$RTS_297)) | |
{ | |
var h$RTS_298 = (h$RTS_295 >> 8); | |
var h$RTS_299 = (0 - h$RTS_298); | |
switch (h$RTS_298) | |
{ | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_299) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_299 << 8) | (1 - (h$RTS_295 & 255)))]; | |
return h$RTS_294; | |
} | |
else | |
{ | |
var h$RTS_296 = h$c3(h$pap_0, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 0) - 1), null); | |
h$r1 = h$RTS_296; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_300 = h$r1.d2.d1; | |
var h$RTS_302 = (h$RTS_300 & 255); | |
if((1 === h$RTS_302)) | |
{ | |
return h$RTS_294; | |
} | |
else | |
{ | |
if((1 > h$RTS_302)) | |
{ | |
var h$RTS_303 = (h$RTS_300 >> 8); | |
var h$RTS_304 = (0 - h$RTS_303); | |
switch (h$RTS_303) | |
{ | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_304) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_304 << 8) | (1 - (h$RTS_300 & 255)))]; | |
return h$RTS_294; | |
} | |
else | |
{ | |
var h$RTS_301 = h$c3(h$pap_0, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 0) - 1), null); | |
h$r1 = h$RTS_301; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
++h$sp; | |
h$stack[h$sp] = h$ap_1_0; | |
return h$RTS_294; | |
case (5): | |
++h$sp; | |
h$stack[h$sp] = h$ap_1_0; | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_1_0_fast: unexpected closure type: " + h$RTS_294.t)); | |
}; | |
}; | |
function h$ap_1_1_fast() | |
{ | |
var h$RTS_305 = h$r1.f; | |
switch (h$RTS_305.t) | |
{ | |
case (1): | |
var h$RTS_306 = h$RTS_305.a; | |
var h$RTS_308 = (h$RTS_306 & 255); | |
if((1 === h$RTS_308)) | |
{ | |
return h$RTS_305; | |
} | |
else | |
{ | |
if((1 > h$RTS_308)) | |
{ | |
var h$RTS_309 = (h$RTS_306 >> 8); | |
var h$RTS_310 = (1 - h$RTS_309); | |
switch (h$RTS_309) | |
{ | |
case (0): | |
h$stack[(h$sp + 1)] = h$r2; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_310) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_310 << 8) | (1 - (h$RTS_306 & 255)))]; | |
return h$RTS_305; | |
} | |
else | |
{ | |
var h$RTS_307 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 1), h$r2); | |
h$r1 = h$RTS_307; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_311 = h$r1.d2.d1; | |
var h$RTS_313 = (h$RTS_311 & 255); | |
if((1 === h$RTS_313)) | |
{ | |
return h$RTS_305; | |
} | |
else | |
{ | |
if((1 > h$RTS_313)) | |
{ | |
var h$RTS_314 = (h$RTS_311 >> 8); | |
var h$RTS_315 = (1 - h$RTS_314); | |
switch (h$RTS_314) | |
{ | |
case (0): | |
h$stack[(h$sp + 1)] = h$r2; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_315) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_315 << 8) | (1 - (h$RTS_311 & 255)))]; | |
return h$RTS_305; | |
} | |
else | |
{ | |
var h$RTS_312 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 1), h$r2); | |
h$r1 = h$RTS_312; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p2(h$r2, h$ap_1_1); | |
return h$RTS_305; | |
case (5): | |
h$p2(h$r2, h$ap_1_1); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_1_1_fast: unexpected closure type: " + h$RTS_305.t)); | |
}; | |
}; | |
function h$ap_1_2_fast() | |
{ | |
var h$RTS_316 = h$r1.f; | |
switch (h$RTS_316.t) | |
{ | |
case (1): | |
var h$RTS_317 = h$RTS_316.a; | |
var h$RTS_319 = (h$RTS_317 & 255); | |
if((1 === h$RTS_319)) | |
{ | |
return h$RTS_316; | |
} | |
else | |
{ | |
if((1 > h$RTS_319)) | |
{ | |
var h$RTS_320 = (h$RTS_317 >> 8); | |
var h$RTS_321 = (2 - h$RTS_320); | |
switch (h$RTS_320) | |
{ | |
case (0): | |
h$stack[(h$sp + 2)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 1)] = h$r3; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_321) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_321 << 8) | (1 - (h$RTS_317 & 255)))]; | |
return h$RTS_316; | |
} | |
else | |
{ | |
var h$RTS_318 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 1), h$r2, h$r3); | |
h$r1 = h$RTS_318; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_322 = h$r1.d2.d1; | |
var h$RTS_324 = (h$RTS_322 & 255); | |
if((1 === h$RTS_324)) | |
{ | |
return h$RTS_316; | |
} | |
else | |
{ | |
if((1 > h$RTS_324)) | |
{ | |
var h$RTS_325 = (h$RTS_322 >> 8); | |
var h$RTS_326 = (2 - h$RTS_325); | |
switch (h$RTS_325) | |
{ | |
case (0): | |
h$stack[(h$sp + 2)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 1)] = h$r3; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_326) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_326 << 8) | (1 - (h$RTS_322 & 255)))]; | |
return h$RTS_316; | |
} | |
else | |
{ | |
var h$RTS_323 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 1), h$r2, h$r3); | |
h$r1 = h$RTS_323; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p3(h$r3, h$r2, h$ap_1_2); | |
return h$RTS_316; | |
case (5): | |
h$p3(h$r3, h$r2, h$ap_1_2); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_1_2_fast: unexpected closure type: " + h$RTS_316.t)); | |
}; | |
}; | |
function h$ap_2_1_fast() | |
{ | |
var h$RTS_327 = h$r1.f; | |
switch (h$RTS_327.t) | |
{ | |
case (1): | |
var h$RTS_328 = h$RTS_327.a; | |
var h$RTS_330 = (h$RTS_328 & 255); | |
if((2 === h$RTS_330)) | |
{ | |
return h$RTS_327; | |
} | |
else | |
{ | |
if((2 > h$RTS_330)) | |
{ | |
var h$RTS_331 = (h$RTS_328 >> 8); | |
var h$RTS_332 = (1 - h$RTS_331); | |
switch (h$RTS_331) | |
{ | |
case (0): | |
h$stack[(h$sp + 1)] = h$r2; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_332) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_332 << 8) | (2 - (h$RTS_328 & 255)))]; | |
return h$RTS_327; | |
} | |
else | |
{ | |
var h$RTS_329 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 2), h$r2); | |
h$r1 = h$RTS_329; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_333 = h$r1.d2.d1; | |
var h$RTS_335 = (h$RTS_333 & 255); | |
if((2 === h$RTS_335)) | |
{ | |
return h$RTS_327; | |
} | |
else | |
{ | |
if((2 > h$RTS_335)) | |
{ | |
var h$RTS_336 = (h$RTS_333 >> 8); | |
var h$RTS_337 = (1 - h$RTS_336); | |
switch (h$RTS_336) | |
{ | |
case (0): | |
h$stack[(h$sp + 1)] = h$r2; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_337) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_337 << 8) | (2 - (h$RTS_333 & 255)))]; | |
return h$RTS_327; | |
} | |
else | |
{ | |
var h$RTS_334 = h$c3(h$pap_1, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 256) - 2), h$r2); | |
h$r1 = h$RTS_334; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p2(h$r2, h$ap_2_1); | |
return h$RTS_327; | |
case (5): | |
h$p2(h$r2, h$ap_2_1); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_2_1_fast: unexpected closure type: " + h$RTS_327.t)); | |
}; | |
}; | |
function h$ap_2_2_fast() | |
{ | |
var h$RTS_338 = h$r1.f; | |
switch (h$RTS_338.t) | |
{ | |
case (1): | |
var h$RTS_339 = h$RTS_338.a; | |
var h$RTS_341 = (h$RTS_339 & 255); | |
if((2 === h$RTS_341)) | |
{ | |
return h$RTS_338; | |
} | |
else | |
{ | |
if((2 > h$RTS_341)) | |
{ | |
var h$RTS_342 = (h$RTS_339 >> 8); | |
var h$RTS_343 = (2 - h$RTS_342); | |
switch (h$RTS_342) | |
{ | |
case (0): | |
h$stack[(h$sp + 2)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 1)] = h$r3; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_343) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_343 << 8) | (2 - (h$RTS_339 & 255)))]; | |
return h$RTS_338; | |
} | |
else | |
{ | |
var h$RTS_340 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 2), h$r2, h$r3); | |
h$r1 = h$RTS_340; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_344 = h$r1.d2.d1; | |
var h$RTS_346 = (h$RTS_344 & 255); | |
if((2 === h$RTS_346)) | |
{ | |
return h$RTS_338; | |
} | |
else | |
{ | |
if((2 > h$RTS_346)) | |
{ | |
var h$RTS_347 = (h$RTS_344 >> 8); | |
var h$RTS_348 = (2 - h$RTS_347); | |
switch (h$RTS_347) | |
{ | |
case (0): | |
h$stack[(h$sp + 2)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 1)] = h$r3; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_348) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_348 << 8) | (2 - (h$RTS_344 & 255)))]; | |
return h$RTS_338; | |
} | |
else | |
{ | |
var h$RTS_345 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 2), h$r2, h$r3); | |
h$r1 = h$RTS_345; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p3(h$r3, h$r2, h$ap_2_2); | |
return h$RTS_338; | |
case (5): | |
h$p3(h$r3, h$r2, h$ap_2_2); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_2_2_fast: unexpected closure type: " + h$RTS_338.t)); | |
}; | |
}; | |
function h$ap_2_3_fast() | |
{ | |
var h$RTS_349 = h$r1.f; | |
switch (h$RTS_349.t) | |
{ | |
case (1): | |
var h$RTS_350 = h$RTS_349.a; | |
var h$RTS_352 = (h$RTS_350 & 255); | |
if((2 === h$RTS_352)) | |
{ | |
return h$RTS_349; | |
} | |
else | |
{ | |
if((2 > h$RTS_352)) | |
{ | |
var h$RTS_353 = (h$RTS_350 >> 8); | |
var h$RTS_354 = (3 - h$RTS_353); | |
switch (h$RTS_353) | |
{ | |
case (0): | |
h$stack[(h$sp + 3)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 2)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 1)] = h$r4; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_354) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_354 << 8) | (2 - (h$RTS_350 & 255)))]; | |
return h$RTS_349; | |
} | |
else | |
{ | |
var h$RTS_351 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 2), h$r2, h$r3, h$r4); | |
h$r1 = h$RTS_351; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_355 = h$r1.d2.d1; | |
var h$RTS_357 = (h$RTS_355 & 255); | |
if((2 === h$RTS_357)) | |
{ | |
return h$RTS_349; | |
} | |
else | |
{ | |
if((2 > h$RTS_357)) | |
{ | |
var h$RTS_358 = (h$RTS_355 >> 8); | |
var h$RTS_359 = (3 - h$RTS_358); | |
switch (h$RTS_358) | |
{ | |
case (0): | |
h$stack[(h$sp + 3)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 2)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 1)] = h$r4; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_359) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_359 << 8) | (2 - (h$RTS_355 & 255)))]; | |
return h$RTS_349; | |
} | |
else | |
{ | |
var h$RTS_356 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 2), h$r2, h$r3, h$r4); | |
h$r1 = h$RTS_356; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p4(h$r4, h$r3, h$r2, h$ap_2_3); | |
return h$RTS_349; | |
case (5): | |
h$p4(h$r4, h$r3, h$r2, h$ap_2_3); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_2_3_fast: unexpected closure type: " + h$RTS_349.t)); | |
}; | |
}; | |
function h$ap_2_4_fast() | |
{ | |
var h$RTS_360 = h$r1.f; | |
switch (h$RTS_360.t) | |
{ | |
case (1): | |
var h$RTS_361 = h$RTS_360.a; | |
var h$RTS_363 = (h$RTS_361 & 255); | |
if((2 === h$RTS_363)) | |
{ | |
return h$RTS_360; | |
} | |
else | |
{ | |
if((2 > h$RTS_363)) | |
{ | |
var h$RTS_364 = (h$RTS_361 >> 8); | |
var h$RTS_365 = (4 - h$RTS_364); | |
switch (h$RTS_364) | |
{ | |
case (0): | |
h$stack[(h$sp + 4)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 3)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 2)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 1)] = h$r5; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_365) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_365 << 8) | (2 - (h$RTS_361 & 255)))]; | |
return h$RTS_360; | |
} | |
else | |
{ | |
var h$RTS_362 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 2), h$r2, h$r3, h$r4, h$r5); | |
h$r1 = h$RTS_362; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_366 = h$r1.d2.d1; | |
var h$RTS_368 = (h$RTS_366 & 255); | |
if((2 === h$RTS_368)) | |
{ | |
return h$RTS_360; | |
} | |
else | |
{ | |
if((2 > h$RTS_368)) | |
{ | |
var h$RTS_369 = (h$RTS_366 >> 8); | |
var h$RTS_370 = (4 - h$RTS_369); | |
switch (h$RTS_369) | |
{ | |
case (0): | |
h$stack[(h$sp + 4)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 3)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 2)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 1)] = h$r5; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_370) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_370 << 8) | (2 - (h$RTS_366 & 255)))]; | |
return h$RTS_360; | |
} | |
else | |
{ | |
var h$RTS_367 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 2), h$r2, h$r3, h$r4, h$r5); | |
h$r1 = h$RTS_367; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p5(h$r5, h$r4, h$r3, h$r2, h$ap_2_4); | |
return h$RTS_360; | |
case (5): | |
h$p5(h$r5, h$r4, h$r3, h$r2, h$ap_2_4); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_2_4_fast: unexpected closure type: " + h$RTS_360.t)); | |
}; | |
}; | |
function h$ap_3_2_fast() | |
{ | |
var h$RTS_371 = h$r1.f; | |
switch (h$RTS_371.t) | |
{ | |
case (1): | |
var h$RTS_372 = h$RTS_371.a; | |
var h$RTS_374 = (h$RTS_372 & 255); | |
if((3 === h$RTS_374)) | |
{ | |
return h$RTS_371; | |
} | |
else | |
{ | |
if((3 > h$RTS_374)) | |
{ | |
var h$RTS_375 = (h$RTS_372 >> 8); | |
var h$RTS_376 = (2 - h$RTS_375); | |
switch (h$RTS_375) | |
{ | |
case (0): | |
h$stack[(h$sp + 2)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 1)] = h$r3; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_376) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_376 << 8) | (3 - (h$RTS_372 & 255)))]; | |
return h$RTS_371; | |
} | |
else | |
{ | |
var h$RTS_373 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 3), h$r2, h$r3); | |
h$r1 = h$RTS_373; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_377 = h$r1.d2.d1; | |
var h$RTS_379 = (h$RTS_377 & 255); | |
if((3 === h$RTS_379)) | |
{ | |
return h$RTS_371; | |
} | |
else | |
{ | |
if((3 > h$RTS_379)) | |
{ | |
var h$RTS_380 = (h$RTS_377 >> 8); | |
var h$RTS_381 = (2 - h$RTS_380); | |
switch (h$RTS_380) | |
{ | |
case (0): | |
h$stack[(h$sp + 2)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 1)] = h$r3; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_381) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_381 << 8) | (3 - (h$RTS_377 & 255)))]; | |
return h$RTS_371; | |
} | |
else | |
{ | |
var h$RTS_378 = h$c4(h$pap_2, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 512) - 3), h$r2, h$r3); | |
h$r1 = h$RTS_378; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p3(h$r3, h$r2, h$ap_3_2); | |
return h$RTS_371; | |
case (5): | |
h$p3(h$r3, h$r2, h$ap_3_2); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_3_2_fast: unexpected closure type: " + h$RTS_371.t)); | |
}; | |
}; | |
function h$ap_3_3_fast() | |
{ | |
var h$RTS_382 = h$r1.f; | |
switch (h$RTS_382.t) | |
{ | |
case (1): | |
var h$RTS_383 = h$RTS_382.a; | |
var h$RTS_385 = (h$RTS_383 & 255); | |
if((3 === h$RTS_385)) | |
{ | |
return h$RTS_382; | |
} | |
else | |
{ | |
if((3 > h$RTS_385)) | |
{ | |
var h$RTS_386 = (h$RTS_383 >> 8); | |
var h$RTS_387 = (3 - h$RTS_386); | |
switch (h$RTS_386) | |
{ | |
case (0): | |
h$stack[(h$sp + 3)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 2)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 1)] = h$r4; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_387) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_387 << 8) | (3 - (h$RTS_383 & 255)))]; | |
return h$RTS_382; | |
} | |
else | |
{ | |
var h$RTS_384 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 3), h$r2, h$r3, h$r4); | |
h$r1 = h$RTS_384; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_388 = h$r1.d2.d1; | |
var h$RTS_390 = (h$RTS_388 & 255); | |
if((3 === h$RTS_390)) | |
{ | |
return h$RTS_382; | |
} | |
else | |
{ | |
if((3 > h$RTS_390)) | |
{ | |
var h$RTS_391 = (h$RTS_388 >> 8); | |
var h$RTS_392 = (3 - h$RTS_391); | |
switch (h$RTS_391) | |
{ | |
case (0): | |
h$stack[(h$sp + 3)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 2)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 1)] = h$r4; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_392) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_392 << 8) | (3 - (h$RTS_388 & 255)))]; | |
return h$RTS_382; | |
} | |
else | |
{ | |
var h$RTS_389 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 3), h$r2, h$r3, h$r4); | |
h$r1 = h$RTS_389; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p4(h$r4, h$r3, h$r2, h$ap_3_3); | |
return h$RTS_382; | |
case (5): | |
h$p4(h$r4, h$r3, h$r2, h$ap_3_3); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_3_3_fast: unexpected closure type: " + h$RTS_382.t)); | |
}; | |
}; | |
function h$ap_3_4_fast() | |
{ | |
var h$RTS_393 = h$r1.f; | |
switch (h$RTS_393.t) | |
{ | |
case (1): | |
var h$RTS_394 = h$RTS_393.a; | |
var h$RTS_396 = (h$RTS_394 & 255); | |
if((3 === h$RTS_396)) | |
{ | |
return h$RTS_393; | |
} | |
else | |
{ | |
if((3 > h$RTS_396)) | |
{ | |
var h$RTS_397 = (h$RTS_394 >> 8); | |
var h$RTS_398 = (4 - h$RTS_397); | |
switch (h$RTS_397) | |
{ | |
case (0): | |
h$stack[(h$sp + 4)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 3)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 2)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 1)] = h$r5; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_398) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_398 << 8) | (3 - (h$RTS_394 & 255)))]; | |
return h$RTS_393; | |
} | |
else | |
{ | |
var h$RTS_395 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 3), h$r2, h$r3, h$r4, h$r5); | |
h$r1 = h$RTS_395; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_399 = h$r1.d2.d1; | |
var h$RTS_401 = (h$RTS_399 & 255); | |
if((3 === h$RTS_401)) | |
{ | |
return h$RTS_393; | |
} | |
else | |
{ | |
if((3 > h$RTS_401)) | |
{ | |
var h$RTS_402 = (h$RTS_399 >> 8); | |
var h$RTS_403 = (4 - h$RTS_402); | |
switch (h$RTS_402) | |
{ | |
case (0): | |
h$stack[(h$sp + 4)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 3)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 2)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 1)] = h$r5; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_403) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_403 << 8) | (3 - (h$RTS_399 & 255)))]; | |
return h$RTS_393; | |
} | |
else | |
{ | |
var h$RTS_400 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 3), h$r2, h$r3, h$r4, h$r5); | |
h$r1 = h$RTS_400; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p5(h$r5, h$r4, h$r3, h$r2, h$ap_3_4); | |
return h$RTS_393; | |
case (5): | |
h$p5(h$r5, h$r4, h$r3, h$r2, h$ap_3_4); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_3_4_fast: unexpected closure type: " + h$RTS_393.t)); | |
}; | |
}; | |
function h$ap_3_5_fast() | |
{ | |
var h$RTS_404 = h$r1.f; | |
switch (h$RTS_404.t) | |
{ | |
case (1): | |
var h$RTS_405 = h$RTS_404.a; | |
var h$RTS_407 = (h$RTS_405 & 255); | |
if((3 === h$RTS_407)) | |
{ | |
return h$RTS_404; | |
} | |
else | |
{ | |
if((3 > h$RTS_407)) | |
{ | |
var h$RTS_408 = (h$RTS_405 >> 8); | |
var h$RTS_409 = (5 - h$RTS_408); | |
switch (h$RTS_408) | |
{ | |
case (0): | |
h$stack[(h$sp + 5)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 4)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 3)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 2)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 1)] = h$r6; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_409) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_409 << 8) | (3 - (h$RTS_405 & 255)))]; | |
return h$RTS_404; | |
} | |
else | |
{ | |
var h$RTS_406 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 3), h$r2, h$r3, h$r4, h$r5, | |
h$r6); | |
h$r1 = h$RTS_406; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_410 = h$r1.d2.d1; | |
var h$RTS_412 = (h$RTS_410 & 255); | |
if((3 === h$RTS_412)) | |
{ | |
return h$RTS_404; | |
} | |
else | |
{ | |
if((3 > h$RTS_412)) | |
{ | |
var h$RTS_413 = (h$RTS_410 >> 8); | |
var h$RTS_414 = (5 - h$RTS_413); | |
switch (h$RTS_413) | |
{ | |
case (0): | |
h$stack[(h$sp + 5)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 4)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 3)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 2)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 1)] = h$r6; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_414) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_414 << 8) | (3 - (h$RTS_410 & 255)))]; | |
return h$RTS_404; | |
} | |
else | |
{ | |
var h$RTS_411 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 3), h$r2, h$r3, h$r4, h$r5, | |
h$r6); | |
h$r1 = h$RTS_411; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p6(h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_3_5); | |
return h$RTS_404; | |
case (5): | |
h$p6(h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_3_5); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_3_5_fast: unexpected closure type: " + h$RTS_404.t)); | |
}; | |
}; | |
function h$ap_3_6_fast() | |
{ | |
var h$RTS_415 = h$r1.f; | |
switch (h$RTS_415.t) | |
{ | |
case (1): | |
var h$RTS_416 = h$RTS_415.a; | |
var h$RTS_418 = (h$RTS_416 & 255); | |
if((3 === h$RTS_418)) | |
{ | |
return h$RTS_415; | |
} | |
else | |
{ | |
if((3 > h$RTS_418)) | |
{ | |
var h$RTS_419 = (h$RTS_416 >> 8); | |
var h$RTS_420 = (6 - h$RTS_419); | |
switch (h$RTS_419) | |
{ | |
case (0): | |
h$stack[(h$sp + 6)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 5)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 4)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 3)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 2)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 1)] = h$r7; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_420) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_420 << 8) | (3 - (h$RTS_416 & 255)))]; | |
return h$RTS_415; | |
} | |
else | |
{ | |
var h$RTS_417 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 3), h$r2, h$r3, h$r4, h$r5, | |
h$r6, h$r7); | |
h$r1 = h$RTS_417; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_421 = h$r1.d2.d1; | |
var h$RTS_423 = (h$RTS_421 & 255); | |
if((3 === h$RTS_423)) | |
{ | |
return h$RTS_415; | |
} | |
else | |
{ | |
if((3 > h$RTS_423)) | |
{ | |
var h$RTS_424 = (h$RTS_421 >> 8); | |
var h$RTS_425 = (6 - h$RTS_424); | |
switch (h$RTS_424) | |
{ | |
case (0): | |
h$stack[(h$sp + 6)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 5)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 4)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 3)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 2)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 1)] = h$r7; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_425) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_425 << 8) | (3 - (h$RTS_421 & 255)))]; | |
return h$RTS_415; | |
} | |
else | |
{ | |
var h$RTS_422 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 3), h$r2, h$r3, h$r4, h$r5, | |
h$r6, h$r7); | |
h$r1 = h$RTS_422; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p7(h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_3_6); | |
return h$RTS_415; | |
case (5): | |
h$p7(h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_3_6); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_3_6_fast: unexpected closure type: " + h$RTS_415.t)); | |
}; | |
}; | |
function h$ap_4_3_fast() | |
{ | |
var h$RTS_426 = h$r1.f; | |
switch (h$RTS_426.t) | |
{ | |
case (1): | |
var h$RTS_427 = h$RTS_426.a; | |
var h$RTS_429 = (h$RTS_427 & 255); | |
if((4 === h$RTS_429)) | |
{ | |
return h$RTS_426; | |
} | |
else | |
{ | |
if((4 > h$RTS_429)) | |
{ | |
var h$RTS_430 = (h$RTS_427 >> 8); | |
var h$RTS_431 = (3 - h$RTS_430); | |
switch (h$RTS_430) | |
{ | |
case (0): | |
h$stack[(h$sp + 3)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 2)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 1)] = h$r4; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_431) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_431 << 8) | (4 - (h$RTS_427 & 255)))]; | |
return h$RTS_426; | |
} | |
else | |
{ | |
var h$RTS_428 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 4), h$r2, h$r3, h$r4); | |
h$r1 = h$RTS_428; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_432 = h$r1.d2.d1; | |
var h$RTS_434 = (h$RTS_432 & 255); | |
if((4 === h$RTS_434)) | |
{ | |
return h$RTS_426; | |
} | |
else | |
{ | |
if((4 > h$RTS_434)) | |
{ | |
var h$RTS_435 = (h$RTS_432 >> 8); | |
var h$RTS_436 = (3 - h$RTS_435); | |
switch (h$RTS_435) | |
{ | |
case (0): | |
h$stack[(h$sp + 3)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 2)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 1)] = h$r4; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_436) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_436 << 8) | (4 - (h$RTS_432 & 255)))]; | |
return h$RTS_426; | |
} | |
else | |
{ | |
var h$RTS_433 = h$c5(h$pap_3, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 768) - 4), h$r2, h$r3, h$r4); | |
h$r1 = h$RTS_433; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p4(h$r4, h$r3, h$r2, h$ap_4_3); | |
return h$RTS_426; | |
case (5): | |
h$p4(h$r4, h$r3, h$r2, h$ap_4_3); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_4_3_fast: unexpected closure type: " + h$RTS_426.t)); | |
}; | |
}; | |
function h$ap_4_4_fast() | |
{ | |
var h$RTS_437 = h$r1.f; | |
switch (h$RTS_437.t) | |
{ | |
case (1): | |
var h$RTS_438 = h$RTS_437.a; | |
var h$RTS_440 = (h$RTS_438 & 255); | |
if((4 === h$RTS_440)) | |
{ | |
return h$RTS_437; | |
} | |
else | |
{ | |
if((4 > h$RTS_440)) | |
{ | |
var h$RTS_441 = (h$RTS_438 >> 8); | |
var h$RTS_442 = (4 - h$RTS_441); | |
switch (h$RTS_441) | |
{ | |
case (0): | |
h$stack[(h$sp + 4)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 3)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 2)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 1)] = h$r5; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_442) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_442 << 8) | (4 - (h$RTS_438 & 255)))]; | |
return h$RTS_437; | |
} | |
else | |
{ | |
var h$RTS_439 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 4), h$r2, h$r3, h$r4, h$r5); | |
h$r1 = h$RTS_439; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_443 = h$r1.d2.d1; | |
var h$RTS_445 = (h$RTS_443 & 255); | |
if((4 === h$RTS_445)) | |
{ | |
return h$RTS_437; | |
} | |
else | |
{ | |
if((4 > h$RTS_445)) | |
{ | |
var h$RTS_446 = (h$RTS_443 >> 8); | |
var h$RTS_447 = (4 - h$RTS_446); | |
switch (h$RTS_446) | |
{ | |
case (0): | |
h$stack[(h$sp + 4)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 3)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 2)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 1)] = h$r5; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_447) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_447 << 8) | (4 - (h$RTS_443 & 255)))]; | |
return h$RTS_437; | |
} | |
else | |
{ | |
var h$RTS_444 = h$c6(h$pap_4, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1024) - 4), h$r2, h$r3, h$r4, h$r5); | |
h$r1 = h$RTS_444; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p5(h$r5, h$r4, h$r3, h$r2, h$ap_4_4); | |
return h$RTS_437; | |
case (5): | |
h$p5(h$r5, h$r4, h$r3, h$r2, h$ap_4_4); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_4_4_fast: unexpected closure type: " + h$RTS_437.t)); | |
}; | |
}; | |
function h$ap_4_5_fast() | |
{ | |
var h$RTS_448 = h$r1.f; | |
switch (h$RTS_448.t) | |
{ | |
case (1): | |
var h$RTS_449 = h$RTS_448.a; | |
var h$RTS_451 = (h$RTS_449 & 255); | |
if((4 === h$RTS_451)) | |
{ | |
return h$RTS_448; | |
} | |
else | |
{ | |
if((4 > h$RTS_451)) | |
{ | |
var h$RTS_452 = (h$RTS_449 >> 8); | |
var h$RTS_453 = (5 - h$RTS_452); | |
switch (h$RTS_452) | |
{ | |
case (0): | |
h$stack[(h$sp + 5)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 4)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 3)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 2)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 1)] = h$r6; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_453) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_453 << 8) | (4 - (h$RTS_449 & 255)))]; | |
return h$RTS_448; | |
} | |
else | |
{ | |
var h$RTS_450 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 4), h$r2, h$r3, h$r4, h$r5, | |
h$r6); | |
h$r1 = h$RTS_450; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_454 = h$r1.d2.d1; | |
var h$RTS_456 = (h$RTS_454 & 255); | |
if((4 === h$RTS_456)) | |
{ | |
return h$RTS_448; | |
} | |
else | |
{ | |
if((4 > h$RTS_456)) | |
{ | |
var h$RTS_457 = (h$RTS_454 >> 8); | |
var h$RTS_458 = (5 - h$RTS_457); | |
switch (h$RTS_457) | |
{ | |
case (0): | |
h$stack[(h$sp + 5)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 4)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 3)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 2)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 1)] = h$r6; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_458) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_458 << 8) | (4 - (h$RTS_454 & 255)))]; | |
return h$RTS_448; | |
} | |
else | |
{ | |
var h$RTS_455 = h$c7(h$pap_5, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1280) - 4), h$r2, h$r3, h$r4, h$r5, | |
h$r6); | |
h$r1 = h$RTS_455; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p6(h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_5); | |
return h$RTS_448; | |
case (5): | |
h$p6(h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_5); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_4_5_fast: unexpected closure type: " + h$RTS_448.t)); | |
}; | |
}; | |
function h$ap_4_6_fast() | |
{ | |
var h$RTS_459 = h$r1.f; | |
switch (h$RTS_459.t) | |
{ | |
case (1): | |
var h$RTS_460 = h$RTS_459.a; | |
var h$RTS_462 = (h$RTS_460 & 255); | |
if((4 === h$RTS_462)) | |
{ | |
return h$RTS_459; | |
} | |
else | |
{ | |
if((4 > h$RTS_462)) | |
{ | |
var h$RTS_463 = (h$RTS_460 >> 8); | |
var h$RTS_464 = (6 - h$RTS_463); | |
switch (h$RTS_463) | |
{ | |
case (0): | |
h$stack[(h$sp + 6)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 5)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 4)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 3)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 2)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 1)] = h$r7; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_464) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_464 << 8) | (4 - (h$RTS_460 & 255)))]; | |
return h$RTS_459; | |
} | |
else | |
{ | |
var h$RTS_461 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 4), h$r2, h$r3, h$r4, h$r5, | |
h$r6, h$r7); | |
h$r1 = h$RTS_461; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_465 = h$r1.d2.d1; | |
var h$RTS_467 = (h$RTS_465 & 255); | |
if((4 === h$RTS_467)) | |
{ | |
return h$RTS_459; | |
} | |
else | |
{ | |
if((4 > h$RTS_467)) | |
{ | |
var h$RTS_468 = (h$RTS_465 >> 8); | |
var h$RTS_469 = (6 - h$RTS_468); | |
switch (h$RTS_468) | |
{ | |
case (0): | |
h$stack[(h$sp + 6)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 5)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 4)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 3)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 2)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 1)] = h$r7; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_469) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_469 << 8) | (4 - (h$RTS_465 & 255)))]; | |
return h$RTS_459; | |
} | |
else | |
{ | |
var h$RTS_466 = h$c8(h$pap_6, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1536) - 4), h$r2, h$r3, h$r4, h$r5, | |
h$r6, h$r7); | |
h$r1 = h$RTS_466; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p7(h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_6); | |
return h$RTS_459; | |
case (5): | |
h$p7(h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_6); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_4_6_fast: unexpected closure type: " + h$RTS_459.t)); | |
}; | |
}; | |
function h$ap_4_7_fast() | |
{ | |
var h$RTS_470 = h$r1.f; | |
switch (h$RTS_470.t) | |
{ | |
case (1): | |
var h$RTS_471 = h$RTS_470.a; | |
var h$RTS_473 = (h$RTS_471 & 255); | |
if((4 === h$RTS_473)) | |
{ | |
return h$RTS_470; | |
} | |
else | |
{ | |
if((4 > h$RTS_473)) | |
{ | |
var h$RTS_474 = (h$RTS_471 >> 8); | |
var h$RTS_475 = (7 - h$RTS_474); | |
switch (h$RTS_474) | |
{ | |
case (0): | |
h$stack[(h$sp + 7)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 6)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 5)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 4)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 3)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 2)] = h$r7; | |
case (6): | |
h$stack[(h$sp + 1)] = h$r8; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_475) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_475 << 8) | (4 - (h$RTS_471 & 255)))]; | |
return h$RTS_470; | |
} | |
else | |
{ | |
var h$RTS_472 = h$c9(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1792) - 4), h$r2, h$r3, h$r4, h$r5, | |
h$r6, h$r7, h$r8); | |
h$r1 = h$RTS_472; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_476 = h$r1.d2.d1; | |
var h$RTS_478 = (h$RTS_476 & 255); | |
if((4 === h$RTS_478)) | |
{ | |
return h$RTS_470; | |
} | |
else | |
{ | |
if((4 > h$RTS_478)) | |
{ | |
var h$RTS_479 = (h$RTS_476 >> 8); | |
var h$RTS_480 = (7 - h$RTS_479); | |
switch (h$RTS_479) | |
{ | |
case (0): | |
h$stack[(h$sp + 7)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 6)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 5)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 4)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 3)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 2)] = h$r7; | |
case (6): | |
h$stack[(h$sp + 1)] = h$r8; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_480) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_480 << 8) | (4 - (h$RTS_476 & 255)))]; | |
return h$RTS_470; | |
} | |
else | |
{ | |
var h$RTS_477 = h$c9(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 1792) - 4), h$r2, h$r3, h$r4, h$r5, | |
h$r6, h$r7, h$r8); | |
h$r1 = h$RTS_477; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p8(h$r8, h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_7); | |
return h$RTS_470; | |
case (5): | |
h$p8(h$r8, h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_7); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_4_7_fast: unexpected closure type: " + h$RTS_470.t)); | |
}; | |
}; | |
function h$ap_4_8_fast() | |
{ | |
var h$RTS_481 = h$r1.f; | |
switch (h$RTS_481.t) | |
{ | |
case (1): | |
var h$RTS_482 = h$RTS_481.a; | |
var h$RTS_484 = (h$RTS_482 & 255); | |
if((4 === h$RTS_484)) | |
{ | |
return h$RTS_481; | |
} | |
else | |
{ | |
if((4 > h$RTS_484)) | |
{ | |
var h$RTS_485 = (h$RTS_482 >> 8); | |
var h$RTS_486 = (8 - h$RTS_485); | |
switch (h$RTS_485) | |
{ | |
case (0): | |
h$stack[(h$sp + 8)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 7)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 6)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 5)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 4)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 3)] = h$r7; | |
case (6): | |
h$stack[(h$sp + 2)] = h$r8; | |
case (7): | |
h$stack[(h$sp + 1)] = h$r9; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_486) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_486 << 8) | (4 - (h$RTS_482 & 255)))]; | |
return h$RTS_481; | |
} | |
else | |
{ | |
var h$RTS_483 = h$c10(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 2048) - 4), h$r2, h$r3, h$r4, | |
h$r5, h$r6, h$r7, h$r8, h$r9); | |
h$r1 = h$RTS_483; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_487 = h$r1.d2.d1; | |
var h$RTS_489 = (h$RTS_487 & 255); | |
if((4 === h$RTS_489)) | |
{ | |
return h$RTS_481; | |
} | |
else | |
{ | |
if((4 > h$RTS_489)) | |
{ | |
var h$RTS_490 = (h$RTS_487 >> 8); | |
var h$RTS_491 = (8 - h$RTS_490); | |
switch (h$RTS_490) | |
{ | |
case (0): | |
h$stack[(h$sp + 8)] = h$r2; | |
case (1): | |
h$stack[(h$sp + 7)] = h$r3; | |
case (2): | |
h$stack[(h$sp + 6)] = h$r4; | |
case (3): | |
h$stack[(h$sp + 5)] = h$r5; | |
case (4): | |
h$stack[(h$sp + 4)] = h$r6; | |
case (5): | |
h$stack[(h$sp + 3)] = h$r7; | |
case (6): | |
h$stack[(h$sp + 2)] = h$r8; | |
case (7): | |
h$stack[(h$sp + 1)] = h$r9; | |
default: | |
}; | |
h$sp = ((h$sp + h$RTS_491) + 1); | |
h$stack[h$sp] = h$apply[((h$RTS_491 << 8) | (4 - (h$RTS_487 & 255)))]; | |
return h$RTS_481; | |
} | |
else | |
{ | |
var h$RTS_488 = h$c10(h$pap_gen, h$r1, ((((h$r1.f.t === 1) ? h$r1.f.a : h$r1.d2.d1) - 2048) - 4), h$r2, h$r3, h$r4, | |
h$r5, h$r6, h$r7, h$r8, h$r9); | |
h$r1 = h$RTS_488; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (0): | |
h$p9(h$r9, h$r8, h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_8); | |
return h$RTS_481; | |
case (5): | |
h$p9(h$r9, h$r8, h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$ap_4_8); | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_4_8_fast: unexpected closure type: " + h$RTS_481.t)); | |
}; | |
}; | |
function h$pap_0() | |
{ | |
var h$RTS_492 = h$r1.d1; | |
var h$RTS_493 = h$r1.d2; | |
var h$RTS_494 = h$RTS_492.f; | |
var h$RTS_495 = ((((h$RTS_494.t === 1) ? h$RTS_494.a : h$RTS_492.d2.d1) >> 8) - 0); | |
switch (h$RTS_495) | |
{ | |
case (127): | |
h$regs[95] = h$regs[95]; | |
case (126): | |
h$regs[94] = h$regs[94]; | |
case (125): | |
h$regs[93] = h$regs[93]; | |
case (124): | |
h$regs[92] = h$regs[92]; | |
case (123): | |
h$regs[91] = h$regs[91]; | |
case (122): | |
h$regs[90] = h$regs[90]; | |
case (121): | |
h$regs[89] = h$regs[89]; | |
case (120): | |
h$regs[88] = h$regs[88]; | |
case (119): | |
h$regs[87] = h$regs[87]; | |
case (118): | |
h$regs[86] = h$regs[86]; | |
case (117): | |
h$regs[85] = h$regs[85]; | |
case (116): | |
h$regs[84] = h$regs[84]; | |
case (115): | |
h$regs[83] = h$regs[83]; | |
case (114): | |
h$regs[82] = h$regs[82]; | |
case (113): | |
h$regs[81] = h$regs[81]; | |
case (112): | |
h$regs[80] = h$regs[80]; | |
case (111): | |
h$regs[79] = h$regs[79]; | |
case (110): | |
h$regs[78] = h$regs[78]; | |
case (109): | |
h$regs[77] = h$regs[77]; | |
case (108): | |
h$regs[76] = h$regs[76]; | |
case (107): | |
h$regs[75] = h$regs[75]; | |
case (106): | |
h$regs[74] = h$regs[74]; | |
case (105): | |
h$regs[73] = h$regs[73]; | |
case (104): | |
h$regs[72] = h$regs[72]; | |
case (103): | |
h$regs[71] = h$regs[71]; | |
case (102): | |
h$regs[70] = h$regs[70]; | |
case (101): | |
h$regs[69] = h$regs[69]; | |
case (100): | |
h$regs[68] = h$regs[68]; | |
case (99): | |
h$regs[67] = h$regs[67]; | |
case (98): | |
h$regs[66] = h$regs[66]; | |
case (97): | |
h$regs[65] = h$regs[65]; | |
case (96): | |
h$regs[64] = h$regs[64]; | |
case (95): | |
h$regs[63] = h$regs[63]; | |
case (94): | |
h$regs[62] = h$regs[62]; | |
case (93): | |
h$regs[61] = h$regs[61]; | |
case (92): | |
h$regs[60] = h$regs[60]; | |
case (91): | |
h$regs[59] = h$regs[59]; | |
case (90): | |
h$regs[58] = h$regs[58]; | |
case (89): | |
h$regs[57] = h$regs[57]; | |
case (88): | |
h$regs[56] = h$regs[56]; | |
case (87): | |
h$regs[55] = h$regs[55]; | |
case (86): | |
h$regs[54] = h$regs[54]; | |
case (85): | |
h$regs[53] = h$regs[53]; | |
case (84): | |
h$regs[52] = h$regs[52]; | |
case (83): | |
h$regs[51] = h$regs[51]; | |
case (82): | |
h$regs[50] = h$regs[50]; | |
case (81): | |
h$regs[49] = h$regs[49]; | |
case (80): | |
h$regs[48] = h$regs[48]; | |
case (79): | |
h$regs[47] = h$regs[47]; | |
case (78): | |
h$regs[46] = h$regs[46]; | |
case (77): | |
h$regs[45] = h$regs[45]; | |
case (76): | |
h$regs[44] = h$regs[44]; | |
case (75): | |
h$regs[43] = h$regs[43]; | |
case (74): | |
h$regs[42] = h$regs[42]; | |
case (73): | |
h$regs[41] = h$regs[41]; | |
case (72): | |
h$regs[40] = h$regs[40]; | |
case (71): | |
h$regs[39] = h$regs[39]; | |
case (70): | |
h$regs[38] = h$regs[38]; | |
case (69): | |
h$regs[37] = h$regs[37]; | |
case (68): | |
h$regs[36] = h$regs[36]; | |
case (67): | |
h$regs[35] = h$regs[35]; | |
case (66): | |
h$regs[34] = h$regs[34]; | |
case (65): | |
h$regs[33] = h$regs[33]; | |
case (64): | |
h$regs[32] = h$regs[32]; | |
case (63): | |
h$regs[31] = h$regs[31]; | |
case (62): | |
h$regs[30] = h$regs[30]; | |
case (61): | |
h$regs[29] = h$regs[29]; | |
case (60): | |
h$regs[28] = h$regs[28]; | |
case (59): | |
h$regs[27] = h$regs[27]; | |
case (58): | |
h$regs[26] = h$regs[26]; | |
case (57): | |
h$regs[25] = h$regs[25]; | |
case (56): | |
h$regs[24] = h$regs[24]; | |
case (55): | |
h$regs[23] = h$regs[23]; | |
case (54): | |
h$regs[22] = h$regs[22]; | |
case (53): | |
h$regs[21] = h$regs[21]; | |
case (52): | |
h$regs[20] = h$regs[20]; | |
case (51): | |
h$regs[19] = h$regs[19]; | |
case (50): | |
h$regs[18] = h$regs[18]; | |
case (49): | |
h$regs[17] = h$regs[17]; | |
case (48): | |
h$regs[16] = h$regs[16]; | |
case (47): | |
h$regs[15] = h$regs[15]; | |
case (46): | |
h$regs[14] = h$regs[14]; | |
case (45): | |
h$regs[13] = h$regs[13]; | |
case (44): | |
h$regs[12] = h$regs[12]; | |
case (43): | |
h$regs[11] = h$regs[11]; | |
case (42): | |
h$regs[10] = h$regs[10]; | |
case (41): | |
h$regs[9] = h$regs[9]; | |
case (40): | |
h$regs[8] = h$regs[8]; | |
case (39): | |
h$regs[7] = h$regs[7]; | |
case (38): | |
h$regs[6] = h$regs[6]; | |
case (37): | |
h$regs[5] = h$regs[5]; | |
case (36): | |
h$regs[4] = h$regs[4]; | |
case (35): | |
h$regs[3] = h$regs[3]; | |
case (34): | |
h$regs[2] = h$regs[2]; | |
case (33): | |
h$regs[1] = h$regs[1]; | |
case (32): | |
h$regs[0] = h$regs[0]; | |
case (31): | |
h$r32 = h$r32; | |
case (30): | |
h$r31 = h$r31; | |
case (29): | |
h$r30 = h$r30; | |
case (28): | |
h$r29 = h$r29; | |
case (27): | |
h$r28 = h$r28; | |
case (26): | |
h$r27 = h$r27; | |
case (25): | |
h$r26 = h$r26; | |
case (24): | |
h$r25 = h$r25; | |
case (23): | |
h$r24 = h$r24; | |
case (22): | |
h$r23 = h$r23; | |
case (21): | |
h$r22 = h$r22; | |
case (20): | |
h$r21 = h$r21; | |
case (19): | |
h$r20 = h$r20; | |
case (18): | |
h$r19 = h$r19; | |
case (17): | |
h$r18 = h$r18; | |
case (16): | |
h$r17 = h$r17; | |
case (15): | |
h$r16 = h$r16; | |
case (14): | |
h$r15 = h$r15; | |
case (13): | |
h$r14 = h$r14; | |
case (12): | |
h$r13 = h$r13; | |
case (11): | |
h$r12 = h$r12; | |
case (10): | |
h$r11 = h$r11; | |
case (9): | |
h$r10 = h$r10; | |
case (8): | |
h$r9 = h$r9; | |
case (7): | |
h$r8 = h$r8; | |
case (6): | |
h$r7 = h$r7; | |
case (5): | |
h$r6 = h$r6; | |
case (4): | |
h$r5 = h$r5; | |
case (3): | |
h$r4 = h$r4; | |
case (2): | |
h$r3 = h$r3; | |
case (1): | |
h$r2 = h$r2; | |
default: | |
}; | |
h$r1 = h$RTS_492; | |
return h$RTS_494; | |
}; | |
h$o(h$pap_0, 3, 0, 2, (-1), null); | |
function h$pap_1() | |
{ | |
var h$RTS_496 = h$r1.d1; | |
var h$RTS_497 = h$r1.d2; | |
var h$RTS_498 = h$RTS_496.f; | |
var h$RTS_499 = ((((h$RTS_498.t === 1) ? h$RTS_498.a : h$RTS_496.d2.d1) >> 8) - 1); | |
switch (h$RTS_499) | |
{ | |
case (126): | |
h$regs[95] = h$regs[94]; | |
case (125): | |
h$regs[94] = h$regs[93]; | |
case (124): | |
h$regs[93] = h$regs[92]; | |
case (123): | |
h$regs[92] = h$regs[91]; | |
case (122): | |
h$regs[91] = h$regs[90]; | |
case (121): | |
h$regs[90] = h$regs[89]; | |
case (120): | |
h$regs[89] = h$regs[88]; | |
case (119): | |
h$regs[88] = h$regs[87]; | |
case (118): | |
h$regs[87] = h$regs[86]; | |
case (117): | |
h$regs[86] = h$regs[85]; | |
case (116): | |
h$regs[85] = h$regs[84]; | |
case (115): | |
h$regs[84] = h$regs[83]; | |
case (114): | |
h$regs[83] = h$regs[82]; | |
case (113): | |
h$regs[82] = h$regs[81]; | |
case (112): | |
h$regs[81] = h$regs[80]; | |
case (111): | |
h$regs[80] = h$regs[79]; | |
case (110): | |
h$regs[79] = h$regs[78]; | |
case (109): | |
h$regs[78] = h$regs[77]; | |
case (108): | |
h$regs[77] = h$regs[76]; | |
case (107): | |
h$regs[76] = h$regs[75]; | |
case (106): | |
h$regs[75] = h$regs[74]; | |
case (105): | |
h$regs[74] = h$regs[73]; | |
case (104): | |
h$regs[73] = h$regs[72]; | |
case (103): | |
h$regs[72] = h$regs[71]; | |
case (102): | |
h$regs[71] = h$regs[70]; | |
case (101): | |
h$regs[70] = h$regs[69]; | |
case (100): | |
h$regs[69] = h$regs[68]; | |
case (99): | |
h$regs[68] = h$regs[67]; | |
case (98): | |
h$regs[67] = h$regs[66]; | |
case (97): | |
h$regs[66] = h$regs[65]; | |
case (96): | |
h$regs[65] = h$regs[64]; | |
case (95): | |
h$regs[64] = h$regs[63]; | |
case (94): | |
h$regs[63] = h$regs[62]; | |
case (93): | |
h$regs[62] = h$regs[61]; | |
case (92): | |
h$regs[61] = h$regs[60]; | |
case (91): | |
h$regs[60] = h$regs[59]; | |
case (90): | |
h$regs[59] = h$regs[58]; | |
case (89): | |
h$regs[58] = h$regs[57]; | |
case (88): | |
h$regs[57] = h$regs[56]; | |
case (87): | |
h$regs[56] = h$regs[55]; | |
case (86): | |
h$regs[55] = h$regs[54]; | |
case (85): | |
h$regs[54] = h$regs[53]; | |
case (84): | |
h$regs[53] = h$regs[52]; | |
case (83): | |
h$regs[52] = h$regs[51]; | |
case (82): | |
h$regs[51] = h$regs[50]; | |
case (81): | |
h$regs[50] = h$regs[49]; | |
case (80): | |
h$regs[49] = h$regs[48]; | |
case (79): | |
h$regs[48] = h$regs[47]; | |
case (78): | |
h$regs[47] = h$regs[46]; | |
case (77): | |
h$regs[46] = h$regs[45]; | |
case (76): | |
h$regs[45] = h$regs[44]; | |
case (75): | |
h$regs[44] = h$regs[43]; | |
case (74): | |
h$regs[43] = h$regs[42]; | |
case (73): | |
h$regs[42] = h$regs[41]; | |
case (72): | |
h$regs[41] = h$regs[40]; | |
case (71): | |
h$regs[40] = h$regs[39]; | |
case (70): | |
h$regs[39] = h$regs[38]; | |
case (69): | |
h$regs[38] = h$regs[37]; | |
case (68): | |
h$regs[37] = h$regs[36]; | |
case (67): | |
h$regs[36] = h$regs[35]; | |
case (66): | |
h$regs[35] = h$regs[34]; | |
case (65): | |
h$regs[34] = h$regs[33]; | |
case (64): | |
h$regs[33] = h$regs[32]; | |
case (63): | |
h$regs[32] = h$regs[31]; | |
case (62): | |
h$regs[31] = h$regs[30]; | |
case (61): | |
h$regs[30] = h$regs[29]; | |
case (60): | |
h$regs[29] = h$regs[28]; | |
case (59): | |
h$regs[28] = h$regs[27]; | |
case (58): | |
h$regs[27] = h$regs[26]; | |
case (57): | |
h$regs[26] = h$regs[25]; | |
case (56): | |
h$regs[25] = h$regs[24]; | |
case (55): | |
h$regs[24] = h$regs[23]; | |
case (54): | |
h$regs[23] = h$regs[22]; | |
case (53): | |
h$regs[22] = h$regs[21]; | |
case (52): | |
h$regs[21] = h$regs[20]; | |
case (51): | |
h$regs[20] = h$regs[19]; | |
case (50): | |
h$regs[19] = h$regs[18]; | |
case (49): | |
h$regs[18] = h$regs[17]; | |
case (48): | |
h$regs[17] = h$regs[16]; | |
case (47): | |
h$regs[16] = h$regs[15]; | |
case (46): | |
h$regs[15] = h$regs[14]; | |
case (45): | |
h$regs[14] = h$regs[13]; | |
case (44): | |
h$regs[13] = h$regs[12]; | |
case (43): | |
h$regs[12] = h$regs[11]; | |
case (42): | |
h$regs[11] = h$regs[10]; | |
case (41): | |
h$regs[10] = h$regs[9]; | |
case (40): | |
h$regs[9] = h$regs[8]; | |
case (39): | |
h$regs[8] = h$regs[7]; | |
case (38): | |
h$regs[7] = h$regs[6]; | |
case (37): | |
h$regs[6] = h$regs[5]; | |
case (36): | |
h$regs[5] = h$regs[4]; | |
case (35): | |
h$regs[4] = h$regs[3]; | |
case (34): | |
h$regs[3] = h$regs[2]; | |
case (33): | |
h$regs[2] = h$regs[1]; | |
case (32): | |
h$regs[1] = h$regs[0]; | |
case (31): | |
h$regs[0] = h$r32; | |
case (30): | |
h$r32 = h$r31; | |
case (29): | |
h$r31 = h$r30; | |
case (28): | |
h$r30 = h$r29; | |
case (27): | |
h$r29 = h$r28; | |
case (26): | |
h$r28 = h$r27; | |
case (25): | |
h$r27 = h$r26; | |
case (24): | |
h$r26 = h$r25; | |
case (23): | |
h$r25 = h$r24; | |
case (22): | |
h$r24 = h$r23; | |
case (21): | |
h$r23 = h$r22; | |
case (20): | |
h$r22 = h$r21; | |
case (19): | |
h$r21 = h$r20; | |
case (18): | |
h$r20 = h$r19; | |
case (17): | |
h$r19 = h$r18; | |
case (16): | |
h$r18 = h$r17; | |
case (15): | |
h$r17 = h$r16; | |
case (14): | |
h$r16 = h$r15; | |
case (13): | |
h$r15 = h$r14; | |
case (12): | |
h$r14 = h$r13; | |
case (11): | |
h$r13 = h$r12; | |
case (10): | |
h$r12 = h$r11; | |
case (9): | |
h$r11 = h$r10; | |
case (8): | |
h$r10 = h$r9; | |
case (7): | |
h$r9 = h$r8; | |
case (6): | |
h$r8 = h$r7; | |
case (5): | |
h$r7 = h$r6; | |
case (4): | |
h$r6 = h$r5; | |
case (3): | |
h$r5 = h$r4; | |
case (2): | |
h$r4 = h$r3; | |
case (1): | |
h$r3 = h$r2; | |
default: | |
}; | |
h$r2 = h$RTS_497.d2; | |
h$r1 = h$RTS_496; | |
return h$RTS_498; | |
}; | |
h$o(h$pap_1, 3, 0, 3, (-1), null); | |
function h$pap_2() | |
{ | |
var h$RTS_500 = h$r1.d1; | |
var h$RTS_501 = h$r1.d2; | |
var h$RTS_502 = h$RTS_500.f; | |
var h$RTS_503 = ((((h$RTS_502.t === 1) ? h$RTS_502.a : h$RTS_500.d2.d1) >> 8) - 2); | |
switch (h$RTS_503) | |
{ | |
case (125): | |
h$regs[95] = h$regs[93]; | |
case (124): | |
h$regs[94] = h$regs[92]; | |
case (123): | |
h$regs[93] = h$regs[91]; | |
case (122): | |
h$regs[92] = h$regs[90]; | |
case (121): | |
h$regs[91] = h$regs[89]; | |
case (120): | |
h$regs[90] = h$regs[88]; | |
case (119): | |
h$regs[89] = h$regs[87]; | |
case (118): | |
h$regs[88] = h$regs[86]; | |
case (117): | |
h$regs[87] = h$regs[85]; | |
case (116): | |
h$regs[86] = h$regs[84]; | |
case (115): | |
h$regs[85] = h$regs[83]; | |
case (114): | |
h$regs[84] = h$regs[82]; | |
case (113): | |
h$regs[83] = h$regs[81]; | |
case (112): | |
h$regs[82] = h$regs[80]; | |
case (111): | |
h$regs[81] = h$regs[79]; | |
case (110): | |
h$regs[80] = h$regs[78]; | |
case (109): | |
h$regs[79] = h$regs[77]; | |
case (108): | |
h$regs[78] = h$regs[76]; | |
case (107): | |
h$regs[77] = h$regs[75]; | |
case (106): | |
h$regs[76] = h$regs[74]; | |
case (105): | |
h$regs[75] = h$regs[73]; | |
case (104): | |
h$regs[74] = h$regs[72]; | |
case (103): | |
h$regs[73] = h$regs[71]; | |
case (102): | |
h$regs[72] = h$regs[70]; | |
case (101): | |
h$regs[71] = h$regs[69]; | |
case (100): | |
h$regs[70] = h$regs[68]; | |
case (99): | |
h$regs[69] = h$regs[67]; | |
case (98): | |
h$regs[68] = h$regs[66]; | |
case (97): | |
h$regs[67] = h$regs[65]; | |
case (96): | |
h$regs[66] = h$regs[64]; | |
case (95): | |
h$regs[65] = h$regs[63]; | |
case (94): | |
h$regs[64] = h$regs[62]; | |
case (93): | |
h$regs[63] = h$regs[61]; | |
case (92): | |
h$regs[62] = h$regs[60]; | |
case (91): | |
h$regs[61] = h$regs[59]; | |
case (90): | |
h$regs[60] = h$regs[58]; | |
case (89): | |
h$regs[59] = h$regs[57]; | |
case (88): | |
h$regs[58] = h$regs[56]; | |
case (87): | |
h$regs[57] = h$regs[55]; | |
case (86): | |
h$regs[56] = h$regs[54]; | |
case (85): | |
h$regs[55] = h$regs[53]; | |
case (84): | |
h$regs[54] = h$regs[52]; | |
case (83): | |
h$regs[53] = h$regs[51]; | |
case (82): | |
h$regs[52] = h$regs[50]; | |
case (81): | |
h$regs[51] = h$regs[49]; | |
case (80): | |
h$regs[50] = h$regs[48]; | |
case (79): | |
h$regs[49] = h$regs[47]; | |
case (78): | |
h$regs[48] = h$regs[46]; | |
case (77): | |
h$regs[47] = h$regs[45]; | |
case (76): | |
h$regs[46] = h$regs[44]; | |
case (75): | |
h$regs[45] = h$regs[43]; | |
case (74): | |
h$regs[44] = h$regs[42]; | |
case (73): | |
h$regs[43] = h$regs[41]; | |
case (72): | |
h$regs[42] = h$regs[40]; | |
case (71): | |
h$regs[41] = h$regs[39]; | |
case (70): | |
h$regs[40] = h$regs[38]; | |
case (69): | |
h$regs[39] = h$regs[37]; | |
case (68): | |
h$regs[38] = h$regs[36]; | |
case (67): | |
h$regs[37] = h$regs[35]; | |
case (66): | |
h$regs[36] = h$regs[34]; | |
case (65): | |
h$regs[35] = h$regs[33]; | |
case (64): | |
h$regs[34] = h$regs[32]; | |
case (63): | |
h$regs[33] = h$regs[31]; | |
case (62): | |
h$regs[32] = h$regs[30]; | |
case (61): | |
h$regs[31] = h$regs[29]; | |
case (60): | |
h$regs[30] = h$regs[28]; | |
case (59): | |
h$regs[29] = h$regs[27]; | |
case (58): | |
h$regs[28] = h$regs[26]; | |
case (57): | |
h$regs[27] = h$regs[25]; | |
case (56): | |
h$regs[26] = h$regs[24]; | |
case (55): | |
h$regs[25] = h$regs[23]; | |
case (54): | |
h$regs[24] = h$regs[22]; | |
case (53): | |
h$regs[23] = h$regs[21]; | |
case (52): | |
h$regs[22] = h$regs[20]; | |
case (51): | |
h$regs[21] = h$regs[19]; | |
case (50): | |
h$regs[20] = h$regs[18]; | |
case (49): | |
h$regs[19] = h$regs[17]; | |
case (48): | |
h$regs[18] = h$regs[16]; | |
case (47): | |
h$regs[17] = h$regs[15]; | |
case (46): | |
h$regs[16] = h$regs[14]; | |
case (45): | |
h$regs[15] = h$regs[13]; | |
case (44): | |
h$regs[14] = h$regs[12]; | |
case (43): | |
h$regs[13] = h$regs[11]; | |
case (42): | |
h$regs[12] = h$regs[10]; | |
case (41): | |
h$regs[11] = h$regs[9]; | |
case (40): | |
h$regs[10] = h$regs[8]; | |
case (39): | |
h$regs[9] = h$regs[7]; | |
case (38): | |
h$regs[8] = h$regs[6]; | |
case (37): | |
h$regs[7] = h$regs[5]; | |
case (36): | |
h$regs[6] = h$regs[4]; | |
case (35): | |
h$regs[5] = h$regs[3]; | |
case (34): | |
h$regs[4] = h$regs[2]; | |
case (33): | |
h$regs[3] = h$regs[1]; | |
case (32): | |
h$regs[2] = h$regs[0]; | |
case (31): | |
h$regs[1] = h$r32; | |
case (30): | |
h$regs[0] = h$r31; | |
case (29): | |
h$r32 = h$r30; | |
case (28): | |
h$r31 = h$r29; | |
case (27): | |
h$r30 = h$r28; | |
case (26): | |
h$r29 = h$r27; | |
case (25): | |
h$r28 = h$r26; | |
case (24): | |
h$r27 = h$r25; | |
case (23): | |
h$r26 = h$r24; | |
case (22): | |
h$r25 = h$r23; | |
case (21): | |
h$r24 = h$r22; | |
case (20): | |
h$r23 = h$r21; | |
case (19): | |
h$r22 = h$r20; | |
case (18): | |
h$r21 = h$r19; | |
case (17): | |
h$r20 = h$r18; | |
case (16): | |
h$r19 = h$r17; | |
case (15): | |
h$r18 = h$r16; | |
case (14): | |
h$r17 = h$r15; | |
case (13): | |
h$r16 = h$r14; | |
case (12): | |
h$r15 = h$r13; | |
case (11): | |
h$r14 = h$r12; | |
case (10): | |
h$r13 = h$r11; | |
case (9): | |
h$r12 = h$r10; | |
case (8): | |
h$r11 = h$r9; | |
case (7): | |
h$r10 = h$r8; | |
case (6): | |
h$r9 = h$r7; | |
case (5): | |
h$r8 = h$r6; | |
case (4): | |
h$r7 = h$r5; | |
case (3): | |
h$r6 = h$r4; | |
case (2): | |
h$r5 = h$r3; | |
case (1): | |
h$r4 = h$r2; | |
default: | |
}; | |
h$r2 = h$RTS_501.d2; | |
h$r3 = h$RTS_501.d3; | |
h$r1 = h$RTS_500; | |
return h$RTS_502; | |
}; | |
h$o(h$pap_2, 3, 0, 4, (-1), null); | |
function h$pap_3() | |
{ | |
var h$RTS_504 = h$r1.d1; | |
var h$RTS_505 = h$r1.d2; | |
var h$RTS_506 = h$RTS_504.f; | |
var h$RTS_507 = ((((h$RTS_506.t === 1) ? h$RTS_506.a : h$RTS_504.d2.d1) >> 8) - 3); | |
switch (h$RTS_507) | |
{ | |
case (124): | |
h$regs[95] = h$regs[92]; | |
case (123): | |
h$regs[94] = h$regs[91]; | |
case (122): | |
h$regs[93] = h$regs[90]; | |
case (121): | |
h$regs[92] = h$regs[89]; | |
case (120): | |
h$regs[91] = h$regs[88]; | |
case (119): | |
h$regs[90] = h$regs[87]; | |
case (118): | |
h$regs[89] = h$regs[86]; | |
case (117): | |
h$regs[88] = h$regs[85]; | |
case (116): | |
h$regs[87] = h$regs[84]; | |
case (115): | |
h$regs[86] = h$regs[83]; | |
case (114): | |
h$regs[85] = h$regs[82]; | |
case (113): | |
h$regs[84] = h$regs[81]; | |
case (112): | |
h$regs[83] = h$regs[80]; | |
case (111): | |
h$regs[82] = h$regs[79]; | |
case (110): | |
h$regs[81] = h$regs[78]; | |
case (109): | |
h$regs[80] = h$regs[77]; | |
case (108): | |
h$regs[79] = h$regs[76]; | |
case (107): | |
h$regs[78] = h$regs[75]; | |
case (106): | |
h$regs[77] = h$regs[74]; | |
case (105): | |
h$regs[76] = h$regs[73]; | |
case (104): | |
h$regs[75] = h$regs[72]; | |
case (103): | |
h$regs[74] = h$regs[71]; | |
case (102): | |
h$regs[73] = h$regs[70]; | |
case (101): | |
h$regs[72] = h$regs[69]; | |
case (100): | |
h$regs[71] = h$regs[68]; | |
case (99): | |
h$regs[70] = h$regs[67]; | |
case (98): | |
h$regs[69] = h$regs[66]; | |
case (97): | |
h$regs[68] = h$regs[65]; | |
case (96): | |
h$regs[67] = h$regs[64]; | |
case (95): | |
h$regs[66] = h$regs[63]; | |
case (94): | |
h$regs[65] = h$regs[62]; | |
case (93): | |
h$regs[64] = h$regs[61]; | |
case (92): | |
h$regs[63] = h$regs[60]; | |
case (91): | |
h$regs[62] = h$regs[59]; | |
case (90): | |
h$regs[61] = h$regs[58]; | |
case (89): | |
h$regs[60] = h$regs[57]; | |
case (88): | |
h$regs[59] = h$regs[56]; | |
case (87): | |
h$regs[58] = h$regs[55]; | |
case (86): | |
h$regs[57] = h$regs[54]; | |
case (85): | |
h$regs[56] = h$regs[53]; | |
case (84): | |
h$regs[55] = h$regs[52]; | |
case (83): | |
h$regs[54] = h$regs[51]; | |
case (82): | |
h$regs[53] = h$regs[50]; | |
case (81): | |
h$regs[52] = h$regs[49]; | |
case (80): | |
h$regs[51] = h$regs[48]; | |
case (79): | |
h$regs[50] = h$regs[47]; | |
case (78): | |
h$regs[49] = h$regs[46]; | |
case (77): | |
h$regs[48] = h$regs[45]; | |
case (76): | |
h$regs[47] = h$regs[44]; | |
case (75): | |
h$regs[46] = h$regs[43]; | |
case (74): | |
h$regs[45] = h$regs[42]; | |
case (73): | |
h$regs[44] = h$regs[41]; | |
case (72): | |
h$regs[43] = h$regs[40]; | |
case (71): | |
h$regs[42] = h$regs[39]; | |
case (70): | |
h$regs[41] = h$regs[38]; | |
case (69): | |
h$regs[40] = h$regs[37]; | |
case (68): | |
h$regs[39] = h$regs[36]; | |
case (67): | |
h$regs[38] = h$regs[35]; | |
case (66): | |
h$regs[37] = h$regs[34]; | |
case (65): | |
h$regs[36] = h$regs[33]; | |
case (64): | |
h$regs[35] = h$regs[32]; | |
case (63): | |
h$regs[34] = h$regs[31]; | |
case (62): | |
h$regs[33] = h$regs[30]; | |
case (61): | |
h$regs[32] = h$regs[29]; | |
case (60): | |
h$regs[31] = h$regs[28]; | |
case (59): | |
h$regs[30] = h$regs[27]; | |
case (58): | |
h$regs[29] = h$regs[26]; | |
case (57): | |
h$regs[28] = h$regs[25]; | |
case (56): | |
h$regs[27] = h$regs[24]; | |
case (55): | |
h$regs[26] = h$regs[23]; | |
case (54): | |
h$regs[25] = h$regs[22]; | |
case (53): | |
h$regs[24] = h$regs[21]; | |
case (52): | |
h$regs[23] = h$regs[20]; | |
case (51): | |
h$regs[22] = h$regs[19]; | |
case (50): | |
h$regs[21] = h$regs[18]; | |
case (49): | |
h$regs[20] = h$regs[17]; | |
case (48): | |
h$regs[19] = h$regs[16]; | |
case (47): | |
h$regs[18] = h$regs[15]; | |
case (46): | |
h$regs[17] = h$regs[14]; | |
case (45): | |
h$regs[16] = h$regs[13]; | |
case (44): | |
h$regs[15] = h$regs[12]; | |
case (43): | |
h$regs[14] = h$regs[11]; | |
case (42): | |
h$regs[13] = h$regs[10]; | |
case (41): | |
h$regs[12] = h$regs[9]; | |
case (40): | |
h$regs[11] = h$regs[8]; | |
case (39): | |
h$regs[10] = h$regs[7]; | |
case (38): | |
h$regs[9] = h$regs[6]; | |
case (37): | |
h$regs[8] = h$regs[5]; | |
case (36): | |
h$regs[7] = h$regs[4]; | |
case (35): | |
h$regs[6] = h$regs[3]; | |
case (34): | |
h$regs[5] = h$regs[2]; | |
case (33): | |
h$regs[4] = h$regs[1]; | |
case (32): | |
h$regs[3] = h$regs[0]; | |
case (31): | |
h$regs[2] = h$r32; | |
case (30): | |
h$regs[1] = h$r31; | |
case (29): | |
h$regs[0] = h$r30; | |
case (28): | |
h$r32 = h$r29; | |
case (27): | |
h$r31 = h$r28; | |
case (26): | |
h$r30 = h$r27; | |
case (25): | |
h$r29 = h$r26; | |
case (24): | |
h$r28 = h$r25; | |
case (23): | |
h$r27 = h$r24; | |
case (22): | |
h$r26 = h$r23; | |
case (21): | |
h$r25 = h$r22; | |
case (20): | |
h$r24 = h$r21; | |
case (19): | |
h$r23 = h$r20; | |
case (18): | |
h$r22 = h$r19; | |
case (17): | |
h$r21 = h$r18; | |
case (16): | |
h$r20 = h$r17; | |
case (15): | |
h$r19 = h$r16; | |
case (14): | |
h$r18 = h$r15; | |
case (13): | |
h$r17 = h$r14; | |
case (12): | |
h$r16 = h$r13; | |
case (11): | |
h$r15 = h$r12; | |
case (10): | |
h$r14 = h$r11; | |
case (9): | |
h$r13 = h$r10; | |
case (8): | |
h$r12 = h$r9; | |
case (7): | |
h$r11 = h$r8; | |
case (6): | |
h$r10 = h$r7; | |
case (5): | |
h$r9 = h$r6; | |
case (4): | |
h$r8 = h$r5; | |
case (3): | |
h$r7 = h$r4; | |
case (2): | |
h$r6 = h$r3; | |
case (1): | |
h$r5 = h$r2; | |
default: | |
}; | |
h$r2 = h$RTS_505.d2; | |
h$r3 = h$RTS_505.d3; | |
h$r4 = h$RTS_505.d4; | |
h$r1 = h$RTS_504; | |
return h$RTS_506; | |
}; | |
h$o(h$pap_3, 3, 0, 5, (-1), null); | |
function h$pap_4() | |
{ | |
var h$RTS_508 = h$r1.d1; | |
var h$RTS_509 = h$r1.d2; | |
var h$RTS_510 = h$RTS_508.f; | |
var h$RTS_511 = ((((h$RTS_510.t === 1) ? h$RTS_510.a : h$RTS_508.d2.d1) >> 8) - 4); | |
switch (h$RTS_511) | |
{ | |
case (123): | |
h$regs[95] = h$regs[91]; | |
case (122): | |
h$regs[94] = h$regs[90]; | |
case (121): | |
h$regs[93] = h$regs[89]; | |
case (120): | |
h$regs[92] = h$regs[88]; | |
case (119): | |
h$regs[91] = h$regs[87]; | |
case (118): | |
h$regs[90] = h$regs[86]; | |
case (117): | |
h$regs[89] = h$regs[85]; | |
case (116): | |
h$regs[88] = h$regs[84]; | |
case (115): | |
h$regs[87] = h$regs[83]; | |
case (114): | |
h$regs[86] = h$regs[82]; | |
case (113): | |
h$regs[85] = h$regs[81]; | |
case (112): | |
h$regs[84] = h$regs[80]; | |
case (111): | |
h$regs[83] = h$regs[79]; | |
case (110): | |
h$regs[82] = h$regs[78]; | |
case (109): | |
h$regs[81] = h$regs[77]; | |
case (108): | |
h$regs[80] = h$regs[76]; | |
case (107): | |
h$regs[79] = h$regs[75]; | |
case (106): | |
h$regs[78] = h$regs[74]; | |
case (105): | |
h$regs[77] = h$regs[73]; | |
case (104): | |
h$regs[76] = h$regs[72]; | |
case (103): | |
h$regs[75] = h$regs[71]; | |
case (102): | |
h$regs[74] = h$regs[70]; | |
case (101): | |
h$regs[73] = h$regs[69]; | |
case (100): | |
h$regs[72] = h$regs[68]; | |
case (99): | |
h$regs[71] = h$regs[67]; | |
case (98): | |
h$regs[70] = h$regs[66]; | |
case (97): | |
h$regs[69] = h$regs[65]; | |
case (96): | |
h$regs[68] = h$regs[64]; | |
case (95): | |
h$regs[67] = h$regs[63]; | |
case (94): | |
h$regs[66] = h$regs[62]; | |
case (93): | |
h$regs[65] = h$regs[61]; | |
case (92): | |
h$regs[64] = h$regs[60]; | |
case (91): | |
h$regs[63] = h$regs[59]; | |
case (90): | |
h$regs[62] = h$regs[58]; | |
case (89): | |
h$regs[61] = h$regs[57]; | |
case (88): | |
h$regs[60] = h$regs[56]; | |
case (87): | |
h$regs[59] = h$regs[55]; | |
case (86): | |
h$regs[58] = h$regs[54]; | |
case (85): | |
h$regs[57] = h$regs[53]; | |
case (84): | |
h$regs[56] = h$regs[52]; | |
case (83): | |
h$regs[55] = h$regs[51]; | |
case (82): | |
h$regs[54] = h$regs[50]; | |
case (81): | |
h$regs[53] = h$regs[49]; | |
case (80): | |
h$regs[52] = h$regs[48]; | |
case (79): | |
h$regs[51] = h$regs[47]; | |
case (78): | |
h$regs[50] = h$regs[46]; | |
case (77): | |
h$regs[49] = h$regs[45]; | |
case (76): | |
h$regs[48] = h$regs[44]; | |
case (75): | |
h$regs[47] = h$regs[43]; | |
case (74): | |
h$regs[46] = h$regs[42]; | |
case (73): | |
h$regs[45] = h$regs[41]; | |
case (72): | |
h$regs[44] = h$regs[40]; | |
case (71): | |
h$regs[43] = h$regs[39]; | |
case (70): | |
h$regs[42] = h$regs[38]; | |
case (69): | |
h$regs[41] = h$regs[37]; | |
case (68): | |
h$regs[40] = h$regs[36]; | |
case (67): | |
h$regs[39] = h$regs[35]; | |
case (66): | |
h$regs[38] = h$regs[34]; | |
case (65): | |
h$regs[37] = h$regs[33]; | |
case (64): | |
h$regs[36] = h$regs[32]; | |
case (63): | |
h$regs[35] = h$regs[31]; | |
case (62): | |
h$regs[34] = h$regs[30]; | |
case (61): | |
h$regs[33] = h$regs[29]; | |
case (60): | |
h$regs[32] = h$regs[28]; | |
case (59): | |
h$regs[31] = h$regs[27]; | |
case (58): | |
h$regs[30] = h$regs[26]; | |
case (57): | |
h$regs[29] = h$regs[25]; | |
case (56): | |
h$regs[28] = h$regs[24]; | |
case (55): | |
h$regs[27] = h$regs[23]; | |
case (54): | |
h$regs[26] = h$regs[22]; | |
case (53): | |
h$regs[25] = h$regs[21]; | |
case (52): | |
h$regs[24] = h$regs[20]; | |
case (51): | |
h$regs[23] = h$regs[19]; | |
case (50): | |
h$regs[22] = h$regs[18]; | |
case (49): | |
h$regs[21] = h$regs[17]; | |
case (48): | |
h$regs[20] = h$regs[16]; | |
case (47): | |
h$regs[19] = h$regs[15]; | |
case (46): | |
h$regs[18] = h$regs[14]; | |
case (45): | |
h$regs[17] = h$regs[13]; | |
case (44): | |
h$regs[16] = h$regs[12]; | |
case (43): | |
h$regs[15] = h$regs[11]; | |
case (42): | |
h$regs[14] = h$regs[10]; | |
case (41): | |
h$regs[13] = h$regs[9]; | |
case (40): | |
h$regs[12] = h$regs[8]; | |
case (39): | |
h$regs[11] = h$regs[7]; | |
case (38): | |
h$regs[10] = h$regs[6]; | |
case (37): | |
h$regs[9] = h$regs[5]; | |
case (36): | |
h$regs[8] = h$regs[4]; | |
case (35): | |
h$regs[7] = h$regs[3]; | |
case (34): | |
h$regs[6] = h$regs[2]; | |
case (33): | |
h$regs[5] = h$regs[1]; | |
case (32): | |
h$regs[4] = h$regs[0]; | |
case (31): | |
h$regs[3] = h$r32; | |
case (30): | |
h$regs[2] = h$r31; | |
case (29): | |
h$regs[1] = h$r30; | |
case (28): | |
h$regs[0] = h$r29; | |
case (27): | |
h$r32 = h$r28; | |
case (26): | |
h$r31 = h$r27; | |
case (25): | |
h$r30 = h$r26; | |
case (24): | |
h$r29 = h$r25; | |
case (23): | |
h$r28 = h$r24; | |
case (22): | |
h$r27 = h$r23; | |
case (21): | |
h$r26 = h$r22; | |
case (20): | |
h$r25 = h$r21; | |
case (19): | |
h$r24 = h$r20; | |
case (18): | |
h$r23 = h$r19; | |
case (17): | |
h$r22 = h$r18; | |
case (16): | |
h$r21 = h$r17; | |
case (15): | |
h$r20 = h$r16; | |
case (14): | |
h$r19 = h$r15; | |
case (13): | |
h$r18 = h$r14; | |
case (12): | |
h$r17 = h$r13; | |
case (11): | |
h$r16 = h$r12; | |
case (10): | |
h$r15 = h$r11; | |
case (9): | |
h$r14 = h$r10; | |
case (8): | |
h$r13 = h$r9; | |
case (7): | |
h$r12 = h$r8; | |
case (6): | |
h$r11 = h$r7; | |
case (5): | |
h$r10 = h$r6; | |
case (4): | |
h$r9 = h$r5; | |
case (3): | |
h$r8 = h$r4; | |
case (2): | |
h$r7 = h$r3; | |
case (1): | |
h$r6 = h$r2; | |
default: | |
}; | |
h$r2 = h$RTS_509.d2; | |
h$r3 = h$RTS_509.d3; | |
h$r4 = h$RTS_509.d4; | |
h$r5 = h$RTS_509.d5; | |
h$r1 = h$RTS_508; | |
return h$RTS_510; | |
}; | |
h$o(h$pap_4, 3, 0, 6, (-1), null); | |
function h$pap_5() | |
{ | |
var h$RTS_512 = h$r1.d1; | |
var h$RTS_513 = h$r1.d2; | |
var h$RTS_514 = h$RTS_512.f; | |
var h$RTS_515 = ((((h$RTS_514.t === 1) ? h$RTS_514.a : h$RTS_512.d2.d1) >> 8) - 5); | |
switch (h$RTS_515) | |
{ | |
case (122): | |
h$regs[95] = h$regs[90]; | |
case (121): | |
h$regs[94] = h$regs[89]; | |
case (120): | |
h$regs[93] = h$regs[88]; | |
case (119): | |
h$regs[92] = h$regs[87]; | |
case (118): | |
h$regs[91] = h$regs[86]; | |
case (117): | |
h$regs[90] = h$regs[85]; | |
case (116): | |
h$regs[89] = h$regs[84]; | |
case (115): | |
h$regs[88] = h$regs[83]; | |
case (114): | |
h$regs[87] = h$regs[82]; | |
case (113): | |
h$regs[86] = h$regs[81]; | |
case (112): | |
h$regs[85] = h$regs[80]; | |
case (111): | |
h$regs[84] = h$regs[79]; | |
case (110): | |
h$regs[83] = h$regs[78]; | |
case (109): | |
h$regs[82] = h$regs[77]; | |
case (108): | |
h$regs[81] = h$regs[76]; | |
case (107): | |
h$regs[80] = h$regs[75]; | |
case (106): | |
h$regs[79] = h$regs[74]; | |
case (105): | |
h$regs[78] = h$regs[73]; | |
case (104): | |
h$regs[77] = h$regs[72]; | |
case (103): | |
h$regs[76] = h$regs[71]; | |
case (102): | |
h$regs[75] = h$regs[70]; | |
case (101): | |
h$regs[74] = h$regs[69]; | |
case (100): | |
h$regs[73] = h$regs[68]; | |
case (99): | |
h$regs[72] = h$regs[67]; | |
case (98): | |
h$regs[71] = h$regs[66]; | |
case (97): | |
h$regs[70] = h$regs[65]; | |
case (96): | |
h$regs[69] = h$regs[64]; | |
case (95): | |
h$regs[68] = h$regs[63]; | |
case (94): | |
h$regs[67] = h$regs[62]; | |
case (93): | |
h$regs[66] = h$regs[61]; | |
case (92): | |
h$regs[65] = h$regs[60]; | |
case (91): | |
h$regs[64] = h$regs[59]; | |
case (90): | |
h$regs[63] = h$regs[58]; | |
case (89): | |
h$regs[62] = h$regs[57]; | |
case (88): | |
h$regs[61] = h$regs[56]; | |
case (87): | |
h$regs[60] = h$regs[55]; | |
case (86): | |
h$regs[59] = h$regs[54]; | |
case (85): | |
h$regs[58] = h$regs[53]; | |
case (84): | |
h$regs[57] = h$regs[52]; | |
case (83): | |
h$regs[56] = h$regs[51]; | |
case (82): | |
h$regs[55] = h$regs[50]; | |
case (81): | |
h$regs[54] = h$regs[49]; | |
case (80): | |
h$regs[53] = h$regs[48]; | |
case (79): | |
h$regs[52] = h$regs[47]; | |
case (78): | |
h$regs[51] = h$regs[46]; | |
case (77): | |
h$regs[50] = h$regs[45]; | |
case (76): | |
h$regs[49] = h$regs[44]; | |
case (75): | |
h$regs[48] = h$regs[43]; | |
case (74): | |
h$regs[47] = h$regs[42]; | |
case (73): | |
h$regs[46] = h$regs[41]; | |
case (72): | |
h$regs[45] = h$regs[40]; | |
case (71): | |
h$regs[44] = h$regs[39]; | |
case (70): | |
h$regs[43] = h$regs[38]; | |
case (69): | |
h$regs[42] = h$regs[37]; | |
case (68): | |
h$regs[41] = h$regs[36]; | |
case (67): | |
h$regs[40] = h$regs[35]; | |
case (66): | |
h$regs[39] = h$regs[34]; | |
case (65): | |
h$regs[38] = h$regs[33]; | |
case (64): | |
h$regs[37] = h$regs[32]; | |
case (63): | |
h$regs[36] = h$regs[31]; | |
case (62): | |
h$regs[35] = h$regs[30]; | |
case (61): | |
h$regs[34] = h$regs[29]; | |
case (60): | |
h$regs[33] = h$regs[28]; | |
case (59): | |
h$regs[32] = h$regs[27]; | |
case (58): | |
h$regs[31] = h$regs[26]; | |
case (57): | |
h$regs[30] = h$regs[25]; | |
case (56): | |
h$regs[29] = h$regs[24]; | |
case (55): | |
h$regs[28] = h$regs[23]; | |
case (54): | |
h$regs[27] = h$regs[22]; | |
case (53): | |
h$regs[26] = h$regs[21]; | |
case (52): | |
h$regs[25] = h$regs[20]; | |
case (51): | |
h$regs[24] = h$regs[19]; | |
case (50): | |
h$regs[23] = h$regs[18]; | |
case (49): | |
h$regs[22] = h$regs[17]; | |
case (48): | |
h$regs[21] = h$regs[16]; | |
case (47): | |
h$regs[20] = h$regs[15]; | |
case (46): | |
h$regs[19] = h$regs[14]; | |
case (45): | |
h$regs[18] = h$regs[13]; | |
case (44): | |
h$regs[17] = h$regs[12]; | |
case (43): | |
h$regs[16] = h$regs[11]; | |
case (42): | |
h$regs[15] = h$regs[10]; | |
case (41): | |
h$regs[14] = h$regs[9]; | |
case (40): | |
h$regs[13] = h$regs[8]; | |
case (39): | |
h$regs[12] = h$regs[7]; | |
case (38): | |
h$regs[11] = h$regs[6]; | |
case (37): | |
h$regs[10] = h$regs[5]; | |
case (36): | |
h$regs[9] = h$regs[4]; | |
case (35): | |
h$regs[8] = h$regs[3]; | |
case (34): | |
h$regs[7] = h$regs[2]; | |
case (33): | |
h$regs[6] = h$regs[1]; | |
case (32): | |
h$regs[5] = h$regs[0]; | |
case (31): | |
h$regs[4] = h$r32; | |
case (30): | |
h$regs[3] = h$r31; | |
case (29): | |
h$regs[2] = h$r30; | |
case (28): | |
h$regs[1] = h$r29; | |
case (27): | |
h$regs[0] = h$r28; | |
case (26): | |
h$r32 = h$r27; | |
case (25): | |
h$r31 = h$r26; | |
case (24): | |
h$r30 = h$r25; | |
case (23): | |
h$r29 = h$r24; | |
case (22): | |
h$r28 = h$r23; | |
case (21): | |
h$r27 = h$r22; | |
case (20): | |
h$r26 = h$r21; | |
case (19): | |
h$r25 = h$r20; | |
case (18): | |
h$r24 = h$r19; | |
case (17): | |
h$r23 = h$r18; | |
case (16): | |
h$r22 = h$r17; | |
case (15): | |
h$r21 = h$r16; | |
case (14): | |
h$r20 = h$r15; | |
case (13): | |
h$r19 = h$r14; | |
case (12): | |
h$r18 = h$r13; | |
case (11): | |
h$r17 = h$r12; | |
case (10): | |
h$r16 = h$r11; | |
case (9): | |
h$r15 = h$r10; | |
case (8): | |
h$r14 = h$r9; | |
case (7): | |
h$r13 = h$r8; | |
case (6): | |
h$r12 = h$r7; | |
case (5): | |
h$r11 = h$r6; | |
case (4): | |
h$r10 = h$r5; | |
case (3): | |
h$r9 = h$r4; | |
case (2): | |
h$r8 = h$r3; | |
case (1): | |
h$r7 = h$r2; | |
default: | |
}; | |
h$r2 = h$RTS_513.d2; | |
h$r3 = h$RTS_513.d3; | |
h$r4 = h$RTS_513.d4; | |
h$r5 = h$RTS_513.d5; | |
h$r6 = h$RTS_513.d6; | |
h$r1 = h$RTS_512; | |
return h$RTS_514; | |
}; | |
h$o(h$pap_5, 3, 0, 7, (-1), null); | |
function h$pap_6() | |
{ | |
var h$RTS_516 = h$r1.d1; | |
var h$RTS_517 = h$r1.d2; | |
var h$RTS_518 = h$RTS_516.f; | |
var h$RTS_519 = ((((h$RTS_518.t === 1) ? h$RTS_518.a : h$RTS_516.d2.d1) >> 8) - 6); | |
switch (h$RTS_519) | |
{ | |
case (121): | |
h$regs[95] = h$regs[89]; | |
case (120): | |
h$regs[94] = h$regs[88]; | |
case (119): | |
h$regs[93] = h$regs[87]; | |
case (118): | |
h$regs[92] = h$regs[86]; | |
case (117): | |
h$regs[91] = h$regs[85]; | |
case (116): | |
h$regs[90] = h$regs[84]; | |
case (115): | |
h$regs[89] = h$regs[83]; | |
case (114): | |
h$regs[88] = h$regs[82]; | |
case (113): | |
h$regs[87] = h$regs[81]; | |
case (112): | |
h$regs[86] = h$regs[80]; | |
case (111): | |
h$regs[85] = h$regs[79]; | |
case (110): | |
h$regs[84] = h$regs[78]; | |
case (109): | |
h$regs[83] = h$regs[77]; | |
case (108): | |
h$regs[82] = h$regs[76]; | |
case (107): | |
h$regs[81] = h$regs[75]; | |
case (106): | |
h$regs[80] = h$regs[74]; | |
case (105): | |
h$regs[79] = h$regs[73]; | |
case (104): | |
h$regs[78] = h$regs[72]; | |
case (103): | |
h$regs[77] = h$regs[71]; | |
case (102): | |
h$regs[76] = h$regs[70]; | |
case (101): | |
h$regs[75] = h$regs[69]; | |
case (100): | |
h$regs[74] = h$regs[68]; | |
case (99): | |
h$regs[73] = h$regs[67]; | |
case (98): | |
h$regs[72] = h$regs[66]; | |
case (97): | |
h$regs[71] = h$regs[65]; | |
case (96): | |
h$regs[70] = h$regs[64]; | |
case (95): | |
h$regs[69] = h$regs[63]; | |
case (94): | |
h$regs[68] = h$regs[62]; | |
case (93): | |
h$regs[67] = h$regs[61]; | |
case (92): | |
h$regs[66] = h$regs[60]; | |
case (91): | |
h$regs[65] = h$regs[59]; | |
case (90): | |
h$regs[64] = h$regs[58]; | |
case (89): | |
h$regs[63] = h$regs[57]; | |
case (88): | |
h$regs[62] = h$regs[56]; | |
case (87): | |
h$regs[61] = h$regs[55]; | |
case (86): | |
h$regs[60] = h$regs[54]; | |
case (85): | |
h$regs[59] = h$regs[53]; | |
case (84): | |
h$regs[58] = h$regs[52]; | |
case (83): | |
h$regs[57] = h$regs[51]; | |
case (82): | |
h$regs[56] = h$regs[50]; | |
case (81): | |
h$regs[55] = h$regs[49]; | |
case (80): | |
h$regs[54] = h$regs[48]; | |
case (79): | |
h$regs[53] = h$regs[47]; | |
case (78): | |
h$regs[52] = h$regs[46]; | |
case (77): | |
h$regs[51] = h$regs[45]; | |
case (76): | |
h$regs[50] = h$regs[44]; | |
case (75): | |
h$regs[49] = h$regs[43]; | |
case (74): | |
h$regs[48] = h$regs[42]; | |
case (73): | |
h$regs[47] = h$regs[41]; | |
case (72): | |
h$regs[46] = h$regs[40]; | |
case (71): | |
h$regs[45] = h$regs[39]; | |
case (70): | |
h$regs[44] = h$regs[38]; | |
case (69): | |
h$regs[43] = h$regs[37]; | |
case (68): | |
h$regs[42] = h$regs[36]; | |
case (67): | |
h$regs[41] = h$regs[35]; | |
case (66): | |
h$regs[40] = h$regs[34]; | |
case (65): | |
h$regs[39] = h$regs[33]; | |
case (64): | |
h$regs[38] = h$regs[32]; | |
case (63): | |
h$regs[37] = h$regs[31]; | |
case (62): | |
h$regs[36] = h$regs[30]; | |
case (61): | |
h$regs[35] = h$regs[29]; | |
case (60): | |
h$regs[34] = h$regs[28]; | |
case (59): | |
h$regs[33] = h$regs[27]; | |
case (58): | |
h$regs[32] = h$regs[26]; | |
case (57): | |
h$regs[31] = h$regs[25]; | |
case (56): | |
h$regs[30] = h$regs[24]; | |
case (55): | |
h$regs[29] = h$regs[23]; | |
case (54): | |
h$regs[28] = h$regs[22]; | |
case (53): | |
h$regs[27] = h$regs[21]; | |
case (52): | |
h$regs[26] = h$regs[20]; | |
case (51): | |
h$regs[25] = h$regs[19]; | |
case (50): | |
h$regs[24] = h$regs[18]; | |
case (49): | |
h$regs[23] = h$regs[17]; | |
case (48): | |
h$regs[22] = h$regs[16]; | |
case (47): | |
h$regs[21] = h$regs[15]; | |
case (46): | |
h$regs[20] = h$regs[14]; | |
case (45): | |
h$regs[19] = h$regs[13]; | |
case (44): | |
h$regs[18] = h$regs[12]; | |
case (43): | |
h$regs[17] = h$regs[11]; | |
case (42): | |
h$regs[16] = h$regs[10]; | |
case (41): | |
h$regs[15] = h$regs[9]; | |
case (40): | |
h$regs[14] = h$regs[8]; | |
case (39): | |
h$regs[13] = h$regs[7]; | |
case (38): | |
h$regs[12] = h$regs[6]; | |
case (37): | |
h$regs[11] = h$regs[5]; | |
case (36): | |
h$regs[10] = h$regs[4]; | |
case (35): | |
h$regs[9] = h$regs[3]; | |
case (34): | |
h$regs[8] = h$regs[2]; | |
case (33): | |
h$regs[7] = h$regs[1]; | |
case (32): | |
h$regs[6] = h$regs[0]; | |
case (31): | |
h$regs[5] = h$r32; | |
case (30): | |
h$regs[4] = h$r31; | |
case (29): | |
h$regs[3] = h$r30; | |
case (28): | |
h$regs[2] = h$r29; | |
case (27): | |
h$regs[1] = h$r28; | |
case (26): | |
h$regs[0] = h$r27; | |
case (25): | |
h$r32 = h$r26; | |
case (24): | |
h$r31 = h$r25; | |
case (23): | |
h$r30 = h$r24; | |
case (22): | |
h$r29 = h$r23; | |
case (21): | |
h$r28 = h$r22; | |
case (20): | |
h$r27 = h$r21; | |
case (19): | |
h$r26 = h$r20; | |
case (18): | |
h$r25 = h$r19; | |
case (17): | |
h$r24 = h$r18; | |
case (16): | |
h$r23 = h$r17; | |
case (15): | |
h$r22 = h$r16; | |
case (14): | |
h$r21 = h$r15; | |
case (13): | |
h$r20 = h$r14; | |
case (12): | |
h$r19 = h$r13; | |
case (11): | |
h$r18 = h$r12; | |
case (10): | |
h$r17 = h$r11; | |
case (9): | |
h$r16 = h$r10; | |
case (8): | |
h$r15 = h$r9; | |
case (7): | |
h$r14 = h$r8; | |
case (6): | |
h$r13 = h$r7; | |
case (5): | |
h$r12 = h$r6; | |
case (4): | |
h$r11 = h$r5; | |
case (3): | |
h$r10 = h$r4; | |
case (2): | |
h$r9 = h$r3; | |
case (1): | |
h$r8 = h$r2; | |
default: | |
}; | |
h$r2 = h$RTS_517.d2; | |
h$r3 = h$RTS_517.d3; | |
h$r4 = h$RTS_517.d4; | |
h$r5 = h$RTS_517.d5; | |
h$r6 = h$RTS_517.d6; | |
h$r7 = h$RTS_517.d7; | |
h$r1 = h$RTS_516; | |
return h$RTS_518; | |
}; | |
h$o(h$pap_6, 3, 0, 8, (-1), null); | |
var h$apply = []; | |
var h$paps = []; | |
h$initStatic.push((function() | |
{ | |
for(var h$RTS_520 = 0;(h$RTS_520 < 65536);(h$RTS_520++)) { | |
h$apply[h$RTS_520] = h$ap_gen; | |
}; | |
for(h$RTS_520 = 0;(h$RTS_520 < 128);(h$RTS_520++)) { | |
h$paps[h$RTS_520] = h$pap_gen; | |
}; | |
h$apply[0] = h$ap_0_0; | |
h$apply[1] = h$ap_1_0; | |
h$apply[1] = h$ap_1_0; | |
h$apply[257] = h$ap_1_1; | |
h$apply[513] = h$ap_1_2; | |
h$apply[258] = h$ap_2_1; | |
h$apply[514] = h$ap_2_2; | |
h$apply[770] = h$ap_2_3; | |
h$apply[1026] = h$ap_2_4; | |
h$apply[515] = h$ap_3_2; | |
h$apply[771] = h$ap_3_3; | |
h$apply[1027] = h$ap_3_4; | |
h$apply[1283] = h$ap_3_5; | |
h$apply[1539] = h$ap_3_6; | |
h$apply[772] = h$ap_4_3; | |
h$apply[1028] = h$ap_4_4; | |
h$apply[1284] = h$ap_4_5; | |
h$apply[1540] = h$ap_4_6; | |
h$apply[1796] = h$ap_4_7; | |
h$apply[2052] = h$ap_4_8; | |
h$paps[0] = h$pap_0; | |
h$paps[1] = h$pap_1; | |
h$paps[2] = h$pap_2; | |
h$paps[3] = h$pap_3; | |
h$paps[4] = h$pap_4; | |
h$paps[5] = h$pap_5; | |
h$paps[6] = h$pap_6; | |
})); | |
function h$ap_gen() | |
{ | |
var h$RTS_521 = h$r1.f; | |
switch (h$RTS_521.t) | |
{ | |
case (0): | |
return h$RTS_521; | |
case (1): | |
var h$RTS_522 = h$stack[(h$sp - 1)]; | |
var h$RTS_523 = (h$RTS_521.a & 255); | |
var h$RTS_524 = (h$RTS_522 & 255); | |
var h$RTS_525 = (h$RTS_522 >> 8); | |
if((h$RTS_524 === h$RTS_523)) | |
{ | |
for(var h$RTS_526 = 0;(h$RTS_526 < h$RTS_525);(h$RTS_526++)) { | |
h$setReg((h$RTS_526 + 2), h$stack[((h$sp - 2) - h$RTS_526)]); | |
}; | |
h$sp = ((h$sp - h$RTS_525) - 2); | |
return h$RTS_521; | |
} | |
else | |
{ | |
if((h$RTS_524 > h$RTS_523)) | |
{ | |
var h$RTS_527 = (h$RTS_521.a >> 8); | |
for(var h$RTS_528 = 0;(h$RTS_528 < h$RTS_527);(h$RTS_528++)) { | |
h$setReg((h$RTS_528 + 2), h$stack[((h$sp - 2) - h$RTS_528)]); | |
}; | |
var h$RTS_529 = (((h$RTS_525 - h$RTS_527) << 8) | (h$RTS_524 - h$RTS_523)); | |
var h$RTS_530 = h$apply[h$RTS_529]; | |
if((h$RTS_530 === h$ap_gen)) | |
{ | |
h$sp -= h$RTS_527; | |
h$stack[(h$sp - 1)] = h$RTS_529; | |
} | |
else | |
{ | |
h$sp = ((h$sp - h$RTS_527) - 1); | |
}; | |
h$stack[h$sp] = h$RTS_530; | |
return h$RTS_521; | |
} | |
else | |
{ | |
var h$RTS_531 = h$paps[h$RTS_525]; | |
var h$RTS_532 = [h$r1, (((((h$RTS_521.a >> 8) - h$RTS_525) * 256) + h$RTS_523) - h$RTS_524)]; | |
for(var h$RTS_533 = 0;(h$RTS_533 < h$RTS_525);(h$RTS_533++)) { | |
h$RTS_532.push(h$stack[((h$sp - h$RTS_533) - 1)]); | |
}; | |
h$sp = ((h$sp - h$RTS_525) - 2); | |
h$r1 = h$init_closure({ d1: null, d2: null, f: h$RTS_531, m: 0 | |
}, h$RTS_532); | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_534 = h$stack[(h$sp - 1)]; | |
var h$RTS_535 = (h$r1.d2.d1 & 255); | |
var h$RTS_536 = (h$RTS_534 & 255); | |
var h$RTS_537 = (h$RTS_534 >> 8); | |
if((h$RTS_536 === h$RTS_535)) | |
{ | |
for(var h$RTS_538 = 0;(h$RTS_538 < h$RTS_537);(h$RTS_538++)) { | |
h$setReg((h$RTS_538 + 2), h$stack[((h$sp - 2) - h$RTS_538)]); | |
}; | |
h$sp = ((h$sp - h$RTS_537) - 2); | |
return h$RTS_521; | |
} | |
else | |
{ | |
if((h$RTS_536 > h$RTS_535)) | |
{ | |
var h$RTS_539 = (h$r1.d2.d1 >> 8); | |
for(var h$RTS_540 = 0;(h$RTS_540 < h$RTS_539);(h$RTS_540++)) { | |
h$setReg((h$RTS_540 + 2), h$stack[((h$sp - 2) - h$RTS_540)]); | |
}; | |
var h$RTS_541 = (((h$RTS_537 - h$RTS_539) << 8) | (h$RTS_536 - h$RTS_535)); | |
var h$RTS_542 = h$apply[h$RTS_541]; | |
if((h$RTS_542 === h$ap_gen)) | |
{ | |
h$sp -= h$RTS_539; | |
h$stack[(h$sp - 1)] = h$RTS_541; | |
} | |
else | |
{ | |
h$sp = ((h$sp - h$RTS_539) - 1); | |
}; | |
h$stack[h$sp] = h$RTS_542; | |
return h$RTS_521; | |
} | |
else | |
{ | |
var h$RTS_543 = h$paps[h$RTS_537]; | |
var h$RTS_544 = [h$r1, (((((h$r1.d2.d1 >> 8) - h$RTS_537) * 256) + h$RTS_535) - h$RTS_536)]; | |
for(var h$RTS_545 = 0;(h$RTS_545 < h$RTS_537);(h$RTS_545++)) { | |
h$RTS_544.push(h$stack[((h$sp - h$RTS_545) - 1)]); | |
}; | |
h$sp = ((h$sp - h$RTS_537) - 2); | |
h$r1 = h$init_closure({ d1: null, d2: null, f: h$RTS_543, m: 0 | |
}, h$RTS_544); | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (5): | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_gen: unexpected closure type " + h$RTS_521.t)); | |
}; | |
}; | |
h$o(h$ap_gen, (-1), 0, (-1), 256, null); | |
function h$ap_gen_fast(h$RTS_546) | |
{ | |
var h$RTS_547 = h$r1.f; | |
switch (h$RTS_547.t) | |
{ | |
case (0): | |
var h$RTS_548 = (h$RTS_546 >> 8); | |
h$sp += h$RTS_548; | |
switch (h$RTS_548) | |
{ | |
case (64): | |
h$stack[(h$sp - 63)] = h$regs[32]; | |
case (63): | |
h$stack[(h$sp - 62)] = h$regs[31]; | |
case (62): | |
h$stack[(h$sp - 61)] = h$regs[30]; | |
case (61): | |
h$stack[(h$sp - 60)] = h$regs[29]; | |
case (60): | |
h$stack[(h$sp - 59)] = h$regs[28]; | |
case (59): | |
h$stack[(h$sp - 58)] = h$regs[27]; | |
case (58): | |
h$stack[(h$sp - 57)] = h$regs[26]; | |
case (57): | |
h$stack[(h$sp - 56)] = h$regs[25]; | |
case (56): | |
h$stack[(h$sp - 55)] = h$regs[24]; | |
case (55): | |
h$stack[(h$sp - 54)] = h$regs[23]; | |
case (54): | |
h$stack[(h$sp - 53)] = h$regs[22]; | |
case (53): | |
h$stack[(h$sp - 52)] = h$regs[21]; | |
case (52): | |
h$stack[(h$sp - 51)] = h$regs[20]; | |
case (51): | |
h$stack[(h$sp - 50)] = h$regs[19]; | |
case (50): | |
h$stack[(h$sp - 49)] = h$regs[18]; | |
case (49): | |
h$stack[(h$sp - 48)] = h$regs[17]; | |
case (48): | |
h$stack[(h$sp - 47)] = h$regs[16]; | |
case (47): | |
h$stack[(h$sp - 46)] = h$regs[15]; | |
case (46): | |
h$stack[(h$sp - 45)] = h$regs[14]; | |
case (45): | |
h$stack[(h$sp - 44)] = h$regs[13]; | |
case (44): | |
h$stack[(h$sp - 43)] = h$regs[12]; | |
case (43): | |
h$stack[(h$sp - 42)] = h$regs[11]; | |
case (42): | |
h$stack[(h$sp - 41)] = h$regs[10]; | |
case (41): | |
h$stack[(h$sp - 40)] = h$regs[9]; | |
case (40): | |
h$stack[(h$sp - 39)] = h$regs[8]; | |
case (39): | |
h$stack[(h$sp - 38)] = h$regs[7]; | |
case (38): | |
h$stack[(h$sp - 37)] = h$regs[6]; | |
case (37): | |
h$stack[(h$sp - 36)] = h$regs[5]; | |
case (36): | |
h$stack[(h$sp - 35)] = h$regs[4]; | |
case (35): | |
h$stack[(h$sp - 34)] = h$regs[3]; | |
case (34): | |
h$stack[(h$sp - 33)] = h$regs[2]; | |
case (33): | |
h$stack[(h$sp - 32)] = h$regs[1]; | |
case (32): | |
h$stack[(h$sp - 31)] = h$regs[0]; | |
case (31): | |
h$stack[(h$sp - 30)] = h$r32; | |
case (30): | |
h$stack[(h$sp - 29)] = h$r31; | |
case (29): | |
h$stack[(h$sp - 28)] = h$r30; | |
case (28): | |
h$stack[(h$sp - 27)] = h$r29; | |
case (27): | |
h$stack[(h$sp - 26)] = h$r28; | |
case (26): | |
h$stack[(h$sp - 25)] = h$r27; | |
case (25): | |
h$stack[(h$sp - 24)] = h$r26; | |
case (24): | |
h$stack[(h$sp - 23)] = h$r25; | |
case (23): | |
h$stack[(h$sp - 22)] = h$r24; | |
case (22): | |
h$stack[(h$sp - 21)] = h$r23; | |
case (21): | |
h$stack[(h$sp - 20)] = h$r22; | |
case (20): | |
h$stack[(h$sp - 19)] = h$r21; | |
case (19): | |
h$stack[(h$sp - 18)] = h$r20; | |
case (18): | |
h$stack[(h$sp - 17)] = h$r19; | |
case (17): | |
h$stack[(h$sp - 16)] = h$r18; | |
case (16): | |
h$stack[(h$sp - 15)] = h$r17; | |
case (15): | |
h$stack[(h$sp - 14)] = h$r16; | |
case (14): | |
h$stack[(h$sp - 13)] = h$r15; | |
case (13): | |
h$stack[(h$sp - 12)] = h$r14; | |
case (12): | |
h$stack[(h$sp - 11)] = h$r13; | |
case (11): | |
h$stack[(h$sp - 10)] = h$r12; | |
case (10): | |
h$stack[(h$sp - 9)] = h$r11; | |
case (9): | |
h$stack[(h$sp - 8)] = h$r10; | |
case (8): | |
h$stack[(h$sp - 7)] = h$r9; | |
case (7): | |
h$stack[(h$sp - 6)] = h$r8; | |
case (6): | |
h$stack[(h$sp - 5)] = h$r7; | |
case (5): | |
h$stack[(h$sp - 4)] = h$r6; | |
case (4): | |
h$stack[(h$sp - 3)] = h$r5; | |
case (3): | |
h$stack[(h$sp - 2)] = h$r4; | |
case (2): | |
h$stack[(h$sp - 1)] = h$r3; | |
case (1): | |
h$stack[(h$sp - 0)] = h$r2; | |
default: | |
}; | |
var h$RTS_549 = h$apply[h$RTS_546]; | |
if((h$RTS_549 === h$ap_gen)) | |
{ | |
h$sp += 2; | |
h$stack[(h$sp - 1)] = h$RTS_546; | |
} | |
else | |
{ | |
++h$sp; | |
}; | |
h$stack[h$sp] = h$RTS_549; | |
return h$RTS_547; | |
case (1): | |
var h$RTS_550 = h$RTS_547.a; | |
var h$RTS_551 = (h$RTS_550 & 255); | |
var h$RTS_552 = (h$RTS_546 & 255); | |
var h$RTS_553 = (h$RTS_546 >> 8); | |
if((h$RTS_552 === h$RTS_551)) | |
{ | |
return h$RTS_547; | |
} | |
else | |
{ | |
if((h$RTS_552 > h$RTS_551)) | |
{ | |
var h$RTS_554 = ((h$RTS_550 >> 8) + 1); | |
h$sp = (((h$sp + h$RTS_553) - h$RTS_554) + 1); | |
for(var h$RTS_555 = h$RTS_553;(h$RTS_555 >= h$RTS_554);(h$RTS_555--)) { | |
h$stack[((h$sp + h$RTS_554) - h$RTS_555)] = h$getReg((h$RTS_555 + 1)); | |
}; | |
var h$RTS_556 = (((h$RTS_553 - (h$RTS_550 >> 8)) << 8) | (h$RTS_552 - h$RTS_551)); | |
var h$RTS_557 = h$apply[h$RTS_556]; | |
if((h$RTS_557 === h$ap_gen)) | |
{ | |
h$sp += 2; | |
h$stack[(h$sp - 1)] = h$RTS_556; | |
} | |
else | |
{ | |
++h$sp; | |
}; | |
h$stack[h$sp] = h$RTS_557; | |
return h$RTS_547; | |
} | |
else | |
{ | |
if((h$RTS_546 != 0)) | |
{ | |
var h$RTS_558 = h$paps[h$RTS_553]; | |
var h$RTS_559 = [h$r1, (((((h$RTS_550 >> 8) - h$RTS_553) * 256) + h$RTS_551) - h$RTS_552)]; | |
for(var h$RTS_560 = 0;(h$RTS_560 < h$RTS_553);(h$RTS_560++)) { | |
h$RTS_559.push(h$getReg((h$RTS_560 + 2))); | |
}; | |
h$r1 = h$init_closure({ d1: null, d2: null, f: h$RTS_558, m: 0 | |
}, h$RTS_559); | |
}; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (3): | |
var h$RTS_561 = h$r1.d2.d1; | |
var h$RTS_562 = (h$RTS_561 & 255); | |
var h$RTS_563 = (h$RTS_546 & 255); | |
var h$RTS_564 = (h$RTS_546 >> 8); | |
if((h$RTS_563 === h$RTS_562)) | |
{ | |
return h$RTS_547; | |
} | |
else | |
{ | |
if((h$RTS_563 > h$RTS_562)) | |
{ | |
var h$RTS_565 = ((h$RTS_561 >> 8) + 1); | |
h$sp = (((h$sp + h$RTS_564) - h$RTS_565) + 1); | |
for(var h$RTS_566 = h$RTS_564;(h$RTS_566 >= h$RTS_565);(h$RTS_566--)) { | |
h$stack[((h$sp + h$RTS_565) - h$RTS_566)] = h$getReg((h$RTS_566 + 1)); | |
}; | |
var h$RTS_567 = (((h$RTS_564 - (h$RTS_561 >> 8)) << 8) | (h$RTS_563 - h$RTS_562)); | |
var h$RTS_568 = h$apply[h$RTS_567]; | |
if((h$RTS_568 === h$ap_gen)) | |
{ | |
h$sp += 2; | |
h$stack[(h$sp - 1)] = h$RTS_567; | |
} | |
else | |
{ | |
++h$sp; | |
}; | |
h$stack[h$sp] = h$RTS_568; | |
return h$RTS_547; | |
} | |
else | |
{ | |
if((h$RTS_546 != 0)) | |
{ | |
var h$RTS_569 = h$paps[h$RTS_564]; | |
var h$RTS_570 = [h$r1, (((((h$RTS_561 >> 8) - h$RTS_564) * 256) + h$RTS_562) - h$RTS_563)]; | |
for(var h$RTS_571 = 0;(h$RTS_571 < h$RTS_564);(h$RTS_571++)) { | |
h$RTS_570.push(h$getReg((h$RTS_571 + 2))); | |
}; | |
h$r1 = h$init_closure({ d1: null, d2: null, f: h$RTS_569, m: 0 | |
}, h$RTS_570); | |
}; | |
return h$stack[h$sp]; | |
}; | |
}; | |
case (2): | |
if((h$RTS_546 != 0)) | |
{ | |
throw("h$ap_gen_fast: invalid apply"); | |
}; | |
return h$RTS_547; | |
case (5): | |
var h$RTS_572 = (h$RTS_546 >> 8); | |
h$sp += h$RTS_572; | |
switch (h$RTS_572) | |
{ | |
case (64): | |
h$stack[(h$sp - 63)] = h$regs[32]; | |
case (63): | |
h$stack[(h$sp - 62)] = h$regs[31]; | |
case (62): | |
h$stack[(h$sp - 61)] = h$regs[30]; | |
case (61): | |
h$stack[(h$sp - 60)] = h$regs[29]; | |
case (60): | |
h$stack[(h$sp - 59)] = h$regs[28]; | |
case (59): | |
h$stack[(h$sp - 58)] = h$regs[27]; | |
case (58): | |
h$stack[(h$sp - 57)] = h$regs[26]; | |
case (57): | |
h$stack[(h$sp - 56)] = h$regs[25]; | |
case (56): | |
h$stack[(h$sp - 55)] = h$regs[24]; | |
case (55): | |
h$stack[(h$sp - 54)] = h$regs[23]; | |
case (54): | |
h$stack[(h$sp - 53)] = h$regs[22]; | |
case (53): | |
h$stack[(h$sp - 52)] = h$regs[21]; | |
case (52): | |
h$stack[(h$sp - 51)] = h$regs[20]; | |
case (51): | |
h$stack[(h$sp - 50)] = h$regs[19]; | |
case (50): | |
h$stack[(h$sp - 49)] = h$regs[18]; | |
case (49): | |
h$stack[(h$sp - 48)] = h$regs[17]; | |
case (48): | |
h$stack[(h$sp - 47)] = h$regs[16]; | |
case (47): | |
h$stack[(h$sp - 46)] = h$regs[15]; | |
case (46): | |
h$stack[(h$sp - 45)] = h$regs[14]; | |
case (45): | |
h$stack[(h$sp - 44)] = h$regs[13]; | |
case (44): | |
h$stack[(h$sp - 43)] = h$regs[12]; | |
case (43): | |
h$stack[(h$sp - 42)] = h$regs[11]; | |
case (42): | |
h$stack[(h$sp - 41)] = h$regs[10]; | |
case (41): | |
h$stack[(h$sp - 40)] = h$regs[9]; | |
case (40): | |
h$stack[(h$sp - 39)] = h$regs[8]; | |
case (39): | |
h$stack[(h$sp - 38)] = h$regs[7]; | |
case (38): | |
h$stack[(h$sp - 37)] = h$regs[6]; | |
case (37): | |
h$stack[(h$sp - 36)] = h$regs[5]; | |
case (36): | |
h$stack[(h$sp - 35)] = h$regs[4]; | |
case (35): | |
h$stack[(h$sp - 34)] = h$regs[3]; | |
case (34): | |
h$stack[(h$sp - 33)] = h$regs[2]; | |
case (33): | |
h$stack[(h$sp - 32)] = h$regs[1]; | |
case (32): | |
h$stack[(h$sp - 31)] = h$regs[0]; | |
case (31): | |
h$stack[(h$sp - 30)] = h$r32; | |
case (30): | |
h$stack[(h$sp - 29)] = h$r31; | |
case (29): | |
h$stack[(h$sp - 28)] = h$r30; | |
case (28): | |
h$stack[(h$sp - 27)] = h$r29; | |
case (27): | |
h$stack[(h$sp - 26)] = h$r28; | |
case (26): | |
h$stack[(h$sp - 25)] = h$r27; | |
case (25): | |
h$stack[(h$sp - 24)] = h$r26; | |
case (24): | |
h$stack[(h$sp - 23)] = h$r25; | |
case (23): | |
h$stack[(h$sp - 22)] = h$r24; | |
case (22): | |
h$stack[(h$sp - 21)] = h$r23; | |
case (21): | |
h$stack[(h$sp - 20)] = h$r22; | |
case (20): | |
h$stack[(h$sp - 19)] = h$r21; | |
case (19): | |
h$stack[(h$sp - 18)] = h$r20; | |
case (18): | |
h$stack[(h$sp - 17)] = h$r19; | |
case (17): | |
h$stack[(h$sp - 16)] = h$r18; | |
case (16): | |
h$stack[(h$sp - 15)] = h$r17; | |
case (15): | |
h$stack[(h$sp - 14)] = h$r16; | |
case (14): | |
h$stack[(h$sp - 13)] = h$r15; | |
case (13): | |
h$stack[(h$sp - 12)] = h$r14; | |
case (12): | |
h$stack[(h$sp - 11)] = h$r13; | |
case (11): | |
h$stack[(h$sp - 10)] = h$r12; | |
case (10): | |
h$stack[(h$sp - 9)] = h$r11; | |
case (9): | |
h$stack[(h$sp - 8)] = h$r10; | |
case (8): | |
h$stack[(h$sp - 7)] = h$r9; | |
case (7): | |
h$stack[(h$sp - 6)] = h$r8; | |
case (6): | |
h$stack[(h$sp - 5)] = h$r7; | |
case (5): | |
h$stack[(h$sp - 4)] = h$r6; | |
case (4): | |
h$stack[(h$sp - 3)] = h$r5; | |
case (3): | |
h$stack[(h$sp - 2)] = h$r4; | |
case (2): | |
h$stack[(h$sp - 1)] = h$r3; | |
case (1): | |
h$stack[(h$sp - 0)] = h$r2; | |
default: | |
}; | |
var h$RTS_573 = h$apply[h$RTS_546]; | |
if((h$RTS_573 === h$ap_gen)) | |
{ | |
h$sp += 2; | |
h$stack[(h$sp - 1)] = h$RTS_546; | |
} | |
else | |
{ | |
++h$sp; | |
}; | |
h$stack[h$sp] = h$RTS_573; | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
throw(("h$ap_gen_fast: unexpected closure type: " + h$RTS_547.t)); | |
}; | |
}; | |
function h$ap_0_0_fast() | |
{ | |
if((typeof h$r1 !== "object")) | |
{ | |
return h$stack[h$sp]; | |
}; | |
var h$RTS_574 = h$r1.f; | |
if((h$RTS_574 === h$unbox_e)) | |
{ | |
h$r1 = h$r1.d1; | |
return h$stack[h$sp]; | |
}; | |
switch (h$RTS_574.t) | |
{ | |
case (2): | |
case (1): | |
case (3): | |
return h$stack[h$sp]; | |
case (5): | |
h$p3(h$ap_0_0, h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
return h$RTS_574; | |
}; | |
}; | |
function h$ap_0_0() | |
{ | |
--h$sp; | |
if((typeof h$r1 !== "object")) | |
{ | |
return h$stack[h$sp]; | |
}; | |
var h$RTS_575 = h$r1.f; | |
if((h$RTS_575 === h$unbox_e)) | |
{ | |
h$r1 = h$r1.d1; | |
return h$stack[h$sp]; | |
}; | |
switch (h$RTS_575.t) | |
{ | |
case (2): | |
case (1): | |
case (3): | |
return h$stack[h$sp]; | |
case (5): | |
h$p3(h$ap_0_0, h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
default: | |
return h$RTS_575; | |
}; | |
}; | |
h$o(h$ap_0_0, (-1), 0, 0, 256, null); | |
function h$ap_1_0(h$RTS_576) | |
{ | |
var h$RTS_577 = h$r1.f; | |
if((h$RTS_577.t === 0)) | |
{ | |
return h$RTS_577; | |
} | |
else | |
{ | |
if((h$RTS_577.t === 5)) | |
{ | |
h$p2(h$r1, h$return); | |
return h$blockOnBlackhole(h$r1); | |
} | |
else | |
{ | |
--h$sp; | |
return h$RTS_577; | |
}; | |
}; | |
}; | |
h$o(h$ap_1_0, (-1), 0, 0, 256, null); | |
function h$e(h$RTS_578) | |
{ | |
h$r1 = h$RTS_578; | |
if((typeof h$RTS_578 !== "object")) | |
{ | |
return h$stack[h$sp]; | |
}; | |
var h$RTS_579 = h$RTS_578.f; | |
if((h$RTS_579 === h$unbox_e)) | |
{ | |
h$r1 = h$RTS_578.d1; | |
return h$stack[h$sp]; | |
}; | |
switch (h$RTS_579.t) | |
{ | |
case (2): | |
case (1): | |
case (3): | |
return h$stack[h$sp]; | |
case (5): | |
h$p3(h$ap_0_0, h$RTS_578, h$return); | |
return h$blockOnBlackhole(h$RTS_578); | |
default: | |
return h$RTS_579; | |
}; | |
}; | |
function h$upd_frame() | |
{ | |
var h$RTS_580 = h$stack[(h$sp - 1)]; | |
var h$RTS_581 = h$RTS_580.d2; | |
if((h$RTS_581 !== null)) | |
{ | |
for(var h$RTS_582 = 0;(h$RTS_582 < h$RTS_581.length);(h$RTS_582++)) { | |
h$wakeupThread(h$RTS_581[h$RTS_582]); | |
}; | |
}; | |
if((typeof h$r1 === "object")) | |
{ | |
h$RTS_580.f = h$r1.f; | |
h$RTS_580.d1 = h$r1.d1; | |
h$RTS_580.d2 = h$r1.d2; | |
h$RTS_580.m = h$r1.m; | |
} | |
else | |
{ | |
h$RTS_580.f = h$unbox_e; | |
h$RTS_580.d1 = h$r1; | |
h$RTS_580.d2 = null; | |
h$RTS_580.m = 0; | |
}; | |
h$sp -= 2; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$upd_frame, (-1), 0, 1, 256, null); | |
function h$upd_frame_lne() | |
{ | |
var h$RTS_583 = h$stack[(h$sp - 1)]; | |
h$stack[h$RTS_583] = h$r1; | |
h$sp -= 2; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$upd_frame_lne, (-1), 0, 1, 256, null); | |
function h$pap_gen() | |
{ | |
var h$RTS_584 = h$r1.d1; | |
var h$RTS_585 = h$RTS_584.f; | |
var h$RTS_586 = h$r1.d2; | |
var h$RTS_587 = (((h$RTS_585.t === 1) ? h$RTS_585.a : h$RTS_584.d2.d1) >> 8); | |
var h$RTS_588 = (h$r1.d2.d1 >> 8); | |
var h$RTS_589 = (h$RTS_587 - h$RTS_588); | |
h$moveRegs2(h$RTS_588, h$RTS_589); | |
switch (h$RTS_589) | |
{ | |
case (127): | |
h$regs[95] = h$RTS_586.d128; | |
case (126): | |
h$regs[94] = h$RTS_586.d127; | |
case (125): | |
h$regs[93] = h$RTS_586.d126; | |
case (124): | |
h$regs[92] = h$RTS_586.d125; | |
case (123): | |
h$regs[91] = h$RTS_586.d124; | |
case (122): | |
h$regs[90] = h$RTS_586.d123; | |
case (121): | |
h$regs[89] = h$RTS_586.d122; | |
case (120): | |
h$regs[88] = h$RTS_586.d121; | |
case (119): | |
h$regs[87] = h$RTS_586.d120; | |
case (118): | |
h$regs[86] = h$RTS_586.d119; | |
case (117): | |
h$regs[85] = h$RTS_586.d118; | |
case (116): | |
h$regs[84] = h$RTS_586.d117; | |
case (115): | |
h$regs[83] = h$RTS_586.d116; | |
case (114): | |
h$regs[82] = h$RTS_586.d115; | |
case (113): | |
h$regs[81] = h$RTS_586.d114; | |
case (112): | |
h$regs[80] = h$RTS_586.d113; | |
case (111): | |
h$regs[79] = h$RTS_586.d112; | |
case (110): | |
h$regs[78] = h$RTS_586.d111; | |
case (109): | |
h$regs[77] = h$RTS_586.d110; | |
case (108): | |
h$regs[76] = h$RTS_586.d109; | |
case (107): | |
h$regs[75] = h$RTS_586.d108; | |
case (106): | |
h$regs[74] = h$RTS_586.d107; | |
case (105): | |
h$regs[73] = h$RTS_586.d106; | |
case (104): | |
h$regs[72] = h$RTS_586.d105; | |
case (103): | |
h$regs[71] = h$RTS_586.d104; | |
case (102): | |
h$regs[70] = h$RTS_586.d103; | |
case (101): | |
h$regs[69] = h$RTS_586.d102; | |
case (100): | |
h$regs[68] = h$RTS_586.d101; | |
case (99): | |
h$regs[67] = h$RTS_586.d100; | |
case (98): | |
h$regs[66] = h$RTS_586.d99; | |
case (97): | |
h$regs[65] = h$RTS_586.d98; | |
case (96): | |
h$regs[64] = h$RTS_586.d97; | |
case (95): | |
h$regs[63] = h$RTS_586.d96; | |
case (94): | |
h$regs[62] = h$RTS_586.d95; | |
case (93): | |
h$regs[61] = h$RTS_586.d94; | |
case (92): | |
h$regs[60] = h$RTS_586.d93; | |
case (91): | |
h$regs[59] = h$RTS_586.d92; | |
case (90): | |
h$regs[58] = h$RTS_586.d91; | |
case (89): | |
h$regs[57] = h$RTS_586.d90; | |
case (88): | |
h$regs[56] = h$RTS_586.d89; | |
case (87): | |
h$regs[55] = h$RTS_586.d88; | |
case (86): | |
h$regs[54] = h$RTS_586.d87; | |
case (85): | |
h$regs[53] = h$RTS_586.d86; | |
case (84): | |
h$regs[52] = h$RTS_586.d85; | |
case (83): | |
h$regs[51] = h$RTS_586.d84; | |
case (82): | |
h$regs[50] = h$RTS_586.d83; | |
case (81): | |
h$regs[49] = h$RTS_586.d82; | |
case (80): | |
h$regs[48] = h$RTS_586.d81; | |
case (79): | |
h$regs[47] = h$RTS_586.d80; | |
case (78): | |
h$regs[46] = h$RTS_586.d79; | |
case (77): | |
h$regs[45] = h$RTS_586.d78; | |
case (76): | |
h$regs[44] = h$RTS_586.d77; | |
case (75): | |
h$regs[43] = h$RTS_586.d76; | |
case (74): | |
h$regs[42] = h$RTS_586.d75; | |
case (73): | |
h$regs[41] = h$RTS_586.d74; | |
case (72): | |
h$regs[40] = h$RTS_586.d73; | |
case (71): | |
h$regs[39] = h$RTS_586.d72; | |
case (70): | |
h$regs[38] = h$RTS_586.d71; | |
case (69): | |
h$regs[37] = h$RTS_586.d70; | |
case (68): | |
h$regs[36] = h$RTS_586.d69; | |
case (67): | |
h$regs[35] = h$RTS_586.d68; | |
case (66): | |
h$regs[34] = h$RTS_586.d67; | |
case (65): | |
h$regs[33] = h$RTS_586.d66; | |
case (64): | |
h$regs[32] = h$RTS_586.d65; | |
case (63): | |
h$regs[31] = h$RTS_586.d64; | |
case (62): | |
h$regs[30] = h$RTS_586.d63; | |
case (61): | |
h$regs[29] = h$RTS_586.d62; | |
case (60): | |
h$regs[28] = h$RTS_586.d61; | |
case (59): | |
h$regs[27] = h$RTS_586.d60; | |
case (58): | |
h$regs[26] = h$RTS_586.d59; | |
case (57): | |
h$regs[25] = h$RTS_586.d58; | |
case (56): | |
h$regs[24] = h$RTS_586.d57; | |
case (55): | |
h$regs[23] = h$RTS_586.d56; | |
case (54): | |
h$regs[22] = h$RTS_586.d55; | |
case (53): | |
h$regs[21] = h$RTS_586.d54; | |
case (52): | |
h$regs[20] = h$RTS_586.d53; | |
case (51): | |
h$regs[19] = h$RTS_586.d52; | |
case (50): | |
h$regs[18] = h$RTS_586.d51; | |
case (49): | |
h$regs[17] = h$RTS_586.d50; | |
case (48): | |
h$regs[16] = h$RTS_586.d49; | |
case (47): | |
h$regs[15] = h$RTS_586.d48; | |
case (46): | |
h$regs[14] = h$RTS_586.d47; | |
case (45): | |
h$regs[13] = h$RTS_586.d46; | |
case (44): | |
h$regs[12] = h$RTS_586.d45; | |
case (43): | |
h$regs[11] = h$RTS_586.d44; | |
case (42): | |
h$regs[10] = h$RTS_586.d43; | |
case (41): | |
h$regs[9] = h$RTS_586.d42; | |
case (40): | |
h$regs[8] = h$RTS_586.d41; | |
case (39): | |
h$regs[7] = h$RTS_586.d40; | |
case (38): | |
h$regs[6] = h$RTS_586.d39; | |
case (37): | |
h$regs[5] = h$RTS_586.d38; | |
case (36): | |
h$regs[4] = h$RTS_586.d37; | |
case (35): | |
h$regs[3] = h$RTS_586.d36; | |
case (34): | |
h$regs[2] = h$RTS_586.d35; | |
case (33): | |
h$regs[1] = h$RTS_586.d34; | |
case (32): | |
h$regs[0] = h$RTS_586.d33; | |
case (31): | |
h$r32 = h$RTS_586.d32; | |
case (30): | |
h$r31 = h$RTS_586.d31; | |
case (29): | |
h$r30 = h$RTS_586.d30; | |
case (28): | |
h$r29 = h$RTS_586.d29; | |
case (27): | |
h$r28 = h$RTS_586.d28; | |
case (26): | |
h$r27 = h$RTS_586.d27; | |
case (25): | |
h$r26 = h$RTS_586.d26; | |
case (24): | |
h$r25 = h$RTS_586.d25; | |
case (23): | |
h$r24 = h$RTS_586.d24; | |
case (22): | |
h$r23 = h$RTS_586.d23; | |
case (21): | |
h$r22 = h$RTS_586.d22; | |
case (20): | |
h$r21 = h$RTS_586.d21; | |
case (19): | |
h$r20 = h$RTS_586.d20; | |
case (18): | |
h$r19 = h$RTS_586.d19; | |
case (17): | |
h$r18 = h$RTS_586.d18; | |
case (16): | |
h$r17 = h$RTS_586.d17; | |
case (15): | |
h$r16 = h$RTS_586.d16; | |
case (14): | |
h$r15 = h$RTS_586.d15; | |
case (13): | |
h$r14 = h$RTS_586.d14; | |
case (12): | |
h$r13 = h$RTS_586.d13; | |
case (11): | |
h$r12 = h$RTS_586.d12; | |
case (10): | |
h$r11 = h$RTS_586.d11; | |
case (9): | |
h$r10 = h$RTS_586.d10; | |
case (8): | |
h$r9 = h$RTS_586.d9; | |
case (7): | |
h$r8 = h$RTS_586.d8; | |
case (6): | |
h$r7 = h$RTS_586.d7; | |
case (5): | |
h$r6 = h$RTS_586.d6; | |
case (4): | |
h$r5 = h$RTS_586.d5; | |
case (3): | |
h$r4 = h$RTS_586.d4; | |
case (2): | |
h$r3 = h$RTS_586.d3; | |
case (1): | |
h$r2 = h$RTS_586.d2; | |
default: | |
}; | |
h$r1 = h$RTS_584; | |
return h$RTS_585; | |
}; | |
h$o(h$pap_gen, 3, 0, (-1), (-1), null); | |
function h$moveRegs2(h$RTS_590, h$RTS_591) | |
{ | |
switch (((h$RTS_590 << 8) | h$RTS_591)) | |
{ | |
case (257): | |
h$r3 = h$r2; | |
break; | |
case (258): | |
h$r4 = h$r2; | |
break; | |
case (259): | |
h$r5 = h$r2; | |
break; | |
case (260): | |
h$r6 = h$r2; | |
break; | |
case (513): | |
h$r4 = h$r3; | |
h$r3 = h$r2; | |
break; | |
case (514): | |
h$r5 = h$r3; | |
h$r4 = h$r2; | |
break; | |
case (515): | |
h$r6 = h$r3; | |
h$r5 = h$r2; | |
break; | |
case (516): | |
h$r7 = h$r3; | |
h$r6 = h$r2; | |
break; | |
case (769): | |
h$r5 = h$r4; | |
h$r4 = h$r3; | |
h$r3 = h$r2; | |
break; | |
case (770): | |
h$r6 = h$r4; | |
h$r5 = h$r3; | |
h$r4 = h$r2; | |
break; | |
case (771): | |
h$r7 = h$r4; | |
h$r6 = h$r3; | |
h$r5 = h$r2; | |
break; | |
case (772): | |
h$r8 = h$r4; | |
h$r7 = h$r3; | |
h$r6 = h$r2; | |
break; | |
case (1025): | |
h$r6 = h$r5; | |
h$r5 = h$r4; | |
h$r4 = h$r3; | |
h$r3 = h$r2; | |
break; | |
case (1026): | |
h$r7 = h$r5; | |
h$r6 = h$r4; | |
h$r5 = h$r3; | |
h$r4 = h$r2; | |
break; | |
case (1027): | |
h$r8 = h$r5; | |
h$r7 = h$r4; | |
h$r6 = h$r3; | |
h$r5 = h$r2; | |
break; | |
case (1028): | |
h$r9 = h$r5; | |
h$r8 = h$r4; | |
h$r7 = h$r3; | |
h$r6 = h$r2; | |
break; | |
case (1281): | |
h$r7 = h$r6; | |
h$r6 = h$r5; | |
h$r5 = h$r4; | |
h$r4 = h$r3; | |
h$r3 = h$r2; | |
break; | |
case (1282): | |
h$r8 = h$r6; | |
h$r7 = h$r5; | |
h$r6 = h$r4; | |
h$r5 = h$r3; | |
h$r4 = h$r2; | |
break; | |
case (1283): | |
h$r9 = h$r6; | |
h$r8 = h$r5; | |
h$r7 = h$r4; | |
h$r6 = h$r3; | |
h$r5 = h$r2; | |
break; | |
case (1284): | |
h$r10 = h$r6; | |
h$r9 = h$r5; | |
h$r8 = h$r4; | |
h$r7 = h$r3; | |
h$r6 = h$r2; | |
break; | |
default: | |
for(var h$RTS_592 = h$RTS_590;(h$RTS_592 > 0);(h$RTS_592--)) { | |
h$setReg(((h$RTS_592 + 1) + h$RTS_591), h$getReg((h$RTS_592 + 1))); | |
}; | |
}; | |
}; | |
var h$THUNK_CLOSURE = 0; | |
var h$FUN_CLOSURE = 1; | |
var h$PAP_CLOSURE = 3; | |
var h$CON_CLOSURE = 2; | |
var h$BLACKHOLE_CLOSURE = 5; | |
var h$STACKFRAME_CLOSURE = (-1); | |
function h$closureTypeName(h$RTS_593) | |
{ | |
if((h$RTS_593 === 0)) | |
{ | |
return "Thunk"; | |
}; | |
if((h$RTS_593 === 1)) | |
{ | |
return "Fun"; | |
}; | |
if((h$RTS_593 === 3)) | |
{ | |
return "Pap"; | |
}; | |
if((h$RTS_593 === 2)) | |
{ | |
return "Con"; | |
}; | |
if((h$RTS_593 === 5)) | |
{ | |
return "Blackhole"; | |
}; | |
if((h$RTS_593 === (-1))) | |
{ | |
return "StackFrame"; | |
}; | |
return "InvalidClosureType"; | |
}; | |
function h$runio_e() | |
{ | |
h$r1 = h$r1.d1; | |
h$stack[++h$sp] = h$ap_1_0; | |
return h$ap_1_0; | |
}; | |
h$o(h$runio_e, 0, 0, 1, 256, null); | |
function h$runio(h$RTS_594) | |
{ | |
return h$c1(h$runio_e, h$RTS_594); | |
}; | |
function h$flushStdout_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziHandlezihFlush; | |
h$r2 = h$baseZCGHCziIOziHandleziFDzistdout; | |
return h$ap_1_1_fast(); | |
}; | |
h$o(h$flushStdout_e, 0, 0, 0, 0, null); | |
var h$flushStdout = h$static_thunk(h$flushStdout_e); | |
var h$RTS_595 = new Date(); | |
function h$dumpRes(h$RTS_596) | |
{ | |
h$printcl(h$RTS_596); | |
var h$RTS_597 = new Date(); | |
h$log((("elapsed time: " + (h$RTS_597.getTime() - h$RTS_595.getTime())) + "ms")); | |
}; | |
function h$ascii(h$RTS_598) | |
{ | |
var h$RTS_599 = []; | |
for(var h$RTS_600 = 0;(h$RTS_600 < h$RTS_598.length);(h$RTS_600++)) { | |
h$RTS_599.push(h$RTS_598.charCodeAt(h$RTS_600)); | |
}; | |
h$RTS_599.push(0); | |
return h$RTS_599; | |
}; | |
function h$dumpStackTop(h$RTS_601, h$RTS_602, h$RTS_603) | |
{ | |
h$RTS_602 = Math.max(h$RTS_602, 0); | |
for(var h$RTS_604 = h$RTS_602;(h$RTS_604 <= h$RTS_603);(h$RTS_604++)) { | |
var h$RTS_605 = h$RTS_601[h$RTS_604]; | |
if((h$RTS_605 && h$RTS_605.n)) | |
{ | |
h$log(((("stack[" + h$RTS_604) + "] = ") + h$RTS_605.n)); | |
} | |
else | |
{ | |
if((h$RTS_605 === null)) | |
{ | |
h$log((("stack[" + h$RTS_604) + "] = null WARNING DANGER")); | |
} | |
else | |
{ | |
if((((((typeof h$RTS_605 === "object") && (h$RTS_605 !== null)) && h$RTS_605.hasOwnProperty("f")) && h$RTS_605. | |
hasOwnProperty("d1")) && h$RTS_605.hasOwnProperty("d2"))) | |
{ | |
if((typeof h$RTS_605.f !== "function")) | |
{ | |
h$log((("stack[" + h$RTS_604) + "] = WARNING: dodgy object")); | |
} | |
else | |
{ | |
if((h$RTS_605.d1 === undefined)) | |
{ | |
h$log((("WARNING: stack[" + h$RTS_604) + "] d1 undefined")); | |
}; | |
if((h$RTS_605.d2 === undefined)) | |
{ | |
h$log((("WARNING: stack[" + h$RTS_604) + "] d2 undefined")); | |
}; | |
if(((((h$RTS_605.f.t === 5) && h$RTS_605.d1) && h$RTS_605.d1.x1) && h$RTS_605.d1.x1.n)) | |
{ | |
h$log(((("stack[" + h$RTS_604) + "] = blackhole -> ") + h$RTS_605.d1.x1.n)); | |
} | |
else | |
{ | |
h$log(((((((((("stack[" + h$RTS_604) + "] = -> ") + (h$RTS_605.alloc ? (h$RTS_605.alloc + ": ") : "")) + h$RTS_605.f. | |
n) + " (") + h$closureTypeName(h$RTS_605.f.t)) + ", a: ") + h$RTS_605.f.a) + ")")); | |
}; | |
}; | |
} | |
else | |
{ | |
if(h$isInstanceOf(h$RTS_605, h$MVar)) | |
{ | |
var h$RTS_606 = ((h$RTS_605.val === null) ? " empty" : (" value -> " + ((typeof h$RTS_605. | |
val === "object") ? (((((h$RTS_605.val.f.n + " (") + h$closureTypeName(h$RTS_605.val.f.t)) + ", a: ") + h$RTS_605.val.f. | |
a) + ")") : h$RTS_605.val))); | |
h$log(((("stack[" + h$RTS_604) + "] = MVar ") + h$RTS_606)); | |
} | |
else | |
{ | |
if(h$isInstanceOf(h$RTS_605, h$MutVar)) | |
{ | |
h$log(((("stack[" + h$RTS_604) + "] = IORef -> ") + ((typeof h$RTS_605.val === "object") ? (((((h$RTS_605.val.f. | |
n + " (") + h$closureTypeName(h$RTS_605.val.f.t)) + ", a: ") + h$RTS_605.val.f.a) + ")") : h$RTS_605.val))); | |
} | |
else | |
{ | |
if((typeof h$RTS_605 === "object")) | |
{ | |
h$log(((("stack[" + h$RTS_604) + "] = ") + h$collectProps(h$RTS_605).substring(0, 50))); | |
} | |
else | |
{ | |
if((typeof h$RTS_605 === "function")) | |
{ | |
var h$RTS_607 = new RegExp("([^\\n]+)\\n(.|\\n)*"); | |
h$log(((("stack[" + h$RTS_604) + "] = ") + ("" + h$RTS_605).substring(0, 50).replace(h$RTS_607, "$1"))); | |
} | |
else | |
{ | |
h$log(((("stack[" + h$RTS_604) + "] = ") + ("" + h$RTS_605).substring(0, 50))); | |
}; | |
}; | |
}; | |
}; | |
}; | |
}; | |
}; | |
}; | |
}; | |
function h$checkObj(h$RTS_608) | |
{ | |
if(((typeof h$RTS_608 === "boolean") || (typeof h$RTS_608 === "number"))) | |
{ | |
return undefined; | |
}; | |
if(((((!h$RTS_608.hasOwnProperty("f") || (h$RTS_608.f === null)) || (h$RTS_608.f === undefined)) || (h$RTS_608.f. | |
a === undefined)) || (typeof h$RTS_608.f !== "function"))) | |
{ | |
h$log("h$checkObj: WARNING, something wrong with f:"); | |
h$log(("" + h$RTS_608).substring(0, 200)); | |
h$log(h$collectProps(h$RTS_608)); | |
h$log(typeof h$RTS_608.f); | |
}; | |
if((!h$RTS_608.hasOwnProperty("d1") || (h$RTS_608.d1 === undefined))) | |
{ | |
h$log("h$checkObj: WARNING, something wrong with d1:"); | |
h$log(("" + h$RTS_608).substring(0, 200)); | |
} | |
else | |
{ | |
if((!h$RTS_608.hasOwnProperty("d2") || (h$RTS_608.d2 === undefined))) | |
{ | |
h$log("h$checkObj: WARNING, something wrong with d2:"); | |
h$log(("" + h$RTS_608).substring(0, 200)); | |
} | |
else | |
{ | |
if((((h$RTS_608.d2 !== null) && (typeof h$RTS_608.d2 === "object")) && (h$RTS_608.f.size !== 2))) | |
{ | |
var h$RTS_609 = h$RTS_608.d2; | |
var h$RTS_610; | |
for(h$RTS_610 in h$RTS_609) | |
{ | |
if(h$RTS_609.hasOwnProperty(h$RTS_610)) | |
{ | |
if((h$RTS_610.substring(0, 1) != "d")) | |
{ | |
h$log(("h$checkObj: WARNING, unexpected field name: " + h$RTS_610)); | |
h$log(("" + h$RTS_608).substring(0, 200)); | |
}; | |
if((h$RTS_609[h$RTS_610] === undefined)) | |
{ | |
h$log(("h$checkObj: WARNING, undefined field detected: " + h$RTS_610)); | |
h$log(("" + h$RTS_608).substring(0, 200)); | |
}; | |
}; | |
}; | |
switch (h$RTS_608.f.size) | |
{ | |
case (6): | |
if((h$RTS_609.d5 === undefined)) | |
{ | |
h$log("h$checkObj: WARNING, undefined field detected: d5"); | |
}; | |
case (5): | |
if((h$RTS_609.d4 === undefined)) | |
{ | |
h$log("h$checkObj: WARNING, undefined field detected: d4"); | |
}; | |
case (4): | |
if((h$RTS_609.d3 === undefined)) | |
{ | |
h$log("h$checkObj: WARNING, undefined field detected: d3"); | |
}; | |
case (3): | |
if((h$RTS_609.d2 === undefined)) | |
{ | |
h$log("h$checkObj: WARNING, undefined field detected: d2"); | |
}; | |
if((h$RTS_609.d1 === undefined)) | |
{ | |
h$log("h$checkObj: WARNING, undefined field detected: d1"); | |
}; | |
default: | |
h$RTS_609 = h$RTS_608.d2; | |
}; | |
}; | |
}; | |
}; | |
}; | |
function h$traceForeign(h$RTS_611, h$RTS_612) | |
{ | |
if(true) | |
{ | |
return undefined; | |
}; | |
var h$RTS_613 = []; | |
for(var h$RTS_614 = 0;(h$RTS_614 < h$RTS_612.length);(h$RTS_614++)) { | |
var h$RTS_615 = h$RTS_612[h$RTS_614]; | |
if((h$RTS_615 === null)) | |
{ | |
h$RTS_613.push("null"); | |
} | |
else | |
{ | |
if((typeof h$RTS_615 === "object")) | |
{ | |
var h$RTS_616 = h$RTS_615.toString(); | |
if((h$RTS_616.length > 40)) | |
{ | |
h$RTS_613.push((h$RTS_616.substring(0, 40) + "...")); | |
} | |
else | |
{ | |
h$RTS_613.push(h$RTS_616); | |
}; | |
} | |
else | |
{ | |
h$RTS_613.push(("" + h$RTS_615)); | |
}; | |
}; | |
}; | |
h$log((((("ffi: " + h$RTS_611) + "(") + h$RTS_613.join(",")) + ")")); | |
}; | |
function h$restoreThread() | |
{ | |
var h$RTS_617 = h$stack[(h$sp - 2)]; | |
var h$RTS_618 = h$stack[(h$sp - 1)]; | |
var h$RTS_619 = (h$RTS_618 - 3); | |
for(var h$RTS_620 = 1;(h$RTS_620 <= h$RTS_619);(h$RTS_620++)) { | |
h$setReg(h$RTS_620, h$stack[((h$sp - 2) - h$RTS_620)]); | |
}; | |
h$sp -= h$RTS_618; | |
return h$RTS_617; | |
}; | |
h$o(h$restoreThread, (-1), 0, (-1), 0, null); | |
function h$return() | |
{ | |
h$r1 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$return, (-1), 0, 1, 0, null); | |
function h$returnf() | |
{ | |
var h$RTS_621 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$RTS_621; | |
}; | |
h$o(h$returnf, (-1), 0, 1, 256, null); | |
function h$reschedule() | |
{ | |
return h$reschedule; | |
}; | |
h$o(h$reschedule, 0, 0, 0, 0, null); | |
function h$suspendCurrentThread(h$RTS_622) | |
{ | |
if((h$RTS_622 === h$reschedule)) | |
{ | |
throw("suspend called with h$reschedule"); | |
}; | |
if((h$RTS_622.t === (-1))) | |
{ | |
h$stack[h$sp] = h$RTS_622; | |
}; | |
if(((h$stack[h$sp] === h$restoreThread) || (h$RTS_622 === h$return))) | |
{ | |
h$currentThread.sp = h$sp; | |
return undefined; | |
}; | |
var h$RTS_623; | |
var h$RTS_624 = 0; | |
var h$RTS_625 = h$RTS_622.t; | |
if((h$RTS_625 === 3)) | |
{ | |
h$RTS_623 = ((h$r1.d2.d1 >> 8) + 1); | |
} | |
else | |
{ | |
if(((h$RTS_625 === 1) || (h$RTS_625 === (-1)))) | |
{ | |
h$RTS_623 = (h$RTS_622.r >> 8); | |
h$RTS_624 = (h$RTS_622.r & 255); | |
} | |
else | |
{ | |
h$RTS_623 = 1; | |
}; | |
}; | |
h$sp = (((h$sp + h$RTS_623) + h$RTS_624) + 3); | |
for(var h$RTS_626 = 1;(h$RTS_626 <= h$RTS_624);(h$RTS_626++)) { | |
h$stack[((h$sp - 2) - h$RTS_626)] = null; | |
}; | |
for(h$RTS_626 = (h$RTS_624 + 1);(h$RTS_626 <= (h$RTS_623 + h$RTS_624));(h$RTS_626++)) { | |
h$stack[((h$sp - 2) - h$RTS_626)] = h$getReg(h$RTS_626); | |
}; | |
h$stack[(h$sp - 2)] = h$RTS_622; | |
h$stack[(h$sp - 1)] = ((h$RTS_623 + h$RTS_624) + 3); | |
h$stack[h$sp] = h$restoreThread; | |
h$currentThread.sp = h$sp; | |
}; | |
function h$dumpRes() | |
{ | |
h$log(("h$dumpRes result: " + h$stack[(h$sp - 1)])); | |
h$log(h$r1); | |
h$log(h$collectProps(h$r1)); | |
if((h$r1.f && h$r1.f.n)) | |
{ | |
h$log(("name: " + h$r1.f.n)); | |
}; | |
if(h$r1.hasOwnProperty("d1")) | |
{ | |
h$log(("d1: " + h$r1.d1)); | |
}; | |
if(h$r1.hasOwnProperty("d2")) | |
{ | |
h$log(("d2: " + h$r1.d2)); | |
}; | |
if(h$r1.f) | |
{ | |
var h$RTS_627 = new RegExp("([^\\n]+)\\n(.|\\n)*"); | |
h$log(("function: " + ("" + h$r1.f).substring(0, 50).replace(h$RTS_627, "$1"))); | |
}; | |
h$sp -= 2; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$dumpRes, 0, 0, 1, 256, null); | |
function h$resume_e() | |
{ | |
var h$RTS_628 = h$r1.d1; | |
h$bh(); | |
for(var h$RTS_629 = 0;(h$RTS_629 < h$RTS_628.length);(h$RTS_629++)) { | |
h$stack[((h$sp + 1) + h$RTS_629)] = h$RTS_628[h$RTS_629]; | |
}; | |
h$sp += h$RTS_628.length; | |
h$r1 = null; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$resume_e, 0, 0, 0, 256, null); | |
function h$unmaskFrame() | |
{ | |
h$currentThread.mask = 0; | |
--h$sp; | |
if((h$currentThread.excep.length > 0)) | |
{ | |
h$p2(h$r1, h$return); | |
return h$reschedule; | |
} | |
else | |
{ | |
return h$stack[h$sp]; | |
}; | |
}; | |
h$o(h$unmaskFrame, (-1), 0, 0, 256, null); | |
function h$maskFrame() | |
{ | |
h$currentThread.mask = 2; | |
--h$sp; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$maskFrame, (-1), 0, 0, 256, null); | |
function h$maskUnintFrame() | |
{ | |
h$currentThread.mask = 1; | |
--h$sp; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$maskUnintFrame, (-1), 0, 0, 256, null); | |
function h$unboxFFIResult() | |
{ | |
var h$RTS_630 = h$r1.d1; | |
for(var h$RTS_631 = 0;(h$RTS_631 < h$RTS_630.length);(h$RTS_631++)) { | |
h$setReg((h$RTS_631 + 1), h$RTS_630[h$RTS_631]); | |
}; | |
--h$sp; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$unboxFFIResult, (-1), 0, 0, 256, null); | |
function h$unbox_e() | |
{ | |
h$r1 = h$r1.d1; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$unbox_e, 0, 0, 1, 256, null); | |
function h$retryInterrupted() | |
{ | |
var h$RTS_632 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
return h$RTS_632[0].apply(this, h$RTS_632.slice(1)); | |
}; | |
h$o(h$retryInterrupted, (-1), 0, 1, 256, null); | |
function h$atomically_e() | |
{ | |
if(h$stmValidateTransaction()) | |
{ | |
h$stmCommitTransaction(); | |
h$sp -= 2; | |
return h$stack[h$sp]; | |
} | |
else | |
{ | |
++h$sp; | |
h$stack[h$sp] = h$checkInvariants_e; | |
return h$stmStartTransaction(h$stack[(h$sp - 2)]); | |
}; | |
}; | |
h$o(h$atomically_e, (-1), 0, 1, 256, null); | |
function h$checkInvariants_e() | |
{ | |
--h$sp; | |
return h$stmCheckInvariants(); | |
}; | |
h$o(h$checkInvariants_e, (-1), 0, 0, 256, null); | |
function h$stmCheckInvariantStart_e() | |
{ | |
var h$RTS_633 = h$stack[(h$sp - 2)]; | |
var h$RTS_634 = h$stack[(h$sp - 1)]; | |
var h$RTS_635 = h$currentThread.mask; | |
h$sp -= 3; | |
var h$RTS_636 = new h$Transaction(h$RTS_634.action, h$RTS_633); | |
h$RTS_636.checkRead = new h$Set(); | |
h$currentThread.transaction = h$RTS_636; | |
h$p4(h$RTS_636, h$RTS_635, h$stmInvariantViolatedHandler, h$catchStm_e); | |
h$r1 = h$RTS_634.action; | |
return h$ap_1_0_fast(); | |
}; | |
h$o(h$stmCheckInvariantStart_e, (-1), 0, 2, 0, null); | |
function h$stmCheckInvariantResult_e() | |
{ | |
var h$RTS_637 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$stmUpdateInvariantDependencies(h$RTS_637); | |
h$stmAbortTransaction(); | |
return h$stack[h$sp]; | |
}; | |
h$o(h$stmCheckInvariantResult_e, (-1), 0, 1, 256, null); | |
function h$stmInvariantViolatedHandler_e() | |
{ | |
if((h$stack[h$sp] !== h$stmCheckInvariantResult_e)) | |
{ | |
throw("h$stmInvariantViolatedHandler_e: unexpected value on stack"); | |
}; | |
var h$RTS_638 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$stmUpdateInvariantDependencies(h$RTS_638); | |
h$stmAbortTransaction(); | |
return h$throw(h$r2, false); | |
}; | |
h$o(h$stmInvariantViolatedHandler_e, 1, 258, 0, 256, null); | |
var h$stmInvariantViolatedHandler = h$c(h$stmInvariantViolatedHandler_e); | |
function h$stmCatchRetry_e() | |
{ | |
h$sp -= 2; | |
h$stmCommitTransaction(); | |
return h$stack[h$sp]; | |
}; | |
h$o(h$stmCatchRetry_e, (-1), 0, 1, 256, null); | |
function h$catchStm_e() | |
{ | |
h$sp -= 4; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$catchStm_e, (-1), 0, 3, 256, null); | |
function h$stmResumeRetry_e() | |
{ | |
if((h$stack[(h$sp - 2)] !== h$atomically_e)) | |
{ | |
throw("h$stmResumeRetry_e: unexpected value on stack"); | |
}; | |
var h$RTS_639 = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
++h$sp; | |
h$stack[h$sp] = h$checkInvariants_e; | |
h$stmRemoveBlockedThread(h$RTS_639, h$currentThread); | |
return h$stmStartTransaction(h$stack[(h$sp - 2)]); | |
}; | |
h$o(h$stmResumeRetry_e, (-1), 0, 0, 256, null); | |
function h$lazy_e() | |
{ | |
var h$RTS_640 = h$r1.d1(); | |
h$bh(); | |
h$r1 = h$RTS_640; | |
return h$stack[h$sp]; | |
}; | |
h$o(h$lazy_e, 0, 0, 0, 256, null); | |
// translated from bytestring cbits/fpstring.c | |
function h$fps_reverse(a_v, a_o, b_v, b_o, n) { | |
if(n > 0) { | |
var au8 = a_v.u8, bu8 = b_v.u8; | |
for(var i=0;i<n;i++) { | |
au8[a_o+n-i-1] = bu8[b_o+i]; | |
} | |
} | |
} | |
function h$fps_intersperse(a_v,a_o,b_v,b_o,n,c) { | |
if(n > 0) { | |
var au8 = a_v.u8, bu8 = b_v.u8, dst_o = a_o; | |
for(var i=0;i<n-1;i++) { | |
au8[dst_o] = bu8[b_o+i]; | |
au8[dst_o+1] = c; | |
dst_o += 2; | |
} | |
au8[dst_o] = bu8[b_o+n-1]; | |
} | |
} | |
function h$fps_maximum(a_v,a_o,n) { | |
if(n > 0) { | |
var au8 = a_v.u8, max = au8[a_o]; | |
for(var i=1;i<n;i++) { | |
var c = au8[a_o+i]; | |
if(c > max) { max = c; } | |
} | |
return max; | |
} | |
return 0; | |
} | |
function h$fps_minimum(a_v,a_o,n) { | |
if(n > 0) { | |
var au8 = a_v.u8, min = a_v.u8[a_o]; | |
for(var i=1;i<n;i++) { | |
var c = au8[a_o+i]; | |
if(c < min) { min = c; } | |
} | |
return min; | |
} | |
return 255; | |
} | |
function h$fps_count(a_v,a_o,n,c) { | |
if(n > 0) { | |
var au8 = a_v.u8, count = 0; | |
for(var i=0;i<n;i++) { | |
if(au8[a_o+i] === c) { count++; } | |
} | |
return count|0; | |
} | |
return 0; | |
} | |
function h$fps_memcpy_offsets(dst_d, dst_o, dst_off | |
, src_d, src_o, src_off, n) { | |
return memcpy(dst_d, dst_o + dst_off, src_d, src_o + src_off, n); | |
} | |
// translated from bytestring cbits/itoa.c | |
var h$_hs_bytestring_digits = [48,49,50,51,52,53,54,55,56,57,97,98,99,100,101,102]; // 0123456789abcdef | |
var h$_hs_bytestring_l10 = goog.math.Long.fromBits(10, 0); | |
var h$_hs_bytestring_b10 = h$bigFromInt(10); | |
// signed integers | |
function h$_hs_bytestring_int_dec(x, buf_d, buf_o) { | |
var c, ptr = buf_o, next_free, x_tmp; | |
var bu8 = buf_d.u8; | |
// we cannot negate directly as 0 - (minBound :: Int) = minBound | |
if(x < 0) { | |
bu8[ptr++] = 45; // '-' | |
buf_o++; | |
x_tmp = x; | |
x = (x / 10) | 0; | |
bu8[ptr++] = h$_hs_bytestring_digits[x * 10 - x_tmp]; | |
if(x === 0) { | |
h$ret1 = ptr; | |
return buf_d; | |
} else { | |
x = -x; | |
} | |
} | |
// encode positive number as little-endian decimal | |
do { | |
x_tmp = x; | |
x = (x / 10) | 0; | |
bu8[ptr++] = h$_hs_bytestring_digits[x_tmp - x * 10]; | |
} while (x); | |
next_free = ptr--; | |
while(buf_o < ptr) { | |
c = bu8[ptr]; | |
bu8[ptr--] = bu8[buf_o]; | |
bu8[buf_o++] = c; | |
} | |
h$ret1 = next_free; | |
return buf_d; | |
} | |
// signed long long ints (64 bit integers) | |
function h$_hs_bytestring_long_long_int_dec(x_a, x_b, buf_d, buf_o) { | |
var l10 = h$_hs_bytestring_l10; | |
var x = goog.math.Long.fromBits(x_b, x_a); | |
var c, ptr = buf_o, next_free; | |
var bu8 = buf_d.u8; | |
// we cannot negate directly as 0 - (minBound :: Int) = minBound | |
if(x.isNegative()) { | |
bu8[ptr++] = 45; // '-'; | |
buf_o++; | |
x_tmp = x; | |
x = x.div(l10); | |
bu8[ptr++] = h$_hs_bytestring_digits[x.multiply(l10).subtract(x_tmp).getLowBits()]; | |
if(x.isZero()) { | |
h$ret1 = ptr; | |
return buf_d; | |
} else { | |
x = x.negate(); | |
} | |
} | |
// encode positive number as little-endian decimal | |
do { | |
x_tmp = x; | |
x = x.div(l10); | |
bu8[ptr++] = h$_hs_bytestring_digits[x_tmp.subtract(x.multiply(l10))]; | |
} while (!x.isZero()); | |
// reverse written digits | |
next_free = ptr--; | |
while(buf_o < ptr) { | |
c = bu8[ptr]; | |
bu8[ptr--] = bu8[buf_o]; | |
bu8[buf_o++] = c; | |
} | |
h$ret1 = next_free; | |
return buf_d; | |
} | |
// unsigned integers | |
function h$_hs_bytestring_uint_dec(x, buf_d, buf_o) { | |
var c, ptr = buf_o, next_free; | |
var bu8 = buf_d.u8; | |
var x_tmp; | |
if(x < 0) x += 4294967296; | |
do { | |
x_tmp = x; | |
x = (x / 10) | 0; | |
bu8[ptr++] = h$_hs_bytestring_digits[x_tmp - x * 10]; | |
} while(x); | |
next_free = ptr--; | |
while(buf_o < ptr) { | |
c = bu8[ptr]; | |
bu8[ptr--] = bu8[buf_o]; | |
bu8[buf_o++] = c; | |
} | |
h$ret1 = next_free; | |
return buf_d; | |
} | |
function h$_hs_bytestring_long_long_uint_dec(x_a, x_b, buf_d, buf_o) { | |
var b10 = h$_hs_bytestring_b10; | |
var c, ptr = buf_o, next_free; | |
var bu8 = buf_d.u8; | |
var x = h$bigFromWord64(x_a, x_b), x_tmp; | |
// encode positive number as little-endian decimal | |
do { | |
x_tmp = x; | |
x = x.divide(b10); | |
bu8[ptr++] = h$_hs_bytestring_digits[x_tmp.subtract(x.multiply(b10))]; | |
} while(x.signum() !== 0); | |
// reverse written digits; | |
next_free = ptr--; | |
while(buf_o < ptr) { | |
c = bu8[ptr]; | |
bu8[ptr--] = bu8[buf_o]; | |
bu8[buf_o++] = c; | |
} | |
h$ret1 = next_free; | |
return buf_d; | |
} | |
// Padded, decimal, positive integers for the decimal output of bignums | |
/////////////////////////////////////////////////////////////////////// | |
// Padded (9 digits), decimal, positive int: | |
// We will use it with numbers that fit in 31 bits; i.e., numbers smaller than | |
// 10^9, as "31 * log 2 / log 10 = 9.33" | |
function h$_hs_bytestring_int_dec_padded9(x, buf_d, buf_o) { | |
var max_width_int32_dec = 9; | |
var ptr = buf_o + max_width_int32_dec; | |
var bu8 = buf_d.u8; | |
var x_tmp; | |
// encode positive number as little-endian decimal | |
do { | |
x_tmp = x; | |
x = (x / 10) | 0; | |
bu8[--ptr] = h$_hs_bytestring_digits[x_tmp - x * 10]; | |
} while(x); | |
// pad beginning | |
while (buf_o < ptr) { bu8[--ptr] = 48; } | |
} | |
// Padded (19 digits), decimal, positive long long int: | |
// We will use it with numbers that fit in 63 bits; i.e., numbers smaller than | |
// 10^18, as "63 * log 2 / log 10 = 18.96" | |
function h$_hs_bytestring_long_long_int_dec_padded18(x_a, x_b, buf_d, buf_o) { | |
var l10 = h$_hs_bytestring_l10; | |
var max_width_int64_dec = 18; | |
var ptr = buf_o + max_width_int64_dec; | |
var bu8 = buf_d.u8; | |
var x = goog.math.Long.fromBits(x_b, x_a); | |
// encode positive number as little-endian decimal | |
do { | |
x_tmp = x; | |
x = x.div(l10); | |
bu8[--ptr] = h$_hs_bytestring_digits[x_tmp.subtract(x.multiply(l10))]; | |
} while (!x.isZero()); | |
// pad beginning | |
while (buf_o < ptr) { bu8[--ptr] = 48; } | |
} | |
/////////////////////// | |
// Hexadecimal encoding | |
/////////////////////// | |
// unsigned ints (32 bit words) | |
function h$_hs_bytestring_uint_hex(x, buf_d, buf_o) { | |
var c, ptr = buf_o, next_free; | |
var bu8 = buf_d.u8; | |
// write hex representation in reverse order | |
do { | |
bu8[ptr++] = h$_hs_bytestring_digits[x & 0xf]; | |
x >>>= 4; | |
} while(x); | |
// invert written digits | |
next_free = ptr--; | |
while(buf_o < ptr) { | |
c = bu8[ptr]; | |
bu8[ptr--] = bu8[buf_o]; | |
bu8[buf_o++] = c; | |
} | |
h$ret1 = next_free; | |
return buf_d; | |
} | |
// unsigned long ints (64 bit words) | |
function h$_hs_bytestring_long_long_uint_hex(x_a, x_b, buf_d, buf_o) { | |
// write hex representation in reverse order | |
var c, ptr = buf_o, next_free; | |
var bu8 = buf_d.u8; | |
if(x_a === 0 && x_b === 0) { | |
bu8[ptr++] = 48; // '0' | |
} else { | |
while(x_b !== 0) { | |
bu8[ptr++] = h$_hs_bytestring_digits[x_b & 0xf]; | |
x_b >>>= 4; | |
} | |
while(x_a !== 0) { | |
bu8[ptr++] = h$_hs_bytestring_digits[x_a & 0xf]; | |
x_a >>>= 4; | |
} | |
} | |
// invert written digits | |
next_free = ptr--; | |
while(buf_o < ptr) { | |
c = bu8[ptr]; | |
bu8[ptr--] = bu8[buf_o]; | |
bu8[buf_o++] = c; | |
} | |
h$ret1 = next_free; | |
return buf_d; | |
} | |
// Copyright 2011 The Closure Library Authors. All Rights Reserved. | |
// | |
// Licensed under the Apache License, Version 2.0 (the "License"); | |
// you may not use this file except in compliance with the License. | |
// You may obtain a copy of the License at | |
// | |
// http://www.apache.org/licenses/LICENSE-2.0 | |
// | |
// Unless required by applicable law or agreed to in writing, software | |
// distributed under the License is distributed on an "AS-IS" BASIS, | |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
// See the License for the specific language governing permissions and | |
// limitations under the License. | |
/** | |
* @fileoverview Abstract cryptographic hash interface. | |
* | |
* See goog.crypt.Sha1 and goog.crypt.Md5 for sample implementations. | |
* | |
*/ | |
goog.provide('goog.crypt.Hash'); | |
/** | |
* Create a cryptographic hash instance. | |
* | |
* @constructor | |
* @struct | |
*/ | |
goog.crypt.Hash = function() { | |
/** | |
* The block size for the hasher. | |
* @type {number} | |
*/ | |
this.blockSize = -1; | |
}; | |
/** | |
* Resets the internal accumulator. | |
*/ | |
goog.crypt.Hash.prototype.reset = goog.abstractMethod; | |
/** | |
* Adds a byte array (array with values in [0-255] range) or a string (might | |
* only contain 8-bit, i.e., Latin1 characters) to the internal accumulator. | |
* | |
* Many hash functions operate on blocks of data and implement optimizations | |
* when a full chunk of data is readily available. Hence it is often preferable | |
* to provide large chunks of data (a kilobyte or more) than to repeatedly | |
* call the update method with few tens of bytes. If this is not possible, or | |
* not feasible, it might be good to provide data in multiplies of hash block | |
* size (often 64 bytes). Please see the implementation and performance tests | |
* of your favourite hash. | |
* | |
* @param {Array<number>|Uint8Array|string} bytes Data used for the update. | |
* @param {number=} opt_length Number of bytes to use. | |
*/ | |
goog.crypt.Hash.prototype.update = goog.abstractMethod; | |
/** | |
* @return {!Array<number>} The finalized hash computed | |
* from the internal accumulator. | |
*/ | |
goog.crypt.Hash.prototype.digest = goog.abstractMethod; | |
// Copyright 2011 The Closure Library Authors. All Rights Reserved. | |
// | |
// Licensed under the Apache License, Version 2.0 (the "License"); | |
// you may not use this file except in compliance with the License. | |
// You may obtain a copy of the License at | |
// | |
// http://www.apache.org/licenses/LICENSE-2.0 | |
// | |
// Unless required by applicable law or agreed to in writing, software | |
// distributed under the License is distributed on an "AS-IS" BASIS, | |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
// See the License for the specific language governing permissions and | |
// limitations under the License. | |
/** | |
* @fileoverview MD5 cryptographic hash. | |
* Implementation of http://tools.ietf.org/html/rfc1321 with common | |
* optimizations and tweaks (see http://en.wikipedia.org/wiki/MD5). | |
* | |
* Usage: | |
* var md5 = new goog.crypt.Md5(); | |
* md5.update(bytes); | |
* var hash = md5.digest(); | |
* | |
* Performance: | |
* Chrome 23 ~680 Mbit/s | |
* Chrome 13 (in a VM) ~250 Mbit/s | |
* Firefox 6.0 (in a VM) ~100 Mbit/s | |
* IE9 (in a VM) ~27 Mbit/s | |
* Firefox 3.6 ~15 Mbit/s | |
* IE8 (in a VM) ~13 Mbit/s | |
* | |
*/ | |
goog.provide('goog.crypt.Md5'); | |
goog.require('goog.crypt.Hash'); | |
/** | |
* MD5 cryptographic hash constructor. | |
* @constructor | |
* @extends {goog.crypt.Hash} | |
* @final | |
* @struct | |
*/ | |
goog.crypt.Md5 = function() { | |
goog.crypt.Md5.base(this, 'constructor'); | |
this.blockSize = 512 / 8; | |
/** | |
* Holds the current values of accumulated A-D variables (MD buffer). | |
* @type {!Array<number>} | |
* @private | |
*/ | |
this.chain_ = new Array(4); | |
/** | |
* A buffer holding the data until the whole block can be processed. | |
* @type {!Array<number>} | |
* @private | |
*/ | |
this.block_ = new Array(this.blockSize); | |
/** | |
* The length of yet-unprocessed data as collected in the block. | |
* @type {number} | |
* @private | |
*/ | |
this.blockLength_ = 0; | |
/** | |
* The total length of the message so far. | |
* @type {number} | |
* @private | |
*/ | |
this.totalLength_ = 0; | |
this.reset(); | |
}; | |
goog.inherits(goog.crypt.Md5, goog.crypt.Hash); | |
/** | |
* Integer rotation constants used by the abbreviated implementation. | |
* They are hardcoded in the unrolled implementation, so it is left | |
* here commented out. | |
* @type {Array<number>} | |
* @private | |
* | |
goog.crypt.Md5.S_ = [ | |
7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, | |
5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, | |
4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, | |
6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 | |
]; | |
*/ | |
/** | |
* Sine function constants used by the abbreviated implementation. | |
* They are hardcoded in the unrolled implementation, so it is left | |
* here commented out. | |
* @type {Array<number>} | |
* @private | |
* | |
goog.crypt.Md5.T_ = [ | |
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, | |
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, | |
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, | |
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, | |
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, | |
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, | |
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, | |
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, | |
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, | |
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, | |
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, | |
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, | |
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, | |
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, | |
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, | |
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 | |
]; | |
*/ | |
/** @override */ | |
goog.crypt.Md5.prototype.reset = function() { | |
this.chain_[0] = 0x67452301; | |
this.chain_[1] = 0xefcdab89; | |
this.chain_[2] = 0x98badcfe; | |
this.chain_[3] = 0x10325476; | |
this.blockLength_ = 0; | |
this.totalLength_ = 0; | |
}; | |
/** | |
* Internal compress helper function. It takes a block of data (64 bytes) | |
* and updates the accumulator. | |
* @param {Array<number>|Uint8Array|string} buf The block to compress. | |
* @param {number=} opt_offset Offset of the block in the buffer. | |
* @private | |
*/ | |
goog.crypt.Md5.prototype.compress_ = function(buf, opt_offset) { | |
if (!opt_offset) { | |
opt_offset = 0; | |
} | |
// We allocate the array every time, but it's cheap in practice. | |
var X = new Array(16); | |
// Get 16 little endian words. It is not worth unrolling this for Chrome 11. | |
if (goog.isString(buf)) { | |
for (var i = 0; i < 16; ++i) { | |
X[i] = (buf.charCodeAt(opt_offset++)) | | |
(buf.charCodeAt(opt_offset++) << 8) | | |
(buf.charCodeAt(opt_offset++) << 16) | | |
(buf.charCodeAt(opt_offset++) << 24); | |
} | |
} else { | |
for (var i = 0; i < 16; ++i) { | |
X[i] = (buf[opt_offset++]) | | |
(buf[opt_offset++] << 8) | | |
(buf[opt_offset++] << 16) | | |
(buf[opt_offset++] << 24); | |
} | |
} | |
var A = this.chain_[0]; | |
var B = this.chain_[1]; | |
var C = this.chain_[2]; | |
var D = this.chain_[3]; | |
var sum = 0; | |
/* | |
* This is an abbreviated implementation, it is left here commented out for | |
* reference purposes. See below for an unrolled version in use. | |
* | |
var f, n, tmp; | |
for (var i = 0; i < 64; ++i) { | |
if (i < 16) { | |
f = (D ^ (B & (C ^ D))); | |
n = i; | |
} else if (i < 32) { | |
f = (C ^ (D & (B ^ C))); | |
n = (5 * i + 1) % 16; | |
} else if (i < 48) { | |
f = (B ^ C ^ D); | |
n = (3 * i + 5) % 16; | |
} else { | |
f = (C ^ (B | (~D))); | |
n = (7 * i) % 16; | |
} | |
tmp = D; | |
D = C; | |
C = B; | |
sum = (A + f + goog.crypt.Md5.T_[i] + X[n]) & 0xffffffff; | |
B += ((sum << goog.crypt.Md5.S_[i]) & 0xffffffff) | | |
(sum >>> (32 - goog.crypt.Md5.S_[i])); | |
A = tmp; | |
} | |
*/ | |
/* | |
* This is an unrolled MD5 implementation, which gives ~30% speedup compared | |
* to the abbreviated implementation above, as measured on Chrome 11. It is | |
* important to keep 32-bit croppings to minimum and inline the integer | |
* rotation. | |
*/ | |
sum = (A + (D ^ (B & (C ^ D))) + X[0] + 0xd76aa478) & 0xffffffff; | |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); | |
sum = (D + (C ^ (A & (B ^ C))) + X[1] + 0xe8c7b756) & 0xffffffff; | |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); | |
sum = (C + (B ^ (D & (A ^ B))) + X[2] + 0x242070db) & 0xffffffff; | |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); | |
sum = (B + (A ^ (C & (D ^ A))) + X[3] + 0xc1bdceee) & 0xffffffff; | |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); | |
sum = (A + (D ^ (B & (C ^ D))) + X[4] + 0xf57c0faf) & 0xffffffff; | |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); | |
sum = (D + (C ^ (A & (B ^ C))) + X[5] + 0x4787c62a) & 0xffffffff; | |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); | |
sum = (C + (B ^ (D & (A ^ B))) + X[6] + 0xa8304613) & 0xffffffff; | |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); | |
sum = (B + (A ^ (C & (D ^ A))) + X[7] + 0xfd469501) & 0xffffffff; | |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); | |
sum = (A + (D ^ (B & (C ^ D))) + X[8] + 0x698098d8) & 0xffffffff; | |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); | |
sum = (D + (C ^ (A & (B ^ C))) + X[9] + 0x8b44f7af) & 0xffffffff; | |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); | |
sum = (C + (B ^ (D & (A ^ B))) + X[10] + 0xffff5bb1) & 0xffffffff; | |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); | |
sum = (B + (A ^ (C & (D ^ A))) + X[11] + 0x895cd7be) & 0xffffffff; | |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); | |
sum = (A + (D ^ (B & (C ^ D))) + X[12] + 0x6b901122) & 0xffffffff; | |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); | |
sum = (D + (C ^ (A & (B ^ C))) + X[13] + 0xfd987193) & 0xffffffff; | |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); | |
sum = (C + (B ^ (D & (A ^ B))) + X[14] + 0xa679438e) & 0xffffffff; | |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); | |
sum = (B + (A ^ (C & (D ^ A))) + X[15] + 0x49b40821) & 0xffffffff; | |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); | |
sum = (A + (C ^ (D & (B ^ C))) + X[1] + 0xf61e2562) & 0xffffffff; | |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); | |
sum = (D + (B ^ (C & (A ^ B))) + X[6] + 0xc040b340) & 0xffffffff; | |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); | |
sum = (C + (A ^ (B & (D ^ A))) + X[11] + 0x265e5a51) & 0xffffffff; | |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); | |
sum = (B + (D ^ (A & (C ^ D))) + X[0] + 0xe9b6c7aa) & 0xffffffff; | |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); | |
sum = (A + (C ^ (D & (B ^ C))) + X[5] + 0xd62f105d) & 0xffffffff; | |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); | |
sum = (D + (B ^ (C & (A ^ B))) + X[10] + 0x02441453) & 0xffffffff; | |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); | |
sum = (C + (A ^ (B & (D ^ A))) + X[15] + 0xd8a1e681) & 0xffffffff; | |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); | |
sum = (B + (D ^ (A & (C ^ D))) + X[4] + 0xe7d3fbc8) & 0xffffffff; | |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); | |
sum = (A + (C ^ (D & (B ^ C))) + X[9] + 0x21e1cde6) & 0xffffffff; | |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); | |
sum = (D + (B ^ (C & (A ^ B))) + X[14] + 0xc33707d6) & 0xffffffff; | |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); | |
sum = (C + (A ^ (B & (D ^ A))) + X[3] + 0xf4d50d87) & 0xffffffff; | |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); | |
sum = (B + (D ^ (A & (C ^ D))) + X[8] + 0x455a14ed) & 0xffffffff; | |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); | |
sum = (A + (C ^ (D & (B ^ C))) + X[13] + 0xa9e3e905) & 0xffffffff; | |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); | |
sum = (D + (B ^ (C & (A ^ B))) + X[2] + 0xfcefa3f8) & 0xffffffff; | |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); | |
sum = (C + (A ^ (B & (D ^ A))) + X[7] + 0x676f02d9) & 0xffffffff; | |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); | |
sum = (B + (D ^ (A & (C ^ D))) + X[12] + 0x8d2a4c8a) & 0xffffffff; | |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); | |
sum = (A + (B ^ C ^ D) + X[5] + 0xfffa3942) & 0xffffffff; | |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); | |
sum = (D + (A ^ B ^ C) + X[8] + 0x8771f681) & 0xffffffff; | |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); | |
sum = (C + (D ^ A ^ B) + X[11] + 0x6d9d6122) & 0xffffffff; | |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); | |
sum = (B + (C ^ D ^ A) + X[14] + 0xfde5380c) & 0xffffffff; | |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); | |
sum = (A + (B ^ C ^ D) + X[1] + 0xa4beea44) & 0xffffffff; | |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); | |
sum = (D + (A ^ B ^ C) + X[4] + 0x4bdecfa9) & 0xffffffff; | |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); | |
sum = (C + (D ^ A ^ B) + X[7] + 0xf6bb4b60) & 0xffffffff; | |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); | |
sum = (B + (C ^ D ^ A) + X[10] + 0xbebfbc70) & 0xffffffff; | |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); | |
sum = (A + (B ^ C ^ D) + X[13] + 0x289b7ec6) & 0xffffffff; | |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); | |
sum = (D + (A ^ B ^ C) + X[0] + 0xeaa127fa) & 0xffffffff; | |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); | |
sum = (C + (D ^ A ^ B) + X[3] + 0xd4ef3085) & 0xffffffff; | |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); | |
sum = (B + (C ^ D ^ A) + X[6] + 0x04881d05) & 0xffffffff; | |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); | |
sum = (A + (B ^ C ^ D) + X[9] + 0xd9d4d039) & 0xffffffff; | |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); | |
sum = (D + (A ^ B ^ C) + X[12] + 0xe6db99e5) & 0xffffffff; | |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); | |
sum = (C + (D ^ A ^ B) + X[15] + 0x1fa27cf8) & 0xffffffff; | |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); | |
sum = (B + (C ^ D ^ A) + X[2] + 0xc4ac5665) & 0xffffffff; | |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); | |
sum = (A + (C ^ (B | (~D))) + X[0] + 0xf4292244) & 0xffffffff; | |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); | |
sum = (D + (B ^ (A | (~C))) + X[7] + 0x432aff97) & 0xffffffff; | |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); | |
sum = (C + (A ^ (D | (~B))) + X[14] + 0xab9423a7) & 0xffffffff; | |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); | |
sum = (B + (D ^ (C | (~A))) + X[5] + 0xfc93a039) & 0xffffffff; | |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); | |
sum = (A + (C ^ (B | (~D))) + X[12] + 0x655b59c3) & 0xffffffff; | |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); | |
sum = (D + (B ^ (A | (~C))) + X[3] + 0x8f0ccc92) & 0xffffffff; | |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); | |
sum = (C + (A ^ (D | (~B))) + X[10] + 0xffeff47d) & 0xffffffff; | |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); | |
sum = (B + (D ^ (C | (~A))) + X[1] + 0x85845dd1) & 0xffffffff; | |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); | |
sum = (A + (C ^ (B | (~D))) + X[8] + 0x6fa87e4f) & 0xffffffff; | |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); | |
sum = (D + (B ^ (A | (~C))) + X[15] + 0xfe2ce6e0) & 0xffffffff; | |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); | |
sum = (C + (A ^ (D | (~B))) + X[6] + 0xa3014314) & 0xffffffff; | |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); | |
sum = (B + (D ^ (C | (~A))) + X[13] + 0x4e0811a1) & 0xffffffff; | |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); | |
sum = (A + (C ^ (B | (~D))) + X[4] + 0xf7537e82) & 0xffffffff; | |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); | |
sum = (D + (B ^ (A | (~C))) + X[11] + 0xbd3af235) & 0xffffffff; | |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); | |
sum = (C + (A ^ (D | (~B))) + X[2] + 0x2ad7d2bb) & 0xffffffff; | |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); | |
sum = (B + (D ^ (C | (~A))) + X[9] + 0xeb86d391) & 0xffffffff; | |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); | |
this.chain_[0] = (this.chain_[0] + A) & 0xffffffff; | |
this.chain_[1] = (this.chain_[1] + B) & 0xffffffff; | |
this.chain_[2] = (this.chain_[2] + C) & 0xffffffff; | |
this.chain_[3] = (this.chain_[3] + D) & 0xffffffff; | |
}; | |
/** @override */ | |
goog.crypt.Md5.prototype.update = function(bytes, opt_length) { | |
if (!goog.isDef(opt_length)) { | |
opt_length = bytes.length; | |
} | |
var lengthMinusBlock = opt_length - this.blockSize; | |
// Copy some object properties to local variables in order to save on access | |
// time from inside the loop (~10% speedup was observed on Chrome 11). | |
var block = this.block_; | |
var blockLength = this.blockLength_; | |
var i = 0; | |
// The outer while loop should execute at most twice. | |
while (i < opt_length) { | |
// When we have no data in the block to top up, we can directly process the | |
// input buffer (assuming it contains sufficient data). This gives ~30% | |
// speedup on Chrome 14 and ~70% speedup on Firefox 6.0, but requires that | |
// the data is provided in large chunks (or in multiples of 64 bytes). | |
if (blockLength == 0) { | |
while (i <= lengthMinusBlock) { | |
this.compress_(bytes, i); | |
i += this.blockSize; | |
} | |
} | |
if (goog.isString(bytes)) { | |
while (i < opt_length) { | |
block[blockLength++] = bytes.charCodeAt(i++); | |
if (blockLength == this.blockSize) { | |
this.compress_(block); | |
blockLength = 0; | |
// Jump to the outer loop so we use the full-block optimization. | |
break; | |
} | |
} | |
} else { | |
while (i < opt_length) { | |
block[blockLength++] = bytes[i++]; | |
if (blockLength == this.blockSize) { | |
this.compress_(block); | |
blockLength = 0; | |
// Jump to the outer loop so we use the full-block optimization. | |
break; | |
} | |
} | |
} | |
} | |
this.blockLength_ = blockLength; | |
this.totalLength_ += opt_length; | |
}; | |
/** @override */ | |
goog.crypt.Md5.prototype.digest = function() { | |
// This must accommodate at least 1 padding byte (0x80), 8 bytes of | |
// total bitlength, and must end at a 64-byte boundary. | |
var pad = new Array((this.blockLength_ < 56 ? | |
this.blockSize : | |
this.blockSize * 2) - this.blockLength_); | |
// Add padding: 0x80 0x00* | |
pad[0] = 0x80; | |
for (var i = 1; i < pad.length - 8; ++i) { | |
pad[i] = 0; | |
} | |
// Add the total number of bits, little endian 64-bit integer. | |
var totalBits = this.totalLength_ * 8; | |
for (var i = pad.length - 8; i < pad.length; ++i) { | |
pad[i] = totalBits & 0xff; | |
totalBits /= 0x100; // Don't use bit-shifting here! | |
} | |
this.update(pad); | |
var digest = new Array(16); | |
var n = 0; | |
for (var i = 0; i < 4; ++i) { | |
for (var j = 0; j < 32; j += 8) { | |
digest[n++] = (this.chain_[i] >>> j) & 0xff; | |
} | |
} | |
return digest; | |
}; | |
/* include/HsBaseConfig.h. Generated from HsBaseConfig.h.in by configure. */ | |
/* include/HsBaseConfig.h.in. Generated from configure.ac by autoheader. */ | |
/* The value of E2BIG. */ | |
/* The value of EACCES. */ | |
/* The value of EADDRINUSE. */ | |
/* The value of EADDRNOTAVAIL. */ | |
/* The value of EADV. */ | |
/* The value of EAFNOSUPPORT. */ | |
/* The value of EAGAIN. */ | |
/* The value of EALREADY. */ | |
/* The value of EBADF. */ | |
/* The value of EBADMSG. */ | |
/* The value of EBADRPC. */ | |
/* The value of EBUSY. */ | |
/* The value of ECHILD. */ | |
/* The value of ECOMM. */ | |
/* The value of ECONNABORTED. */ | |
/* The value of ECONNREFUSED. */ | |
/* The value of ECONNRESET. */ | |
/* The value of EDEADLK. */ | |
/* The value of EDESTADDRREQ. */ | |
/* The value of EDIRTY. */ | |
/* The value of EDOM. */ | |
/* The value of EDQUOT. */ | |
/* The value of EEXIST. */ | |
/* The value of EFAULT. */ | |
/* The value of EFBIG. */ | |
/* The value of EFTYPE. */ | |
/* The value of EHOSTDOWN. */ | |
/* The value of EHOSTUNREACH. */ | |
/* The value of EIDRM. */ | |
/* The value of EILSEQ. */ | |
/* The value of EINPROGRESS. */ | |
/* The value of EINTR. */ | |
/* The value of EINVAL. */ | |
/* The value of EIO. */ | |
/* The value of EISCONN. */ | |
/* The value of EISDIR. */ | |
/* The value of ELOOP. */ | |
/* The value of EMFILE. */ | |
/* The value of EMLINK. */ | |
/* The value of EMSGSIZE. */ | |
/* The value of EMULTIHOP. */ | |
/* The value of ENAMETOOLONG. */ | |
/* The value of ENETDOWN. */ | |
/* The value of ENETRESET. */ | |
/* The value of ENETUNREACH. */ | |
/* The value of ENFILE. */ | |
/* The value of ENOBUFS. */ | |
/* The value of ENOCIGAR. */ | |
/* The value of ENODATA. */ | |
/* The value of ENODEV. */ | |
/* The value of ENOENT. */ | |
/* The value of ENOEXEC. */ | |
/* The value of ENOLCK. */ | |
/* The value of ENOLINK. */ | |
/* The value of ENOMEM. */ | |
/* The value of ENOMSG. */ | |
/* The value of ENONET. */ | |
/* The value of ENOPROTOOPT. */ | |
/* The value of ENOSPC. */ | |
/* The value of ENOSR. */ | |
/* The value of ENOSTR. */ | |
/* The value of ENOSYS. */ | |
/* The value of ENOTBLK. */ | |
/* The value of ENOTCONN. */ | |
/* The value of ENOTDIR. */ | |
/* The value of ENOTEMPTY. */ | |
/* The value of ENOTSOCK. */ | |
/* The value of ENOTSUP. */ | |
/* The value of ENOTTY. */ | |
/* The value of ENXIO. */ | |
/* The value of EOPNOTSUPP. */ | |
/* The value of EPERM. */ | |
/* The value of EPFNOSUPPORT. */ | |
/* The value of EPIPE. */ | |
/* The value of EPROCLIM. */ | |
/* The value of EPROCUNAVAIL. */ | |
/* The value of EPROGMISMATCH. */ | |
/* The value of EPROGUNAVAIL. */ | |
/* The value of EPROTO. */ | |
/* The value of EPROTONOSUPPORT. */ | |
/* The value of EPROTOTYPE. */ | |
/* The value of ERANGE. */ | |
/* The value of EREMCHG. */ | |
/* The value of EREMOTE. */ | |
/* The value of EROFS. */ | |
/* The value of ERPCMISMATCH. */ | |
/* The value of ERREMOTE. */ | |
/* The value of ESHUTDOWN. */ | |
/* The value of ESOCKTNOSUPPORT. */ | |
/* The value of ESPIPE. */ | |
/* The value of ESRCH. */ | |
/* The value of ESRMNT. */ | |
/* The value of ESTALE. */ | |
/* The value of ETIME. */ | |
/* The value of ETIMEDOUT. */ | |
/* The value of ETOOMANYREFS. */ | |
/* The value of ETXTBSY. */ | |
/* The value of EUSERS. */ | |
/* The value of EWOULDBLOCK. */ | |
/* The value of EXDEV. */ | |
/* The value of O_BINARY. */ | |
/* The value of SIGINT. */ | |
/* Define to 1 if you have the `clock_gettime' function. */ | |
/* #undef HAVE_CLOCK_GETTIME */ | |
/* Define to 1 if you have the <ctype.h> header file. */ | |
/* Define if you have epoll support. */ | |
/* #undef HAVE_EPOLL */ | |
/* Define to 1 if you have the `epoll_ctl' function. */ | |
/* #undef HAVE_EPOLL_CTL */ | |
/* Define to 1 if you have the <errno.h> header file. */ | |
/* Define to 1 if you have the `eventfd' function. */ | |
/* #undef HAVE_EVENTFD */ | |
/* Define to 1 if you have the <fcntl.h> header file. */ | |
/* Define to 1 if you have the `ftruncate' function. */ | |
/* Define to 1 if you have the `getclock' function. */ | |
/* #undef HAVE_GETCLOCK */ | |
/* Define to 1 if you have the `getrusage' function. */ | |
/* Define to 1 if you have the <inttypes.h> header file. */ | |
/* Define to 1 if you have the `iswspace' function. */ | |
/* Define to 1 if you have the `kevent' function. */ | |
/* Define to 1 if you have the `kevent64' function. */ | |
/* Define if you have kqueue support. */ | |
/* Define to 1 if you have the <langinfo.h> header file. */ | |
/* Define to 1 if you have libcharset. */ | |
/* Define to 1 if you have the `rt' library (-lrt). */ | |
/* #undef HAVE_LIBRT */ | |
/* Define to 1 if you have the <limits.h> header file. */ | |
/* Define to 1 if the system has the type `long long'. */ | |
/* Define to 1 if you have the `lstat' function. */ | |
/* Define to 1 if you have the <memory.h> header file. */ | |
/* Define if you have poll support. */ | |
/* Define to 1 if you have the <poll.h> header file. */ | |
/* Define to 1 if you have the <signal.h> header file. */ | |
/* Define to 1 if you have the <stdint.h> header file. */ | |
/* Define to 1 if you have the <stdlib.h> header file. */ | |
/* Define to 1 if you have the <strings.h> header file. */ | |
/* Define to 1 if you have the <string.h> header file. */ | |
/* Define to 1 if you have the <sys/epoll.h> header file. */ | |
/* #undef HAVE_SYS_EPOLL_H */ | |
/* Define to 1 if you have the <sys/eventfd.h> header file. */ | |
/* #undef HAVE_SYS_EVENTFD_H */ | |
/* Define to 1 if you have the <sys/event.h> header file. */ | |
/* Define to 1 if you have the <sys/resource.h> header file. */ | |
/* Define to 1 if you have the <sys/select.h> header file. */ | |
/* Define to 1 if you have the <sys/stat.h> header file. */ | |
/* Define to 1 if you have the <sys/syscall.h> header file. */ | |
/* Define to 1 if you have the <sys/timeb.h> header file. */ | |
/* Define to 1 if you have the <sys/timers.h> header file. */ | |
/* #undef HAVE_SYS_TIMERS_H */ | |
/* Define to 1 if you have the <sys/times.h> header file. */ | |
/* Define to 1 if you have the <sys/time.h> header file. */ | |
/* Define to 1 if you have the <sys/types.h> header file. */ | |
/* Define to 1 if you have the <sys/utsname.h> header file. */ | |
/* Define to 1 if you have the <sys/wait.h> header file. */ | |
/* Define to 1 if you have the <termios.h> header file. */ | |
/* Define to 1 if you have the `times' function. */ | |
/* Define to 1 if you have the <time.h> header file. */ | |
/* Define to 1 if you have the <unistd.h> header file. */ | |
/* Define to 1 if you have the <utime.h> header file. */ | |
/* Define to 1 if you have the <wctype.h> header file. */ | |
/* Define to 1 if you have the <windows.h> header file. */ | |
/* #undef HAVE_WINDOWS_H */ | |
/* Define to 1 if you have the <winsock.h> header file. */ | |
/* #undef HAVE_WINSOCK_H */ | |
/* Define to 1 if you have the `_chsize' function. */ | |
/* #undef HAVE__CHSIZE */ | |
/* Define to Haskell type for cc_t */ | |
/* Define to Haskell type for char */ | |
/* Define to Haskell type for clock_t */ | |
/* Define to Haskell type for dev_t */ | |
/* Define to Haskell type for double */ | |
/* Define to Haskell type for float */ | |
/* Define to Haskell type for gid_t */ | |
/* Define to Haskell type for ino_t */ | |
/* Define to Haskell type for int */ | |
/* Define to Haskell type for intmax_t */ | |
/* Define to Haskell type for intptr_t */ | |
/* Define to Haskell type for long */ | |
/* Define to Haskell type for long long */ | |
/* Define to Haskell type for mode_t */ | |
/* Define to Haskell type for nlink_t */ | |
/* Define to Haskell type for off_t */ | |
/* Define to Haskell type for pid_t */ | |
/* Define to Haskell type for ptrdiff_t */ | |
/* Define to Haskell type for rlim_t */ | |
/* Define to Haskell type for short */ | |
/* Define to Haskell type for signed char */ | |
/* Define to Haskell type for sig_atomic_t */ | |
/* Define to Haskell type for size_t */ | |
/* Define to Haskell type for speed_t */ | |
/* Define to Haskell type for ssize_t */ | |
/* Define to Haskell type for suseconds_t */ | |
/* Define to Haskell type for tcflag_t */ | |
/* Define to Haskell type for time_t */ | |
/* Define to Haskell type for uid_t */ | |
/* Define to Haskell type for uintmax_t */ | |
/* Define to Haskell type for uintptr_t */ | |
/* Define to Haskell type for unsigned char */ | |
/* Define to Haskell type for unsigned int */ | |
/* Define to Haskell type for unsigned long */ | |
/* Define to Haskell type for unsigned long long */ | |
/* Define to Haskell type for unsigned short */ | |
/* Define to Haskell type for useconds_t */ | |
/* Define to Haskell type for wchar_t */ | |
/* Define to the address where bug reports for this package should be sent. */ | |
/* Define to the full name of this package. */ | |
/* Define to the full name and version of this package. */ | |
/* Define to the one symbol short name of this package. */ | |
/* Define to the home page for this package. */ | |
/* Define to the version of this package. */ | |
/* The size of `kev.filter', as computed by sizeof. */ | |
/* The size of `kev.flags', as computed by sizeof. */ | |
/* The size of `struct MD5Context', as computed by sizeof. */ | |
/* Define to 1 if you have the ANSI C header files. */ | |
/* Number of bits in a file offset, on hosts where this is settable. */ | |
/* #undef _FILE_OFFSET_BITS */ | |
/* Define for large files, on AIX-style hosts. */ | |
/* #undef _LARGE_FILES */ | |
// #define GHCJS_TRACE_IO 1 | |
function h$base_access(file, file_off, mode, c) { | |
; | |
if(h$isNode) { | |
h$fs.stat(fd, function(err, fs) { | |
if(err) { | |
h$handleErrnoC(err, -1, 0, c); | |
} else { | |
c(mode & fs.mode); // fixme is this ok? | |
} | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_chmod(file, file_off, mode, c) { | |
; | |
if(h$isNode) { | |
h$fs.chmod(h$decodeUtf8z(file, file_off), mode, function(err) { | |
h$handleErrnoC(err, -1, 0, c); | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_close(fd, c) { | |
; | |
var fdo = h$base_fds[fd]; | |
if(fdo && fdo.close) { | |
fdo.close(fd, fdo, c); | |
} else { | |
h$errno = 22; | |
c(-1); | |
} | |
} | |
function h$base_dup(fd, something, c) { | |
throw "h$base_dup"; | |
} | |
function h$base_dup2(fd, c) { | |
throw "h$base_dup2"; | |
} | |
function h$base_fstat(fd, stat, stat_off, c) { | |
; | |
if(h$isNode) { | |
h$fs.fstat(fd, function(err, fs) { | |
if(err) { | |
h$handlErrnoC(err, -1, 0, c); | |
} else { | |
h$base_fillStat(fs, stat, stat_off); | |
c(0); | |
} | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_isatty(fd) { | |
; | |
if(h$isNode) { | |
if(fd === 0) return process.stdin.isTTY?1:0; | |
if(fd === 1) return process.stdout.isTTY?1:0; | |
if(fd === 2) return process.stderr.isTTY?1:0; | |
} | |
if(fd === 1 || fd === 2) return 1; | |
return 0; | |
} | |
function h$base_lseek(fd, pos_1, pos_2, whence, c) { | |
; | |
if(h$isNode) { | |
var p = goog.math.Long.fromBits(pos_2, pos_1), p1; | |
var o = h$base_fds[fd]; | |
if(!o) { | |
h$errno = CONST_BADF; | |
c(-1,-1); | |
} else { | |
switch(whence) { | |
case 0: /* SET */ | |
o.pos = p.toNumber(); | |
c(p.getHighBits(), p.getLowBits()); | |
break; | |
case 1: /* CUR */ | |
o.pos += p.toNumber(); | |
p1 = goog.math.Long.fromNumber(o.pos); | |
c(p1.getHighBits(), p1.getLowBits()); | |
break; | |
case 2: /* END */ | |
h$fs.fstat(fd, function(err, fs) { | |
if(err) { | |
h$setErrno(err); | |
c(-1,-1); | |
} else { | |
o.pos = fs.size + p.toNumber(); | |
p1 = goog.math.Long.fromNumber(o.pos); | |
c(p1.getHighBits(), p1.getLowBits()); | |
} | |
}); | |
break; | |
default: | |
h$errno = 22; | |
c(-1,-1); | |
} | |
} | |
} else { | |
h$unsupported(); | |
c(-1, -1); | |
} | |
} | |
function h$base_lstat(file, file_off, stat, stat_off, c) { | |
; | |
if(h$isNode) { | |
h$fs.lstat(h$decodeUtf8z(file, file_off), function(err, fs) { | |
if(err) { | |
h$handleErrnoC(err, -1, 0, c); | |
} else { | |
h$base_fillStat(fs, stat, stat_off); | |
c(0); | |
} | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_open(file, file_off, how, mode, c) { | |
if(h$isNode) { | |
var flags, off; | |
var fp = h$decodeUtf8z(file, file_off); | |
var acc = how & h$base_o_accmode; | |
// passing a number lets node.js use it directly as the flags (undocumented) | |
if(acc === h$base_o_rdonly) { | |
flags = h$processConstants['O_RDONLY']; | |
} else if(acc === h$base_o_wronly) { | |
flags = h$processConstants['O_WRONLY']; | |
} else { // r+w | |
flags = h$processConstants['O_RDWR']; | |
} | |
off = (how & h$base_o_append) ? -1 : 0; | |
flags = flags | ((how & h$base_o_trunc) ? h$processConstants['O_TRUNC'] : 0) | |
| ((how & h$base_o_creat) ? h$processConstants['O_CREAT'] : 0) | |
| ((how & h$base_o_excl) ? h$processConstants['O_EXCL'] : 0) | |
| ((how & h$base_o_append) ? h$processConstants['O_APPEND'] : 0); | |
h$fs.open(fp, flags, mode, function(err, fd) { | |
if(err) { | |
h$handleErrnoC(err, -1, 0, c); | |
} else { | |
var f = function(p) { | |
h$base_fds[fd] = { read: h$base_readFile | |
, write: h$base_writeFile | |
, close: h$base_closeFile | |
, pos: p | |
}; | |
c(fd); | |
} | |
if(off === -1) { | |
h$fs.stat(fp, function(err, fs) { | |
if(err) h$handleErrnoC(err, -1, 0, c); else f(fs.size); | |
}); | |
} else { | |
f(0); | |
} | |
} | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_read(fd, buf, buf_off, n, c) { | |
; | |
var fdo = h$base_fds[fd]; | |
if(fdo && fdo.read) { | |
fdo.read(fd, fdo, buf, buf_off, n, c); | |
} else { | |
h$errno = 22; | |
c(-1); | |
} | |
} | |
function h$base_stat(file, file_off, stat, stat_off, c) { | |
; | |
if(h$isNode) { | |
h$fs.stat(h$decodeUtf8z(file, file_off), function(err, fs) { | |
if(err) { | |
h$handlErrnoC(err, -1, 0, c); | |
} else { | |
h$base_fillStat(fs, stat, stat_off); | |
c(0); | |
} | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_umask(mode) { | |
; | |
if(h$isNode) return process.umask(mode); | |
return 0; | |
} | |
function h$base_write(fd, buf, buf_off, n, c) { | |
; | |
var fdo = h$base_fds[fd]; | |
if(fdo && fdo.write) { | |
fdo.write(fd, fdo, buf, buf_off, n, c); | |
} else { | |
h$errno = 22; | |
c(-1); | |
} | |
} | |
function h$base_ftruncate(fd, pos_1, pos_2, c) { | |
; | |
if(h$isNode) { | |
h$fs.ftruncate(fd, goog.math.Long.fromBits(pos_2, pos_1).toNumber(), function(err) { | |
h$handleErrnoC(err, -1, 0, c); | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_unlink(file, file_off, c) { | |
; | |
if(h$isNode) { | |
h$fs.unlink(h$decodeUtf8z(file, file_off), function(err) { | |
h$handleErrnoC(err, -1, 0, c); | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_getpid() { | |
; | |
if(h$isNode) return process.pid; | |
return 0; | |
} | |
function h$base_link(file1, file1_off, file2, file2_off, c) { | |
; | |
if(h$isNode) { | |
h$fs.link(h$decodeUtf8z(file1, file1_off), h$decodeUtf8z(file2, file2_off), function(err) { | |
h$handleErrnoC(err, -1, 0, c); | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_mkfifo(file, file_off, mode, c) { | |
throw "h$base_mkfifo"; | |
} | |
function h$base_sigemptyset(sigset, sigset_off) { | |
return 0; | |
// throw "h$base_sigemptyset"; | |
} | |
function h$base_sigaddset(sigset, sigset_off, sig) { | |
return 0; | |
// throw "h$base_sigaddset"; | |
} | |
function h$base_sigprocmask(sig, sigset1, sigset1_off, sigset2, sigset2_off) { | |
return 0; | |
// throw "h$base_sigprocmask"; | |
} | |
function h$base_tcgetattr(attr, termios, termios_off) { | |
return 0; | |
} | |
function h$base_tcsetattr(attr, val, termios, termios_off) { | |
return 0; | |
} | |
function h$base_utime(file, file_off, timbuf, timbuf_off, c) { | |
; | |
if(h$isNode) { | |
h$fs.fstat(h$decodeUtf8z(file, file_off), function(err, fs) { | |
if(err) { | |
h$handleErrnoC(err, 0, -1, c); // fixme | |
} else { | |
var atime = goog.math.Long.fromNumber(fs.atime.getTime()); | |
var mtime = goog.math.Long.fromNumber(fs.mtime.getTime()); | |
var ctime = goog.math.Long.fromNumber(fs.ctime.getTime()); | |
timbuf.i3[0] = atime.getHighBits(); | |
timbuf.i3[1] = atime.getLowBits(); | |
timbuf.i3[2] = mtime.getHighBits(); | |
timbuf.i3[3] = mtime.getLowBits(); | |
timbuf.i3[4] = ctime.getHighBits(); | |
timbuf.i3[5] = ctime.getLowBits(); | |
c(0); | |
} | |
}); | |
} else | |
h$unsupported(-1, c); | |
} | |
function h$base_waitpid(pid, stat, stat_off, options, c) { | |
throw "h$base_waitpid"; | |
} | |
/** @const */ var h$base_o_rdonly = 0x00000; | |
/** @const */ var h$base_o_wronly = 0x00001; | |
/** @const */ var h$base_o_rdwr = 0x00002; | |
/** @const */ var h$base_o_accmode = 0x00003; | |
/** @const */ var h$base_o_append = 0x00008; | |
/** @const */ var h$base_o_creat = 0x00200; | |
/** @const */ var h$base_o_trunc = 0x00400; | |
/** @const */ var h$base_o_excl = 0x00800; | |
/** @const */ var h$base_o_noctty = 0x20000; | |
/** @const */ var h$base_o_nonblock = 0x00004; | |
/** @const */ var h$base_o_binary = 0x00000; | |
function h$base_c_s_isreg(mode) { | |
return 1; | |
} | |
function h$base_c_s_ischr(mode) { | |
return 0; | |
} | |
function h$base_c_s_isblk(mode) { | |
return 0; | |
} | |
function h$base_c_s_isdir(mode) { | |
return 0; // fixme | |
} | |
function h$base_c_s_isfifo(mode) { | |
return 0; | |
} | |
function h$base_fillStat(fs, b, off) { | |
if(off%4) throw "h$base_fillStat: not aligned"; | |
var o = off>>2; | |
b.i3[o+0] = fs.mode; | |
var s = goog.math.Long.fromNumber(fs.size); | |
b.i3[o+1] = s.getHighBits(); | |
b.i3[o+2] = s.getLowBits(); | |
b.i3[o+3] = 0; // fixme | |
b.i3[o+4] = 0; // fixme | |
b.i3[o+5] = fs.dev; | |
var i = goog.math.Long.fromNumber(fs.ino); | |
b.i3[o+6] = i.getHighBits(); | |
b.i3[o+7] = i.getLowBits(); | |
b.i3[o+8] = fs.uid; | |
b.i3[o+9] = fs.gid; | |
} | |
// [mode,size1,size2,mtime1,mtime2,dev,ino1,ino2,uid,gid] all 32 bit | |
/** @const */ var h$base_sizeof_stat = 40; | |
function h$base_st_mtime(stat, stat_off) { | |
h$ret1 = stat.i3[(stat_off>>2)+4]; | |
return stat.i3[(stat_off>>2)+3]; | |
} | |
function h$base_st_size(stat, stat_off) { | |
h$ret1 = stat.i3[(stat_off>>2)+2]; | |
return stat.i3[(stat_off>>2)+1]; | |
} | |
function h$base_st_mode(stat, stat_off) { | |
return stat.i3[stat_off>>2]; | |
} | |
function h$base_st_dev(stat, stat_off) { | |
return stat.i3[(stat_off>>2)+5]; | |
} | |
function h$base_st_ino(stat, stat_off) { | |
h$ret1 = stat.i3[(stat_off>>2)+7]; | |
return stat.i3[(stat_off>>2)+6]; | |
} | |
/** @const */ var h$base_echo = 1; | |
/** @const */ var h$base_tcsanow = 2; | |
/** @const */ var h$base_icanon = 4; | |
/** @const */ var h$base_vmin = 8; | |
/** @const */ var h$base_vtime = 16; | |
/** @const */ var h$base_sigttou = 0; | |
/** @const */ var h$base_sig_block = 0; | |
/** @const */ var h$base_sig_setmask = 0; | |
/** @const */ var h$base_f_getfl = 0; | |
/** @const */ var h$base_f_setfl = 0; | |
/** @const */ var h$base_f_setfd = 0; | |
/** @const */ var h$base_fd_cloexec = 0; | |
/** @const */ var h$base_sizeof_termios = 4; | |
/** @const */ var h$base_sizeof_sigset_t = 4; | |
/** @const */ var h$base_lflag = 0; | |
function h$base_poke_lflag(termios, termios_off, flag) { | |
return 0; | |
} | |
function h$base_ptr_c_cc(termios, termios_off) { | |
h$ret1 = 0; | |
return h$newByteArray(8); | |
} | |
/** @const */ var h$base_default_buffer_size = 32768; | |
function h$base_c_s_issock(mode) { | |
return 0; // fixme | |
} | |
/** @const */ var h$base_SEEK_SET = 0; | |
/** @const */ var h$base_SEEK_CUR = 1; | |
/** @const */ var h$base_SEEK_END = 2; | |
function h$base_set_saved_termios(a, b, c) { | |
h$ret1 = 0 | |
return null; | |
} | |
function h$base_get_saved_termios(r) { | |
h$ret1 = 0; | |
return null; | |
} | |
// fixme | |
function h$lockFile(fd, dev, ino, for_writing) { | |
; | |
return 0; | |
} | |
function h$unlockFile(fd) { | |
; | |
return 0; | |
} | |
// engine-dependent setup | |
var h$base_readStdin, h$base_writeStderr, h$base_writeStdout; | |
var h$base_readFile, h$base_writeFile, h$base_closeFile; | |
var h$base_stdin_waiting = new h$Queue(); | |
var h$base_stdin_chunk = { buf: null | |
, pos: 0 | |
, processing: false | |
}; | |
var h$base_stdin_eof = false; | |
var h$base_process_stdin = function() { | |
var c = h$base_stdin_chunk; | |
var q = h$base_stdin_waiting; | |
if(!q.length() || c.processing) return; | |
c.processing = true; | |
if(!c.buf) { c.pos = 0; c.buf = process.stdin.read(); } | |
while(c.buf && q.length()) { | |
var x = q.dequeue(); | |
var n = Math.min(c.buf.length - c.pos, x.n); | |
for(var i=0;i<n;i++) { | |
x.buf.u8[i+x.off] = c.buf[c.pos+i]; | |
} | |
c.pos += n; | |
x.c(n); | |
if(c.pos >= c.buf.length) c.buf = null; | |
if(!c.buf && q.length()) { c.pos = 0; c.buf = process.stdin.read(); } | |
} | |
while(h$base_stdin_eof && q.length()) q.dequeue().c(0); | |
c.processing = false; | |
} | |
if(h$isNode) { | |
h$base_closeFile = function(fd, fdo, c) { | |
h$fs.close(fd, function(err) { | |
delete h$base_fds[fd]; | |
h$handleErrnoC(err, -1, 0, c); | |
}); | |
} | |
h$base_readFile = function(fd, fdo, buf, buf_offset, n, c) { | |
var pos = typeof fdo.pos === 'number' ? fdo.pos : null; | |
; | |
h$fs.read(fd, new Buffer(n), 0, n, pos, function(err, bytesRead, nbuf) { | |
if(err) { | |
h$setErrno(err); | |
c(-1); | |
} else { | |
for(var i=bytesRead-1;i>=0;i--) buf.u8[buf_offset+i] = nbuf[i]; | |
if(typeof fdo.pos === 'number') fdo.pos += bytesRead; | |
c(bytesRead); | |
} | |
}); | |
} | |
h$base_readStdin = function(fd, fdo, buf, buf_offset, n, c) { | |
; | |
h$base_stdin_waiting.enqueue({buf: buf, off: buf_offset, n: n, c: c}); | |
h$base_process_stdin(); | |
} | |
h$base_writeFile = function(fd, fdo, buf, buf_offset, n, c) { | |
var pos = typeof fdo.pos === 'number' ? fdo.pos : null; | |
; | |
var nbuf = new Buffer(n); | |
for(var i=0;i<n;i++) nbuf[i] = buf.u8[i+buf_offset]; | |
if(typeof fdo.pos === 'number') fdo.pos += n; | |
h$fs.write(fd, nbuf, 0, n, pos, function(err, bytesWritten) { | |
; | |
if(err) { | |
h$setErrno(err); | |
if(typeof fdo.pos === 'number') fdo.pos -= n; | |
if(h$errno === 35) | |
setTimeout(function() { h$base_writeFile(fd, fdo, buf, buf_offset, n, c); }, 20); | |
else c(-1); | |
} else { | |
if(typeof fdo.pos === 'number') fdo.pos += bytesWritten - n; | |
c(bytesWritten); | |
} | |
}); | |
} | |
h$base_writeStdout = function(fd, fdo, buf, buf_offset, n, c) { | |
; | |
h$base_writeFile(1, fdo, buf, buf_offset, n, c); | |
} | |
h$base_writeStderr = function(fd, fdo, buf, buf_offset, n, c) { | |
; | |
h$base_writeFile(2, fdo, buf, buf_offset, n, c); | |
} | |
process.stdin.on('readable', h$base_process_stdin); | |
process.stdin.on('end', function() { h$base_stdin_eof = true; h$base_process_stdin(); }); | |
} else if (h$isJsShell) { | |
h$base_readStdin = function(fd, fdo, buf, buf_offset, n, c) { | |
c(0); | |
} | |
h$base_writeStdout = function(fd, fdo, buf, buf_offset, n, c) { | |
putstr(h$decodeUtf8(buf, n, buf_offset)); | |
c(n); | |
} | |
h$base_writeStderr = function(fd, fdo, buf, buf_offset, n, c) { | |
printErr(h$decodeUtf8(buf, n, buf_offset)); | |
c(n); | |
} | |
} else if(h$isJsCore) { | |
h$base_readStdin = function(fd, fdo, buf, buf_offset, n, c) { | |
c(0); | |
} | |
var h$base_stdoutLeftover = { f: print, val: null }; | |
var h$base_stderrLeftover = { f: debug, val: null }; | |
var h$base_writeWithLeftover = function(buf, n, buf_offset, c, lo) { | |
var lines = h$decodeUtf8(buf, n, buf_offset).split(/\r?\n/); | |
if(lines.length === 1) { | |
if(lines[0].length) { | |
if(lo.val !== null) lo.val += lines[0]; | |
else lo.val = lines[0]; | |
} | |
} else { | |
lo.f(((lo.val !== null) ? lo.val : '') + lines[0]); | |
for(var i=1;i<lines.length-1;i++) lo.f(lines[i]); | |
if(lines[lines.length-1].length) lo.val = lines[lines.length-1]; | |
else lo.val = null; | |
} | |
c(n); | |
} | |
h$base_writeStdout = function(fd, fdo, buf, buf_offset, n, c) { | |
h$base_writeWithLeftover(buf, n, buf_offset, c, h$base_stdoutLeftover); | |
} | |
h$base_writeStderr = function(fd, fdo, buf, buf_offset, n, c) { | |
// writing to stderr not supported, write to stdout | |
h$base_writeWithLeftover(buf, n, buf_offset, c, h$base_stderrLeftover); | |
} | |
} else { // browser / fallback | |
h$base_readStdin = function(fd, fdo, buf, buf_offset, n, c) { | |
c(0); | |
} | |
h$base_writeStdout = function(fd, fdo, buf, buf_offset, n, c) { | |
console.log(h$decodeUtf8(buf, n, buf_offset)); | |
c(n); | |
} | |
h$base_writeStderr = function(fd, fdo, buf, buf_offset, n, c) { | |
console.log(h$decodeUtf8(buf, n, buf_offset)); | |
c(n); | |
} | |
} | |
var h$base_stdin_fd = { read: h$base_readStdin }; | |
var h$base_stdout_fd = { write: h$base_writeStdout }; | |
var h$base_stderr_fd = { write: h$base_writeStderr }; | |
var h$base_fdN = -1; // negative file descriptors are 'virtual' | |
var h$base_fds = [h$base_stdin_fd, h$base_stdout_fd, h$base_stderr_fd]; | |
function h$shutdownHaskellAndExit(code, fast) { | |
if(h$isNode) { | |
process.exit(code); | |
} else if(h$isJsShell) { | |
quit(code); | |
} else if(h$isJsCore) { | |
if(h$base_stdoutLeftover.val !== null) print(h$base_stdoutLeftover.val); | |
if(h$base_stderrLeftover.val !== null) debug(h$base_stderrLeftover.val); | |
// jsc does not support returning a nonzero value, print it instead | |
if(code !== 0) debug("GHCJS JSC exit status: " + code); | |
quit(); | |
} | |
} | |
// RAND_MAX = 32767 | |
function h$rand() { | |
return (32768 * Math.random()) & 32767; | |
} | |
// generated by generate_threefish_block.hs | |
var h$Threefish_256_Process_Block; | |
h$Threefish_256_Process_Block=function(p,q,y,r){var m;m=p.i3;var a;a=q.i3;y=y.i3;var b,g,l,c,d,h,k,e,f,t,u,v,n,w,x;q=m[0];p=m[1];r=m[2];t=m[3];u=m[4];v=m[5];n=m[6];m=m[7];w=q^r^u^n^2851871266;x=p^t^v^m^466688986;b=a[0];g=a[1];c=a[2];d=a[3];h=a[4];k=a[5];e=a[6];f=a[7];a=(b&16777215)+(q&16777215);b=(a>>>24)+(b>>>24)+(q>>>24)+((g&65535)<<8)+((p&65535)<<8);l=((b>>>24)+(g>>>16)+(p>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(r&16777215)+0;b=(a>>>24)+(c>>>24)+(r>>>24)+0+((d&65535)<<8)+((t& | |
65535)<<8)+0;d=((b>>>24)+(d>>>16)+(t>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(u&16777215)+0;b=(a>>>24)+(h>>>24)+(u>>>24)+0+((k&65535)<<8)+((v&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(v>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(n&16777215);b=(a>>>24)+(e>>>24)+(n>>>24)+((f&65535)<<8)+((m&65535)<<8);f=((b>>>24)+(f>>>16)+(m>>>16)<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>> | |
16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c& | |
16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535); | |
h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(r&16777215);b=(a>>>24)+(g>>>24)+(r>>>24)+ | |
((l&65535)<<8)+((t&65535)<<8);l=((b>>>24)+(l>>>16)+(t>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(u&16777215)+0;b=(a>>>24)+(c>>>24)+(u>>>24)+0+((d&65535)<<8)+((v&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(v>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(n&16777215)+0;b=(a>>>24)+(h>>>24)+(n>>>24)+0+((k&65535)<<8)+((m&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(m>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(w&16777215)+1;b=(a>>>24)+(e>>>24)+(w>>>24)+0+((f&65535)<<8)+((x& | |
65535)<<8)+0;f=((b>>>24)+(f>>>16)+(x>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>> | |
24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a& | |
16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8); | |
k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(u&16777215);b=(a>>>24)+(g>>>24)+(u>>>24)+((l&65535)<<8)+((v&65535)<<8);l=((b>>>24)+(l>>>16)+(v>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(n&16777215)+0;b=(a>>>24)+(c>>>24)+(n>>>24)+0+((d&65535)<<8)+((m&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(m>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(w&16777215)+0;b=(a>>>24)+(h>>>24)+(w>>>24)+0+((k&65535)<<8)+((x&65535)<<8)+0;k=((b>>>24)+ | |
(k>>>16)+(x>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(q&16777215)+2;b=(a>>>24)+(e>>>24)+(q>>>24)+0+((f&65535)<<8)+((p&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(p>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8); | |
k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a= | |
(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<< | |
16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(n&16777215);b=(a>>>24)+(g>>>24)+(n>>>24)+((l&65535)<<8)+((m&65535)<<8);l=((b>>>24)+(l>>>16)+(m>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(w&16777215)+0;b=(a>>>24)+(c>>>24)+(w>>>24)+0+((d&65535)<<8)+((x& | |
65535)<<8)+0;d=((b>>>24)+(d>>>16)+(x>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(q&16777215)+0;b=(a>>>24)+(h>>>24)+(q>>>24)+0+((k&65535)<<8)+((p&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(p>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(r&16777215)+3;b=(a>>>24)+(e>>>24)+(r>>>24)+0+((f&65535)<<8)+((t&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(t>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>> | |
24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+ | |
(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>> | |
8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(w&16777215);b=(a>>>24)+(g>>>24)+(w>>>24)+((l&65535)<<8)+((x&65535)<<8);l=((b>>> | |
24)+(l>>>16)+(x>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(q&16777215)+0;b=(a>>>24)+(c>>>24)+(q>>>24)+0+((d&65535)<<8)+((p&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(p>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(r&16777215)+0;b=(a>>>24)+(h>>>24)+(r>>>24)+0+((k&65535)<<8)+((t&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(t>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(u&16777215)+4;b=(a>>>24)+(e>>>24)+(u>>>24)+0+((f&65535)<<8)+((v&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(v>>> | |
16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<< | |
8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<< | |
23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>> | |
16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(q&16777215);b=(a>>>24)+(g>>>24)+(q>>>24)+((l&65535)<<8)+((p&65535)<<8);l=((b>>>24)+(l>>>16)+(p>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(r&16777215)+0;b=(a>>>24)+(c>>>24)+(r>>>24)+0+((d&65535)<<8)+((t&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(t>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(u&16777215)+0;b=(a>>>24)+(h>>>24)+(u>>>24)+0+((k&65535)<<8)+((v&65535)<<8)+0;k= | |
((b>>>24)+(k>>>16)+(v>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(n&16777215)+5;b=(a>>>24)+(e>>>24)+(n>>>24)+0+((f&65535)<<8)+((m&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(m>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<< | |
8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h; | |
a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>> | |
16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(r&16777215);b=(a>>>24)+(g>>>24)+(r>>>24)+((l&65535)<<8)+((t&65535)<<8);l=((b>>>24)+(l>>>16)+(t>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(u&16777215)+0;b=(a>>>24)+(c>>>24)+(u>>>24)+0+((d&65535)<<8)+((v&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(v>>>16)+ | |
0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(n&16777215)+0;b=(a>>>24)+(h>>>24)+(n>>>24)+0+((k&65535)<<8)+((m&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(m>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(w&16777215)+6;b=(a>>>24)+(e>>>24)+(w>>>24)+0+((f&65535)<<8)+((x&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(x>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<< | |
24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>> | |
24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8| | |
f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(u&16777215);b=(a>>>24)+(g>>>24)+(u>>>24)+((l&65535)<<8)+((v&65535)<<8); | |
l=((b>>>24)+(l>>>16)+(v>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(n&16777215)+0;b=(a>>>24)+(c>>>24)+(n>>>24)+0+((d&65535)<<8)+((m&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(m>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(w&16777215)+0;b=(a>>>24)+(h>>>24)+(w>>>24)+0+((k&65535)<<8)+((x&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(x>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(q&16777215)+7;b=(a>>>24)+(e>>>24)+(q>>>24)+0+((f&65535)<<8)+((p&65535)<<8)+0;f=((b>>>24)+(f>>> | |
16)+(p>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l& | |
65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>> | |
6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>> | |
16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(n&16777215);b=(a>>>24)+(g>>>24)+(n>>>24)+((l&65535)<<8)+((m&65535)<<8);l=((b>>>24)+(l>>>16)+(m>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(w&16777215)+0;b=(a>>>24)+(c>>>24)+(w>>>24)+0+((d&65535)<<8)+((x&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(x>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(q&16777215)+0;b=(a>>>24)+(h>>>24)+(q>>>24)+0+((k&65535)<<8)+((p&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(p>>>16)+0<<16)+ | |
(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(r&16777215)+8;b=(a>>>24)+(e>>>24)+(r>>>24)+0+((f&65535)<<8)+((t&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(t>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>> | |
16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215); | |
b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24| | |
a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(w&16777215);b=(a>>>24)+(g>>>24)+(w>>>24)+((l&65535)<<8)+((x&65535)<<8);l=((b>>>24)+(l>>>16)+(x>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(q&16777215)+0;b=(a>>>24)+(c>>>24)+(q>>>24)+0+((d&65535)<<8)+((p&65535)<<8)+0;d=((b>>>24)+ | |
(d>>>16)+(p>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(r&16777215)+0;b=(a>>>24)+(h>>>24)+(r>>>24)+0+((k&65535)<<8)+((t&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(t>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(u&16777215)+9;b=(a>>>24)+(e>>>24)+(u>>>24)+0+((f&65535)<<8)+((v&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(v>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+ | |
(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+ | |
(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215; | |
a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(q&16777215);b=(a>>>24)+(g>>>24)+(q>>>24)+((l&65535)<<8)+((p&65535)<<8);l=((b>>>24)+(l>>>16)+(p>>>16)<<16)+ | |
(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(r&16777215)+0;b=(a>>>24)+(c>>>24)+(r>>>24)+0+((d&65535)<<8)+((t&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(t>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(u&16777215)+0;b=(a>>>24)+(h>>>24)+(u>>>24)+0+((k&65535)<<8)+((v&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(v>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(n&16777215)+10;b=(a>>>24)+(e>>>24)+(n>>>24)+0+((f&65535)<<8)+((m&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(m>>>16)+0<<16)+(b>>8&65535);e= | |
b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>> | |
24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+ | |
(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8& | |
65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(r&16777215);b=(a>>>24)+(g>>>24)+(r>>>24)+((l&65535)<<8)+((t&65535)<<8);l=((b>>>24)+(l>>>16)+(t>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(u&16777215)+0;b=(a>>>24)+(c>>>24)+(u>>>24)+0+((d&65535)<<8)+((v&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(v>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(n&16777215)+0;b=(a>>>24)+(h>>>24)+(n>>>24)+0+((k&65535)<<8)+((m&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(m>>> | |
16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(w&16777215)+11;b=(a>>>24)+(e>>>24)+(w>>>24)+0+((f&65535)<<8)+((x&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(x>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>> | |
16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215); | |
b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<< | |
24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(u&16777215);b=(a>>>24)+(g>>>24)+(u>>>24)+((l&65535)<<8)+((v&65535)<<8);l=((b>>>24)+(l>>>16)+(v>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(n&16777215)+0;b=(a>>>24)+(c>>>24)+(n>>>24)+0+((d&65535)<<8)+((m&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(m>>>16)+0<<16)+(b>>8&65535);c=b<< | |
24|a&16777215;a=(h&16777215)+(w&16777215)+0;b=(a>>>24)+(h>>>24)+(w>>>24)+0+((k&65535)<<8)+((x&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(x>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(q&16777215)+12;b=(a>>>24)+(e>>>24)+(q>>>24)+0+((f&65535)<<8)+((p&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(p>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<< | |
14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<< | |
8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g& | |
16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(n&16777215);b=(a>>>24)+(g>>>24)+(n>>>24)+((l&65535)<<8)+((m&65535)<<8);l=((b>>>24)+(l>>>16)+(m>>>16)<< | |
16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(w&16777215)+0;b=(a>>>24)+(c>>>24)+(w>>>24)+0+((d&65535)<<8)+((x&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(x>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(q&16777215)+0;b=(a>>>24)+(h>>>24)+(q>>>24)+0+((k&65535)<<8)+((p&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(p>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(r&16777215)+13;b=(a>>>24)+(e>>>24)+(r>>>24)+0+((f&65535)<<8)+((t&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(t>>>16)+0<<16)+(b>>8&65535); | |
e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>> | |
24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+ | |
(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215; | |
a=d;d=c^k;c=a^h;a=(g&16777215)+(w&16777215);b=(a>>>24)+(g>>>24)+(w>>>24)+((l&65535)<<8)+((x&65535)<<8);l=((b>>>24)+(l>>>16)+(x>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(q&16777215)+0;b=(a>>>24)+(c>>>24)+(q>>>24)+0+((d&65535)<<8)+((p&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(p>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(r&16777215)+0;b=(a>>>24)+(h>>>24)+(r>>>24)+0+((k&65535)<<8)+((t&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(t>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+ | |
(u&16777215)+14;b=(a>>>24)+(e>>>24)+(u>>>24)+0+((f&65535)<<8)+((v&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(v>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f; | |
f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d& | |
65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^ | |
g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>>27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(q&16777215);b=(a>>>24)+(g>>>24)+(q>>>24)+((l&65535)<<8)+((p&65535)<<8);l=((b>>>24)+(l>>>16)+(p>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(r&16777215)+0;b=(a>>>24)+(c>>>24)+(r>>>24)+0+((d&65535)<<8)+((t&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(t>>>16)+0<<16)+(b>>8&65535);c=b<<24| | |
a&16777215;a=(h&16777215)+(u&16777215)+0;b=(a>>>24)+(h>>>24)+(u>>>24)+0+((k&65535)<<8)+((v&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(v>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(n&16777215)+15;b=(a>>>24)+(e>>>24)+(n>>>24)+0+((f&65535)<<8)+((m&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(m>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25| | |
c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<< | |
8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h; | |
a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(r&16777215);b=(a>>>24)+(g>>>24)+(r>>>24)+((l&65535)<<8)+((t&65535)<<8);l=((b>>>24)+(l>>>16)+(t>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+ | |
(u&16777215)+0;b=(a>>>24)+(c>>>24)+(u>>>24)+0+((d&65535)<<8)+((v&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(v>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(n&16777215)+0;b=(a>>>24)+(h>>>24)+(n>>>24)+0+((k&65535)<<8)+((m&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(m>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(w&16777215)+16;b=(a>>>24)+(e>>>24)+(w>>>24)+0+((f&65535)<<8)+((x&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(x>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b= | |
(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<14|c>>>18)^l;c=(c<<14|a>>>18)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<16|e>>>16)^k;e=(e<<16|a>>>16)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<< | |
24|a&16777215;a=f;f=(e<<20|f>>>12)^l;e=(a<<20|e>>>12)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<25|d>>>7)^k;c=(a<<25|c>>>7)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<23|c>>>9)^l;c=(c<<23|a>>>9)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+ | |
((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(e<<8|f>>>24)^k;e=(a<<8|e>>>24)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(f<<5|e>>>27)^l;e=(e<<5|a>>>27)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(c<<5|d>>> | |
27)^k;c=(a<<5|c>>>27)^h;a=(g&16777215)+(u&16777215);b=(a>>>24)+(g>>>24)+(u>>>24)+((l&65535)<<8)+((v&65535)<<8);l=((b>>>24)+(l>>>16)+(v>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(n&16777215)+0;b=(a>>>24)+(c>>>24)+(n>>>24)+0+((d&65535)<<8)+((m&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(m>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(w&16777215)+0;b=(a>>>24)+(h>>>24)+(w>>>24)+0+((k&65535)<<8)+((x&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(x>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215; | |
a=(e&16777215)+(q&16777215)+17;b=(a>>>24)+(e>>>24)+(q>>>24)+0+((f&65535)<<8)+((p&65535)<<8)+0;f=((b>>>24)+(f>>>16)+(p>>>16)+0<<16)+(b>>8&65535);e=b<<24|a&16777215;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l&65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(d<<25|c>>>7)^l;c=(c<<25|a>>>7)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a& | |
16777215;a=f;f=(e<<1|f>>>31)^k;e=(a<<1|e>>>31)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=(e<<14|f>>>18)^l;e=(a<<14|e>>>18)^g;a=(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=(d<<12|c>>>20)^k;c=(c<<12|a>>>20)^h;a=(g&16777215)+(c&16777215);b=(a>>>24)+(g>>>24)+(c>>>24)+((l& | |
65535)<<8)+((d&65535)<<8);l=((b>>>24)+(l>>>16)+(d>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=d;d=(c<<26|d>>>6)^l;c=(a<<26|c>>>6)^g;a=(h&16777215)+(e&16777215);b=(a>>>24)+(h>>>24)+(e>>>24)+((k&65535)<<8)+((f&65535)<<8);k=((b>>>24)+(k>>>16)+(f>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=f;f=(f<<22|e>>>10)^k;e=(e<<22|a>>>10)^h;a=(g&16777215)+(e&16777215);b=(a>>>24)+(g>>>24)+(e>>>24)+((l&65535)<<8)+((f&65535)<<8);l=((b>>>24)+(l>>>16)+(f>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=f;f=e^l;e=a^g;a= | |
(h&16777215)+(c&16777215);b=(a>>>24)+(h>>>24)+(c>>>24)+((k&65535)<<8)+((d&65535)<<8);k=((b>>>24)+(k>>>16)+(d>>>16)<<16)+(b>>8&65535);h=b<<24|a&16777215;a=d;d=c^k;c=a^h;a=(g&16777215)+(n&16777215);b=(a>>>24)+(g>>>24)+(n>>>24)+((l&65535)<<8)+((m&65535)<<8);l=((b>>>24)+(l>>>16)+(m>>>16)<<16)+(b>>8&65535);g=b<<24|a&16777215;a=(c&16777215)+(w&16777215)+0;b=(a>>>24)+(c>>>24)+(w>>>24)+0+((d&65535)<<8)+((x&65535)<<8)+0;d=((b>>>24)+(d>>>16)+(x>>>16)+0<<16)+(b>>8&65535);c=b<<24|a&16777215;a=(h&16777215)+(q& | |
16777215)+0;b=(a>>>24)+(h>>>24)+(q>>>24)+0+((k&65535)<<8)+((p&65535)<<8)+0;k=((b>>>24)+(k>>>16)+(p>>>16)+0<<16)+(b>>8&65535);h=b<<24|a&16777215;a=(e&16777215)+(r&16777215)+18;b=(a>>>24)+(e>>>24)+(r>>>24)+0+((f&65535)<<8)+((t&65535)<<8)+0;y[0]=g;y[1]=l;y[2]=c;y[3]=d;y[4]=h;y[5]=k;y[6]=b<<24|a&16777215;y[7]=((b>>>24)+(f>>>16)+(t>>>16)+0<<16)+(b>>8&65535)};"undefined"!==typeof exports&&(exports.h$Threefish_256_Process_Block=h$Threefish_256_Process_Block); | |
function h$ghczmprimZCGHCziTypesziTrue_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziZMZN_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziIzh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziIzh_e() | |
{ | |
h$r1 = h$r2; | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziFzh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziFzh_e() | |
{ | |
h$r1 = h$r2; | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziFalse_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziZC_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziZC_e() | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziCzh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTypesziCzh_e() | |
{ | |
h$r1 = h$r2; | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTupleziZLz2cUz2cUz2cUZR_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTupleziZLz2cUz2cUz2cUZR_e() | |
{ | |
h$r1 = h$c4(h$ghczmprimZCGHCziTupleziZLz2cUz2cUz2cUZR_con_e, h$r2, h$r3, h$r4, h$r5); | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_e() | |
{ | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$r2, h$r3, h$r4); | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTupleziZLz2cUZR_e() | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziTupleziZLZR_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziIntWord64ziintToInt64zh_e() | |
{ | |
var a = h$hs_intToInt64(h$r2); | |
h$r1 = a; | |
h$r2 = h$ret1; | |
return h$stack[h$sp]; | |
}; | |
function h$$b() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(((b + 1) | 0), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$a() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = h$r2; | |
var g = a.u8[(c + f)]; | |
if((g === 0)) | |
{ | |
return h$e(d); | |
} | |
else | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, g, h$c2(h$$b, e, f)); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziCStringziunpackAppendCStringzh_e() | |
{ | |
var a = h$r3; | |
var b = h$r4; | |
var c = h$c(h$$a); | |
c.d1 = h$r2; | |
c.d2 = h$d3(a, b, c); | |
h$l2(0, c); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$d() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(((b + 1) | 0), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$c() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = h$r2; | |
var f = a.u8[(c + e)]; | |
if((f === 0)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, f, h$c2(h$$d, d, e)); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziCStringziunpackCStringzh_e() | |
{ | |
var a = h$r3; | |
var b = h$c(h$$c); | |
b.d1 = h$r2; | |
b.d2 = h$d2(a, b); | |
h$l2(0, b); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$f() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(((b + 1) | 0), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$e() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = b.d4; | |
var g = h$r2; | |
var h = a.u8[(c + g)]; | |
if((h === 0)) | |
{ | |
h$r1 = e; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$l3(h$c2(h$$f, f, g), h, d); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$ghczmprimZCGHCziCStringziunpackFoldrCStringzh_e() | |
{ | |
var a = h$r3; | |
var b = h$r4; | |
var c = h$r5; | |
var d = h$c(h$$e); | |
d.d1 = h$r2; | |
d.d2 = h$d4(a, b, c, d); | |
h$l2(0, d); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$k() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(((b + 4) | 0), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$j() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(((b + 3) | 0), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$i() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(((b + 2) | 0), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$h() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(((b + 1) | 0), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$g() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = h$r2; | |
var f = a.u8[(c + e)]; | |
if((f === 0)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
if((f <= 127)) | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, f, h$c2(h$$h, d, e)); | |
} | |
else | |
{ | |
if((f <= 223)) | |
{ | |
var g = h$c2(h$$i, d, e); | |
var h = ((e + 1) | 0); | |
var i = a.u8[(c + h)]; | |
var j = ((i - 128) | 0); | |
var k = f; | |
var l = ((k - 192) | 0); | |
var m = (l << 6); | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, ((m + j) | 0), g); | |
} | |
else | |
{ | |
if((f <= 239)) | |
{ | |
var n = h$c2(h$$j, d, e); | |
var o = ((e + 2) | 0); | |
var p = a.u8[(c + o)]; | |
var q = ((e + 1) | 0); | |
var r = a.u8[(c + q)]; | |
var s = p; | |
var t = ((s - 128) | 0); | |
var u = r; | |
var v = ((u - 128) | 0); | |
var w = (v << 6); | |
var x = f; | |
var y = ((x - 224) | 0); | |
var z = (y << 12); | |
var A = ((z + w) | 0); | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, ((A + t) | 0), n); | |
} | |
else | |
{ | |
var B = h$c2(h$$k, d, e); | |
var C = ((e + 3) | 0); | |
var D = a.u8[(c + C)]; | |
var E = ((e + 2) | 0); | |
var F = a.u8[(c + E)]; | |
var G = ((e + 1) | 0); | |
var H = a.u8[(c + G)]; | |
var I = D; | |
var J = ((I - 128) | 0); | |
var K = F; | |
var L = ((K - 128) | 0); | |
var M = (L << 6); | |
var N = H; | |
var O = ((N - 128) | 0); | |
var P = (O << 12); | |
var Q = f; | |
var R = ((Q - 240) | 0); | |
var S = (R << 18); | |
var T = ((S + P) | 0); | |
var U = ((T + M) | 0); | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, ((U + J) | 0), B); | |
}; | |
}; | |
}; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$ghczmprimZCGHCziCStringziunpackCStringUtf8zh_e() | |
{ | |
var a = h$r3; | |
var b = h$c(h$$g); | |
b.d1 = h$r2; | |
b.d2 = h$d2(a, b); | |
h$l2(0, b); | |
return h$ap_1_1_fast(); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziInternalziblockedIndefinitelyOnSTM_e() | |
{ | |
h$bh(); | |
h$l2(h$baseZCGHCziIOziExceptionziBlockedIndefinitelyOnSTM, | |
h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTMzuzdctoException); | |
return h$ap_1_1_fast(); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziInternalziblockedIndefinitelyOnMVar_e() | |
{ | |
h$bh(); | |
h$l2(h$baseZCGHCziIOziExceptionziBlockedIndefinitelyOnMVar, | |
h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVarzuzdctoException); | |
return h$ap_1_1_fast(); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziInternalziwouldBlock_e() | |
{ | |
h$l2(h$c1(h$ghcjszmprimZCGHCJSziPrimziWouldBlockException_con_e, h$r2), | |
h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockExceptionzuzdctoException); | |
return h$ap_1_1_fast(); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockExceptionzuzdctoException_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziExceptionziSomeException_con_e, h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockException, | |
h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSExceptionzuzdctoException_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziExceptionziSomeException_con_e, h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSException, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$$m() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l4(c, a.d1, b, h$ghcjszmprimZCGHCJSziPrimzizdwzdcshowsPrec); | |
return h$ghcjszmprimZCGHCJSziPrimzizdwzdcshowsPrec_e; | |
}; | |
function h$$l() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 3; | |
h$pp5(a, h$$m); | |
return h$e(b); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockExceptionzuzdcshowsPrec_e() | |
{ | |
h$p3(h$r3, h$r4, h$$l); | |
return h$e(h$r2); | |
}; | |
function h$$n() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l4(h$ghczmprimZCGHCziTypesziZMZN, a.d1, 0, h$ghcjszmprimZCGHCJSziPrimzizdwzdcshowsPrec); | |
return h$ghcjszmprimZCGHCJSziPrimzizdwzdcshowsPrec_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockExceptionzuzdcshow_e() | |
{ | |
h$p1(h$$n); | |
return h$e(h$r2); | |
}; | |
var h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockException2 = h$strta("WouldBlockException "); | |
function h$$q() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzizdfShowChar1, b), a, h$baseZCGHCziShowzishowLitString); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$p() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzizdfShowChar1, h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, | |
h$baseZCGHCziShowzishows12, b)), a, h$baseZCGHCziShowzishowLitString); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$o() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzizdfShowChar1, h$c2(h$$p, a, b)), | |
h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockException2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdwzdcshowsPrec_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
if((a >= 11)) | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzishows13, h$c2(h$$o, b, c)); | |
} | |
else | |
{ | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzizdfShowChar1, h$c2(h$$q, b, c)), | |
h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockException2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$r() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l4(b, a.d1, 0, h$ghcjszmprimZCGHCJSziPrimzizdwzdcshowsPrec); | |
return h$ghcjszmprimZCGHCJSziPrimzizdwzdcshowsPrec_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockException1_e() | |
{ | |
h$p2(h$r3, h$$r); | |
return h$e(h$r2); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockExceptionzuzdcshowList_e() | |
{ | |
h$l4(h$r3, h$r2, h$ghcjszmprimZCGHCJSziPrimzizdfShowWouldBlockException1, h$baseZCGHCziShowzishowListzuzu); | |
return h$baseZCGHCziShowzishowListzuzu_e; | |
}; | |
var h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockExceptionzuww5 = h$strta("WouldBlockException"); | |
function h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockExceptionzuzdctypeRepzh_e() | |
{ | |
h$r1 = h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockException1; | |
return h$stack[h$sp]; | |
}; | |
function h$$t() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l4(b, h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockExceptionzuzdctypeRepzh, a, h$baseZCDataziTypeablezicast); | |
return h$baseZCDataziTypeablezicast_e; | |
}; | |
function h$$s() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$p2(a.d2, h$$t); | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfExceptionWouldBlockExceptionzuzdcfromException_e() | |
{ | |
h$p1(h$$s); | |
return h$e(h$r2); | |
}; | |
function h$$v() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(a, b, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$u() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l3(h$c2(h$$v, b, a.d2), h$ghczmprimZCGHCziTypesziZC, h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException2); | |
return h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException2_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowJSExceptionzuzdcshowsPrec_e() | |
{ | |
h$p2(h$r4, h$$u); | |
return h$e(h$r3); | |
}; | |
function h$$w() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l3(a.d2, h$ghczmprimZCGHCziTypesziZC, h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException2); | |
return h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException2_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowJSExceptionzuzdcshow_e() | |
{ | |
h$p1(h$$w); | |
return h$e(h$r2); | |
}; | |
var h$$ghcjszmprimzm0zi1zi0zi0ZCGHCJSziPrim_V = h$str("JavaScript exception: "); | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException2_e() | |
{ | |
h$r5 = h$r3; | |
h$r4 = h$r2; | |
h$r3 = 0; | |
h$r2 = h$$ghcjszmprimzm0zi1zi0zi0ZCGHCJSziPrim_V(); | |
h$r1 = h$ghczmprimZCGHCziCStringziunpackFoldrCStringzh; | |
return h$ap_3_4_fast(); | |
}; | |
function h$$y() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(a, b, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$x() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l3(h$c2(h$$y, b, a.d2), h$ghczmprimZCGHCziTypesziZC, h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException2); | |
return h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException2_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException1_e() | |
{ | |
h$p2(h$r3, h$$x); | |
return h$e(h$r2); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfShowJSExceptionzuzdcshowList_e() | |
{ | |
h$l4(h$r3, h$r2, h$ghcjszmprimZCGHCJSziPrimzizdfShowJSException1, h$baseZCGHCziShowzishowListzuzu); | |
return h$baseZCGHCziShowzishowListzuzu_e; | |
}; | |
var h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSExceptionzuww3 = h$strta("ghcjs-prim-0.1.0.0"); | |
var h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSException4 = h$strta("GHCJS.Prim"); | |
var h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSException3 = h$strta("JSException"); | |
function h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSExceptionzuzdctypeRepzh_e() | |
{ | |
h$r1 = h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSException1; | |
return h$stack[h$sp]; | |
}; | |
function h$$A() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l4(b, h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSExceptionzuzdctypeRepzh, a, h$baseZCDataziTypeablezicast); | |
return h$baseZCDataziTypeablezicast_e; | |
}; | |
function h$$z() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$p2(a.d2, h$$A); | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSExceptionzuzdcfromException_e() | |
{ | |
h$p1(h$$z); | |
return h$e(h$r2); | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimzizdfTypeableJSException_e() | |
{ | |
h$r1 = h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSExceptionzuzdctypeRepzh; | |
return h$ghcjszmprimZCGHCJSziPrimzizdfExceptionJSExceptionzuzdctypeRepzh_e; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziWouldBlockException_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziWouldBlockException_e() | |
{ | |
h$r1 = h$c1(h$ghcjszmprimZCGHCJSziPrimziWouldBlockException_con_e, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziJSException_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziJSException_e() | |
{ | |
h$r1 = h$c2(h$ghcjszmprimZCGHCJSziPrimziJSException_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziJSRef_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$ghcjszmprimZCGHCJSziPrimziJSRef_e() | |
{ | |
h$r1 = h$c1(h$ghcjszmprimZCGHCJSziPrimziJSRef_con_e, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$$D() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
var d = ((b / c) | 0); | |
h$r1 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, d); | |
h$r2 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, (b - (c * d))); | |
} | |
else | |
{ | |
var e = h$integer_cmm_int2Integerzh(b); | |
h$l3(a, h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, e, h$ret1), | |
h$integerzmgmpZCGHCziIntegerziTypeziquotRemInteger); | |
return h$ap_2_2_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$C() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
var d = a.d1; | |
if((d < 0)) | |
{ | |
var e = h$integer_cmm_quotRemIntegerWordzh(b, c, (-d | 0)); | |
var f = e; | |
var g = h$ret1; | |
var h = f.negate(); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, h); | |
h$r2 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, g); | |
} | |
else | |
{ | |
var i = h$integer_cmm_quotRemIntegerWordzh(b, c, d); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, i); | |
h$r2 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, h$ret1); | |
}; | |
} | |
else | |
{ | |
var j = a.d1; | |
var k = h$integer_cmm_quotRemIntegerzh(b, c, j, a.d2); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, k); | |
h$r2 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, h$ret1); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$B() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
if((c === (-2147483648))) | |
{ | |
h$l3(b, h$integerzmgmpZCGHCziIntegerziTypeziminIntAsBig, h$integerzmgmpZCGHCziIntegerziTypeziquotRemInteger); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
h$p2(c, h$$D); | |
return h$e(b); | |
}; | |
} | |
else | |
{ | |
var d = a.d1; | |
h$p3(d, a.d2, h$$C); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziquotRemInteger_e() | |
{ | |
h$p2(h$r3, h$$B); | |
return h$e(h$r2); | |
}; | |
function h$$G() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
h$r1 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, ((b / c) | 0)); | |
} | |
else | |
{ | |
var d = h$integer_cmm_int2Integerzh(b); | |
h$l3(a, h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, d, h$ret1), | |
h$integerzmgmpZCGHCziIntegerziTypeziquotInteger); | |
return h$ap_2_2_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$F() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
var d = a.d1; | |
if((d < 0)) | |
{ | |
var e = h$integer_cmm_quotIntegerWordzh(b, c, (-d | 0)); | |
var f = e.negate(); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, f); | |
} | |
else | |
{ | |
var g = h$integer_cmm_quotIntegerWordzh(b, c, d); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, g); | |
}; | |
} | |
else | |
{ | |
var h = a.d1; | |
var i = h$integer_cmm_quotIntegerzh(b, c, h, a.d2); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, i); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$E() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
if((c === (-2147483648))) | |
{ | |
h$l3(b, h$integerzmgmpZCGHCziIntegerziTypeziminIntAsBig, h$integerzmgmpZCGHCziIntegerziTypeziquotInteger); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
h$p2(c, h$$G); | |
return h$e(b); | |
}; | |
} | |
else | |
{ | |
var d = a.d1; | |
h$p3(d, a.d2, h$$F); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziquotInteger_e() | |
{ | |
h$p2(h$r3, h$$E); | |
return h$e(h$r2); | |
}; | |
function h$$J() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
var d = a.d1; | |
var e; | |
var f = (c + d); | |
e = (f | 0); | |
var g = e; | |
var h = ((e != f) ? 1 : 0); | |
if((h === 0)) | |
{ | |
h$r1 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, g); | |
} | |
else | |
{ | |
var i = h$integer_cmm_int2Integerzh(c); | |
var j = h$integer_cmm_plusIntegerIntzh(i, h$ret1, d); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, j); | |
}; | |
} | |
else | |
{ | |
h$l3(b, a, h$integerzmgmpZCGHCziIntegerziTypeziplusInteger); | |
return h$ap_2_2_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$I() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
var e = a.d1; | |
if((e === 0)) | |
{ | |
h$r1 = b; | |
} | |
else | |
{ | |
var f = h$integer_cmm_plusIntegerIntzh(c, d, e); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, f); | |
}; | |
} | |
else | |
{ | |
var g = a.d1; | |
var h = h$integer_cmm_plusIntegerzh(c, d, g, a.d2); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, h); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$H() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$p3(a, a.d1, h$$J); | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$p4(a, c, a.d2, h$$I); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziplusInteger_e() | |
{ | |
h$p2(h$r3, h$$H); | |
return h$e(h$r2); | |
}; | |
function h$$M() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
var d; | |
var e = (b * c); | |
d = ((e === (e | 0)) ? 0 : 1); | |
if((d === 0)) | |
{ | |
h$r1 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, h$mulInt32(b, c)); | |
} | |
else | |
{ | |
var f = h$integer_cmm_int2Integerzh(b); | |
var g = h$integer_cmm_timesIntegerIntzh(f, h$ret1, c); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, g); | |
}; | |
} | |
else | |
{ | |
var h = a.d1; | |
switch (b) | |
{ | |
case ((-1)): | |
h$l2(a, h$integerzmgmpZCGHCziIntegerziTypezinegateInteger); | |
return h$integerzmgmpZCGHCziIntegerziTypezinegateInteger_e; | |
case (0): | |
h$r1 = h$$ag; | |
break; | |
case (1): | |
h$r1 = a; | |
break; | |
default: | |
var i = h$integer_cmm_timesIntegerIntzh(h, a.d2, b); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, i); | |
}; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$L() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$l3(b, a, h$integerzmgmpZCGHCziIntegerziTypezitimesInteger); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
var e = a.d1; | |
var f = h$integer_cmm_timesIntegerzh(c, d, e, a.d2); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, f); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$K() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$p2(a.d1, h$$M); | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$p4(a, c, a.d2, h$$L); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypezitimesInteger_e() | |
{ | |
h$p2(h$r3, h$$K); | |
return h$e(h$r2); | |
}; | |
function h$$N() | |
{ | |
h$bh(); | |
h$l3(h$$ah, h$$af, h$integerzmgmpZCGHCziIntegerziTypeziplusInteger); | |
return h$ap_2_2_fast(); | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziminIntAsBig_e() | |
{ | |
h$bh(); | |
var a = h$integer_cmm_int2Integerzh((-2147483648)); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, a, h$ret1); | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziJzh_e() | |
{ | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziSzh_e() | |
{ | |
h$r1 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziint64ToInteger_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$hs_intToInt64(2147483647); | |
if(h$hs_leInt64(a, b, c, h$ret1)) | |
{ | |
var d = h$hs_intToInt64((-2147483648)); | |
if(h$hs_geInt64(a, b, d, h$ret1)) | |
{ | |
h$l2(h$hs_int64ToInt(a, b), h$integerzmgmpZCGHCziIntegerziTypezismallInteger); | |
return h$integerzmgmpZCGHCziIntegerziTypezismallInteger_e; | |
} | |
else | |
{ | |
var e = h$integer_cmm_int64ToIntegerzh(a, b); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, e, h$ret1); | |
}; | |
} | |
else | |
{ | |
var f = h$integer_cmm_int64ToIntegerzh(a, b); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, f, h$ret1); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$O() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = a.d1; | |
} | |
else | |
{ | |
var b = a.d1; | |
var c = h$integer_cbits_encodeFloat(b, a.d2, 0); | |
h$r1 = c; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypezifloatFromInteger_e() | |
{ | |
h$p1(h$$O); | |
return h$e(h$r2); | |
}; | |
function h$$R() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
h$r1 = ((b < c) ? 1 : 0); | |
} | |
else | |
{ | |
var d = a.d1; | |
var e = h$integer_cmm_cmpIntegerIntzh(d, a.d2, b); | |
h$r1 = ((e > 0) ? 1 : 0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$Q() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
var d = h$integer_cmm_cmpIntegerIntzh(b, c, a.d1); | |
h$r1 = ((d < 0) ? 1 : 0); | |
} | |
else | |
{ | |
var e = a.d1; | |
var f = h$integer_cmm_cmpIntegerzh(b, c, e, a.d2); | |
h$r1 = ((f < 0) ? 1 : 0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$P() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$p2(a.d1, h$$R); | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$p3(c, a.d2, h$$Q); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziltIntegerzh_e() | |
{ | |
h$p2(h$r3, h$$P); | |
return h$e(h$r2); | |
}; | |
function h$$U() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
h$r1 = ((b > c) ? 1 : 0); | |
} | |
else | |
{ | |
var d = a.d1; | |
var e = h$integer_cmm_cmpIntegerIntzh(d, a.d2, b); | |
h$r1 = ((e < 0) ? 1 : 0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$T() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
var d = h$integer_cmm_cmpIntegerIntzh(b, c, a.d1); | |
h$r1 = ((d > 0) ? 1 : 0); | |
} | |
else | |
{ | |
var e = a.d1; | |
var f = h$integer_cmm_cmpIntegerzh(b, c, e, a.d2); | |
h$r1 = ((f > 0) ? 1 : 0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$S() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$p2(a.d1, h$$U); | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$p3(c, a.d2, h$$T); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypezigtIntegerzh_e() | |
{ | |
h$p2(h$r3, h$$S); | |
return h$e(h$r2); | |
}; | |
function h$$X() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
h$r1 = ((b <= c) ? 1 : 0); | |
} | |
else | |
{ | |
var d = a.d1; | |
var e = h$integer_cmm_cmpIntegerIntzh(d, a.d2, b); | |
h$r1 = ((e >= 0) ? 1 : 0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$W() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
var d = h$integer_cmm_cmpIntegerIntzh(b, c, a.d1); | |
h$r1 = ((d <= 0) ? 1 : 0); | |
} | |
else | |
{ | |
var e = a.d1; | |
var f = h$integer_cmm_cmpIntegerzh(b, c, e, a.d2); | |
h$r1 = ((f <= 0) ? 1 : 0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$V() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$p2(a.d1, h$$X); | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$p3(c, a.d2, h$$W); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypezileIntegerzh_e() | |
{ | |
h$p2(h$r3, h$$V); | |
return h$e(h$r2); | |
}; | |
function h$$aa() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
var c = a.d1; | |
h$r1 = ((b === c) ? 1 : 0); | |
} | |
else | |
{ | |
var d = a.d1; | |
var e = h$integer_cmm_cmpIntegerIntzh(d, a.d2, b); | |
if((e === 0)) | |
{ | |
h$r1 = 1; | |
} | |
else | |
{ | |
h$r1 = 0; | |
}; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$Z() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
var d = h$integer_cmm_cmpIntegerIntzh(b, c, a.d1); | |
if((d === 0)) | |
{ | |
h$r1 = 1; | |
} | |
else | |
{ | |
h$r1 = 0; | |
}; | |
} | |
else | |
{ | |
var e = a.d1; | |
var f = h$integer_cmm_cmpIntegerzh(b, c, e, a.d2); | |
if((f === 0)) | |
{ | |
h$r1 = 1; | |
} | |
else | |
{ | |
h$r1 = 0; | |
}; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$Y() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$p2(a.d1, h$$aa); | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$p3(c, a.d2, h$$Z); | |
return h$e(b); | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypezieqIntegerzh_e() | |
{ | |
h$p2(h$r3, h$$Y); | |
return h$e(h$r2); | |
}; | |
function h$$ab() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
var b = a.d1; | |
if((b === (-2147483648))) | |
{ | |
return h$e(h$$ae); | |
} | |
else | |
{ | |
h$r1 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, (-b | 0)); | |
}; | |
} | |
else | |
{ | |
var c = a.d2; | |
var d = c.negate(); | |
h$r1 = h$c2(h$integerzmgmpZCGHCziIntegerziTypeziJzh_con_e, 0, d); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypezinegateInteger_e() | |
{ | |
h$p1(h$$ab); | |
return h$e(h$r2); | |
}; | |
function h$$ac() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
h$l2(a.d1, h$ghczmprimZCGHCziIntWord64ziintToInt64zh); | |
return h$ghczmprimZCGHCziIntWord64ziintToInt64zh_e; | |
} | |
else | |
{ | |
var b = a.d1; | |
h$l3(a.d2, b, h$integerzmgmpZCGHCziIntegerziGMPziPrimziintegerToInt64zh); | |
return h$integerzmgmpZCGHCziIntegerziGMPziPrimziintegerToInt64zh_e; | |
}; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziintegerToInt64_e() | |
{ | |
h$p1(h$$ac); | |
return h$e(h$r2); | |
}; | |
function h$$ad() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = a.d1; | |
} | |
else | |
{ | |
var b = a.d1; | |
h$r1 = h$integer_cmm_integer2Intzh(b, a.d2); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypeziintegerToInt_e() | |
{ | |
h$p1(h$$ad); | |
return h$e(h$r2); | |
}; | |
function h$integerzmgmpZCGHCziIntegerziTypezismallInteger_e() | |
{ | |
h$r1 = h$c1(h$integerzmgmpZCGHCziIntegerziTypeziSzh_con_e, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$integerzmgmpZCGHCziIntegerziGMPziPrimziintegerToInt64zh_e() | |
{ | |
var a = h$hs_integerToInt64(h$r2, h$r3); | |
h$r1 = a; | |
h$r2 = h$ret1; | |
return h$stack[h$sp]; | |
}; | |
var h$$aZ = h$strta("sigprocmask"); | |
var h$$a0 = h$strta("sigaddset"); | |
var h$$a1 = h$strta("sigemptyset"); | |
var h$$a2 = h$strta("tcSetAttr"); | |
function h$baseZCSystemziPosixziInternalszisetEcho2_e() | |
{ | |
h$bh(); | |
var a = h$base_echo; | |
var b = (a | 0); | |
var c = (b | 0); | |
h$r1 = (c ^ (-1)); | |
return h$stack[h$sp]; | |
}; | |
function h$$am() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a; | |
var f = (d | 0); | |
h$base_poke_lflag(b, c, (f & e)); | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$al() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a; | |
var f = (d | 0); | |
h$base_poke_lflag(b, c, (f | e)); | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$ak() | |
{ | |
var a = h$r1; | |
h$sp -= 4; | |
if(a) | |
{ | |
h$pp8(h$$al); | |
return h$e(h$baseZCSystemziPosixziInternalszigetEcho3); | |
} | |
else | |
{ | |
h$pp8(h$$am); | |
return h$e(h$baseZCSystemziPosixziInternalszisetEcho2); | |
}; | |
}; | |
function h$$aj() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = h$base_lflag(c, d); | |
h$p4(c, d, e, h$$ak); | |
return h$e(b); | |
}; | |
function h$$ai() | |
{ | |
h$p2(h$r1.d1, h$$aj); | |
return h$e(h$r2); | |
}; | |
function h$baseZCSystemziPosixziInternalszisetEcho1_e() | |
{ | |
h$r3 = h$c1(h$$ai, h$r3); | |
h$r1 = h$baseZCSystemziPosixziInternalszigetEcho4; | |
return h$baseZCSystemziPosixziInternalszigetEcho4_e; | |
}; | |
function h$baseZCSystemziPosixziInternalszisetCooked5_e() | |
{ | |
h$bh(); | |
var a = h$base_vmin; | |
h$r1 = (a | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCSystemziPosixziInternalszisetCooked4_e() | |
{ | |
h$bh(); | |
var a = h$base_vtime; | |
h$r1 = (a | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCSystemziPosixziInternalszisetCooked3_e() | |
{ | |
h$bh(); | |
var a = h$base_icanon; | |
var b = (a | 0); | |
var c = (b | 0); | |
h$r1 = (c ^ (-1)); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCSystemziPosixziInternalszisetCooked2_e() | |
{ | |
h$bh(); | |
var a = h$base_icanon; | |
var b = (a | 0); | |
h$r1 = (b | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$av() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a; | |
var e; | |
var f; | |
e = b; | |
f = (c + d); | |
e.u8[(f + 0)] = 0; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$au() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a; | |
var e; | |
var f; | |
e = b; | |
f = (c + d); | |
e.u8[(f + 0)] = 1; | |
h$pp4(h$$av); | |
return h$e(h$baseZCSystemziPosixziInternalszisetCooked4); | |
}; | |
function h$$at() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if(a) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
var d = h$base_ptr_c_cc(c, b); | |
h$p3(d, h$ret_1, h$$au); | |
return h$e(h$baseZCSystemziPosixziInternalszisetCooked5); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$as() | |
{ | |
var a = h$stack[(h$sp - 3)]; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
h$base_poke_lflag(b, c, h$r1); | |
h$pp5(c, h$$at); | |
return h$e(a); | |
}; | |
function h$$ar() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 3; | |
var c = a; | |
var d = (b | 0); | |
h$r1 = (d & c); | |
h$sp += 3; | |
++h$sp; | |
return h$$as; | |
}; | |
function h$$aq() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 3; | |
var c = a; | |
var d = (b | 0); | |
h$r1 = (d | c); | |
h$sp += 3; | |
++h$sp; | |
return h$$as; | |
}; | |
function h$$ap() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
h$sp -= 3; | |
if(a) | |
{ | |
h$sp += 3; | |
h$pp2(h$$aq); | |
return h$e(h$baseZCSystemziPosixziInternalszisetCooked2); | |
} | |
else | |
{ | |
h$sp += 3; | |
h$pp2(h$$ar); | |
return h$e(h$baseZCSystemziPosixziInternalszisetCooked3); | |
}; | |
}; | |
function h$$ao() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = h$base_lflag(c, d); | |
h$pp6(c, d); | |
h$p2(e, h$$ap); | |
return h$e(b); | |
}; | |
function h$$an() | |
{ | |
h$p2(h$r1.d1, h$$ao); | |
return h$e(h$r2); | |
}; | |
function h$baseZCSystemziPosixziInternalszisetCooked1_e() | |
{ | |
h$r3 = h$c1(h$$an, h$r3); | |
h$r1 = h$baseZCSystemziPosixziInternalszigetEcho4; | |
return h$baseZCSystemziPosixziInternalszigetEcho4_e; | |
}; | |
function h$$aK() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = h$base_tcgetattr(a, b, c); | |
var e = d; | |
h$r1 = (e | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$aJ() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p3(c, b.d2, h$$aK); | |
return h$e(a); | |
}; | |
function h$$aI() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = h$base_tcsanow; | |
var f = h$base_tcsetattr(d, (e | 0), a, c); | |
var g = f; | |
h$r1 = (g | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$aH() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$aG() | |
{ | |
var a = h$stack[(h$sp - 5)]; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
h$sp -= 6; | |
var d = h$base_sig_setmask; | |
var e = h$base_sigprocmask((d | 0), a, b, null, 0); | |
var f = e; | |
var g = (f | 0); | |
if((g === (-1))) | |
{ | |
var h = h$__hscore_get_errno(); | |
var i = h; | |
h$p1(h$$aH); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (i | 0), h$$aZ, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
h$r1 = c; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$aF() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 2)]; | |
var f = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
h$pp39(e, f, a, h$$aG); | |
h$l4(h$c3(h$$aI, b, c, d), h$$a2, h$baseZCSystemziPosixziInternalszifdFileSizzezupred, | |
h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$$aE() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$aD() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$aC() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$aB() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = h$newByteArray(h$base_sizeof_sigset_t); | |
var g = h$newByteArray(h$base_sizeof_sigset_t); | |
var h; | |
var i; | |
h = f; | |
i = 0; | |
var j = h$base_sigemptyset(f, 0); | |
var k = j; | |
var l = (k | 0); | |
if((l === (-1))) | |
{ | |
var m = h$__hscore_get_errno(); | |
var n = m; | |
h$p1(h$$aC); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (n | 0), h$$a1, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
var o = h$base_sigttou; | |
var p = h$base_sigaddset(h, i, (o | 0)); | |
var q = p; | |
var r = (q | 0); | |
if((r === (-1))) | |
{ | |
var s = h$__hscore_get_errno(); | |
var t = s; | |
h$p1(h$$aD); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (t | 0), h$$a0, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
var u = h$base_sig_block; | |
var v; | |
var w; | |
v = g; | |
w = 0; | |
var x = h$base_sigprocmask((u | 0), h, i, v, w); | |
var y = x; | |
var z = (y | 0); | |
if((z === (-1))) | |
{ | |
var A = h$__hscore_get_errno(); | |
var B = A; | |
h$p1(h$$aE); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (B | 0), h$$aZ, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
h$p8(c, d, e, f, g, v, w, h$$aF); | |
h$l2(h$c2(h$baseZCGHCziPtrziPtr_con_e, c, d), a); | |
return h$ap_2_1_fast(); | |
}; | |
}; | |
}; | |
}; | |
function h$$aA() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$az() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$ay() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$ax() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 5)]; | |
var c = h$stack[(h$sp - 4)]; | |
var d = h$stack[(h$sp - 3)]; | |
var e = h$stack[(h$sp - 2)]; | |
var f = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
var g = a; | |
var h = h$c4(h$$aB, c, f, b, a); | |
if((g <= 2)) | |
{ | |
var i = h$__hscore_get_saved_termios(g); | |
var j = i; | |
var k = h$ret1; | |
if(((j === null) && (k === 0))) | |
{ | |
var l = d; | |
var m = h$malloc((l | 0)); | |
var n = m; | |
var o = h$ret1; | |
if(((n === null) && (o === 0))) | |
{ | |
h$l2(h$baseZCForeignziMarshalziAlloczimallocBytes2, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
} | |
else | |
{ | |
var p = d; | |
var q = h$memcpy(n, o, f, b, (p | 0)); | |
h$__hscore_set_saved_termios(g, n, o); | |
h$p2(e, h$$ay); | |
h$r1 = h; | |
return h$ap_1_0_fast(); | |
}; | |
} | |
else | |
{ | |
h$p2(e, h$$az); | |
h$r1 = h; | |
return h$ap_1_0_fast(); | |
}; | |
} | |
else | |
{ | |
h$p2(e, h$$aA); | |
h$r1 = h; | |
return h$ap_1_0_fast(); | |
}; | |
}; | |
function h$$aw() | |
{ | |
var a = h$stack[(h$sp - 6)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
h$pp33(b, h$$ax); | |
return h$e(a); | |
}; | |
function h$baseZCSystemziPosixziInternalszigetEcho4_e() | |
{ | |
var a = h$newByteArray(h$base_sizeof_termios); | |
h$p7(h$r2, h$r3, h$base_sizeof_termios, a, a, 0, h$$aw); | |
h$l4(h$c3(h$$aJ, h$r2, a, 0), h$$a2, h$baseZCSystemziPosixziInternalszifdFileSizzezupred, | |
h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$baseZCSystemziPosixziInternalszigetEcho3_e() | |
{ | |
h$bh(); | |
var a = h$base_echo; | |
var b = (a | 0); | |
h$r1 = (b | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$aN() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a; | |
var d = (b | 0); | |
var e = (d & c); | |
if((e === 0)) | |
{ | |
h$r1 = false; | |
} | |
else | |
{ | |
h$r1 = true; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$aM() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p2(a, h$$aN); | |
return h$e(h$baseZCSystemziPosixziInternalszigetEcho3); | |
}; | |
function h$$aL() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
var c = h$base_lflag(b, a.d2); | |
h$r1 = h$c1(h$$aM, c); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCSystemziPosixziInternalszigetEcho2_e() | |
{ | |
h$p1(h$$aL); | |
return h$e(h$r2); | |
}; | |
var h$baseZCSystemziPosixziInternalsziioezuunknownfiletype2 = h$strta("fdType"); | |
var h$baseZCSystemziPosixziInternalsziioezuunknownfiletype1 = h$strta("unknown file type"); | |
function h$$aS() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
h$r1 = (b | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$aR() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a; | |
h$p1(h$$aS); | |
try | |
{ | |
var e; | |
var f = { mv: null | |
}; | |
e = h$mkForeignCallback(f); | |
h$base_fstat(d, b, c, e); | |
if((f.mv === null)) | |
{ | |
f.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(f.mv); | |
} | |
else | |
{ | |
var g = f.mv; | |
h$r1 = g[0]; | |
}; | |
} | |
catch(h$SystemziPosixziInternals_id_108_0) | |
{ | |
return h$throwJSException(h$SystemziPosixziInternals_id_108_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$aQ() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p3(c, b.d2, h$$aR); | |
return h$e(a); | |
}; | |
function h$$aP() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var c = h$r1; | |
var d = h$base_st_dev(a, b); | |
var e = d; | |
var f; | |
var g; | |
f = h$base_st_ino(a, b); | |
var h = h$c2(h$baseZCGHCziWordziW64zh_con_e, f, g); | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, c, (e | 0), h); | |
return h$stack[h$sp]; | |
}; | |
function h$$aO() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var c = h$base_st_mode(a, b); | |
var d = c; | |
var e = (d & 65535); | |
var f = h$base_c_s_isdir(e); | |
var g = f; | |
var h = (g | 0); | |
if((h === 0)) | |
{ | |
var i = h$base_c_s_isfifo(e); | |
var j = i; | |
var k = (j | 0); | |
if((k === 0)) | |
{ | |
var l = h$base_c_s_issock(e); | |
var m = l; | |
var n = (m | 0); | |
if((n === 0)) | |
{ | |
var o = h$base_c_s_ischr(e); | |
var p = o; | |
var q = (p | 0); | |
if((q === 0)) | |
{ | |
var r = h$base_c_s_isreg(e); | |
var s = r; | |
var t = (s | 0); | |
if((t === 0)) | |
{ | |
var u = h$base_c_s_isblk(e); | |
var v = u; | |
var w = (v | 0); | |
if((w === 0)) | |
{ | |
h$l2(h$baseZCSystemziPosixziInternalsziioezuunknownfiletype, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziIOziDeviceziRawDevice; | |
h$sp += 3; | |
++h$sp; | |
return h$$aP; | |
}; | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziIOziDeviceziRegularFile; | |
h$sp += 3; | |
++h$sp; | |
return h$$aP; | |
}; | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziIOziDeviceziStream; | |
h$sp += 3; | |
++h$sp; | |
return h$$aP; | |
}; | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziIOziDeviceziStream; | |
h$sp += 3; | |
++h$sp; | |
return h$$aP; | |
}; | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziIOziDeviceziStream; | |
h$sp += 3; | |
++h$sp; | |
return h$$aP; | |
}; | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziIOziDeviceziDirectory; | |
h$sp += 3; | |
++h$sp; | |
return h$$aP; | |
}; | |
}; | |
function h$baseZCSystemziPosixziInternalszifdStat1_e() | |
{ | |
var a = h$newByteArray(h$base_sizeof_stat); | |
h$p4(a, a, 0, h$$aO); | |
h$l4(h$c3(h$$aQ, h$r2, a, 0), h$baseZCSystemziPosixziInternalsziioezuunknownfiletype2, | |
h$baseZCSystemziPosixziInternalszifdFileSizzezupred, h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$$aT() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
if((b === (-1))) | |
{ | |
h$r1 = true; | |
} | |
else | |
{ | |
h$r1 = false; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCSystemziPosixziInternalszifdFileSizzezupred_e() | |
{ | |
h$p1(h$$aT); | |
return h$e(h$r2); | |
}; | |
var h$baseZCSystemziPosixziInternalszifdFileSizzezuloc = h$strta("fileSize"); | |
function h$$aY() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
h$r1 = (b | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$aX() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a; | |
h$p1(h$$aY); | |
try | |
{ | |
var e; | |
var f = { mv: null | |
}; | |
e = h$mkForeignCallback(f); | |
h$base_fstat(d, b, c, e); | |
if((f.mv === null)) | |
{ | |
f.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(f.mv); | |
} | |
else | |
{ | |
var g = f.mv; | |
h$r1 = g[0]; | |
}; | |
} | |
catch(h$SystemziPosixziInternals_id_114_0) | |
{ | |
return h$throwJSException(h$SystemziPosixziInternals_id_114_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$aW() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p3(c, b.d2, h$$aX); | |
return h$e(a); | |
}; | |
function h$$aV() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(b, a, h$integerzmgmpZCGHCziIntegerziTypeziint64ToInteger); | |
return h$ap_1_2_fast(); | |
}; | |
function h$$aU() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var c = h$base_st_mode(a, b); | |
var d = c; | |
var e = h$base_c_s_isreg((d & 65535)); | |
var f = e; | |
var g = (f | 0); | |
if((g === 0)) | |
{ | |
h$r1 = h$baseZCSystemziPosixziInternalszifdFileSizze2; | |
} | |
else | |
{ | |
var h = h$base_st_size(a, b); | |
h$r1 = h$c2(h$$aV, h, h$ret1); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCSystemziPosixziInternalszifdFileSizze1_e() | |
{ | |
var a = h$newByteArray(h$base_sizeof_stat); | |
h$p4(a, a, 0, h$$aU); | |
h$l4(h$c3(h$$aW, h$r2, a, 0), h$baseZCSystemziPosixziInternalszifdFileSizzezuloc, | |
h$baseZCSystemziPosixziInternalszifdFileSizzezupred, h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$baseZCGHCziWordziW32zh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziWordziW32zh_e() | |
{ | |
h$r1 = h$r2; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziWordziW64zh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziWordziW64zh_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziWordziW64zh_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$$a3() | |
{ | |
h$l3(h$r1.d1, h$$bS, h$$bO); | |
return h$$a4; | |
}; | |
function h$baseZCGHCziTopHandlerzirunIO2_e() | |
{ | |
h$r1 = h$baseZCGHCziTopHandlerzirunIO3; | |
return h$ap_2_1_fast(); | |
}; | |
function h$baseZCGHCziTopHandlerzirunIO3_e() | |
{ | |
return h$catch(h$c1(h$$a3, h$r2), h$baseZCGHCziTopHandlerzirunIO2); | |
}; | |
function h$$bI() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bH() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bI); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bG() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bF() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bG); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bE() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bD() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bE); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bC() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bB() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bC); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bA() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bz() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bA); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$by() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bx() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$by); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bw() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bv() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bw); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bu() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bt() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bu); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bs() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$br() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bs); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bq() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
var d = a.d2; | |
if((c === d)) | |
{ | |
h$l2(h$$bQ, b); | |
return h$ap_2_1_fast(); | |
} | |
else | |
{ | |
h$pp4(h$$bt); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
}; | |
} | |
else | |
{ | |
h$pp4(h$$br); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
}; | |
}; | |
function h$$bp() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bo() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bp); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bn() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l2(h$$bR, a); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bm() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp2(h$$bn); | |
h$l2(b, c.val); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bl() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$pp4(h$$bo); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
} | |
else | |
{ | |
var d = a.d2; | |
var e = d.d1; | |
if((c === e)) | |
{ | |
h$l2(h$$bQ, b); | |
return h$ap_2_1_fast(); | |
} | |
else | |
{ | |
h$pp4(h$$bm); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
}; | |
}; | |
}; | |
function h$$bk() | |
{ | |
var a = h$r1; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$pp12(a.d2, h$$bq); | |
return h$e(h$baseZCGHCziIOziHandleziFDzistdout); | |
} | |
else | |
{ | |
var b = a.d2; | |
h$pp12(b.d1, h$$bl); | |
return h$e(h$baseZCGHCziIOziHandleziFDzistdout); | |
}; | |
}; | |
function h$$bj() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
switch (a) | |
{ | |
case ((-1)): | |
h$pp4(h$$bv); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
case (32): | |
h$pp4(h$$bk); | |
return h$e(b); | |
default: | |
h$pp4(h$$bx); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
}; | |
}; | |
function h$$bi() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$pp4(h$$bz); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
} | |
else | |
{ | |
h$pp12(a.d1, h$$bj); | |
return h$e(b); | |
}; | |
}; | |
function h$$bh() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$pp4(h$$bB); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
} | |
else | |
{ | |
h$pp12(a.d1, h$$bi); | |
return h$e(b); | |
}; | |
}; | |
function h$$bg() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
if((a.f.a === 18)) | |
{ | |
h$pp8(h$$bh); | |
return h$e(b); | |
} | |
else | |
{ | |
h$pp4(h$$bD); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
}; | |
}; | |
function h$$bf() | |
{ | |
var a = h$r1; | |
h$sp -= 3; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
h$pp28(b, c.d4, h$$bg); | |
return h$e(d); | |
}; | |
function h$$be() | |
{ | |
var a = h$stack[(h$sp - 5)]; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
if(h$hs_eqWord64(b, c, 1685460941, (-241344014))) | |
{ | |
if(h$hs_eqWord64(d, e, (-1787550655), (-601376313))) | |
{ | |
h$pp4(h$$bf); | |
h$r1 = a; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$pp4(h$$bF); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
}; | |
} | |
else | |
{ | |
h$pp4(h$$bH); | |
return h$e(h$baseZCGHCziConcziSyncziuncaughtExceptionHandler); | |
}; | |
}; | |
function h$$bd() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$l2(h$$bQ, b); | |
return h$ap_2_1_fast(); | |
} | |
else | |
{ | |
h$l2(a.d1, b); | |
return h$ap_2_1_fast(); | |
}; | |
}; | |
function h$$bc() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
if(h$hs_eqWord64(c, e, (-91230330), 1741995454)) | |
{ | |
if(h$hs_eqWord64(f, g, (-1145465021), (-1155709843))) | |
{ | |
h$pp2(h$$bd); | |
h$r1 = b; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$pp120(c, e, f, g); | |
++h$sp; | |
return h$$be; | |
}; | |
} | |
else | |
{ | |
h$pp120(c, e, f, g); | |
++h$sp; | |
return h$$be; | |
}; | |
}; | |
function h$$bb() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
var b = a.d1; | |
h$pp14(a, a.d2, h$$bc); | |
++h$sp; | |
h$stack[h$sp] = h$ap_1_0; | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$$ba() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$pp2(h$$bb); | |
return h$e(a); | |
}; | |
function h$$a9() | |
{ | |
--h$sp; | |
h$l2(h$$bT, h$baseZCGHCziIOzifailIO); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$a8() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
switch (a.f.a) | |
{ | |
case (1): | |
h$stackOverflow(h$currentThread); | |
h$l2(h$$bP, b); | |
return h$ap_2_1_fast(); | |
case (4): | |
h$p1(h$$a9); | |
h$shutdownHaskellAndExit(252, 0); | |
break; | |
default: | |
h$sp += 2; | |
++h$sp; | |
return h$$ba; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$a7() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$sp += 2; | |
++h$sp; | |
return h$$ba; | |
} | |
else | |
{ | |
var b = a.d1; | |
h$sp += 2; | |
h$p1(h$$a8); | |
return h$e(b); | |
}; | |
}; | |
function h$$a6() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$sp += 2; | |
h$p1(h$$a7); | |
h$l2(a, h$baseZCGHCziIOziExceptionzizdfExceptionAsyncExceptionzuzdsasyncExceptionFromException); | |
return h$baseZCGHCziIOziExceptionzizdfExceptionAsyncExceptionzuzdsasyncExceptionFromException_e; | |
}; | |
function h$$a5() | |
{ | |
h$sp -= 3; | |
h$pp4(h$$a6); | |
return h$catch(h$baseZCGHCziTopHandlerziflushStdHandles2, h$baseZCGHCziTopHandlerziflushStdHandles3); | |
}; | |
function h$$a4() | |
{ | |
h$p3(h$r2, h$r3, h$$a5); | |
return h$catch(h$baseZCGHCziTopHandlerziflushStdHandles4, h$baseZCGHCziTopHandlerziflushStdHandles3); | |
}; | |
function h$$bL() | |
{ | |
--h$sp; | |
h$l2(h$$bT, h$baseZCGHCziIOzifailIO); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$bK() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
h$p1(h$$bL); | |
h$shutdownHaskellAndExit((b | 0), 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$bJ() | |
{ | |
h$p1(h$$bK); | |
return h$e(h$r2); | |
}; | |
var h$$bT = h$strta("If you can read this, shutdownHaskellAndExit did not exit."); | |
function h$$bM() | |
{ | |
var a = h$r1.d1; | |
var b = h$makeWeakNoFinalizer(h$currentThread, h$c1(h$baseZCGHCziConcziSyncziThreadId_con_e, h$currentThread)); | |
h$r1 = a; | |
return h$ap_1_0_fast(); | |
}; | |
function h$baseZCGHCziTopHandlerzirunMainIO1_e() | |
{ | |
return h$catch(h$c1(h$$bM, h$r2), h$baseZCGHCziTopHandlerzirunIO2); | |
}; | |
function h$baseZCGHCziTopHandlerziflushStdHandles4_e() | |
{ | |
h$l2(h$baseZCGHCziIOziHandleziFDzistdout, h$baseZCGHCziIOziHandlezihFlush1); | |
return h$baseZCGHCziIOziHandlezihFlush1_e; | |
}; | |
function h$$bN() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziTopHandlerziflushStdHandles3_e() | |
{ | |
h$p1(h$$bN); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziTopHandlerziflushStdHandles2_e() | |
{ | |
h$l2(h$baseZCGHCziIOziHandleziFDzistderr, h$baseZCGHCziIOziHandlezihFlush1); | |
return h$baseZCGHCziIOziHandlezihFlush1_e; | |
}; | |
function h$baseZCGHCziTopHandlerzitopHandler_e() | |
{ | |
h$r1 = h$baseZCGHCziTopHandlerzirunIO3; | |
return h$ap_2_1_fast(); | |
}; | |
function h$baseZCGHCziTopHandlerzirunMainIO_e() | |
{ | |
h$r1 = h$baseZCGHCziTopHandlerzirunMainIO1; | |
return h$baseZCGHCziTopHandlerzirunMainIO1_e; | |
}; | |
function h$$bW() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a; | |
b.dv.setUint32((d + (c << 2)), e, true); | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$bV() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 4; | |
h$pp10(a, h$$bW); | |
return h$e(b); | |
}; | |
function h$$bU() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp13(c, a.d2, h$$bV); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziStorableziwriteWideCharOffPtr1_e() | |
{ | |
h$p3(h$r3, h$r4, h$$bU); | |
return h$e(h$r2); | |
}; | |
function h$$bY() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a; | |
var e = b.dv.getUint32((c + (d << 2)), true); | |
h$r1 = e; | |
return h$stack[h$sp]; | |
}; | |
function h$$bX() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
h$p3(c, a.d2, h$$bY); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziStorablezireadWideCharOffPtr1_e() | |
{ | |
h$p2(h$r3, h$$bX); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziShowzizdwitoszq_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
if((a < 10)) | |
{ | |
h$r1 = ((48 + a) | 0); | |
h$r2 = b; | |
} | |
else | |
{ | |
var c = ((a / 10) | 0); | |
var d = c; | |
var e = (a - (10 * c)); | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, ((48 + e) | 0), b), d, h$baseZCGHCziShowzizdwitoszq); | |
return h$ap_2_2_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$b2() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(a, b, h$baseZCGHCziShowzishowLitString); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$b1() | |
{ | |
h$l3(h$r1.d1, h$r1.d2, h$baseZCGHCziShowzishowLitString); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$b0() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a; | |
if((d === 34)) | |
{ | |
h$l3(h$c2(h$$b1, b, c), h$$cG, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
h$l3(h$c2(h$$b2, b, c), d, h$baseZCGHCziShowzizdwshowLitChar); | |
return h$baseZCGHCziShowzizdwshowLitChar_e; | |
}; | |
}; | |
function h$$bZ() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$pp6(a.d2, h$$b0); | |
return h$e(c); | |
}; | |
}; | |
function h$baseZCGHCziShowzishowLitString_e() | |
{ | |
h$p2(h$r3, h$$bZ); | |
return h$e(h$r2); | |
}; | |
var h$$cG = h$strta("\\\""); | |
var h$$cH = h$strta("\\a"); | |
var h$$cI = h$strta("\\b"); | |
var h$$cJ = h$strta("\\t"); | |
var h$$cK = h$strta("\\n"); | |
var h$$cL = h$strta("\\v"); | |
var h$$cM = h$strta("\\f"); | |
var h$$cN = h$strta("\\r"); | |
var h$$cO = h$strta("\\SO"); | |
var h$$cP = h$strta("\\\\"); | |
var h$$cQ = h$strta("\\DEL"); | |
function h$$b5() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$b4() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$b5); | |
h$l3(h$ghczmprimZCGHCziTypesziZMZN, a, h$baseZCGHCziShowzizdwitos); | |
return h$baseZCGHCziShowzizdwitos_e; | |
}; | |
function h$$b3() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziErrzierror); | |
return h$ap_1_1_fast(); | |
}; | |
var h$$baseZCGHCziShow_9 = h$str("Char.intToDigit: not a digit "); | |
function h$baseZCGHCziShowziintToDigit1_e() | |
{ | |
h$p1(h$$b3); | |
h$r4 = h$c1(h$$b4, h$r2); | |
h$r3 = 0; | |
h$r2 = h$$baseZCGHCziShow_9(); | |
h$r1 = h$ghczmprimZCGHCziCStringziunpackAppendCStringzh; | |
return h$ap_2_3_fast(); | |
}; | |
function h$$b6() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a >= 10)) | |
{ | |
if((a <= 15)) | |
{ | |
var b = ((97 + a) | 0); | |
h$r1 = ((b - 10) | 0); | |
} | |
else | |
{ | |
h$l2(a, h$baseZCGHCziShowziintToDigit1); | |
return h$baseZCGHCziShowziintToDigit1_e; | |
}; | |
} | |
else | |
{ | |
h$l2(a, h$baseZCGHCziShowziintToDigit1); | |
return h$baseZCGHCziShowziintToDigit1_e; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziShowzizdwintToDigit_e() | |
{ | |
var a = h$r2; | |
if((a >= 0)) | |
{ | |
if((a <= 9)) | |
{ | |
h$r1 = ((48 + a) | 0); | |
} | |
else | |
{ | |
h$p1(a); | |
++h$sp; | |
return h$$b6; | |
}; | |
} | |
else | |
{ | |
h$p1(a); | |
++h$sp; | |
return h$$b6; | |
}; | |
return h$stack[h$sp]; | |
}; | |
var h$baseZCGHCziShowziasciiTab65 = h$strta("NUL"); | |
var h$baseZCGHCziShowziasciiTab64 = h$strta("SOH"); | |
var h$baseZCGHCziShowziasciiTab63 = h$strta("STX"); | |
var h$baseZCGHCziShowziasciiTab62 = h$strta("ETX"); | |
var h$baseZCGHCziShowziasciiTab61 = h$strta("EOT"); | |
var h$baseZCGHCziShowziasciiTab60 = h$strta("ENQ"); | |
var h$baseZCGHCziShowziasciiTab59 = h$strta("ACK"); | |
var h$baseZCGHCziShowziasciiTab58 = h$strta("BEL"); | |
var h$baseZCGHCziShowziasciiTab57 = h$strta("BS"); | |
var h$baseZCGHCziShowziasciiTab56 = h$strta("HT"); | |
var h$baseZCGHCziShowziasciiTab55 = h$strta("LF"); | |
var h$baseZCGHCziShowziasciiTab54 = h$strta("VT"); | |
var h$baseZCGHCziShowziasciiTab53 = h$strta("FF"); | |
var h$baseZCGHCziShowziasciiTab52 = h$strta("CR"); | |
var h$baseZCGHCziShowziasciiTab51 = h$strta("SO"); | |
var h$baseZCGHCziShowziasciiTab50 = h$strta("SI"); | |
var h$baseZCGHCziShowziasciiTab49 = h$strta("DLE"); | |
var h$baseZCGHCziShowziasciiTab48 = h$strta("DC1"); | |
var h$baseZCGHCziShowziasciiTab47 = h$strta("DC2"); | |
var h$baseZCGHCziShowziasciiTab46 = h$strta("DC3"); | |
var h$baseZCGHCziShowziasciiTab45 = h$strta("DC4"); | |
var h$baseZCGHCziShowziasciiTab44 = h$strta("NAK"); | |
var h$baseZCGHCziShowziasciiTab43 = h$strta("SYN"); | |
var h$baseZCGHCziShowziasciiTab42 = h$strta("ETB"); | |
var h$baseZCGHCziShowziasciiTab41 = h$strta("CAN"); | |
var h$baseZCGHCziShowziasciiTab40 = h$strta("EM"); | |
var h$baseZCGHCziShowziasciiTab39 = h$strta("SUB"); | |
var h$baseZCGHCziShowziasciiTab38 = h$strta("ESC"); | |
var h$baseZCGHCziShowziasciiTab37 = h$strta("FS"); | |
var h$baseZCGHCziShowziasciiTab36 = h$strta("GS"); | |
var h$baseZCGHCziShowziasciiTab35 = h$strta("RS"); | |
var h$baseZCGHCziShowziasciiTab34 = h$strta("US"); | |
var h$baseZCGHCziShowziasciiTab33 = h$strta("SP"); | |
function h$$b8() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$b7() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$p1(h$$b8); | |
h$l4(h$ghczmprimZCGHCziTypesziZMZN, a, 0, h$baseZCGHCziShowzizdwshowSignedInt); | |
return h$baseZCGHCziShowzizdwshowSignedInt_e; | |
}; | |
function h$baseZCGHCziShowzizdfShowIntzuzdcshow_e() | |
{ | |
h$p1(h$$b7); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziShowzizdfShowIntzuzdcshowList_e() | |
{ | |
h$l4(h$r3, h$r2, h$baseZCGHCziShowzishows18, h$baseZCGHCziShowzishowListzuzu); | |
return h$baseZCGHCziShowzishowListzuzu_e; | |
}; | |
function h$$b9() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(b, a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$baseZCGHCziShowzizdfShowZLz2cUZR1_e() | |
{ | |
var a = h$r2; | |
h$l2(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzishowListzuzu1, h$c2(h$$b9, h$r3, h$r4)), a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$ci() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
var b = a; | |
if((b < 0)) | |
{ | |
h$r1 = h$baseZCGHCziListziznzn1; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$l3(b, h$baseZCGHCziShowziasciiTab, h$baseZCGHCziListziznznzusub); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
var h$$baseZCGHCziShow_dQ = h$str("\\&"); | |
function h$$ch() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a; | |
if((c === 72)) | |
{ | |
h$r4 = b; | |
h$r3 = 0; | |
h$r2 = h$$baseZCGHCziShow_dQ(); | |
h$r1 = h$ghczmprimZCGHCziCStringziunpackAppendCStringzh; | |
return h$ap_2_3_fast(); | |
} | |
else | |
{ | |
h$r1 = b; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$cg() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
h$p2(a, h$$ch); | |
return h$e(a.d1); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$cf() | |
{ | |
h$p1(h$$cg); | |
return h$e(h$r1.d1); | |
}; | |
var h$$baseZCGHCziShow_dX = h$str("\\&"); | |
function h$$ce() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a; | |
if((c >= 48)) | |
{ | |
if((c <= 57)) | |
{ | |
h$r4 = b; | |
h$r3 = 0; | |
h$r2 = h$$baseZCGHCziShow_dX(); | |
h$r1 = h$ghczmprimZCGHCziCStringziunpackAppendCStringzh; | |
return h$ap_2_3_fast(); | |
} | |
else | |
{ | |
h$r1 = b; | |
}; | |
} | |
else | |
{ | |
h$r1 = b; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$cd() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
h$p2(a, h$$ce); | |
return h$e(a.d1); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$cc() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$cd); | |
return h$e(a); | |
}; | |
function h$$cb() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$ca() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p1(h$$cb); | |
h$l3(h$c1(h$$cc, b), a, h$baseZCGHCziShowzizdwitos); | |
return h$baseZCGHCziShowzizdwitos_e; | |
}; | |
function h$baseZCGHCziShowzizdwshowLitChar_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
if((a > 127)) | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$$cR, h$c2(h$$ca, a, b)); | |
} | |
else | |
{ | |
var c = a; | |
switch (a) | |
{ | |
case (92): | |
h$l3(b, h$$cP, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (127): | |
h$l3(b, h$$cQ, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
default: | |
if((c >= 32)) | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, c, b); | |
} | |
else | |
{ | |
switch (c) | |
{ | |
case (7): | |
h$l3(b, h$$cH, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (8): | |
h$l3(b, h$$cI, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (9): | |
h$l3(b, h$$cJ, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (10): | |
h$l3(b, h$$cK, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (11): | |
h$l3(b, h$$cL, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (12): | |
h$l3(b, h$$cM, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (13): | |
h$l3(b, h$$cN, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (14): | |
h$l3(h$c1(h$$cf, b), h$$cO, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
default: | |
h$l3(b, h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$$cR, h$c1(h$$ci, c)), h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
}; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$co() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$cn() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p1(h$$co); | |
h$l3(a, (-b | 0), h$baseZCGHCziShowzizdwitoszq); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$cm() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$cl() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p1(h$$cm); | |
h$l3(a, (-b | 0), h$baseZCGHCziShowzizdwitoszq); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$ck() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$cj() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
var b = (((-2147483648) / 10) | 0); | |
var c = b; | |
h$p1(h$$ck); | |
h$l3(h$c2(h$$cl, a, ((-2147483648) - (10 * b))), (-c | 0), h$baseZCGHCziShowzizdwitoszq); | |
return h$ap_2_2_fast(); | |
}; | |
function h$baseZCGHCziShowzizdwitos_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
if((a < 0)) | |
{ | |
var c = a; | |
if((c === (-2147483648))) | |
{ | |
h$r1 = h$baseZCGHCziShowzishows15; | |
h$r2 = h$c1(h$$cj, b); | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziShowzishows15; | |
h$r2 = h$c2(h$$cn, b, c); | |
}; | |
} | |
else | |
{ | |
h$l3(b, a, h$baseZCGHCziShowzizdwitoszq); | |
return h$ap_2_2_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$cq() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$cp() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p1(h$$cq); | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzishows12, b), a, h$baseZCGHCziShowzizdwitos); | |
return h$baseZCGHCziShowzizdwitos_e; | |
}; | |
function h$baseZCGHCziShowzizdwshowSignedInt_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
if((b < 0)) | |
{ | |
if((a > 6)) | |
{ | |
h$r1 = h$baseZCGHCziShowzishows13; | |
h$r2 = h$c2(h$$cp, b, c); | |
} | |
else | |
{ | |
h$l3(c, b, h$baseZCGHCziShowzizdwitos); | |
return h$baseZCGHCziShowzizdwitos_e; | |
}; | |
} | |
else | |
{ | |
h$l3(c, b, h$baseZCGHCziShowzizdwitos); | |
return h$baseZCGHCziShowzizdwitos_e; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$cs() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$cr() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$p1(h$$cs); | |
h$l4(b, a, 0, h$baseZCGHCziShowzizdwshowSignedInt); | |
return h$baseZCGHCziShowzizdwshowSignedInt_e; | |
}; | |
function h$baseZCGHCziShowzishows18_e() | |
{ | |
h$p2(h$r3, h$$cr); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziShowziDZCShow_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziShowziDZCShow_e() | |
{ | |
h$r1 = h$c3(h$baseZCGHCziShowziDZCShow_con_e, h$r2, h$r3, h$r4); | |
return h$stack[h$sp]; | |
}; | |
function h$$cv() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$cu() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$p1(h$$cv); | |
h$l4(c, a, b, h$baseZCGHCziShowzizdwshowSignedInt); | |
return h$baseZCGHCziShowzizdwshowSignedInt_e; | |
}; | |
function h$$ct() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 3; | |
h$pp5(a, h$$cu); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziShowzishowSignedInt_e() | |
{ | |
h$p3(h$r3, h$r4, h$$ct); | |
return h$e(h$r2); | |
}; | |
function h$$cx() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$cw() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$p1(h$$cx); | |
h$l2(a, h$baseZCGHCziShowzizdwintToDigit); | |
return h$baseZCGHCziShowzizdwintToDigit_e; | |
}; | |
function h$baseZCGHCziShowziintToDigit_e() | |
{ | |
h$p1(h$$cw); | |
return h$e(h$r2); | |
}; | |
var h$$baseZCGHCziShow_fz = h$str("[]"); | |
function h$$cE() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(b, a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$cD() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$bh(); | |
h$l3(h$c2(h$$cE, c, b.d3), d, a); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$cC() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = c; | |
} | |
else | |
{ | |
var e = a.d1; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzishowListzuzu1, h$c4(h$$cD, b, d, e, a.d2)); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$cB() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p4(a, c, b.d2, h$$cC); | |
return h$e(h$r2); | |
}; | |
function h$$cA() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$bh(); | |
var e = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzishowListzuzu2, c); | |
var f = h$c(h$$cB); | |
f.d1 = a; | |
f.d2 = h$d2(e, f); | |
h$l2(d, f); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$cz() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$bh(); | |
h$l3(h$c3(h$$cA, a, c, b.d3), d, a); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$cy() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$r4 = c; | |
h$r3 = 0; | |
h$r2 = h$$baseZCGHCziShow_fz(); | |
h$r1 = h$ghczmprimZCGHCziCStringziunpackAppendCStringzh; | |
return h$ap_2_3_fast(); | |
} | |
else | |
{ | |
var d = a.d1; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziShowzishowListzuzu3, h$c4(h$$cz, b, c, d, a.d2)); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziShowzishowListzuzu_e() | |
{ | |
h$p3(h$r2, h$r4, h$$cy); | |
return h$e(h$r3); | |
}; | |
function h$$cF() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$ap_0_0_fast(); | |
}; | |
function h$baseZCGHCziShowzishowsPrec_e() | |
{ | |
h$p1(h$$cF); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziSTRefziSTRef_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziSTRefziSTRef_e() | |
{ | |
h$r1 = h$c1(h$baseZCGHCziSTRefziSTRef_con_e, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$$cS() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a; | |
return h$ap_0_0_fast(); | |
}; | |
function h$baseZCGHCziSTzirunSTRep_e() | |
{ | |
h$p1(h$$cS); | |
h$r1 = h$r2; | |
return h$ap_1_0_fast(); | |
}; | |
function h$$cW() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l4(c, b, a, h$$c0); | |
return h$ap_3_3_fast(); | |
}; | |
function h$$cV() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = ((c - 1) | 0); | |
h$p3(((d / 2) | 0), a, h$$cW); | |
h$l3(b, b, h$integerzmgmpZCGHCziIntegerziTypezitimesInteger); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$cU() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l4(b, c, a, h$$c0); | |
return h$ap_3_3_fast(); | |
}; | |
function h$$cT() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = (b % 2); | |
if((d === 0)) | |
{ | |
h$p3(c, ((b / 2) | 0), h$$cU); | |
h$l3(a, a, h$integerzmgmpZCGHCziIntegerziTypezitimesInteger); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
var e = b; | |
if((e === 1)) | |
{ | |
h$l3(c, a, h$integerzmgmpZCGHCziIntegerziTypezitimesInteger); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
h$p3(a, e, h$$cV); | |
h$l3(c, a, h$integerzmgmpZCGHCziIntegerziTypezitimesInteger); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
}; | |
function h$$cY() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l4(b, c, a, h$$c0); | |
return h$$cT; | |
}; | |
function h$$cX() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l3(b, a, h$baseZCGHCziRealzizdwf1); | |
return h$ap_2_2_fast(); | |
}; | |
function h$baseZCGHCziRealzizdwf1_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = (b % 2); | |
if((c === 0)) | |
{ | |
h$p2(((b / 2) | 0), h$$cX); | |
h$l3(a, a, h$integerzmgmpZCGHCziIntegerziTypezitimesInteger); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
var d = b; | |
if((d === 1)) | |
{ | |
return h$e(a); | |
} | |
else | |
{ | |
var e = ((d - 1) | 0); | |
h$p3(a, ((e / 2) | 0), h$$cY); | |
h$l3(a, a, h$integerzmgmpZCGHCziIntegerziTypezitimesInteger); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
}; | |
var h$$c1 = h$strta("Negative exponent"); | |
function h$baseZCGHCziRealzizc3_e() | |
{ | |
h$bh(); | |
h$l2(h$$c1, h$baseZCGHCziErrzierror); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$cZ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
var c = (b % 2); | |
if((c === 0)) | |
{ | |
h$r1 = true; | |
} | |
else | |
{ | |
h$r1 = false; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziRealzievenzuzdseven1_e() | |
{ | |
h$p1(h$$cZ); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziRealzidivZZeroError_e() | |
{ | |
h$bh(); | |
return h$throw(h$baseZCGHCziExceptionzidivZZeroException, false); | |
}; | |
function h$baseZCGHCziPtrziPtr_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziPtrziPtr_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziPtrziPtr_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$$c2() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziNumzizdfNumIntzuzdcfromInteger_e() | |
{ | |
h$p1(h$$c2); | |
h$r1 = h$integerzmgmpZCGHCziIntegerziTypeziintegerToInt; | |
return h$ap_1_1_fast(); | |
}; | |
function h$baseZCGHCziMVarziMVar_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziMVarziMVar_e() | |
{ | |
h$r1 = h$c1(h$baseZCGHCziMVarziMVar_con_e, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$$c7() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$bh(); | |
h$l5(b.d3, d, c, a, h$baseZCGHCziListzizzipWith3); | |
return h$ap_4_4_fast(); | |
}; | |
function h$$c6() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$bh(); | |
h$l4(b.d3, d, c, a); | |
return h$ap_3_3_fast(); | |
}; | |
function h$$c5() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 5)]; | |
var c = h$stack[(h$sp - 4)]; | |
var d = h$stack[(h$sp - 3)]; | |
var e = h$stack[(h$sp - 2)]; | |
var f = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
var g = a.d1; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$c4(h$$c6, b, c, d, g), h$c4(h$$c7, b, e, f, a.d2)); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$c4() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 5; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
var c = a.d1; | |
h$pp52(c, a.d2, h$$c5); | |
return h$e(b); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$c3() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
var c = a.d1; | |
h$pp26(c, a.d2, h$$c4); | |
return h$e(b); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziListzizzipWith3_e() | |
{ | |
h$p4(h$r2, h$r4, h$r5, h$$c3); | |
return h$e(h$r3); | |
}; | |
function h$$c8() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$$dG; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
var c = a.d1; | |
var d = a.d2; | |
var e = b; | |
if((e === 0)) | |
{ | |
h$r1 = c; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$l3(((e - 1) | 0), d, h$baseZCGHCziListziznznzusub); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
}; | |
function h$baseZCGHCziListziznznzusub_e() | |
{ | |
h$p2(h$r3, h$$c8); | |
return h$e(h$r2); | |
}; | |
function h$$da() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if(a) | |
{ | |
h$l3(c, b, h$baseZCGHCziListziall); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
h$r1 = false; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$c9() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = true; | |
} | |
else | |
{ | |
var c = a.d1; | |
h$pp6(a.d2, h$$da); | |
h$l2(c, b); | |
return h$ap_1_1_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziListziall_e() | |
{ | |
h$p2(h$r2, h$$c9); | |
return h$e(h$r3); | |
}; | |
function h$$db() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
return h$e(b); | |
} | |
else | |
{ | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, a.d1, b), a.d2, h$baseZCGHCziListzireverse1); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$baseZCGHCziListzireverse1_e() | |
{ | |
h$p2(h$r3, h$$db); | |
return h$e(h$r2); | |
}; | |
function h$$dj() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$di() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p1(h$$dj); | |
h$l3(b, a, h$baseZCGHCziListzizdwspan); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$dh() | |
{ | |
var a = h$r1; | |
--h$sp; | |
return h$e(a.d2); | |
}; | |
function h$$dg() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$dh); | |
return h$e(a); | |
}; | |
function h$$df() | |
{ | |
var a = h$r1; | |
--h$sp; | |
return h$e(a.d1); | |
}; | |
function h$$de() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$df); | |
return h$e(a); | |
}; | |
function h$$dd() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
if(a) | |
{ | |
var f = h$c2(h$$di, b, e); | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, d, h$c1(h$$de, f)); | |
h$r2 = h$c1(h$$dg, f); | |
} | |
else | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
h$r2 = c; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$dc() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
h$r2 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
var c = a.d1; | |
h$pp30(a, c, a.d2, h$$dd); | |
h$l2(c, b); | |
return h$ap_1_1_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziListzizdwspan_e() | |
{ | |
h$p2(h$r2, h$$dc); | |
return h$e(h$r3); | |
}; | |
function h$$dr() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$dq() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p1(h$$dr); | |
h$l3(b, ((a - 1) | 0), h$baseZCGHCziListzizdwsplitAtzh); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$dp() | |
{ | |
var a = h$r1; | |
--h$sp; | |
return h$e(a.d2); | |
}; | |
function h$$dn() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$dp); | |
return h$e(a); | |
}; | |
function h$$dm() | |
{ | |
var a = h$r1; | |
--h$sp; | |
return h$e(a.d1); | |
}; | |
function h$$dl() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$dm); | |
return h$e(a); | |
}; | |
function h$$dk() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
h$r2 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
var c = a.d1; | |
var d = h$c2(h$$dq, b, a.d2); | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, c, h$c1(h$$dl, d)); | |
h$r2 = h$c1(h$$dn, d); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziListzizdwsplitAtzh_e() | |
{ | |
var a = h$r3; | |
var b = h$r2; | |
if((b === 0)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
h$r2 = a; | |
} | |
else | |
{ | |
h$p2(b, h$$dk); | |
return h$e(a); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$du() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(b, a, h$baseZCGHCziListzifoldr1); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$dt() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = c; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$l3(h$c2(h$$du, b, a), c, b); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$$ds() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$$dD; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$pp6(a.d1, h$$dt); | |
return h$e(a.d2); | |
}; | |
}; | |
function h$baseZCGHCziListzifoldr1_e() | |
{ | |
h$p2(h$r2, h$$ds); | |
return h$e(h$r3); | |
}; | |
function h$$dv() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = b; | |
} | |
else | |
{ | |
var c = a.d2; | |
h$l3(((b + 1) | 0), c, h$baseZCGHCziListzizdwlenAcc); | |
return h$ap_2_2_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziListzizdwlenAcc_e() | |
{ | |
h$p2(h$r3, h$$dv); | |
return h$e(h$r2); | |
}; | |
function h$$dx() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(b, a, h$baseZCGHCziListziinit1); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$dw() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
} | |
else | |
{ | |
var c = a.d1; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, b, h$c2(h$$dx, c, a.d2)); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziListziinit1_e() | |
{ | |
h$p2(h$r2, h$$dw); | |
return h$e(h$r3); | |
}; | |
var h$$dC = h$strta("init"); | |
function h$$dy() | |
{ | |
h$bh(); | |
h$l2(h$$dE, h$baseZCGHCziListzierrorEmptyList); | |
return h$baseZCGHCziListzierrorEmptyList_e; | |
}; | |
var h$$dE = h$strta("foldr1"); | |
var h$$dF = h$strta("Prelude.(!!): negative index\n"); | |
function h$$dz() | |
{ | |
h$bh(); | |
h$l2(h$$dH, h$baseZCGHCziErrzierror); | |
return h$ap_1_1_fast(); | |
}; | |
var h$$dH = h$strta("Prelude.(!!): index too large\n"); | |
var h$$dI = h$strta(": empty list"); | |
function h$baseZCGHCziListziinit2_e() | |
{ | |
h$bh(); | |
h$l2(h$$dC, h$baseZCGHCziListzierrorEmptyList); | |
return h$baseZCGHCziListzierrorEmptyList_e; | |
}; | |
function h$baseZCGHCziListziznzn1_e() | |
{ | |
h$bh(); | |
h$l2(h$$dF, h$baseZCGHCziErrzierror); | |
return h$ap_1_1_fast(); | |
}; | |
var h$$dJ = h$strta("Prelude."); | |
function h$$dB() | |
{ | |
h$l3(h$$dI, h$r1.d1, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$dA() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziErrzierror); | |
return h$ap_1_1_fast(); | |
}; | |
function h$baseZCGHCziListzierrorEmptyList_e() | |
{ | |
h$p1(h$$dA); | |
h$l3(h$c1(h$$dB, h$r2), h$$dJ, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$dL() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a.d1; | |
var e = h$hs_eqInt64(b, c, d, a.d2); | |
h$r1 = (e ? true : false); | |
return h$stack[h$sp]; | |
}; | |
function h$$dK() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
h$p3(c, a.d2, h$$dL); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIntzizdfEqInt64zuzdczeze_e() | |
{ | |
h$p2(h$r3, h$$dK); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIntziI32zh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIntziI32zh_e() | |
{ | |
h$r1 = h$r2; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIntziI64zh_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIntziI64zh_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIntziI64zh_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
var h$baseZCGHCziIOziHandleziTypeszishowHandle2 = h$strta("{handle: "); | |
function h$baseZCGHCziIOziHandleziTypesziNewlineMode_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziNewlineMode_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIOziHandleziTypesziNewlineMode_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziFileHandle_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziFileHandle_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIOziHandleziTypesziFileHandle_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$$dM() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$r1 = h$c2(h$baseZCGHCziIOziHandleziTypesziFileHandle_con_e, b, a.d1); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypeszizdWFileHandle_e() | |
{ | |
h$p2(h$r2, h$$dM); | |
return h$e(h$r3); | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziHandlezuzu_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziHandlezuzu_e() | |
{ | |
h$r1 = h$c16(h$baseZCGHCziIOziHandleziTypesziHandlezuzu_con_e, h$r2, h$r3, h$r4, h$r5, h$r6, h$r7, h$r8, h$r9, h$r10, | |
h$r11, h$r12, h$r13, h$r14, h$r15, h$r16, h$r17); | |
return h$stack[h$sp]; | |
}; | |
function h$$dR() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 15)]; | |
var c = h$stack[(h$sp - 14)]; | |
var d = h$stack[(h$sp - 13)]; | |
var e = h$stack[(h$sp - 12)]; | |
var f = h$stack[(h$sp - 11)]; | |
var g = h$stack[(h$sp - 10)]; | |
var h = h$stack[(h$sp - 9)]; | |
var i = h$stack[(h$sp - 8)]; | |
var j = h$stack[(h$sp - 7)]; | |
var k = h$stack[(h$sp - 6)]; | |
var l = h$stack[(h$sp - 5)]; | |
var m = h$stack[(h$sp - 4)]; | |
var n = h$stack[(h$sp - 3)]; | |
var o = h$stack[(h$sp - 2)]; | |
var p = h$stack[(h$sp - 1)]; | |
h$sp -= 16; | |
h$r1 = h$c16(h$baseZCGHCziIOziHandleziTypesziHandlezuzu_con_e, b, c, d, f, e, h, g, i, j, a.d1, k, l, m, n, o, p); | |
return h$stack[h$sp]; | |
}; | |
function h$$dQ() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
h$sp -= 16; | |
var c = a.d1; | |
h$sp += 16; | |
h$stack[(h$sp - 7)] = c; | |
h$stack[h$sp] = h$$dR; | |
return h$e(b); | |
}; | |
function h$$dP() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 8)]; | |
h$sp -= 16; | |
var c = a.d1; | |
h$sp += 16; | |
h$stack[(h$sp - 8)] = c; | |
h$stack[h$sp] = h$$dQ; | |
return h$e(b); | |
}; | |
function h$$dO() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 9)]; | |
h$sp -= 16; | |
var c = a.d1; | |
h$sp += 16; | |
h$stack[(h$sp - 9)] = c; | |
h$stack[h$sp] = h$$dP; | |
return h$e(b); | |
}; | |
function h$$dN() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 11)]; | |
h$sp -= 16; | |
h$sp += 16; | |
h$stack[(h$sp - 11)] = a; | |
h$stack[h$sp] = h$$dO; | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziHandleziTypeszizdWHandlezuzu_e() | |
{ | |
h$p16(h$r2, h$r3, h$r4, h$r6, h$r7, h$r8, h$r9, h$r10, h$r11, h$r12, h$r13, h$r14, h$r15, h$r16, h$r17, h$$dN); | |
h$r1 = h$r5; | |
return h$ap_0_0_fast(); | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziLF_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziBlockBuffering_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziBlockBuffering_e() | |
{ | |
h$r1 = h$c1(h$baseZCGHCziIOziHandleziTypesziBlockBuffering_con_e, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziLineBuffering_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziNoBuffering_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziWriteHandle_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziBufferListCons_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziBufferListCons_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIOziHandleziTypesziBufferListCons_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTypesziBufferListNil_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$$dU() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l3(b, a, h$baseZCGHCziIOziHandleziTextzihPutStr3); | |
return h$ap_3_2_fast(); | |
}; | |
function h$$dT() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 3; | |
h$pp4(h$$dU); | |
h$l3(a, b, h$baseZCGHCziIOziHandleziTextzizdwa7); | |
return h$baseZCGHCziIOziHandleziTextzizdwa7_e; | |
}; | |
function h$$dS() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
var b = a.d1; | |
h$pp6(a.d2, h$$dT); | |
return h$e(b); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziTextzihPutStr3_e() | |
{ | |
h$p2(h$r2, h$$dS); | |
return h$e(h$r3); | |
}; | |
var h$$eJ = h$strta("no buffer!"); | |
var h$$eK = h$strta("commitBuffer"); | |
var h$baseZCGHCziIOziHandleziTextzihPutStr7 = h$strta("hPutStr"); | |
function h$baseZCGHCziIOziHandleziTextzihPutStr6_e() | |
{ | |
h$bh(); | |
h$l2(h$$eJ, h$baseZCGHCziErrzierror); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$d1() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a.d2; | |
var e = d.d4; | |
var f = h$mulInt32(e, 4); | |
if((f < 0)) | |
{ | |
h$r1 = h$baseZCGHCziForeignPtrzimallocForeignPtrBytes2; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
var g = new h$MutVar(h$baseZCGHCziForeignPtrziNoFinalizzers); | |
var h = h$newByteArray(f); | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, b, | |
h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, h, 0, h$c2(h$baseZCGHCziForeignPtrziMallocPtr_con_e, h, g), | |
h$baseZCGHCziIOziBufferziWriteBuffer, e, 0, 0)), c); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$d0() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a.d2; | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, h$baseZCGHCziIOziBufferziWriteBuffer, e.d4, 0, 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$dZ() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
h$p4(c, e, d.d2, h$$d0); | |
return h$e(b); | |
}; | |
function h$$dY() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p2(a, h$$dZ); | |
return h$e(b); | |
}; | |
function h$$dX() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
if((a.f.a === 1)) | |
{ | |
h$pp6(d, h$$d1); | |
return h$e(e); | |
} | |
else | |
{ | |
var f = a.d1; | |
c.val = a.d2; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, b, h$c2(h$$dY, e, | |
f)), d); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$dW() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, h$baseZCGHCziIOziHandleziTextzihPutStr5, d); | |
} | |
else | |
{ | |
var e = c.val; | |
h$pp25(a, b.val, h$$dX); | |
return h$e(e); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$dV() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d2; | |
var c = b.d6; | |
var d = b.d8; | |
var e = b.d9; | |
h$p4(d, e, b.d14, h$$dW); | |
return h$e(c); | |
}; | |
function h$baseZCGHCziIOziHandleziTextzihPutStr4_e() | |
{ | |
h$p1(h$$dV); | |
return h$e(h$r2); | |
}; | |
function h$$eo() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a.d2; | |
var f = e.d4; | |
if((c === f)) | |
{ | |
d.val = h$c2(h$baseZCGHCziIOziHandleziTypesziBufferListCons_con_e, b, d.val); | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$en() | |
{ | |
var a = h$stack[(h$sp - 3)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
h$pp10(b, h$$eo); | |
return h$e(a.val); | |
}; | |
function h$$em() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 6)]; | |
var c = h$stack[(h$sp - 5)]; | |
var d = h$stack[(h$sp - 4)]; | |
var e = h$stack[(h$sp - 3)]; | |
var f = h$stack[(h$sp - 2)]; | |
var g = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
var h = a.d2; | |
var i = h.d8; | |
h$pp23(f, i, h.d9, h$$en); | |
h$l9(g, 0, e, h$baseZCGHCziIOziBufferziWriteBuffer, d, c, b, a, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
function h$$el() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = b.d4; | |
h$p7(a, c, d, e, f, b.d5, h$$em); | |
return h$e(h$r2); | |
}; | |
function h$$ek() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = h$stack[(h$sp - 7)]; | |
var d = h$stack[(h$sp - 4)]; | |
var e = h$stack[(h$sp - 3)]; | |
var f = h$stack[(h$sp - 2)]; | |
var g = h$stack[(h$sp - 1)]; | |
var h = h$stack[h$sp]; | |
h$sp -= 8; | |
if((a.f.a === 1)) | |
{ | |
h$l4(h$c6(h$$el, d, e, f, g, h, b), c, h$$eK, h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1_e; | |
} | |
else | |
{ | |
h$l3(h$ghczmprimZCGHCziTypesziZMZN, a, b); | |
h$sp += 8; | |
++h$sp; | |
return h$$d4; | |
}; | |
}; | |
function h$$ej() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
b.val = a; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$ei() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a.d2; | |
var f = e.d5; | |
var g = e.d6; | |
if((f === g)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$p2(d, h$$ej); | |
h$p3(a, c, h$ap_3_2); | |
h$l2(b, h$baseZCGHCziIOziBufferedIOziflushWriteBuffer); | |
return h$baseZCGHCziIOziBufferedIOziflushWriteBuffer_e; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$eh() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
h$pp8(h$$ei); | |
return h$e(a.val); | |
}; | |
function h$$eg() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 5)]; | |
var c = h$stack[(h$sp - 4)]; | |
var d = h$stack[(h$sp - 3)]; | |
var e = h$stack[(h$sp - 2)]; | |
var f = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
var g = a.d2; | |
var h = g.d1; | |
var i = g.d3; | |
h$p4(h, i, g.d5, h$$eh); | |
h$l9(f, 0, e, h$baseZCGHCziIOziBufferziWriteBuffer, d, c, b, a, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
function h$$ef() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
h$p6(a, c, d, e, b.d4, h$$eg); | |
return h$e(h$r2); | |
}; | |
function h$$ee() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$sp -= 8; | |
h$l3(a, b, 0); | |
h$sp += 8; | |
++h$sp; | |
return h$$d4; | |
}; | |
function h$$ed() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = h$stack[(h$sp - 7)]; | |
var f = h$stack[(h$sp - 4)]; | |
var g = h$stack[(h$sp - 3)]; | |
var h = h$stack[(h$sp - 2)]; | |
var i = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
if(a) | |
{ | |
var j = h$c5(h$$ef, f, g, h, i, d); | |
h$sp += 8; | |
h$pp4(h$$ee); | |
h$l4(j, e, h$$eK, h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1_e; | |
} | |
else | |
{ | |
h$l3(b, c, d); | |
h$sp += 8; | |
++h$sp; | |
return h$$d4; | |
}; | |
}; | |
function h$$ec() | |
{ | |
var a = h$stack[(h$sp - 9)]; | |
h$sp -= 11; | |
var b = h$r1; | |
h$sp += 8; | |
h$pp12(b, h$$ed); | |
return h$e(a); | |
}; | |
function h$$eb() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
h$sp -= 10; | |
if((a.f.a === 1)) | |
{ | |
c.dv.setUint32((d + (b << 2)), 10, true); | |
h$r1 = ((b + 1) | 0); | |
h$sp += 10; | |
++h$sp; | |
return h$$ec; | |
} | |
else | |
{ | |
c.dv.setUint32((d + (b << 2)), 13, true); | |
var e = ((b + 1) | 0); | |
c.dv.setUint32((d + (e << 2)), 10, true); | |
h$r1 = ((e + 1) | 0); | |
h$sp += 10; | |
++h$sp; | |
return h$$ec; | |
}; | |
}; | |
function h$$ea() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = h$stack[(h$sp - 5)]; | |
var f = h$stack[(h$sp - 4)]; | |
var g = h$stack[(h$sp - 3)]; | |
h$sp -= 8; | |
var h = a; | |
if((h === 10)) | |
{ | |
h$sp += 10; | |
h$stack[(h$sp - 1)] = c; | |
h$stack[h$sp] = d; | |
h$p2(b, h$$eb); | |
return h$e(e); | |
} | |
else | |
{ | |
f.dv.setUint32((g + (b << 2)), h, true); | |
h$l3(c, d, ((b + 1) | 0)); | |
h$sp += 8; | |
++h$sp; | |
return h$$d4; | |
}; | |
}; | |
function h$$d9() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$d8() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 5)]; | |
var c = h$stack[(h$sp - 4)]; | |
var d = h$stack[(h$sp - 3)]; | |
var e = h$stack[(h$sp - 2)]; | |
var f = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
h$p1(h$$d9); | |
h$l9(f, 0, e, h$baseZCGHCziIOziBufferziWriteBuffer, d, c, b, a, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
function h$$d7() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
h$p6(a, c, d, e, b.d4, h$$d8); | |
return h$e(h$r2); | |
}; | |
function h$$d6() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$sp -= 8; | |
h$l3(b, a, 0); | |
h$sp += 8; | |
++h$sp; | |
return h$$d4; | |
}; | |
function h$$d5() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = h$stack[(h$sp - 7)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
if((a.f.a === 1)) | |
{ | |
h$sp += 8; | |
h$pp2(h$$ek); | |
return h$e(c); | |
} | |
else | |
{ | |
var i = a.d1; | |
var j = a.d2; | |
var k = ((b + 1) | 0); | |
if((k >= h)) | |
{ | |
var l = h$c5(h$$d7, e, f, g, h, b); | |
h$sp += 8; | |
h$pp5(a, h$$d6); | |
h$l4(l, d, h$$eK, h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1_e; | |
} | |
else | |
{ | |
h$sp += 8; | |
h$pp12(j, h$$ea); | |
return h$e(i); | |
}; | |
}; | |
}; | |
function h$$d4() | |
{ | |
h$sp -= 9; | |
var a = h$r1; | |
var b = h$r2; | |
var c = h$r3; | |
h$sp += 8; | |
h$p3(a, c, h$$d5); | |
return h$e(b); | |
}; | |
function h$$d3() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if(a) | |
{ | |
h$r1 = h$$eM; | |
} | |
else | |
{ | |
h$r1 = h$ghczmprimZCGHCziTypesziZMZN; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$d2() | |
{ | |
h$p1(h$$d3); | |
return h$e(h$r1.d1); | |
}; | |
function h$baseZCGHCziIOziHandleziTextzizdwa8_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
h$l3(h$c1(h$$d2, h$r4), h$r10, 0); | |
h$p8(a, b, h$r5, h$r6, h$r7, h$r8, h$r9, h$c3(h$baseZCGHCziForeignPtrziForeignPtr_con_e, h$r6, h$r7, h$r8)); | |
++h$sp; | |
return h$$d4; | |
}; | |
function h$$ew() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if(a) | |
{ | |
h$l3(10, b, h$baseZCGHCziIOziHandleziTextzizdwa7); | |
return h$baseZCGHCziIOziHandleziTextzizdwa7_e; | |
} | |
else | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$ev() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$pp2(h$$ew); | |
return h$e(a); | |
}; | |
function h$$eu() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
var f = a.d1; | |
var g = a.d2; | |
var h = g.d1; | |
var i = g.d2; | |
h$l10(c, g.d4, i, h, f, e, d, true, b, h$baseZCGHCziIOziHandleziTextzizdwa8); | |
return h$baseZCGHCziIOziHandleziTextzizdwa8_e; | |
}; | |
function h$$et() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
var f = a.d1; | |
var g = a.d2; | |
var h = g.d1; | |
var i = g.d2; | |
h$l10(c, g.d4, i, h, f, e, d, false, b, h$baseZCGHCziIOziHandleziTextzizdwa8); | |
return h$baseZCGHCziIOziHandleziTextzizdwa8_e; | |
}; | |
function h$$es() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 5)]; | |
var c = h$stack[(h$sp - 4)]; | |
var d = h$stack[(h$sp - 3)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
switch (a.f.a) | |
{ | |
case (1): | |
h$pp6(d, h$$ev); | |
h$l3(c, b, h$baseZCGHCziIOziHandleziTextzihPutStr3); | |
return h$ap_3_2_fast(); | |
case (2): | |
h$pp16(h$$eu); | |
return h$e(e); | |
default: | |
h$pp16(h$$et); | |
return h$e(e); | |
}; | |
}; | |
function h$$er() | |
{ | |
var a = h$r1; | |
h$sp -= 5; | |
var b = a.d1; | |
h$pp48(a.d2, h$$es); | |
return h$e(b); | |
}; | |
function h$$eq() | |
{ | |
var a = h$r1; | |
h$sp -= 4; | |
var b = a.d1; | |
h$pp24(a.d2, h$$er); | |
return h$e(b); | |
}; | |
function h$$ep() | |
{ | |
var a = h$r1; | |
h$sp -= 4; | |
h$pp8(h$$eq); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziHandleziTextzihPutStr2_e() | |
{ | |
h$p4(h$r2, h$r3, h$r4, h$$ep); | |
h$l4(h$baseZCGHCziIOziHandleziTextzihPutStr4, h$r2, h$baseZCGHCziIOziHandleziTextzihPutStr7, | |
h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1_e; | |
}; | |
var h$baseZCGHCziIOziHandleziTextzihPutChar2 = h$strta("hPutChar"); | |
function h$$eI() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$eH() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a.d1; | |
var e = a.d2; | |
var f = e.d1; | |
var g = e.d2; | |
var h = e.d3; | |
var i = e.d4; | |
var j = e.d5; | |
var k = e.d6; | |
d.dv.setUint32((f + (k << 2)), c, true); | |
h$p1(h$$eI); | |
h$l9(((k + 1) | 0), j, i, h, g, f, d, b, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
function h$$eG() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
b.val = a; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$eF() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var d = a.d2; | |
var e = d.d5; | |
var f = d.d6; | |
if((e === f)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$pp2(h$$eG); | |
h$p3(a, c, h$ap_3_2); | |
h$l2(b, h$baseZCGHCziIOziBufferedIOziflushWriteBuffer); | |
return h$baseZCGHCziIOziBufferedIOziflushWriteBuffer_e; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$eE() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
h$sp -= 4; | |
if((a.f.a === 2)) | |
{ | |
h$pp8(h$$eF); | |
return h$e(b.val); | |
} | |
else | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$eD() | |
{ | |
var a = h$stack[(h$sp - 4)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
h$pp9(b, h$$eE); | |
return h$e(a); | |
}; | |
function h$$eC() | |
{ | |
var a = h$stack[(h$sp - 5)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
h$pp17(b, h$$eD); | |
h$l9(h$r7, h$r6, h$r5, h$r4, h$r3, h$r2, h$r1, a, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
function h$$eB() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 5; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d2; | |
var f = c.d3; | |
var g = c.d4; | |
var h = c.d5; | |
var i = c.d6; | |
b.dv.setUint32((d + (i << 2)), 10, true); | |
h$l7(((i + 1) | 0), h, g, f, e, d, b); | |
h$sp += 5; | |
++h$sp; | |
return h$$eC; | |
}; | |
function h$$eA() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 5; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d2; | |
var f = c.d3; | |
var g = c.d4; | |
var h = c.d5; | |
var i = c.d6; | |
b.dv.setUint32((d + (i << 2)), 13, true); | |
var j = ((i + 1) | 0); | |
b.dv.setUint32((d + (j << 2)), 10, true); | |
h$l7(((j + 1) | 0), h, g, f, e, d, b); | |
h$sp += 5; | |
++h$sp; | |
return h$$eC; | |
}; | |
function h$$ez() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 5; | |
if((a.f.a === 1)) | |
{ | |
h$sp += 5; | |
h$p1(h$$eB); | |
return h$e(b); | |
} | |
else | |
{ | |
h$sp += 5; | |
h$p1(h$$eA); | |
return h$e(b); | |
}; | |
}; | |
function h$$ey() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d3; | |
var f = c.d5; | |
var g = c.d6; | |
var h = c.d8; | |
var i = c.d14; | |
var j = h.val; | |
var k = b; | |
if((k === 10)) | |
{ | |
h$p5(a, d, e, f, g); | |
h$p2(j, h$$ez); | |
return h$e(i); | |
} | |
else | |
{ | |
h$p3(a, k, h$$eH); | |
return h$e(j); | |
}; | |
}; | |
function h$$ex() | |
{ | |
h$p2(h$r1.d1, h$$ey); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziHandleziTextzizdwa7_e() | |
{ | |
h$l4(h$c1(h$$ex, h$r3), h$r2, h$baseZCGHCziIOziHandleziTextzihPutChar2, | |
h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1_e; | |
}; | |
function h$$e5() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
var j = d.d6; | |
if((i === j)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$l9(j, i, h, g, f, e, c, b, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$e4() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
b.val = a; | |
h$pp2(h$$e5); | |
return h$e(c); | |
}; | |
function h$$e3() | |
{ | |
var a = h$stack[(h$sp - 7)]; | |
var b = h$stack[(h$sp - 6)]; | |
var c = h$stack[(h$sp - 5)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 9; | |
h$pp14(c, d, h$$e4); | |
h$p3(e, b, h$ap_3_2); | |
h$l2(a, h$baseZCGHCziIOziBufferedIOziflushWriteBuffer); | |
return h$baseZCGHCziIOziBufferedIOziflushWriteBuffer_e; | |
}; | |
function h$$e2() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 9)]; | |
var c = h$stack[(h$sp - 8)]; | |
var d = h$stack[(h$sp - 7)]; | |
var e = h$stack[(h$sp - 6)]; | |
var f = h$stack[(h$sp - 5)]; | |
var g = h$stack[(h$sp - 4)]; | |
var h = h$stack[(h$sp - 3)]; | |
var i = h$stack[(h$sp - 2)]; | |
var j = h$stack[(h$sp - 1)]; | |
h$sp -= 10; | |
var k = h$stack[(h$sp - 7)]; | |
var l = h$stack[(h$sp - 4)]; | |
var m = h$stack[h$sp]; | |
h$sp -= 8; | |
var n = a; | |
var o = ((c - b) | 0); | |
if((o >= n)) | |
{ | |
h$sp += 8; | |
++h$sp; | |
return h$$e3; | |
} | |
else | |
{ | |
l.val = m; | |
if((i === j)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$l9(j, i, h, g, f, e, d, k, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$e1() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 10; | |
var i = h$stack[(h$sp - 7)]; | |
var j = h$stack[(h$sp - 4)]; | |
var k = h$stack[h$sp]; | |
h$sp -= 8; | |
if((a.f.a === 1)) | |
{ | |
j.val = k; | |
if((g === h)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$l9(h, g, f, e, d, c, b, i, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
} | |
else | |
{ | |
var l = a.d1; | |
h$sp += 8; | |
h$sp += 10; | |
h$stack[h$sp] = h$$e2; | |
return h$e(l); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$e0() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 10; | |
var i = h$stack[(h$sp - 7)]; | |
var j = h$stack[(h$sp - 4)]; | |
var k = h$stack[h$sp]; | |
h$sp -= 8; | |
switch (a.f.a) | |
{ | |
case (1): | |
h$sp += 8; | |
++h$sp; | |
return h$$e3; | |
case (2): | |
j.val = k; | |
if((g === h)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$l9(h, g, f, e, d, c, b, i, h$baseZCGHCziIOziHandleziInternalszizdwa3); | |
return h$ap_gen_fast(2056); | |
}; | |
break; | |
default: | |
var l = a.d1; | |
h$sp += 8; | |
h$sp += 10; | |
h$stack[h$sp] = h$$e1; | |
return h$e(l); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$eZ() | |
{ | |
var a = h$stack[(h$sp - 13)]; | |
h$sp -= 18; | |
h$sp += 8; | |
h$sp += 10; | |
h$stack[h$sp] = h$$e0; | |
return h$e(a); | |
}; | |
function h$$eY() | |
{ | |
var a = h$r1; | |
h$sp -= 3; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 8; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
var j = d.d6; | |
if((i === j)) | |
{ | |
h$sp += 17; | |
h$stack[(h$sp - 6)] = c; | |
h$stack[(h$sp - 5)] = e; | |
h$stack[(h$sp - 4)] = f; | |
h$stack[(h$sp - 3)] = g; | |
h$stack[(h$sp - 2)] = h; | |
h$stack[(h$sp - 1)] = i; | |
h$stack[h$sp] = j; | |
++h$sp; | |
return h$$eZ; | |
} | |
else | |
{ | |
if((i === b)) | |
{ | |
h$sp += 8; | |
++h$sp; | |
return h$$e3; | |
} | |
else | |
{ | |
h$sp += 17; | |
h$stack[(h$sp - 6)] = c; | |
h$stack[(h$sp - 5)] = e; | |
h$stack[(h$sp - 4)] = f; | |
h$stack[(h$sp - 3)] = g; | |
h$stack[(h$sp - 2)] = h; | |
h$stack[(h$sp - 1)] = i; | |
h$stack[h$sp] = j; | |
++h$sp; | |
return h$$eZ; | |
}; | |
}; | |
}; | |
function h$$eX() | |
{ | |
h$sp -= 7; | |
var a = h$r1; | |
var b = h$r6; | |
var c = h$r7; | |
var d = h$r8; | |
var e = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, h$r2, h$r3, h$r4, h$r5, h$r6, h$r7, h$r8); | |
if((b === d)) | |
{ | |
h$pp192(a, e); | |
++h$sp; | |
return h$$e3; | |
} | |
else | |
{ | |
h$pp192(a, e); | |
h$p3(c, d, h$$eY); | |
return h$e(a); | |
}; | |
}; | |
function h$$eW() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 6; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
h$l8(d.d6, i, h, g, f, e, c, b); | |
h$sp += 6; | |
++h$sp; | |
return h$$eX; | |
}; | |
function h$$eV() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 6; | |
var b = a.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$sp += 6; | |
h$p2(c, h$$eW); | |
return h$e(d); | |
}; | |
function h$$eU() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 6; | |
var b = a; | |
h$sp += 6; | |
h$p1(h$$eV); | |
return h$e(b); | |
}; | |
function h$$eT() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 6)]; | |
var c = h$stack[(h$sp - 5)]; | |
var d = h$stack[(h$sp - 4)]; | |
var e = h$stack[(h$sp - 3)]; | |
var f = h$stack[(h$sp - 2)]; | |
var g = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
var h = h$stack[h$sp]; | |
h$sp -= 6; | |
var i = a.d1; | |
var j = a.d2; | |
var k = j.d1; | |
var l = j.d2; | |
var m = j.d3; | |
var n = j.d4; | |
var o = j.d5; | |
var p = j.d6; | |
h$sp += 6; | |
h$p1(h$$eU); | |
h$l15(p, o, n, m, l, k, i, b, h, g, f, e, d, c, h$baseZCGHCziIOziEncodingziLatin1zizdwa); | |
return h$baseZCGHCziIOziEncodingziLatin1zizdwa_e; | |
}; | |
function h$$eS() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 6; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
h$l8(d.d6, i, h, g, f, e, c, b); | |
h$sp += 6; | |
++h$sp; | |
return h$$eX; | |
}; | |
function h$$eR() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 6; | |
var b = a.d1; | |
var c = a.d2; | |
h$sp += 6; | |
h$p2(b, h$$eS); | |
return h$e(c); | |
}; | |
function h$$eQ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 6; | |
var b = a; | |
h$sp += 6; | |
h$p1(h$$eR); | |
return h$e(b); | |
}; | |
function h$$eP() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var i = h$stack[h$sp]; | |
h$sp -= 6; | |
var j = a.d1; | |
var k = a.d2; | |
var l = k.d1; | |
var m = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, c, d, e, f, g, i, b); | |
h$sp += 6; | |
h$p1(h$$eQ); | |
h$l5(h, m, l, j, h$baseZCGHCziIOziHandleziInternalszizdwa); | |
return h$baseZCGHCziIOziHandleziInternalszizdwa_e; | |
}; | |
function h$$eO() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
h$sp -= 6; | |
if((a.f.a === 1)) | |
{ | |
h$sp += 6; | |
h$pp64(h$$eT); | |
return h$e(b); | |
} | |
else | |
{ | |
var c = a.d1; | |
h$sp += 6; | |
h$pp128(h$$eP); | |
return h$e(c); | |
}; | |
}; | |
function h$$eN() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
h$sp -= 8; | |
var g = a.d2; | |
var h = g.d1; | |
var i = g.d3; | |
var j = g.d5; | |
var k = g.d6; | |
var l = g.d10; | |
var m = j.val; | |
h$sp += 6; | |
h$stack[(h$sp - 5)] = a; | |
h$stack[(h$sp - 4)] = h; | |
h$stack[(h$sp - 3)] = i; | |
h$stack[(h$sp - 2)] = j; | |
h$stack[(h$sp - 1)] = k; | |
h$pp254(b, c, d, e, f, m, h$$eO); | |
return h$e(l); | |
}; | |
function h$baseZCGHCziIOziHandleziInternalszizdwa3_e() | |
{ | |
h$p8(h$r3, h$r4, h$r5, h$r6, h$r7, h$r8, h$r9, h$$eN); | |
return h$e(h$r2); | |
}; | |
function h$$fe() | |
{ | |
var a = h$stack[(h$sp - 4)]; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
h$l5(d, c, b, a, h$baseZCGHCziIOziHandleziInternalszizdwa2); | |
return h$ap_gen_fast(1029); | |
}; | |
function h$$fd() | |
{ | |
var a = h$stack[(h$sp - 5)]; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 10; | |
if(h$hs_eqWord64(b, c, (-645907477), (-1617761578))) | |
{ | |
if(h$hs_eqWord64(d, e, (-980415011), (-840439589))) | |
{ | |
h$pp16(h$$fe); | |
return h$killThread(h$currentThread, a); | |
} | |
else | |
{ | |
return h$throw(a, false); | |
}; | |
} | |
else | |
{ | |
return h$throw(a, false); | |
}; | |
}; | |
function h$$fc() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$fb() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 6)]; | |
var c = h$stack[(h$sp - 5)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
var e = a.d1; | |
var f = a.d2; | |
var g = f.d1; | |
var h = f.d2; | |
var i = f.d3; | |
if(h$hs_eqWord64(e, g, 1685460941, (-241344014))) | |
{ | |
if(h$hs_eqWord64(h, i, (-1787550655), (-601376313))) | |
{ | |
h$p1(h$$fc); | |
h$l4(c, b, d, h$baseZCGHCziIOziHandleziInternalsziaugmentIOError); | |
return h$baseZCGHCziIOziHandleziInternalsziaugmentIOError_e; | |
} | |
else | |
{ | |
h$sp += 9; | |
h$stack[(h$sp - 3)] = e; | |
h$stack[(h$sp - 2)] = g; | |
h$stack[(h$sp - 1)] = h; | |
h$stack[h$sp] = i; | |
++h$sp; | |
return h$$fd; | |
}; | |
} | |
else | |
{ | |
h$sp += 9; | |
h$stack[(h$sp - 3)] = e; | |
h$stack[(h$sp - 2)] = g; | |
h$stack[(h$sp - 1)] = h; | |
h$stack[h$sp] = i; | |
++h$sp; | |
return h$$fd; | |
}; | |
}; | |
function h$$fa() | |
{ | |
var a = h$r1; | |
h$sp -= 5; | |
var b = a.d1; | |
h$pp112(a, a.d2, h$$fb); | |
++h$sp; | |
h$stack[h$sp] = h$ap_1_0; | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$$e9() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
h$pp16(h$$fa); | |
return h$e(a); | |
}; | |
function h$$e8() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
h$p6(a, c, d, e, h$r2, h$$e9); | |
return h$putMVar(e, b.d4); | |
}; | |
function h$$e7() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l2(b, a); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$e6() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
return h$catch(h$c2(h$$e7, d, a), h$c5(h$$e8, b, c, d, e, a)); | |
}; | |
function h$baseZCGHCziIOziHandleziInternalszizdwa2_e() | |
{ | |
h$p5(h$r2, h$r3, h$r4, h$r5, h$$e6); | |
return h$takeMVar(h$r5); | |
}; | |
var h$$gE = h$strta("codec_state"); | |
var h$$gF = h$strta("handle is finalized"); | |
var h$$gG = h$strta("handle is not open for writing"); | |
function h$$fj() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$fi() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
h$p2(a.d2, h$$fj); | |
return h$putMVar(b, c); | |
}; | |
function h$$fh() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
h$pp2(h$$fi); | |
return h$e(a); | |
}; | |
function h$$fg() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a.d1; | |
h$p2(e, h$$fh); | |
h$l5(e, d, c, b, h$baseZCGHCziIOziHandleziInternalszizdwa2); | |
return h$ap_gen_fast(1029); | |
}; | |
function h$$ff() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$p4(a, c, b.d3, h$$fg); | |
return h$e(d); | |
}; | |
function h$baseZCGHCziIOziHandleziInternalsziwithHandlezq1_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = h$r5; | |
var e = h$maskStatus(); | |
var f = h$c4(h$$ff, a, b, c, d); | |
var g = e; | |
if((g === 0)) | |
{ | |
return h$maskAsync(f); | |
} | |
else | |
{ | |
h$r1 = f; | |
return h$ap_1_0_fast(); | |
}; | |
}; | |
function h$$fO() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, b, a); | |
return h$stack[h$sp]; | |
}; | |
function h$$fN() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d2; | |
var f = c.d4; | |
var g = c.d5; | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, d, e, h$baseZCGHCziIOziBufferziWriteBuffer, f, g, c.d6); | |
return h$stack[h$sp]; | |
}; | |
function h$$fM() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$fN); | |
return h$e(a); | |
}; | |
function h$$fL() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, b, a); | |
return h$stack[h$sp]; | |
}; | |
function h$$fK() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
d.val = a; | |
h$p2(c, h$$fL); | |
h$l2(c, b); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$fJ() | |
{ | |
var a = h$stack[(h$sp - 4)]; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
a.val = h$c1(h$$fM, a.val); | |
h$pp12(d, h$$fK); | |
h$p3(d.val, c, h$ap_3_2); | |
h$l2(b, h$baseZCGHCziIOziBufferedIOziemptyWriteBuffer); | |
return h$baseZCGHCziIOziBufferedIOziemptyWriteBuffer_e; | |
}; | |
function h$$fI() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
var c = ((b - a) | 0); | |
h$l2((-c | 0), h$integerzmgmpZCGHCziIntegerziTypezismallInteger); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$fH() | |
{ | |
var a = h$stack[(h$sp - 5)]; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
var f = h$stack[h$sp]; | |
h$sp -= 6; | |
f.val = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, e, a, 0, 0); | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
h$sp += 6; | |
++h$sp; | |
return h$$fJ; | |
}; | |
function h$$fG() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 8)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 9; | |
var f = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
if(a) | |
{ | |
var g = h$c2(h$$fI, d, e); | |
h$sp += 6; | |
h$pp33(c, h$$fH); | |
h$p4(g, h$baseZCGHCziIOziDeviceziRelativeSeek, f, h$ap_4_3); | |
h$l2(b, h$baseZCGHCziIOziDeviceziseek); | |
return h$baseZCGHCziIOziDeviceziseek_e; | |
} | |
else | |
{ | |
h$l2(h$baseZCGHCziIOziHandleziInternalsziflushBuffer3, h$baseZCGHCziIOziExceptionziioException); | |
return h$ap_2_1_fast(); | |
}; | |
}; | |
function h$$fF() | |
{ | |
var a = h$r1; | |
h$sp -= 9; | |
h$sp -= 6; | |
var b = a; | |
h$sp += 6; | |
h$sp += 9; | |
h$stack[h$sp] = h$$fG; | |
return h$e(b); | |
}; | |
function h$$fE() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 5)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var e = a.d1; | |
var f = a.d2; | |
var g = f.d1; | |
var h = f.d2; | |
var i = f.d3; | |
var j = f.d4; | |
var k = f.d5; | |
var l = f.d6; | |
if((k === l)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
h$sp += 6; | |
h$stack[(h$sp - 3)] = d; | |
++h$sp; | |
return h$$fJ; | |
} | |
else | |
{ | |
h$sp += 6; | |
h$stack[(h$sp - 3)] = d; | |
h$p9(b, e, g, h, i, j, k, l, h$$fF); | |
h$p2(c, h$ap_2_1); | |
h$l2(b, h$baseZCGHCziIOziDeviceziisSeekable); | |
return h$baseZCGHCziIOziDeviceziisSeekable_e; | |
}; | |
}; | |
function h$$fD() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
h$sp -= 8; | |
h$pp128(h$$fE); | |
return h$e(a.val); | |
}; | |
function h$$fC() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d2; | |
var f = c.d3; | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, d, e, f, c.d4, 0, 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$fB() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$fC); | |
return h$e(a); | |
}; | |
function h$$fA() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
var j = d.d6; | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, c, e, f, g, h, ((i + b) | 0), j); | |
return h$stack[h$sp]; | |
}; | |
function h$$fz() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p2(b, h$$fA); | |
return h$e(a); | |
}; | |
function h$$fy() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
b.val = a.d1; | |
h$sp += 7; | |
++h$sp; | |
return h$$fD; | |
}; | |
function h$$fx() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 7; | |
var b = a; | |
h$sp += 7; | |
h$p1(h$$fy); | |
return h$e(b); | |
}; | |
function h$$fw() | |
{ | |
var a = h$stack[(h$sp - 8)]; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 9; | |
h$sp -= 7; | |
var i = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, d, e, f, g, 0, 0); | |
h$sp += 7; | |
h$p1(h$$fx); | |
h$l5(i, c, h, b, h$baseZCGHCziIOziHandleziInternalszizdwa); | |
return h$baseZCGHCziIOziHandleziInternalszizdwa_e; | |
}; | |
function h$$fv() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 6)]; | |
h$sp -= 8; | |
h$sp -= 7; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d4; | |
h$sp += 7; | |
h$sp += 9; | |
h$stack[(h$sp - 7)] = c; | |
h$stack[(h$sp - 1)] = e; | |
h$stack[h$sp] = h$$fw; | |
h$l2(b, f); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$fu() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 5)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
if((a.f.a === 1)) | |
{ | |
d.val = h$c2(h$$fz, b, c); | |
h$sp += 7; | |
++h$sp; | |
return h$$fD; | |
} | |
else | |
{ | |
var e = a.d1; | |
h$sp += 7; | |
h$pp128(h$$fv); | |
return h$e(e); | |
}; | |
}; | |
function h$$ft() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
var e = a.d1; | |
var f = a.d2; | |
var g = f.d1; | |
var h = f.d2; | |
var i = f.d3; | |
var j = f.d5; | |
if((j === 0)) | |
{ | |
d.val = c; | |
h$sp += 7; | |
++h$sp; | |
return h$$fD; | |
} | |
else | |
{ | |
h$sp += 7; | |
h$pp249(e, g, h, i, j, h$$fu); | |
return h$e(b); | |
}; | |
}; | |
function h$$fs() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
var b = h$stack[h$sp]; | |
h$sp -= 7; | |
var c = a.d1; | |
var d = a.d2; | |
var e = b.val; | |
b.val = h$c1(h$$fB, e); | |
h$sp += 7; | |
h$pp14(c, d, h$$ft); | |
return h$e(e); | |
}; | |
function h$$fr() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
h$sp -= 7; | |
if((a.f.a === 1)) | |
{ | |
if((d === e)) | |
{ | |
h$sp += 7; | |
++h$sp; | |
return h$$fD; | |
} | |
else | |
{ | |
var f = b.val; | |
h$sp += 7; | |
h$p2(c, h$$fs); | |
return h$e(f); | |
}; | |
} | |
else | |
{ | |
h$sp += 7; | |
++h$sp; | |
return h$$fD; | |
}; | |
}; | |
function h$$fq() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
h$sp -= 10; | |
var d = a.d2; | |
var e = d.d3; | |
var f = d.d5; | |
h$pp64(c); | |
h$pp29(b, f, d.d6, h$$fr); | |
return h$e(e); | |
}; | |
function h$$fp() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, b, a); | |
return h$stack[h$sp]; | |
}; | |
function h$$fo() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 9)]; | |
var c = h$stack[(h$sp - 8)]; | |
var d = h$stack[(h$sp - 2)]; | |
h$sp -= 10; | |
if((a.f.a === 1)) | |
{ | |
var e = d.val; | |
h$sp += 10; | |
h$stack[h$sp] = h$$fq; | |
return h$e(e); | |
} | |
else | |
{ | |
h$p2(c, h$$fp); | |
h$l2(c, b); | |
return h$ap_2_1_fast(); | |
}; | |
}; | |
function h$$fn() | |
{ | |
var a = h$r1; | |
h$sp -= 10; | |
var b = a.d2; | |
var c = b.d3; | |
h$sp += 10; | |
h$stack[h$sp] = h$$fo; | |
return h$e(c); | |
}; | |
function h$$fm() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 9)]; | |
var c = h$stack[(h$sp - 8)]; | |
var d = h$stack[(h$sp - 2)]; | |
h$sp -= 10; | |
switch (a.f.a) | |
{ | |
case (1): | |
h$l2(h$baseZCGHCziIOziHandleziInternalsziwantSeekableHandle3, h$baseZCGHCziIOziExceptionziioException); | |
return h$ap_2_1_fast(); | |
case (2): | |
h$l2(h$baseZCGHCziIOziHandleziInternalsziwantSeekableHandle3, h$baseZCGHCziIOziExceptionziioException); | |
return h$ap_2_1_fast(); | |
case (3): | |
h$l2(h$$gH, h$baseZCGHCziIOziExceptionziioException); | |
return h$ap_2_1_fast(); | |
case (6): | |
var e = d.val; | |
h$sp += 10; | |
h$stack[h$sp] = h$$fn; | |
return h$e(e); | |
default: | |
h$p2(c, h$$fO); | |
h$l2(c, b); | |
return h$ap_2_1_fast(); | |
}; | |
}; | |
function h$$fl() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d3; | |
var f = c.d4; | |
var g = c.d5; | |
var h = c.d7; | |
var i = c.d8; | |
var j = c.d11; | |
h$sp += 10; | |
h$stack[(h$sp - 8)] = a; | |
h$stack[(h$sp - 7)] = b; | |
h$stack[(h$sp - 6)] = d; | |
h$stack[(h$sp - 5)] = e; | |
h$stack[(h$sp - 4)] = g; | |
h$stack[(h$sp - 3)] = h; | |
h$stack[(h$sp - 2)] = i; | |
h$stack[(h$sp - 1)] = j; | |
h$stack[h$sp] = h$$fm; | |
return h$e(f); | |
}; | |
function h$$fk() | |
{ | |
h$p2(h$r1.d1, h$$fl); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle2_e() | |
{ | |
h$r5 = h$c1(h$$fk, h$r5); | |
h$r1 = h$baseZCGHCziIOziHandleziInternalsziwithHandlezq1; | |
return h$baseZCGHCziIOziHandleziInternalsziwithHandlezq1_e; | |
}; | |
function h$$fP() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$l5(c, h$c1(h$baseZCGHCziMVarziMVar_con_e, a.d2), a, b, h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle2); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle2_e; | |
} | |
else | |
{ | |
var d = a.d2; | |
h$l5(c, h$c1(h$baseZCGHCziMVarziMVar_con_e, d.d2), a, b, h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle2); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle2_e; | |
}; | |
}; | |
function h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1_e() | |
{ | |
h$p3(h$r2, h$r4, h$$fP); | |
return h$e(h$r3); | |
}; | |
var h$baseZCGHCziIOziHandleziInternalsziwantSeekableHandle4 = h$strta("handle is closed"); | |
function h$$gi() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 3)) | |
{ | |
h$r1 = h$baseZCGHCziIOziBufferziReadBuffer; | |
} | |
else | |
{ | |
h$r1 = h$baseZCGHCziIOziBufferziWriteBuffer; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$gh() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$gi); | |
return h$e(a); | |
}; | |
function h$$gg() | |
{ | |
var a = h$r1; | |
--h$sp; | |
return h$e(a.d2); | |
}; | |
function h$$gf() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$gg); | |
return h$e(a); | |
}; | |
function h$$ge() | |
{ | |
var a = h$r1; | |
--h$sp; | |
return h$e(a.d1); | |
}; | |
function h$$gd() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$ge); | |
return h$e(a); | |
}; | |
function h$$gc() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 14)]; | |
var c = h$stack[(h$sp - 13)]; | |
var d = h$stack[(h$sp - 12)]; | |
var e = h$stack[(h$sp - 11)]; | |
var f = h$stack[(h$sp - 10)]; | |
var g = h$stack[(h$sp - 9)]; | |
var h = h$stack[(h$sp - 8)]; | |
var i = h$stack[(h$sp - 7)]; | |
var j = h$stack[(h$sp - 6)]; | |
var k = h$stack[(h$sp - 5)]; | |
var l = h$stack[(h$sp - 4)]; | |
var m = h$stack[(h$sp - 3)]; | |
var n = h$stack[(h$sp - 2)]; | |
var o = h$stack[(h$sp - 1)]; | |
h$sp -= 15; | |
h$r1 = h$c16(h$baseZCGHCziIOziHandleziTypesziHandlezuzu_con_e, b, c, d, m, e, k, n, l, a.d1, o, i, j, f, h$c1(h$$gd, g), | |
h$c1(h$$gf, g), h); | |
return h$stack[h$sp]; | |
}; | |
function h$$gb() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
h$sp -= 15; | |
h$sp += 15; | |
h$stack[(h$sp - 3)] = a; | |
h$stack[h$sp] = h$$gc; | |
return h$e(b); | |
}; | |
function h$$ga() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = b.d4; | |
var g = b.d5; | |
var h = b.d6; | |
var i = b.d7; | |
var j = b.d8; | |
var k = b.d9; | |
var l = b.d10; | |
var m = b.d11; | |
var n = b.d12; | |
var o = b.d13; | |
h$bh(); | |
h$p15(a, c, d, f, g, h, i, j, k, l, m, n, o, b.d14, h$$gb); | |
h$r1 = e; | |
return h$ap_0_0_fast(); | |
}; | |
function h$$f9() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(h$c1(h$baseZCGHCziMVarziMVar_con_e, b.d1), a, b.d2); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$f8() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIOziHandleziTypesziFileHandle_con_e, b, c); | |
} | |
else | |
{ | |
var d = h$makeWeak(c, h$ghczmprimZCGHCziTupleziZLZR, h$c3(h$$f9, b, c, a.d1)); | |
h$r1 = h$c2(h$baseZCGHCziIOziHandleziTypesziFileHandle_con_e, b, c); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$f7() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
h$pp6(b, h$$f8); | |
return h$e(a); | |
}; | |
function h$$f6() | |
{ | |
var a = h$stack[(h$sp - 14)]; | |
var b = h$stack[(h$sp - 13)]; | |
var c = h$stack[(h$sp - 12)]; | |
var d = h$stack[(h$sp - 11)]; | |
var e = h$stack[(h$sp - 10)]; | |
var f = h$stack[(h$sp - 9)]; | |
var g = h$stack[(h$sp - 8)]; | |
var h = h$stack[(h$sp - 7)]; | |
var i = h$stack[(h$sp - 6)]; | |
var j = h$stack[(h$sp - 5)]; | |
var k = h$stack[(h$sp - 4)]; | |
var l = h$stack[(h$sp - 3)]; | |
var m = h$stack[(h$sp - 2)]; | |
var n = h$stack[(h$sp - 1)]; | |
h$sp -= 15; | |
var o = h$r1; | |
var p = h$r2; | |
var q = new h$MutVar(h$baseZCGHCziIOziHandleziTypesziBufferListNil); | |
var r = q; | |
var s = new h$MVar(); | |
h$p4(e, j, s, h$$f7); | |
return h$putMVar(s, h$c15(h$$ga, a, b, c, d, f, h, i, k, l, m, g, n, o, p, r)); | |
}; | |
function h$$f5() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if(a) | |
{ | |
h$r1 = h$baseZCGHCziIOziHandleziTypesziLineBuffering; | |
} | |
else | |
{ | |
h$r1 = h$$gD; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$f4() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$f5); | |
return h$e(a); | |
}; | |
function h$$f3() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 14; | |
h$l2(h$c1(h$$f4, a), h$c1(h$baseZCGHCziSTRefziSTRef_con_e, b)); | |
h$sp += 14; | |
++h$sp; | |
return h$$f6; | |
}; | |
function h$$f2() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = h$stack[(h$sp - 13)]; | |
var d = h$stack[(h$sp - 10)]; | |
h$sp -= 14; | |
if(a) | |
{ | |
var e = new h$MutVar(h$baseZCGHCziForeignPtrziNoFinalizzers); | |
var f = h$newByteArray(8192); | |
var g = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, f, 0, h$c2(h$baseZCGHCziForeignPtrziMallocPtr_con_e, f, e), b, 2048, | |
0, 0); | |
var h = new h$MutVar(g); | |
var i = h; | |
h$sp += 14; | |
h$p2(i, h$$f3); | |
h$p2(d, h$ap_2_1); | |
h$l2(c, h$baseZCGHCziIOziDeviceziisTerminal); | |
return h$baseZCGHCziIOziDeviceziisTerminal_e; | |
} | |
else | |
{ | |
var j = new h$MutVar(h$baseZCGHCziForeignPtrziNoFinalizzers); | |
var k = h$newByteArray(8192); | |
var l = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, k, 0, h$c2(h$baseZCGHCziForeignPtrziMallocPtr_con_e, k, j), b, 2048, | |
0, 0); | |
var m = new h$MutVar(l); | |
h$l2(h$baseZCGHCziIOziHandleziTypesziNoBuffering, h$c1(h$baseZCGHCziSTRefziSTRef_con_e, m)); | |
h$sp += 14; | |
++h$sp; | |
return h$$f6; | |
}; | |
}; | |
function h$$f1() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 8)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 15; | |
var d = a; | |
var e = new h$MutVar(d); | |
var f = e; | |
var g = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, h$baseZCGHCziIOziHandleziInternalszidecodeByteBuf2, d); | |
var h = new h$MutVar(g); | |
var i = h; | |
h$sp += 14; | |
h$stack[(h$sp - 7)] = f; | |
h$stack[h$sp] = i; | |
h$p2(c, h$$f2); | |
return h$e(b); | |
}; | |
function h$$f0() | |
{ | |
var a = h$stack[(h$sp - 10)]; | |
var b = h$stack[(h$sp - 8)]; | |
var c = h$stack[(h$sp - 6)]; | |
h$sp -= 12; | |
var d = h$r1; | |
var e = h$r2; | |
var f = h$c1(h$$gh, c); | |
h$sp += 15; | |
h$stack[(h$sp - 3)] = d; | |
h$stack[(h$sp - 2)] = e; | |
h$stack[(h$sp - 1)] = f; | |
h$stack[h$sp] = h$$f1; | |
h$p3(f, b, h$ap_3_2); | |
h$l2(a, h$baseZCGHCziIOziBufferedIOzinewBuffer); | |
return h$baseZCGHCziIOziBufferedIOzinewBuffer_e; | |
}; | |
function h$$fZ() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 11; | |
h$l2(b, h$c1(h$baseZCDataziMaybeziJust_con_e, a)); | |
h$sp += 11; | |
++h$sp; | |
return h$$f0; | |
}; | |
function h$$fY() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 11; | |
h$l2(b, h$c1(h$baseZCDataziMaybeziJust_con_e, a)); | |
h$sp += 11; | |
++h$sp; | |
return h$$f0; | |
}; | |
function h$$fX() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 11; | |
h$l2(b, h$c1(h$baseZCDataziMaybeziJust_con_e, a)); | |
h$sp += 11; | |
++h$sp; | |
return h$$f0; | |
}; | |
function h$$fW() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$sp -= 11; | |
switch (a.f.a) | |
{ | |
case (4): | |
h$sp += 11; | |
h$p2(c, h$$fZ); | |
h$r1 = b; | |
return h$ap_1_0_fast(); | |
case (5): | |
h$sp += 11; | |
h$p2(c, h$$fY); | |
h$r1 = b; | |
return h$ap_1_0_fast(); | |
case (6): | |
h$sp += 11; | |
h$p2(c, h$$fX); | |
h$r1 = b; | |
return h$ap_1_0_fast(); | |
default: | |
h$l2(c, h$baseZCDataziMaybeziNothing); | |
h$sp += 11; | |
++h$sp; | |
return h$$f0; | |
}; | |
}; | |
function h$$fV() | |
{ | |
var a = h$stack[(h$sp - 7)]; | |
h$sp -= 13; | |
var b = h$r1; | |
h$sp += 11; | |
h$pp6(b, h$$fW); | |
return h$e(a); | |
}; | |
function h$$fU() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 12; | |
h$r1 = h$c1(h$baseZCDataziMaybeziJust_con_e, a); | |
h$sp += 12; | |
++h$sp; | |
return h$$fV; | |
}; | |
function h$$fT() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 12; | |
h$r1 = h$c1(h$baseZCDataziMaybeziJust_con_e, a); | |
h$sp += 12; | |
++h$sp; | |
return h$$fV; | |
}; | |
function h$$fS() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 12; | |
switch (a.f.a) | |
{ | |
case (3): | |
h$sp += 12; | |
h$p1(h$$fU); | |
h$r1 = b; | |
return h$ap_1_0_fast(); | |
case (6): | |
h$sp += 12; | |
h$p1(h$$fT); | |
h$r1 = b; | |
return h$ap_1_0_fast(); | |
default: | |
h$r1 = h$baseZCDataziMaybeziNothing; | |
h$sp += 12; | |
++h$sp; | |
return h$$fV; | |
}; | |
}; | |
function h$$fR() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = h$stack[(h$sp - 5)]; | |
h$sp -= 11; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d2; | |
h$sp += 12; | |
h$stack[h$sp] = e; | |
h$p2(d, h$$fS); | |
return h$e(b); | |
}; | |
function h$$fQ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 11; | |
if((a.f.a === 1)) | |
{ | |
h$l2(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing); | |
h$sp += 11; | |
++h$sp; | |
return h$$f0; | |
} | |
else | |
{ | |
var b = a.d1; | |
h$sp += 11; | |
h$p1(h$$fR); | |
return h$e(b); | |
}; | |
}; | |
function h$baseZCGHCziIOziHandleziInternalszimkDuplexHandle5_e() | |
{ | |
h$p11(h$r2, h$r3, h$r4, h$r5, h$r6, h$r7, h$r8, h$r9, h$r10, h$r11, h$r12); | |
h$p1(h$$fQ); | |
return h$e(h$r9); | |
}; | |
function h$$gn() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
b.val = a; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$gm() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a.d2; | |
var f = e.d5; | |
var g = e.d6; | |
if((f === g)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$p2(d, h$$gn); | |
h$p3(a, c, h$ap_3_2); | |
h$l2(b, h$baseZCGHCziIOziBufferedIOziflushWriteBuffer); | |
return h$baseZCGHCziIOziBufferedIOziflushWriteBuffer_e; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$gl() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
h$pp8(h$$gm); | |
return h$e(b.val); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$gk() | |
{ | |
var a = h$r1; | |
h$sp -= 4; | |
var b = a.d2; | |
h$pp8(h$$gl); | |
return h$e(b.d3); | |
}; | |
function h$$gj() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d2; | |
var c = b.d1; | |
var d = b.d3; | |
var e = b.d5; | |
h$p4(c, d, e, h$$gk); | |
return h$e(e.val); | |
}; | |
function h$baseZCGHCziIOziHandleziInternalsziflushWriteBuffer1_e() | |
{ | |
h$p1(h$$gj); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziHandleziInternalsziflushBuffer4 = h$strta("cannot flush the read buffer: underlying device is not seekable"); | |
function h$baseZCGHCziIOziHandleziInternalszidecodeByteBuf2_e() | |
{ | |
h$bh(); | |
h$l2(h$$gE, h$baseZCGHCziErrzierror); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$gy() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
h$l3(a.d2, c, b); | |
return h$ap_3_2_fast(); | |
}; | |
function h$$gx() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
h$pp2(h$$gy); | |
return h$e(a); | |
}; | |
function h$$gw() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
var f = a.d2; | |
var g = f.d5; | |
if((d === g)) | |
{ | |
h$p2(c, h$$gx); | |
h$l3(e, a, b); | |
return h$ap_3_2_fast(); | |
} | |
else | |
{ | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, a, e); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$gv() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 5; | |
var c = a.d2; | |
h$pp20(c.d5, h$$gw); | |
return h$e(b); | |
}; | |
function h$$gu() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 7; | |
if((a.f.a === 3)) | |
{ | |
h$pp28(d, e, h$$gv); | |
return h$e(b); | |
} | |
else | |
{ | |
h$r1 = c; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$gt() | |
{ | |
var a = h$r1; | |
h$sp -= 5; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
h$pp112(d, c.d2, h$$gu); | |
return h$e(b); | |
}; | |
function h$$gs() | |
{ | |
var a = h$r1; | |
h$sp -= 4; | |
h$pp24(a, h$$gt); | |
return h$e(a); | |
}; | |
function h$$gr() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p4(c, b.d2, h$r2, h$$gs); | |
h$r1 = a; | |
return h$ap_3_2_fast(); | |
}; | |
function h$$gq() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d2; | |
var c = b.d1; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, c, b.d2); | |
return h$stack[h$sp]; | |
}; | |
function h$$gp() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$gq); | |
return h$e(a); | |
}; | |
function h$$go() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = h$c1(h$$gp, a); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziInternalszizdwa_e() | |
{ | |
var a = h$r3; | |
var b = h$r4; | |
var c = h$r5; | |
var d = h$c(h$$gr); | |
d.d1 = h$r2; | |
d.d2 = h$d2(a, d); | |
h$p1(h$$go); | |
h$l3(c, b, d); | |
return h$ap_3_2_fast(); | |
}; | |
function h$baseZCGHCziIOziHandleziInternalsziioezufinalizzedHandle_e() | |
{ | |
h$l3(h$baseZCGHCziIOziExceptionzizdfExceptionIOExceptionzuzdctoException, | |
h$c6(h$baseZCGHCziIOziExceptionziIOError_con_e, h$baseZCDataziMaybeziNothing, | |
h$baseZCGHCziIOziExceptionziIllegalOperation, h$ghczmprimZCGHCziTypesziZMZN, h$$gF, h$baseZCDataziMaybeziNothing, | |
h$c1(h$baseZCDataziMaybeziJust_con_e, h$r2)), h$baseZCGHCziExceptionzithrow2); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$gC() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
h$r1 = h$c1(h$baseZCDataziMaybeziJust_con_e, a.d1); | |
} | |
else | |
{ | |
h$r1 = h$c1(h$baseZCDataziMaybeziJust_con_e, a.d1); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$gB() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$p1(h$$gC); | |
return h$e(b); | |
} | |
else | |
{ | |
h$r1 = a; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$gA() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p2(a, h$$gB); | |
return h$e(b); | |
}; | |
function h$$gz() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d3; | |
var g = d.d4; | |
h$r1 = h$c6(h$baseZCGHCziIOziExceptionziIOError_con_e, h$c1(h$baseZCDataziMaybeziJust_con_e, c), e, b, f, g, h$c2(h$$gA, | |
c, d.d5)); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziHandleziInternalsziaugmentIOError_e() | |
{ | |
h$p3(h$r3, h$r4, h$$gz); | |
return h$e(h$r2); | |
}; | |
function h$$gK() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l12(h$baseZCDataziMaybeziNothing, h$$hn, h$baseZCGHCziIOziHandleziTypeszinoNewlineTranslation, | |
h$c1(h$baseZCDataziMaybeziJust_con_e, a), true, h$baseZCGHCziIOziHandleziTypesziWriteHandle, h$$hj, | |
h$baseZCGHCziIOziFDzistdout, h$baseZCGHCziIOziFDzizdfTypeableFDzuzdctypeRepzh, h$baseZCGHCziIOziFDzizdfBufferedIOFD, | |
h$baseZCGHCziIOziFDzizdfIODeviceFD, h$baseZCGHCziIOziHandleziInternalszimkDuplexHandle5); | |
return h$ap_gen_fast(2828); | |
}; | |
function h$$gJ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$p1(h$$gK); | |
h$r1 = a.d1; | |
return h$ap_1_0_fast(); | |
}; | |
function h$$gI() | |
{ | |
h$p1(h$$gJ); | |
return h$e(h$baseZCGHCziIOziEncodingzigetLocaleEncoding1); | |
}; | |
var h$$hj = h$strta("<stdout>"); | |
function h$$gN() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l12(h$baseZCDataziMaybeziNothing, h$$hn, h$baseZCGHCziIOziHandleziTypeszinoNewlineTranslation, | |
h$c1(h$baseZCDataziMaybeziJust_con_e, a), false, h$baseZCGHCziIOziHandleziTypesziWriteHandle, h$$hl, | |
h$baseZCGHCziIOziFDzistderr, h$baseZCGHCziIOziFDzizdfTypeableFDzuzdctypeRepzh, h$baseZCGHCziIOziFDzizdfBufferedIOFD, | |
h$baseZCGHCziIOziFDzizdfIODeviceFD, h$baseZCGHCziIOziHandleziInternalszimkDuplexHandle5); | |
return h$ap_gen_fast(2828); | |
}; | |
function h$$gM() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$p1(h$$gN); | |
h$r1 = a.d1; | |
return h$ap_1_0_fast(); | |
}; | |
function h$$gL() | |
{ | |
h$p1(h$$gM); | |
return h$e(h$baseZCGHCziIOziEncodingzigetLocaleEncoding1); | |
}; | |
var h$$hl = h$strta("<stderr>"); | |
function h$$gP() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l3(a.d1, b, h$$ho); | |
return h$$gQ; | |
}; | |
function h$$gO() | |
{ | |
h$p2(h$r2, h$$gP); | |
return h$e(h$r3); | |
}; | |
function h$$hh() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziHandleziInternalsziioezufinalizzedHandle); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$hg() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$hf() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziHandleziInternalsziioezufinalizzedHandle); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$he() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$hd() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$p1(h$$he); | |
return h$putMVar(b, h$c1(h$$hf, a)); | |
}; | |
function h$$hc() | |
{ | |
var a = h$r1; | |
h$sp -= 3; | |
var b = a.d2; | |
h$pp4(h$$hd); | |
h$r1 = b.d2; | |
return h$ap_1_0_fast(); | |
}; | |
function h$$hb() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$p1(h$$hg); | |
return h$putMVar(c, h$c1(h$$hh, b)); | |
} | |
else | |
{ | |
h$pp4(h$$hc); | |
return h$e(a.d1); | |
}; | |
}; | |
function h$$ha() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziHandleziInternalsziioezufinalizzedHandle); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$g9() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$g8() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziHandleziInternalsziioezufinalizzedHandle); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$g7() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$g6() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$p1(h$$g7); | |
return h$putMVar(b, h$c1(h$$g8, a)); | |
}; | |
function h$$g5() | |
{ | |
var a = h$r1; | |
h$sp -= 3; | |
var b = a.d2; | |
h$pp4(h$$g6); | |
h$r1 = b.d2; | |
return h$ap_1_0_fast(); | |
}; | |
function h$$g4() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$p1(h$$g9); | |
return h$putMVar(c, h$c1(h$$ha, b)); | |
} | |
else | |
{ | |
h$pp4(h$$g5); | |
return h$e(a.d1); | |
}; | |
}; | |
function h$$g3() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
h$pp4(h$$g4); | |
return h$e(a); | |
}; | |
function h$$g2() | |
{ | |
var a = h$r1; | |
h$sp -= 4; | |
var b = a.d2; | |
h$pp8(h$$g3); | |
h$r1 = b.d2; | |
return h$ap_1_0_fast(); | |
}; | |
function h$$g1() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
if((a.f.a === 1)) | |
{ | |
h$pp4(h$$hb); | |
return h$e(b); | |
} | |
else | |
{ | |
h$pp8(h$$g2); | |
return h$e(a.d1); | |
}; | |
}; | |
function h$$g0() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziHandleziInternalsziioezufinalizzedHandle); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$gZ() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$$gY() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
if((a.f.a === 1)) | |
{ | |
h$p1(h$$gZ); | |
return h$putMVar(c, h$c1(h$$g0, b)); | |
} | |
else | |
{ | |
h$pp8(h$$g1); | |
return h$e(d); | |
}; | |
}; | |
function h$$gX() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
h$pp16(h$$gY); | |
return h$e(a); | |
}; | |
function h$$gW() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$sp -= 5; | |
b.val = a; | |
h$sp += 5; | |
++h$sp; | |
return h$$gX; | |
}; | |
function h$$gV() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
h$sp -= 5; | |
var d = a.d2; | |
var e = d.d5; | |
var f = d.d6; | |
if((e === f)) | |
{ | |
h$sp += 5; | |
++h$sp; | |
return h$$gX; | |
} | |
else | |
{ | |
h$sp += 5; | |
h$pp2(h$$gW); | |
h$p3(a, c, h$ap_3_2); | |
h$l2(b, h$baseZCGHCziIOziBufferedIOziflushWriteBuffer); | |
return h$baseZCGHCziIOziBufferedIOziflushWriteBuffer_e; | |
}; | |
}; | |
function h$$gU() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
h$sp -= 4; | |
h$sp -= 5; | |
if((a.f.a === 1)) | |
{ | |
h$sp += 5; | |
++h$sp; | |
return h$$gX; | |
} | |
else | |
{ | |
var c = b.val; | |
h$sp += 5; | |
h$pp8(h$$gV); | |
return h$e(c); | |
}; | |
}; | |
function h$$gT() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 6)]; | |
var c = h$stack[(h$sp - 5)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 9; | |
var f = a.d2; | |
var g = f.d3; | |
h$sp += 5; | |
h$stack[(h$sp - 2)] = d; | |
h$stack[(h$sp - 1)] = e; | |
h$pp14(b, c, h$$gU); | |
return h$e(g); | |
}; | |
function h$$gS() | |
{ | |
var a = h$r1; | |
h$sp -= 3; | |
var b = a.d2; | |
var c = b.d1; | |
var d = b.d3; | |
var e = b.d4; | |
var f = b.d5; | |
var g = b.d10; | |
var h = b.d11; | |
var i = f.val; | |
h$sp += 9; | |
h$stack[(h$sp - 6)] = c; | |
h$stack[(h$sp - 5)] = d; | |
h$stack[(h$sp - 4)] = e; | |
h$stack[(h$sp - 3)] = f; | |
h$stack[(h$sp - 2)] = g; | |
h$stack[(h$sp - 1)] = h; | |
h$stack[h$sp] = h$$gT; | |
return h$e(i); | |
}; | |
function h$$gR() | |
{ | |
var a = h$r1; | |
h$sp -= 3; | |
h$pp4(h$$gS); | |
return h$e(a); | |
}; | |
function h$$gQ() | |
{ | |
h$p3(h$r2, h$r3, h$$gR); | |
return h$takeMVar(h$r3); | |
}; | |
function h$baseZCGHCziIOziHandleziFDzistderr_e() | |
{ | |
h$bh(); | |
h$l2(h$$hk, h$baseZCGHCziIOziunsafeDupablePerformIO); | |
return h$ap_1_1_fast(); | |
}; | |
function h$baseZCGHCziIOziHandleziFDzistdout_e() | |
{ | |
h$bh(); | |
h$l2(h$$hi, h$baseZCGHCziIOziunsafeDupablePerformIO); | |
return h$ap_1_1_fast(); | |
}; | |
var h$baseZCGHCziIOziHandlezihFlush2 = h$strta("hFlush"); | |
function h$baseZCGHCziIOziHandlezihFlush1_e() | |
{ | |
h$l4(h$baseZCGHCziIOziHandleziInternalsziflushWriteBuffer1, h$r2, h$baseZCGHCziIOziHandlezihFlush2, | |
h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1); | |
return h$baseZCGHCziIOziHandleziInternalsziwantWritableHandle1_e; | |
}; | |
function h$baseZCGHCziIOziHandlezihFlush_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziHandlezihFlush1; | |
return h$baseZCGHCziIOziHandlezihFlush1_e; | |
}; | |
function h$$hB() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = c; | |
h$r1 = h$c2(h$baseZCGHCziPtrziPtr_con_e, e, (d + b)); | |
return h$stack[h$sp]; | |
}; | |
function h$$hA() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$p2(b, h$$hB); | |
return h$e(a); | |
}; | |
function h$$hz() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a; | |
if((d < e)) | |
{ | |
h$l4(((e - d) | 0), h$c2(h$$hA, c, d), b, h$baseZCGHCziIOziFDzizdwa2); | |
return h$ap_4_3_fast(); | |
} | |
else | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$hy() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
h$pp12(a, h$$hz); | |
return h$e(b); | |
}; | |
function h$$hx() | |
{ | |
h$sp -= 4; | |
h$pp8(h$$hy); | |
return h$e(h$r1); | |
}; | |
function h$$hw() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
var c = (b | 0); | |
if((c === (-1))) | |
{ | |
h$l2(h$$jl, h$baseZCForeignziCziErrorzithrowErrno1); | |
return h$baseZCForeignziCziErrorzithrowErrno1_e; | |
} | |
else | |
{ | |
h$r1 = c; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$hv() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a; | |
var f = (e | 0); | |
h$p1(h$$hw); | |
try | |
{ | |
var g; | |
var h = { mv: null | |
}; | |
g = h$mkForeignCallback(h); | |
h$base_write(b, c, d, f, g); | |
if((h.mv === null)) | |
{ | |
h.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(h.mv); | |
} | |
else | |
{ | |
var i = h.mv; | |
h$r1 = i[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_2_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_2_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$hu() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp14(c, a.d2, h$$hv); | |
return h$e(b); | |
}; | |
function h$$ht() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p3(a, b.d2, h$$hu); | |
return h$e(c); | |
}; | |
function h$$hs() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziFDziwriteRawBufferPtr2); | |
return h$baseZCGHCziIOziFDziwriteRawBufferPtr2_e; | |
}; | |
function h$$hr() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 3; | |
h$r1 = h$c1(h$$hs, a); | |
h$sp += 3; | |
++h$sp; | |
return h$$hx; | |
}; | |
function h$$hq() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziFDziwriteRawBufferPtr2); | |
return h$baseZCGHCziIOziFDziwriteRawBufferPtr2_e; | |
}; | |
function h$$hp() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 3; | |
h$r1 = h$c1(h$$hq, a); | |
h$sp += 3; | |
++h$sp; | |
return h$$hx; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa2_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = h$maskStatus(); | |
var e = h$c3(h$$ht, a, b, c); | |
var f = d; | |
if((f === 1)) | |
{ | |
h$p3(a, b, c); | |
h$p1(h$$hp); | |
h$r1 = e; | |
return h$ap_1_0_fast(); | |
} | |
else | |
{ | |
h$p3(a, b, c); | |
h$p1(h$$hr); | |
return h$maskUnintAsync(e); | |
}; | |
}; | |
var h$$jl = h$strta("GHC.IO.FD.fdWrite"); | |
function h$$hC() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
h$r1 = (b | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDziwriteRawBufferPtr2_e() | |
{ | |
h$p1(h$$hC); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziFDzizdfTypeableFD5 = h$strta("base"); | |
var h$baseZCGHCziIOziFDzizdfTypeableFD4 = h$strta("GHC.IO.FD"); | |
var h$baseZCGHCziIOziFDzizdfTypeableFD3 = h$strta("FD"); | |
function h$baseZCGHCziIOziFDzizdfTypeableFDzuzdctypeRepzh_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziFDzizdfTypeableFD1; | |
return h$stack[h$sp]; | |
}; | |
var h$baseZCGHCziIOziFDzizdfIODeviceFD19 = h$strta("GHC.IO.FD.ready"); | |
function h$$hJ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
h$r1 = (b | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$hI() | |
{ | |
var a = h$stack[(h$sp - 2)]; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = h$r1; | |
var d = (b | 0); | |
h$p1(h$$hJ); | |
h$r1 = h$fdReady(a, (c | 0), d, 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$hH() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$sp -= 2; | |
if(a) | |
{ | |
h$r1 = 1; | |
h$sp += 2; | |
++h$sp; | |
return h$$hI; | |
} | |
else | |
{ | |
h$r1 = 0; | |
h$sp += 2; | |
++h$sp; | |
return h$$hI; | |
}; | |
}; | |
function h$$hG() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p2(a, b.d2); | |
h$p1(h$$hH); | |
return h$e(c); | |
}; | |
function h$$hF() | |
{ | |
var a = h$r1; | |
--h$sp; | |
switch (a) | |
{ | |
case (0): | |
h$r1 = false; | |
break; | |
case (1): | |
h$r1 = true; | |
break; | |
default: | |
return h$e(h$baseZCGHCziEnumzizdfEnumBool1); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$hE() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$hF); | |
return h$e(a); | |
}; | |
function h$$hD() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = h$c1(h$$hE, a); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa12_e() | |
{ | |
h$p1(h$$hD); | |
h$l4(h$c3(h$$hG, h$r2, h$r3, h$r4), h$baseZCGHCziIOziFDzizdfIODeviceFD19, h$baseZCGHCziIOziFDzizdfIODeviceFD17, | |
h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$$hL() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l4(a, b, c, h$baseZCGHCziIOziFDzizdwa12); | |
return h$baseZCGHCziIOziFDzizdwa12_e; | |
}; | |
function h$$hK() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$pp6(a.d1, h$$hL); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD18_e() | |
{ | |
h$p3(h$r3, h$r4, h$$hK); | |
return h$e(h$r2); | |
}; | |
function h$$hM() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
if((b === (-1))) | |
{ | |
h$r1 = true; | |
} | |
else | |
{ | |
h$r1 = false; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD17_e() | |
{ | |
h$p1(h$$hM); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziFDzizdfIODeviceFD16 = h$strta("GHC.IO.FD.close"); | |
function h$$hP() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
h$r1 = (b | 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$hO() | |
{ | |
var a = h$r1.d1; | |
var b = (a | 0); | |
h$p1(h$$hP); | |
try | |
{ | |
var c; | |
var d = { mv: null | |
}; | |
c = h$mkForeignCallback(d); | |
h$base_close(b, c); | |
if((d.mv === null)) | |
{ | |
d.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(d.mv); | |
} | |
else | |
{ | |
var e = d.mv; | |
h$r1 = e[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_46_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_46_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$hN() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa11_e() | |
{ | |
var a = h$r2; | |
var b = h$unlockFile(h$r2); | |
h$p1(h$$hN); | |
h$l4(h$c1(h$$hO, a), h$baseZCGHCziIOziFDzizdfIODeviceFD16, h$baseZCGHCziIOziFDzizdfIODeviceFD17, | |
h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$$hQ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a.d1, h$baseZCGHCziIOziFDzizdwa11); | |
return h$baseZCGHCziIOziFDzizdwa11_e; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD15_e() | |
{ | |
h$p1(h$$hQ); | |
return h$e(h$r2); | |
}; | |
function h$$hR() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = h$base_isatty(a.d1); | |
var c = b; | |
var d; | |
var e = (c | 0); | |
if((e === 0)) | |
{ | |
d = false; | |
} | |
else | |
{ | |
d = true; | |
}; | |
h$r1 = d; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD14_e() | |
{ | |
h$p1(h$$hR); | |
return h$e(h$r2); | |
}; | |
function h$$hX() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$stack[h$sp]; | |
}; | |
function h$$hW() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$hX); | |
return h$e(a); | |
}; | |
function h$$hV() | |
{ | |
var a = h$r1; | |
--h$sp; | |
switch (a.f.a) | |
{ | |
case (3): | |
h$r1 = true; | |
break; | |
case (4): | |
h$r1 = true; | |
break; | |
default: | |
h$r1 = false; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$hU() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$hV); | |
return h$e(a); | |
}; | |
function h$$hT() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = h$c1(h$$hU, a.d1); | |
return h$stack[h$sp]; | |
}; | |
function h$$hS() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$p1(h$$hT); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD13_e() | |
{ | |
h$p1(h$$hS); | |
h$l2(h$c1(h$$hW, h$r2), h$baseZCSystemziPosixziInternalszifdStat1); | |
return h$baseZCSystemziPosixziInternalszifdStat1_e; | |
}; | |
var h$baseZCGHCziIOziFDzizdfIODeviceFDzuloc2 = h$strta("seek"); | |
function h$$h4() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$baseZCGHCziIntziI64zh_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$h3() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$baseZCGHCziIntziI64zh_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$h2() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$baseZCGHCziIntziI64zh_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$h1() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
switch (a.f.a) | |
{ | |
case (1): | |
var e = h$base_SEEK_SET; | |
var f = (e | 0); | |
h$p1(h$$h4); | |
try | |
{ | |
var g; | |
var h = { mv: null | |
}; | |
g = h$mkForeignCallback(h); | |
h$base_lseek(b, c, d, f, g); | |
if((h.mv === null)) | |
{ | |
h.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(h.mv); | |
} | |
else | |
{ | |
var i = h.mv; | |
h$r1 = i[0]; | |
h$r2 = i[1]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_54_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_54_0); | |
}; | |
break; | |
case (2): | |
var j = h$base_SEEK_CUR; | |
var k = (j | 0); | |
h$p1(h$$h3); | |
try | |
{ | |
var l; | |
var m = { mv: null | |
}; | |
l = h$mkForeignCallback(m); | |
h$base_lseek(b, c, d, k, l); | |
if((m.mv === null)) | |
{ | |
m.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(m.mv); | |
} | |
else | |
{ | |
var n = m.mv; | |
h$r1 = n[0]; | |
h$r2 = n[1]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_54_3) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_54_3); | |
}; | |
break; | |
default: | |
var o = h$base_SEEK_END; | |
var p = (o | 0); | |
h$p1(h$$h2); | |
try | |
{ | |
var q; | |
var r = { mv: null | |
}; | |
q = h$mkForeignCallback(r); | |
h$base_lseek(b, c, d, p, q); | |
if((r.mv === null)) | |
{ | |
r.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(r.mv); | |
} | |
else | |
{ | |
var s = r.mv; | |
h$r1 = s[0]; | |
h$r2 = s[1]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_54_6) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_54_6); | |
}; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$h0() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$pp14(a, b, h$$h1); | |
return h$e(c); | |
}; | |
function h$$hZ() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$p3(a, b.d1, h$$h0); | |
h$l2(b.d2, h$integerzmgmpZCGHCziIntegerziTypeziintegerToInt64); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$hY() | |
{ | |
--h$sp; | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa10_e() | |
{ | |
h$p1(h$$hY); | |
h$l4(h$c3(h$$hZ, h$r2, h$r3, h$r4), h$baseZCGHCziIOziFDzizdfIODeviceFDzuloc2, h$baseZCGHCziIOziFDzizdfIODeviceFDzupred, | |
h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$$h5() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l4(c, b, a.d1, h$baseZCGHCziIOziFDzizdwa10); | |
return h$baseZCGHCziIOziFDzizdwa10_e; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD12_e() | |
{ | |
h$p3(h$r3, h$r4, h$$h5); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFDzuds_e() | |
{ | |
h$bh(); | |
var a = h$hs_negateInt64(0, 1); | |
h$r1 = h$c2(h$baseZCGHCziIntziI64zh_con_e, a, h$ret1); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFDzupred_e() | |
{ | |
h$r3 = h$baseZCGHCziIOziFDzizdfIODeviceFDzuds; | |
h$r1 = h$baseZCGHCziIntzizdfEqInt64zuzdczeze; | |
return h$baseZCGHCziIntzizdfEqInt64zuzdczeze_e; | |
}; | |
var h$baseZCGHCziIOziFDzizdfIODeviceFD11 = h$strta("hGetPosn"); | |
function h$$ia() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
--h$sp; | |
h$r1 = h$c2(h$baseZCGHCziIntziI64zh_con_e, a, b); | |
return h$stack[h$sp]; | |
}; | |
function h$$h9() | |
{ | |
var a = h$r1.d1; | |
var b = h$base_SEEK_CUR; | |
var c = (b | 0); | |
h$p1(h$$ia); | |
try | |
{ | |
var d; | |
var e = { mv: null | |
}; | |
d = h$mkForeignCallback(e); | |
h$base_lseek(a, 0, 0, c, d); | |
if((e.mv === null)) | |
{ | |
e.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(e.mv); | |
} | |
else | |
{ | |
var f = e.mv; | |
h$r1 = f[0]; | |
h$r2 = f[1]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_60_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_60_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$h8() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$l3(a.d2, b, h$integerzmgmpZCGHCziIntegerziTypeziint64ToInteger); | |
return h$ap_1_2_fast(); | |
}; | |
function h$$h7() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$h8); | |
return h$e(a); | |
}; | |
function h$$h6() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = h$c1(h$$h7, a); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa9_e() | |
{ | |
h$p1(h$$h6); | |
h$l4(h$c1(h$$h9, h$r2), h$baseZCGHCziIOziFDzizdfIODeviceFD11, h$baseZCGHCziIOziFDzizdfIODeviceFDzupred, | |
h$baseZCForeignziCziErrorzithrowErrnoIfMinus1Retry2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$$ib() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a.d1, h$baseZCGHCziIOziFDzizdwa9); | |
return h$baseZCGHCziIOziFDzizdwa9_e; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD10_e() | |
{ | |
h$p1(h$$ib); | |
return h$e(h$r2); | |
}; | |
function h$$id() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$stack[h$sp]; | |
}; | |
function h$$ic() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$id); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD9_e() | |
{ | |
h$l2(h$c1(h$$ic, h$r2), h$baseZCSystemziPosixziInternalszifdFileSizze1); | |
return h$baseZCSystemziPosixziInternalszifdFileSizze1_e; | |
}; | |
var h$baseZCGHCziIOziFDzizdfIODeviceFD8 = h$strta("GHC.IO.FD.setSize"); | |
function h$$ih() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$ig() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
var c = (b | 0); | |
if((c === 0)) | |
{ | |
h$r1 = h$ghczmprimZCGHCziTupleziZLZR; | |
} | |
else | |
{ | |
var d = h$__hscore_get_errno(); | |
var e = d; | |
h$p1(h$$ih); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (e | 0), h$baseZCGHCziIOziFDzizdfIODeviceFD8, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$ie() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$p1(h$$ig); | |
try | |
{ | |
var d; | |
var e = { mv: null | |
}; | |
d = h$mkForeignCallback(e); | |
h$base_ftruncate(c, a, b, d); | |
if((e.mv === null)) | |
{ | |
e.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(e.mv); | |
} | |
else | |
{ | |
var f = e.mv; | |
h$r1 = f[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_66_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_66_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa8_e() | |
{ | |
h$p2(h$r2, h$$ie); | |
h$l2(h$r3, h$integerzmgmpZCGHCziIntegerziTypeziintegerToInt64); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$ii() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l3(b, a.d1, h$baseZCGHCziIOziFDzizdwa8); | |
return h$baseZCGHCziIOziFDzizdwa8_e; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD7_e() | |
{ | |
h$p2(h$r3, h$$ii); | |
return h$e(h$r2); | |
}; | |
function h$$ik() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$stack[h$sp]; | |
}; | |
function h$$ij() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$ik); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD6_e() | |
{ | |
h$l2(h$c1(h$$ij, h$r2), h$baseZCSystemziPosixziInternalszisetEcho1); | |
return h$baseZCSystemziPosixziInternalszisetEcho1_e; | |
}; | |
function h$$im() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$stack[h$sp]; | |
}; | |
function h$$il() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$im); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD5_e() | |
{ | |
h$l3(h$baseZCSystemziPosixziInternalszigetEcho2, h$c1(h$$il, h$r2), h$baseZCSystemziPosixziInternalszigetEcho4); | |
return h$ap_3_2_fast(); | |
}; | |
function h$$ir() | |
{ | |
var a = h$r1; | |
--h$sp; | |
if(a) | |
{ | |
h$r1 = false; | |
} | |
else | |
{ | |
h$r1 = true; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iq() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$ir); | |
return h$e(a); | |
}; | |
function h$$ip() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$stack[h$sp]; | |
}; | |
function h$$io() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$ip); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD4_e() | |
{ | |
h$l3(h$c1(h$$iq, h$r3), h$c1(h$$io, h$r2), h$baseZCSystemziPosixziInternalszisetCooked1); | |
return h$baseZCSystemziPosixziInternalszisetCooked1_e; | |
}; | |
function h$$iv() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$stack[h$sp]; | |
}; | |
function h$$iu() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$iv); | |
return h$e(a); | |
}; | |
function h$$it() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a.d1; | |
return h$stack[h$sp]; | |
}; | |
function h$$is() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$p1(h$$it); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD3_e() | |
{ | |
h$p1(h$$is); | |
h$l2(h$c1(h$$iu, h$r2), h$baseZCSystemziPosixziInternalszifdStat1); | |
return h$baseZCSystemziPosixziInternalszifdStat1_e; | |
}; | |
var h$baseZCGHCziIOziFDzizdfIODeviceFDzuloc1 = h$strta("GHC.IO.FD.dup"); | |
function h$$ix() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$iw() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a; | |
var d = (c | 0); | |
if((d === (-1))) | |
{ | |
var e = h$__hscore_get_errno(); | |
var f = e; | |
h$p1(h$$ix); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (f | 0), h$baseZCGHCziIOziFDzizdfIODeviceFDzuloc1, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIOziFDziFD_con_e, d, b); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa7_e() | |
{ | |
var a = h$r2; | |
h$p2(h$r3, h$$iw); | |
try | |
{ | |
var b; | |
var c = { mv: null | |
}; | |
b = h$mkForeignCallback(c); | |
h$base_dup(a, b); | |
if((c.mv === null)) | |
{ | |
c.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(c.mv); | |
} | |
else | |
{ | |
var d = c.mv; | |
h$r1 = d[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_76_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_76_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iy() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$l3(a.d2, b, h$baseZCGHCziIOziFDzizdwa7); | |
return h$baseZCGHCziIOziFDzizdwa7_e; | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD2_e() | |
{ | |
h$p1(h$$iy); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziFDzizdfIODeviceFDzuloc = h$strta("GHC.IO.FD.dup2"); | |
function h$$iA() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$iz() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var d = a; | |
var e = (d | 0); | |
if((e === (-1))) | |
{ | |
var f = h$__hscore_get_errno(); | |
var g = f; | |
h$p1(h$$iA); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (g | 0), h$baseZCGHCziIOziFDzizdfIODeviceFDzuloc, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIOziFDziFD_con_e, c, b); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa6_e() | |
{ | |
var a = h$r2; | |
var b = h$r4; | |
h$p3(h$r3, h$r4, h$$iz); | |
try | |
{ | |
var c; | |
var d = { mv: null | |
}; | |
c = h$mkForeignCallback(d); | |
h$base_dup2(a, b, c); | |
if((d.mv === null)) | |
{ | |
d.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(d.mv); | |
} | |
else | |
{ | |
var e = d.mv; | |
h$r1 = e[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_80_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_80_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iC() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
h$l4(a.d1, c, b, h$baseZCGHCziIOziFDzizdwa6); | |
return h$baseZCGHCziIOziFDzizdwa6_e; | |
}; | |
function h$$iB() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
h$p3(c, a.d2, h$$iC); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziFDzizdfIODeviceFD1_e() | |
{ | |
h$p2(h$r3, h$$iB); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziFDzizdfBufferedIOFD12_e() | |
{ | |
var a = h$r3; | |
var b = new h$MutVar(h$baseZCGHCziForeignPtrziNoFinalizzers); | |
var c = h$newByteArray(8096); | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, c, 0, h$c2(h$baseZCGHCziForeignPtrziMallocPtr_con_e, c, b), a, 8096, | |
0, 0); | |
return h$stack[h$sp]; | |
}; | |
var h$baseZCGHCziIOziFDzizdfBufferedIOFD11 = h$strta("GHC.IO.FD.fdRead"); | |
function h$$iL() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
var c = (b | 0); | |
if((c === (-1))) | |
{ | |
h$l2(h$baseZCGHCziIOziFDzizdfBufferedIOFD11, h$baseZCForeignziCziErrorzithrowErrno1); | |
return h$baseZCForeignziCziErrorzithrowErrno1_e; | |
} | |
else | |
{ | |
h$r1 = c; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iK() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = b.d4; | |
var g = ((e - f) | 0); | |
var h = (g | 0); | |
var i; | |
var j; | |
i = c; | |
j = (d + f); | |
h$p1(h$$iL); | |
try | |
{ | |
var k; | |
var l = { mv: null | |
}; | |
k = h$mkForeignCallback(l); | |
h$base_read(a, i, j, h, k); | |
if((l.mv === null)) | |
{ | |
l.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(l.mv); | |
} | |
else | |
{ | |
var m = l.mv; | |
h$r1 = m[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_86_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_86_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iJ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$iI() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$iJ); | |
return h$e(a); | |
}; | |
function h$$iH() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var i = a; | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, e, f, g, ((h + i) | 0)); | |
return h$stack[h$sp]; | |
}; | |
function h$$iG() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = b.d4; | |
var g = b.d5; | |
h$bh(); | |
h$p8(a, c, d, e, f, g, b.d6, h$$iH); | |
return h$e(b.d7); | |
}; | |
function h$$iF() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var i = h$c1(h$$iI, a); | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, i, h$c8(h$$iG, b, c, d, e, f, g, h, i)); | |
return h$stack[h$sp]; | |
}; | |
function h$$iE() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$iD() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var i = a; | |
var j = (i | 0); | |
if((j === (-1))) | |
{ | |
var k = h$__hscore_get_errno(); | |
var l = k; | |
h$p1(h$$iE); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (l | 0), h$baseZCGHCziIOziFDzizdfBufferedIOFD11, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, j, h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, e, f, g, | |
((h + j) | 0))); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa5_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = h$r5; | |
var e = h$r6; | |
var f = h$r7; | |
var g = h$r8; | |
var h = h$r9; | |
var i = h$maskStatus(); | |
var j = i; | |
if((j === 1)) | |
{ | |
var k = ((f - h) | 0); | |
var l = (k | 0); | |
var m; | |
var n; | |
m = b; | |
n = (c + h); | |
h$p8(b, c, d, e, f, g, h, h$$iD); | |
try | |
{ | |
var o; | |
var p = { mv: null | |
}; | |
o = h$mkForeignCallback(p); | |
h$base_read(a, m, n, l, o); | |
if((p.mv === null)) | |
{ | |
p.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(p.mv); | |
} | |
else | |
{ | |
var q = p.mv; | |
h$r1 = q[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_86_3) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_86_3); | |
}; | |
} | |
else | |
{ | |
h$p8(b, c, d, e, f, g, h, h$$iF); | |
return h$maskUnintAsync(h$c5(h$$iK, a, b, c, f, h)); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iN() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
h$l9(d.d6, i, h, g, f, e, c, b, h$baseZCGHCziIOziFDzizdwa5); | |
return h$baseZCGHCziIOziFDzizdwa5_e; | |
}; | |
function h$$iM() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$p2(a.d1, h$$iN); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziFDzizdfBufferedIOFD10_e() | |
{ | |
h$p2(h$r3, h$$iM); | |
return h$e(h$r2); | |
}; | |
function h$$iT() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$iS() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a; | |
var d = (c | 0); | |
switch (d) | |
{ | |
case ((-1)): | |
var e = h$__hscore_get_errno(); | |
var f = e; | |
h$p1(h$$iT); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (f | 0), b, h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
case (0): | |
h$r1 = h$baseZCGHCziIOziFDzizdfBufferedIOFD9; | |
break; | |
default: | |
h$r1 = d; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iR() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
var f = a; | |
var g; | |
var h; | |
g = c; | |
h = (e + d); | |
h$pp2(h$$iS); | |
try | |
{ | |
var i; | |
var j = { mv: null | |
}; | |
i = h$mkForeignCallback(j); | |
h$base_read(b, g, h, f, i); | |
if((j.mv === null)) | |
{ | |
j.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(j.mv); | |
} | |
else | |
{ | |
var k = j.mv; | |
h$r1 = k[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_90_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_90_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iQ() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 6; | |
h$pp40(a, h$$iR); | |
return h$e(b); | |
}; | |
function h$$iP() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
h$sp -= 5; | |
var c = a.d1; | |
h$pp52(c, a.d2, h$$iQ); | |
return h$e(b); | |
}; | |
function h$$iO() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
h$p5(a, c, e, b.d4, h$$iP); | |
return h$e(d); | |
}; | |
function h$baseZCGHCziIOziFDzizdwa4_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = h$r5; | |
var e = h$r6; | |
var f = h$maskStatus(); | |
var g = h$c5(h$$iO, a, b, c, d, e); | |
var h = f; | |
if((h === 1)) | |
{ | |
h$r1 = g; | |
return h$ap_1_0_fast(); | |
} | |
else | |
{ | |
return h$maskUnintAsync(g); | |
}; | |
}; | |
var h$baseZCGHCziIOziFDzizdfBufferedIOFD8 = h$strta("GHC.IO.FD.fdReadNonBlocking"); | |
function h$$iV() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var i = a; | |
if((i === (-1))) | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, h$baseZCDataziMaybeziNothing, | |
h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, e, f, g, h)); | |
} | |
else | |
{ | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, h$c1(h$baseZCDataziMaybeziJust_con_e, a), | |
h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, e, f, g, ((h + i) | 0))); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$iU() | |
{ | |
var a = h$r1; | |
h$sp -= 8; | |
h$pp128(h$$iV); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdwa3_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = h$r5; | |
var e = h$r6; | |
var f = h$r7; | |
var g = h$r8; | |
var h = h$r9; | |
var i = ((f - h) | 0); | |
var j = b; | |
h$p8(b, c, d, e, f, g, h, h$$iU); | |
h$l6((i | 0), h$baseZCGHCziIOziFDzizdfBufferedIOFD7, h$c2(h$baseZCGHCziPtrziPtr_con_e, j, (c + h)), a, | |
h$baseZCGHCziIOziFDzizdfBufferedIOFD8, h$baseZCGHCziIOziFDzizdwa4); | |
return h$baseZCGHCziIOziFDzizdwa4_e; | |
}; | |
function h$$iX() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
h$l9(d.d6, i, h, g, f, e, c, b, h$baseZCGHCziIOziFDzizdwa3); | |
return h$baseZCGHCziIOziFDzizdwa3_e; | |
}; | |
function h$$iW() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$p2(a.d1, h$$iX); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziFDzizdfBufferedIOFD6_e() | |
{ | |
h$p2(h$r3, h$$iW); | |
return h$e(h$r2); | |
}; | |
function h$$iZ() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d2; | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, d, e, h$baseZCGHCziIOziBufferziWriteBuffer, c.d4, 0, 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$iY() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$iZ); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziFDzizdfBufferedIOFD5_e() | |
{ | |
h$r1 = h$c1(h$$iY, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$$i2() | |
{ | |
var a = h$stack[(h$sp - 5)]; | |
var b = h$stack[(h$sp - 4)]; | |
var c = h$stack[(h$sp - 3)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 6; | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, 0, 0); | |
return h$stack[h$sp]; | |
}; | |
function h$$i1() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 2)]; | |
var e = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var f = a.d1; | |
var g = b; | |
h$pp32(h$$i2); | |
h$l4(((e - d) | 0), h$c2(h$baseZCGHCziPtrziPtr_con_e, g, (c + d)), f, h$baseZCGHCziIOziFDzizdwa2); | |
return h$ap_4_3_fast(); | |
}; | |
function h$$i0() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
h$p8(c, e, f, g, h, i, d.d6, h$$i1); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziFDzizdfBufferedIOFD3_e() | |
{ | |
h$p2(h$r2, h$$i0); | |
return h$e(h$r3); | |
}; | |
var h$baseZCGHCziIOziFDzizdfBufferedIOFD2 = h$strta("GHC.IO.FD.fdWriteNonBlocking"); | |
function h$$jd() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$l2(a, h$baseZCGHCziIOziExceptionziioError); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$jc() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
var c = (b | 0); | |
if((c === (-1))) | |
{ | |
var d = h$__hscore_get_errno(); | |
var e = d; | |
h$p1(h$$jd); | |
h$l5(h$baseZCDataziMaybeziNothing, h$baseZCDataziMaybeziNothing, (e | 0), h$baseZCGHCziIOziFDzizdfBufferedIOFD2, | |
h$baseZCForeignziCziErrorzierrnoToIOError); | |
return h$ap_4_4_fast(); | |
} | |
else | |
{ | |
h$r1 = (c | 0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$jb() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 2)]; | |
var d = h$stack[(h$sp - 1)]; | |
h$sp -= 4; | |
var e = a; | |
var f = (e | 0); | |
h$p1(h$$jc); | |
try | |
{ | |
var g; | |
var h = { mv: null | |
}; | |
g = h$mkForeignCallback(h); | |
h$base_write(b, c, d, f, g); | |
if((h.mv === null)) | |
{ | |
h.mv = new h$MVar(); | |
++h$sp; | |
h$stack[h$sp] = h$unboxFFIResult; | |
return h$takeMVar(h.mv); | |
} | |
else | |
{ | |
var i = h.mv; | |
h$r1 = i[0]; | |
}; | |
} | |
catch(h$GHCziIOziFD_id_102_0) | |
{ | |
return h$throwJSException(h$GHCziIOziFD_id_102_0); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$ja() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
var c = a.d1; | |
h$pp14(c, a.d2, h$$jb); | |
return h$e(b); | |
}; | |
function h$$i9() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$p3(a, b.d2, h$$ja); | |
return h$e(c); | |
}; | |
function h$$i8() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$i7() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$i8); | |
return h$e(a); | |
}; | |
function h$$i6() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = h$c1(h$$i7, a); | |
return h$stack[h$sp]; | |
}; | |
function h$$i5() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = a; | |
return h$stack[h$sp]; | |
}; | |
function h$$i4() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$p1(h$$i5); | |
return h$e(a); | |
}; | |
function h$$i3() | |
{ | |
var a = h$r1; | |
--h$sp; | |
h$r1 = h$c1(h$$i4, a); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa1_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = h$maskStatus(); | |
var e = h$c3(h$$i9, a, b, c); | |
var f = d; | |
if((f === 1)) | |
{ | |
h$p1(h$$i3); | |
h$r1 = e; | |
return h$ap_1_0_fast(); | |
} | |
else | |
{ | |
h$p1(h$$i6); | |
return h$maskUnintAsync(e); | |
}; | |
}; | |
function h$$jg() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
var i = a; | |
var j = ((g + i) | 0); | |
if((j === h)) | |
{ | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, e, f, 0, 0); | |
} | |
else | |
{ | |
h$r1 = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, b, c, d, e, f, j, h); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$jf() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
var e = b.d3; | |
var f = b.d4; | |
var g = b.d5; | |
h$bh(); | |
h$p8(a, c, d, e, f, g, b.d6, h$$jg); | |
return h$e(b.d7); | |
}; | |
function h$$je() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 7)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 8; | |
h$r1 = h$c2(h$ghczmprimZCGHCziTupleziZLz2cUZR_con_e, a, h$c8(h$$jf, b, c, d, e, f, g, h, a)); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDzizdwa_e() | |
{ | |
var a = h$r2; | |
var b = h$r3; | |
var c = h$r4; | |
var d = h$r5; | |
var e = h$r6; | |
var f = h$r7; | |
var g = h$r8; | |
var h = h$r9; | |
var i = b; | |
h$p8(b, c, d, e, f, g, h, h$$je); | |
h$l4(((h - g) | 0), h$c2(h$baseZCGHCziPtrziPtr_con_e, i, (c + g)), a, h$baseZCGHCziIOziFDzizdwa1); | |
return h$baseZCGHCziIOziFDzizdwa1_e; | |
}; | |
function h$$ji() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
var h = d.d4; | |
var i = d.d5; | |
h$l9(d.d6, i, h, g, f, e, c, b, h$baseZCGHCziIOziFDzizdwa); | |
return h$baseZCGHCziIOziFDzizdwa_e; | |
}; | |
function h$$jh() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$p2(a.d1, h$$ji); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziFDzizdfBufferedIOFD1_e() | |
{ | |
h$p2(h$r3, h$$jh); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziFDziFD_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziFDziFD_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziIOziFDziFD_con_e, h$r2, h$r3); | |
return h$stack[h$sp]; | |
}; | |
function h$$jk() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$r1 = h$c2(h$baseZCGHCziIOziFDziFD_con_e, b, a); | |
return h$stack[h$sp]; | |
}; | |
function h$$jj() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$p2(a, h$$jk); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziFDzizdWFD_e() | |
{ | |
h$p2(h$r3, h$$jj); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVarzuzdctoException_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziExceptionziSomeException_con_e, | |
h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVar, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTMzuzdctoException_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziExceptionziSomeException_con_e, | |
h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTM, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfExceptionIOExceptionzuzdctoException_e() | |
{ | |
h$r1 = h$c2(h$baseZCGHCziExceptionziSomeException_con_e, h$baseZCGHCziIOziExceptionzizdfExceptionIOException, h$r2); | |
return h$stack[h$sp]; | |
}; | |
function h$$jn() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l2(a, h$baseZCGHCziIOziExceptionzizdfExceptionIOExceptionzuzdctoException); | |
return h$ap_1_1_fast(); | |
}; | |
function h$$jm() | |
{ | |
return h$throw(h$c1(h$$jn, h$r2), false); | |
}; | |
var h$$j7 = h$strta("interrupted"); | |
var h$$j8 = h$strta("resource vanished"); | |
var h$$j9 = h$strta("timeout"); | |
var h$$ka = h$strta("unsupported operation"); | |
var h$$kb = h$strta("hardware fault"); | |
var h$$kc = h$strta("inappropriate type"); | |
var h$$kd = h$strta("invalid argument"); | |
var h$$ke = h$strta("failed"); | |
var h$$kf = h$strta("protocol error"); | |
var h$$kg = h$strta("system error"); | |
var h$$kh = h$strta("unsatisified constraints"); | |
var h$$ki = h$strta("user error"); | |
var h$$kj = h$strta("permission denied"); | |
var h$$kk = h$strta("illegal operation"); | |
var h$$kl = h$strta("end of file"); | |
var h$$km = h$strta("resource exhausted"); | |
var h$$kn = h$strta("resource busy"); | |
var h$$ko = h$strta("does not exist"); | |
var h$$kp = h$strta("already exists"); | |
function h$$jo() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a; | |
if((b === 124)) | |
{ | |
h$r1 = false; | |
} | |
else | |
{ | |
h$r1 = true; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziuntangle4_e() | |
{ | |
h$p1(h$$jo); | |
return h$e(h$r2); | |
}; | |
function h$$jp() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
h$l7(b, d.d5, g, f, e, c, h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec1); | |
return h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec1_e; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowIOExceptionzuzdcshowsPrec_e() | |
{ | |
h$p2(h$r4, h$$jp); | |
return h$e(h$r3); | |
}; | |
function h$$jq() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
var c = a.d2; | |
var d = c.d1; | |
var e = c.d2; | |
var f = c.d3; | |
h$l7(h$ghczmprimZCGHCziTypesziZMZN, c.d5, f, e, d, b, h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec1); | |
return h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec1_e; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowIOExceptionzuzdcshow_e() | |
{ | |
h$p1(h$$jq); | |
return h$e(h$r2); | |
}; | |
function h$$jr() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
switch (a.f.a) | |
{ | |
case (1): | |
h$l3(b, h$$kp, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (2): | |
h$l3(b, h$$ko, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (3): | |
h$l3(b, h$$kn, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (4): | |
h$l3(b, h$$km, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (5): | |
h$l3(b, h$$kl, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (6): | |
h$l3(b, h$$kk, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (7): | |
h$l3(b, h$$kj, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (8): | |
h$l3(b, h$$ki, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (9): | |
h$l3(b, h$$kh, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (10): | |
h$l3(b, h$$kg, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (11): | |
h$l3(b, h$$kf, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (12): | |
h$l3(b, h$$ke, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (13): | |
h$l3(b, h$$kd, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (14): | |
h$l3(b, h$$kc, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (15): | |
h$l3(b, h$$kb, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (16): | |
h$l3(b, h$$ka, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (17): | |
h$l3(b, h$$j9, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
case (18): | |
h$l3(b, h$$j8, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
default: | |
h$l3(b, h$$j7, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec2_e() | |
{ | |
h$p2(h$r3, h$$jr); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfShowIOException3 = h$strta(" ("); | |
function h$$jG() | |
{ | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziIOziExceptionzizdfShowIOException2, h$r1.d1), h$r1.d2, | |
h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jF() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
return h$e(b); | |
} | |
else | |
{ | |
h$l3(h$c2(h$$jG, b, a), h$baseZCGHCziIOziExceptionzizdfShowIOException3, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$$jE() | |
{ | |
var a = h$r1.d1; | |
h$p2(h$r1.d2, h$$jF); | |
return h$e(a); | |
}; | |
function h$$jD() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
h$l3(h$c2(h$$jE, c, b.d2), a, h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec2); | |
return h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec2_e; | |
}; | |
function h$$jC() | |
{ | |
h$l3(h$r1.d1, h$baseZCGHCziIOziExceptionzizdfShowArrayException2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jB() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
return h$e(b); | |
} | |
else | |
{ | |
h$l3(h$c1(h$$jC, b), a, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$$jA() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
var c = b.d1; | |
var d = b.d2; | |
h$p2(h$c3(h$$jD, a, d, b.d3), h$$jB); | |
return h$e(c); | |
}; | |
function h$$jz() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l3(a, h$baseZCGHCziIOziExceptionzizdfShowArrayException2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jy() | |
{ | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziIOziHandleziTypeszishowHandle1, h$c1(h$$jz, h$r1.d1)), h$r1. | |
d2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jx() | |
{ | |
var a = h$r1.d1; | |
h$bh(); | |
h$l3(a, h$baseZCGHCziIOziExceptionzizdfShowArrayException2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jw() | |
{ | |
h$l3(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziIOziHandleziTypeszishowHandle1, h$c1(h$$jx, h$r1.d1)), h$r1. | |
d2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jv() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
h$l3(h$c2(h$$jy, b, a.d1), h$baseZCGHCziIOziHandleziTypeszishowHandle2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
} | |
else | |
{ | |
h$l3(h$c2(h$$jw, b, a.d1), h$baseZCGHCziIOziHandleziTypeszishowHandle2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$$ju() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
if((a.f.a === 1)) | |
{ | |
return h$e(b); | |
} | |
else | |
{ | |
h$pp2(h$$jv); | |
return h$e(a.d1); | |
}; | |
}; | |
function h$$jt() | |
{ | |
h$l3(h$r1.d1, h$baseZCGHCziIOziExceptionzizdfShowArrayException2, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$js() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
if((a.f.a === 1)) | |
{ | |
h$p2(c, h$$ju); | |
return h$e(b); | |
} | |
else | |
{ | |
h$l3(h$c1(h$$jt, c), a.d1, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec1_e() | |
{ | |
h$p3(h$r2, h$c4(h$$jA, h$r3, h$r4, h$r5, h$r7), h$$js); | |
return h$e(h$r6); | |
}; | |
function h$$jH() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
var g = d.d3; | |
h$l7(b, d.d5, g, f, e, c, h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec1); | |
return h$baseZCGHCziIOziExceptionzizdwzdcshowsPrec1_e; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowIOException1_e() | |
{ | |
h$p2(h$r3, h$$jH); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowIOExceptionzuzdcshowList_e() | |
{ | |
h$l4(h$r3, h$r2, h$baseZCGHCziIOziExceptionzizdfShowIOException1, h$baseZCGHCziShowzishowListzuzu); | |
return h$baseZCGHCziShowzishowListzuzu_e; | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfExceptionIOException3 = h$strta("IOException"); | |
function h$baseZCGHCziIOziExceptionzizdfExceptionIOExceptionzuzdctypeRepzh_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfExceptionIOException1; | |
return h$stack[h$sp]; | |
}; | |
function h$$jJ() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l4(b, h$baseZCGHCziIOziExceptionzizdfExceptionIOExceptionzuzdctypeRepzh, a, h$baseZCDataziTypeablezicast); | |
return h$baseZCDataziTypeablezicast_e; | |
}; | |
function h$$jI() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$p2(a.d2, h$$jJ); | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfExceptionIOExceptionzuzdcfromException_e() | |
{ | |
h$p1(h$$jI); | |
return h$e(h$r2); | |
}; | |
function h$$jK() | |
{ | |
--h$sp; | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM2; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTMzuzdcshowsPrec_e() | |
{ | |
h$p1(h$$jK); | |
return h$e(h$r3); | |
}; | |
function h$$jL() | |
{ | |
--h$sp; | |
return h$e(h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM3); | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTMzuzdcshow_e() | |
{ | |
h$p1(h$$jL); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM3 = h$strta("thread blocked indefinitely in an STM transaction"); | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM2_e() | |
{ | |
h$l3(h$r2, h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM3, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jM() | |
{ | |
--h$sp; | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM2; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM1_e() | |
{ | |
h$p1(h$$jM); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTMzuzdcshowList_e() | |
{ | |
h$l4(h$r3, h$r2, h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnSTM1, h$baseZCGHCziShowzishowListzuzu); | |
return h$baseZCGHCziShowzishowListzuzu_e; | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTMzuww5 = h$strta("BlockedIndefinitelyOnSTM"); | |
function h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTMzuzdctypeRepzh_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTM1; | |
return h$stack[h$sp]; | |
}; | |
function h$$jO() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l4(b, h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTMzuzdctypeRepzh, a, | |
h$baseZCDataziTypeablezicast); | |
return h$baseZCDataziTypeablezicast_e; | |
}; | |
function h$$jN() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$p2(a.d2, h$$jO); | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnSTMzuzdcfromException_e() | |
{ | |
h$p1(h$$jN); | |
return h$e(h$r2); | |
}; | |
function h$$jP() | |
{ | |
--h$sp; | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar2; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVarzuzdcshowsPrec_e() | |
{ | |
h$p1(h$$jP); | |
return h$e(h$r3); | |
}; | |
function h$$jQ() | |
{ | |
--h$sp; | |
return h$e(h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar3); | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVarzuzdcshow_e() | |
{ | |
h$p1(h$$jQ); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar3 = h$strta("thread blocked indefinitely in an MVar operation"); | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar2_e() | |
{ | |
h$l3(h$r2, h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar3, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$jR() | |
{ | |
--h$sp; | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar2; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar1_e() | |
{ | |
h$p1(h$$jR); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVarzuzdcshowList_e() | |
{ | |
h$l4(h$r3, h$r2, h$baseZCGHCziIOziExceptionzizdfShowBlockedIndefinitelyOnMVar1, h$baseZCGHCziShowzishowListzuzu); | |
return h$baseZCGHCziShowzishowListzuzu_e; | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVarzuww5 = h$strta("BlockedIndefinitelyOnMVar"); | |
function h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVarzuzdctypeRepzh_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVar1; | |
return h$stack[h$sp]; | |
}; | |
function h$$jT() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l4(b, h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVarzuzdctypeRepzh, a, | |
h$baseZCDataziTypeablezicast); | |
return h$baseZCDataziTypeablezicast_e; | |
}; | |
function h$$jS() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$p2(a.d2, h$$jT); | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfExceptionBlockedIndefinitelyOnMVarzuzdcfromException_e() | |
{ | |
h$p1(h$$jS); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfExceptionAsyncExceptionzuww5 = h$strta("AsyncException"); | |
function h$baseZCGHCziIOziExceptionzizdfExceptionAsyncExceptionzuzdctypeRepzh_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfExceptionAsyncException1; | |
return h$stack[h$sp]; | |
}; | |
function h$$jX() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l4(b, h$baseZCGHCziIOziExceptionzizdfExceptionAsyncExceptionzuzdctypeRepzh, a, h$baseZCDataziTypeablezicast); | |
return h$baseZCDataziTypeablezicast_e; | |
}; | |
function h$$jW() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$p2(a.d2, h$$jX); | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$$jV() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
if(h$hs_eqWord64(c, e, (-645907477), (-1617761578))) | |
{ | |
if(h$hs_eqWord64(f, d.d3, (-980415011), (-840439589))) | |
{ | |
h$p1(h$$jW); | |
h$r1 = b; | |
return h$ap_0_0_fast(); | |
} | |
else | |
{ | |
h$r1 = h$baseZCDataziMaybeziNothing; | |
}; | |
} | |
else | |
{ | |
h$r1 = h$baseZCDataziMaybeziNothing; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$jU() | |
{ | |
var a = h$r1; | |
--h$sp; | |
var b = a.d1; | |
h$p2(a.d2, h$$jV); | |
++h$sp; | |
h$stack[h$sp] = h$ap_1_0; | |
h$l2(b, h$baseZCGHCziExceptionzizdp1Exception); | |
return h$baseZCGHCziExceptionzizdp1Exception_e; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfExceptionAsyncExceptionzuzdsasyncExceptionFromException_e() | |
{ | |
h$p1(h$$jU); | |
return h$e(h$r2); | |
}; | |
var h$baseZCGHCziIOziExceptionzizdfShowArrayException2 = h$strta(": "); | |
var h$baseZCGHCziIOziExceptionzizdfExceptionArrayException3 = h$strta("base"); | |
var h$baseZCGHCziIOziExceptionzizdfExceptionArrayExceptionzuww4 = h$strta("GHC.IO.Exception"); | |
function h$baseZCGHCziIOziExceptionziBlockedIndefinitelyOnMVar_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziBlockedIndefinitelyOnSTM_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziIOError_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziIOError_e() | |
{ | |
h$r1 = h$c6(h$baseZCGHCziIOziExceptionziIOError_con_e, h$r2, h$r3, h$r4, h$r5, h$r6, h$r7); | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziInterrupted_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziResourceVanished_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziTimeExpired_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziUnsupportedOperation_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziHardwareFault_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziInappropriateType_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziInvalidArgument_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziOtherError_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziProtocolError_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziUnsatisfiedConstraints_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziUserError_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziPermissionDenied_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziIllegalOperation_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziResourceExhausted_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziResourceBusy_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziNoSuchThing_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziAlreadyExists_con_e() | |
{ | |
return h$stack[h$sp]; | |
}; | |
function h$$j5() | |
{ | |
h$l3(h$baseZCGHCziIOziExceptionziuntangle2, h$r1.d1, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$j4() | |
{ | |
var a = h$r1.d1; | |
var b = h$r1.d2; | |
h$bh(); | |
h$l3(h$c1(h$$j5, b), a, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
var h$$baseZCGHCziIOziException_ea = h$str(": "); | |
function h$$j3() | |
{ | |
var a = h$r1.d1; | |
h$r4 = h$c2(h$$j4, a, h$r1.d2); | |
h$r3 = 0; | |
h$r2 = h$$baseZCGHCziIOziException_ea(); | |
h$r1 = h$ghczmprimZCGHCziCStringziunpackAppendCStringzh; | |
return h$ap_2_3_fast(); | |
}; | |
function h$$j2() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$l3(h$c2(h$$j3, a, h$r2), h$r1, h$baseZCGHCziBasezizpzp); | |
return h$ap_2_2_fast(); | |
}; | |
function h$$j1() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 2)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 3; | |
--h$sp; | |
var d = a; | |
if((d === 124)) | |
{ | |
h$l2(h$c2(h$ghczmprimZCGHCziTypesziZC_con_e, h$baseZCGHCziIOziExceptionziuntangle1, c), b); | |
++h$sp; | |
++h$sp; | |
return h$$j2; | |
} | |
else | |
{ | |
h$l2(h$ghczmprimZCGHCziTypesziZMZN, b); | |
++h$sp; | |
++h$sp; | |
return h$$j2; | |
}; | |
}; | |
function h$$j0() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
--h$sp; | |
if((a.f.a === 1)) | |
{ | |
h$l2(h$ghczmprimZCGHCziTypesziZMZN, b); | |
++h$sp; | |
++h$sp; | |
return h$$j2; | |
} | |
else | |
{ | |
var c = a.d1; | |
var d = a.d2; | |
++h$sp; | |
h$pp6(d, h$$j1); | |
return h$e(c); | |
}; | |
}; | |
function h$$jZ() | |
{ | |
var a; | |
var b; | |
a = h$r1; | |
b = h$r2; | |
h$sp -= 2; | |
var c = a; | |
var d = b; | |
++h$sp; | |
h$p2(c, h$$j0); | |
return h$e(d); | |
}; | |
function h$$jY() | |
{ | |
var a = h$r1; | |
h$sp -= 2; | |
h$pp2(h$$jZ); | |
h$l3(a, h$baseZCGHCziIOziExceptionziuntangle4, h$baseZCGHCziListzizdwspan); | |
return h$ap_2_2_fast(); | |
}; | |
function h$baseZCGHCziIOziExceptionziuntangle_e() | |
{ | |
h$p2(h$r4, h$$jY); | |
h$r1 = h$ghczmprimZCGHCziCStringziunpackCStringUtf8zh; | |
return h$ghczmprimZCGHCziCStringziunpackCStringUtf8zh_e; | |
}; | |
function h$baseZCGHCziIOziExceptionziioError_e() | |
{ | |
h$r1 = h$$j6; | |
return h$$jm; | |
}; | |
function h$baseZCGHCziIOziExceptionziioException_e() | |
{ | |
h$r1 = h$$j6; | |
return h$$jm; | |
}; | |
function h$baseZCGHCziIOziExceptionzizdfxExceptionIOException_e() | |
{ | |
h$bh(); | |
h$r1 = h$baseZCGHCziIOziExceptionzizdfExceptionIOException; | |
return h$stack[h$sp]; | |
}; | |
function h$baseZCGHCziIOziExceptionziuserError_e() | |
{ | |
h$r1 = h$c6(h$baseZCGHCziIOziExceptionziIOError_con_e, h$baseZCDataziMaybeziNothing, | |
h$baseZCGHCziIOziExceptionziUserError, h$ghczmprimZCGHCziTypesziZMZN, h$r2, h$baseZCDataziMaybeziNothing, | |
h$baseZCDataziMaybeziNothing); | |
return h$stack[h$sp]; | |
}; | |
function h$$kr() | |
{ | |
--h$sp; | |
h$l2(h$baseZCGHCziIOziEncodingziFailurezirecoverDecode2, h$baseZCGHCziIOziExceptionziioException); | |
return h$ap_2_1_fast(); | |
}; | |
function h$$kq() | |
{ | |
var a = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
h$p1(h$$kr); | |
return h$e(a); | |
}; | |
function h$baseZCGHCziIOziEncodingziUTF8ziutf6_e() | |
{ | |
h$p2(h$r3, h$$kq); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziEncodingziUTF8ziutf4_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziEncodingziUTF8ziutf5; | |
return h$stack[h$sp]; | |
}; | |
function h$$kt() | |
{ | |
var a = h$stack[(h$sp - 4)]; | |
var b = h$stack[(h$sp - 3)]; | |
var c = h$stack[(h$sp - 1)]; | |
h$sp -= 5; | |
var d = a.dv.getUint32((b + (c << 2)), true); | |
h$r1 = h$baseZCGHCziIOziEncodingziFailurezizdwa2; | |
return h$ap_1_0_fast(); | |
}; | |
function h$$ks() | |
{ | |
var a = h$r1; | |
var b = h$stack[(h$sp - 1)]; | |
h$sp -= 2; | |
var c = a.d1; | |
var d = a.d2; | |
var e = d.d1; | |
var f = d.d2; | |
h$p5(c, e, f, d.d5, h$$kt); | |
return h$e(b); | |
}; | |
function h$baseZCGHCziIOziEncodingziUTF8ziutf3_e() | |
{ | |
h$p2(h$r3, h$$ks); | |
return h$e(h$r2); | |
}; | |
function h$baseZCGHCziIOziEncodingziUTF8ziutf1_e() | |
{ | |
h$r1 = h$baseZCGHCziIOziEncodingziUTF8ziutf2; | |
return h$stack[h$sp]; | |
}; | |
var h$baseZCGHCziIOziEncodingziUTF8zimkUTF5 = h$strta("UTF-8"); | |
function h$$kJ() | |
{ | |
var a = h$stack[(h$sp - 19)]; | |
var b = h$stack[(h$sp - 18)]; | |
var c = h$stack[(h$sp - 17)]; | |
var d = h$stack[(h$sp - 16)]; | |
var e = h$stack[(h$sp - 15)]; | |
var f = h$stack[(h$sp - 14)]; | |
var g = h$stack[(h$sp - 13)]; | |
var h = h$stack[(h$sp - 12)]; | |
var i = h$stack[(h$sp - 11)]; | |
var j = h$stack[(h$sp - 10)]; | |
var k = h$stack[(h$sp - 9)]; | |
var l = h$stack[(h$sp - 8)]; | |
var m = h$stack[(h$sp - 7)]; | |
var n = h$stack[(h$sp - 6)]; | |
var o = h$stack[(h$sp - 5)]; | |
var p = h$stack[(h$sp - 4)]; | |
var q = h$stack[(h$sp - 3)]; | |
var r = h$stack[(h$sp - 2)]; | |
var s = h$stack[(h$sp - 1)]; | |
h$sp -= 20; | |
var t = p; | |
if((t === 244)) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 71) || (((q >>> 1) == 71) && ((q & 1) <= 1)))) | |
{ | |
if((((r >>> 1) > 64) || (((r >>> 1) == 64) && ((r & 1) >= 0)))) | |
{ | |
if((((r >>> 1) < 95) || (((r >>> 1) == 95) && ((r & 1) <= 1)))) | |
{ | |
if((((s >>> 1) > 64) || (((s >>> 1) == 64) && ((s & 1) >= 0)))) | |
{ | |
if((((s >>> 1) < 95) || (((s >>> 1) == 95) && ((s & 1) <= 1)))) | |
{ | |
var u = s; | |
var v = ((u - 128) | 0); | |
var w = r; | |
var x = ((w - 128) | 0); | |
var y = (x << 6); | |
var z = q; | |
var A = ((z - 128) | 0); | |
var B = (A << 12); | |
var C = ((1048576 + B) | 0); | |
var D = ((C + y) | 0); | |
var E = ((D + v) | 0); | |
g.dv.setUint32((h + (o << 2)), E, true); | |
h$l2(((o + 1) | 0), ((n + 4) | 0)); | |
h$sp += 13; | |
++h$sp; | |
return h$$ku; | |
} | |
else | |
{ | |
var F = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var G; | |
if((n === f)) | |
{ | |
G = m; | |
} | |
else | |
{ | |
G = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, G, F); | |
}; | |
} | |
else | |
{ | |
var H = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var I; | |
if((n === f)) | |
{ | |
I = m; | |
} | |
else | |
{ | |
I = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, I, H); | |
}; | |
} | |
else | |
{ | |
var J = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var K; | |
if((n === f)) | |
{ | |
K = m; | |
} | |
else | |
{ | |
K = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, K, J); | |
}; | |
} | |
else | |
{ | |
var L = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var M; | |
if((n === f)) | |
{ | |
M = m; | |
} | |
else | |
{ | |
M = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, M, L); | |
}; | |
} | |
else | |
{ | |
var N = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var O; | |
if((n === f)) | |
{ | |
O = m; | |
} | |
else | |
{ | |
O = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, O, N); | |
}; | |
} | |
else | |
{ | |
var P = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var Q; | |
if((n === f)) | |
{ | |
Q = m; | |
} | |
else | |
{ | |
Q = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, Q, P); | |
}; | |
} | |
else | |
{ | |
var R = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var S; | |
if((n === f)) | |
{ | |
S = m; | |
} | |
else | |
{ | |
S = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, S, R); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kI() | |
{ | |
var a = h$stack[(h$sp - 13)]; | |
var b = h$stack[(h$sp - 12)]; | |
var c = h$stack[(h$sp - 6)]; | |
var d = h$stack[(h$sp - 5)]; | |
var e = h$stack[(h$sp - 4)]; | |
var f = h$stack[(h$sp - 3)]; | |
var g = h$stack[(h$sp - 2)]; | |
var h = h$stack[(h$sp - 1)]; | |
h$sp -= 20; | |
if((((e >>> 1) > 120) || (((e >>> 1) == 120) && ((e & 1) >= 1)))) | |
{ | |
if((((e >>> 1) < 121) || (((e >>> 1) == 121) && ((e & 1) <= 1)))) | |
{ | |
if((((f >>> 1) > 64) || (((f >>> 1) == 64) && ((f & 1) >= 0)))) | |
{ | |
if((((f >>> 1) < 95) || (((f >>> 1) == 95) && ((f & 1) <= 1)))) | |
{ | |
if((((g >>> 1) > 64) || (((g >>> 1) == 64) && ((g & 1) >= 0)))) | |
{ | |
if((((g >>> 1) < 95) || (((g >>> 1) == 95) && ((g & 1) <= 1)))) | |
{ | |
if((((h >>> 1) > 64) || (((h >>> 1) == 64) && ((h & 1) >= 0)))) | |
{ | |
if((((h >>> 1) < 95) || (((h >>> 1) == 95) && ((h & 1) <= 1)))) | |
{ | |
var i = h; | |
var j = ((i - 128) | 0); | |
var k = g; | |
var l = ((k - 128) | 0); | |
var m = (l << 6); | |
var n = f; | |
var o = ((n - 128) | 0); | |
var p = (o << 12); | |
var q = e; | |
var r = ((q - 240) | 0); | |
var s = (r << 18); | |
var t = ((s + p) | 0); | |
var u = ((t + m) | 0); | |
var v = ((u + j) | 0); | |
a.dv.setUint32((b + (d << 2)), v, true); | |
h$l2(((d + 1) | 0), ((c + 4) | 0)); | |
h$sp += 13; | |
++h$sp; | |
return h$$ku; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
++h$sp; | |
return h$$kJ; | |
}; | |
}; | |
function h$$kH() | |
{ | |
var a = h$stack[(h$sp - 17)]; | |
var b = h$stack[(h$sp - 16)]; | |
var c = h$stack[(h$sp - 15)]; | |
var d = h$stack[(h$sp - 14)]; | |
var e = h$stack[(h$sp - 13)]; | |
var f = h$stack[(h$sp - 12)]; | |
var g = h$stack[(h$sp - 11)]; | |
var h = h$stack[(h$sp - 10)]; | |
var i = h$stack[(h$sp - 9)]; | |
var j = h$stack[(h$sp - 8)]; | |
var k = h$stack[(h$sp - 7)]; | |
var l = h$stack[(h$sp - 6)]; | |
var m = h$stack[(h$sp - 5)]; | |
var n = h$stack[(h$sp - 4)]; | |
var o = h$stack[(h$sp - 3)]; | |
var p = h$stack[(h$sp - 2)]; | |
var q = h$stack[(h$sp - 1)]; | |
h$sp -= 18; | |
var r = p; | |
if((r === 244)) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 71) || (((q >>> 1) == 71) && ((q & 1) <= 1)))) | |
{ | |
var s = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var t; | |
if((n === f)) | |
{ | |
t = m; | |
} | |
else | |
{ | |
t = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, t, s); | |
} | |
else | |
{ | |
var u = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var v; | |
if((n === f)) | |
{ | |
v = m; | |
} | |
else | |
{ | |
v = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, v, u); | |
}; | |
} | |
else | |
{ | |
var w = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var x; | |
if((n === f)) | |
{ | |
x = m; | |
} | |
else | |
{ | |
x = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, x, w); | |
}; | |
} | |
else | |
{ | |
var y = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var z; | |
if((n === f)) | |
{ | |
z = m; | |
} | |
else | |
{ | |
z = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, z, y); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kG() | |
{ | |
var a = h$stack[(h$sp - 17)]; | |
var b = h$stack[(h$sp - 16)]; | |
var c = h$stack[(h$sp - 15)]; | |
var d = h$stack[(h$sp - 14)]; | |
var e = h$stack[(h$sp - 13)]; | |
var f = h$stack[(h$sp - 12)]; | |
var g = h$stack[(h$sp - 11)]; | |
var h = h$stack[(h$sp - 10)]; | |
var i = h$stack[(h$sp - 9)]; | |
var j = h$stack[(h$sp - 8)]; | |
var k = h$stack[(h$sp - 7)]; | |
var l = h$stack[(h$sp - 6)]; | |
var m = h$stack[(h$sp - 5)]; | |
var n = h$stack[(h$sp - 4)]; | |
var o = h$stack[(h$sp - 3)]; | |
var p = h$stack[(h$sp - 2)]; | |
var q = h$stack[(h$sp - 1)]; | |
h$sp -= 18; | |
if((((p >>> 1) > 120) || (((p >>> 1) == 120) && ((p & 1) >= 1)))) | |
{ | |
if((((p >>> 1) < 121) || (((p >>> 1) == 121) && ((p & 1) <= 1)))) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 95) || (((q >>> 1) == 95) && ((q & 1) <= 1)))) | |
{ | |
var r = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var s; | |
if((n === f)) | |
{ | |
s = m; | |
} | |
else | |
{ | |
s = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, s, r); | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$kH; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$kH; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$kH; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$kH; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kF() | |
{ | |
var a = h$stack[(h$sp - 18)]; | |
var b = h$stack[(h$sp - 17)]; | |
var c = h$stack[(h$sp - 16)]; | |
var d = h$stack[(h$sp - 15)]; | |
var e = h$stack[(h$sp - 14)]; | |
var f = h$stack[(h$sp - 13)]; | |
var g = h$stack[(h$sp - 12)]; | |
var h = h$stack[(h$sp - 11)]; | |
var i = h$stack[(h$sp - 10)]; | |
var j = h$stack[(h$sp - 9)]; | |
var k = h$stack[(h$sp - 8)]; | |
var l = h$stack[(h$sp - 7)]; | |
var m = h$stack[(h$sp - 6)]; | |
var n = h$stack[(h$sp - 5)]; | |
var o = h$stack[(h$sp - 4)]; | |
var p = h$stack[(h$sp - 3)]; | |
var q = h$stack[(h$sp - 2)]; | |
var r = h$stack[(h$sp - 1)]; | |
h$sp -= 19; | |
var s = p; | |
if((s === 244)) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 71) || (((q >>> 1) == 71) && ((q & 1) <= 1)))) | |
{ | |
if((((r >>> 1) > 64) || (((r >>> 1) == 64) && ((r & 1) >= 0)))) | |
{ | |
if((((r >>> 1) < 95) || (((r >>> 1) == 95) && ((r & 1) <= 1)))) | |
{ | |
var t = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var u; | |
if((n === f)) | |
{ | |
u = m; | |
} | |
else | |
{ | |
u = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, u, t); | |
} | |
else | |
{ | |
var v = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var w; | |
if((n === f)) | |
{ | |
w = m; | |
} | |
else | |
{ | |
w = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, w, v); | |
}; | |
} | |
else | |
{ | |
var x = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var y; | |
if((n === f)) | |
{ | |
y = m; | |
} | |
else | |
{ | |
y = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, y, x); | |
}; | |
} | |
else | |
{ | |
var z = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var A; | |
if((n === f)) | |
{ | |
A = m; | |
} | |
else | |
{ | |
A = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, A, z); | |
}; | |
} | |
else | |
{ | |
var B = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var C; | |
if((n === f)) | |
{ | |
C = m; | |
} | |
else | |
{ | |
C = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, C, B); | |
}; | |
} | |
else | |
{ | |
var D = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var E; | |
if((n === f)) | |
{ | |
E = m; | |
} | |
else | |
{ | |
E = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, E, D); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kE() | |
{ | |
var a = h$stack[(h$sp - 18)]; | |
var b = h$stack[(h$sp - 17)]; | |
var c = h$stack[(h$sp - 16)]; | |
var d = h$stack[(h$sp - 15)]; | |
var e = h$stack[(h$sp - 14)]; | |
var f = h$stack[(h$sp - 13)]; | |
var g = h$stack[(h$sp - 12)]; | |
var h = h$stack[(h$sp - 11)]; | |
var i = h$stack[(h$sp - 10)]; | |
var j = h$stack[(h$sp - 9)]; | |
var k = h$stack[(h$sp - 8)]; | |
var l = h$stack[(h$sp - 7)]; | |
var m = h$stack[(h$sp - 6)]; | |
var n = h$stack[(h$sp - 5)]; | |
var o = h$stack[(h$sp - 4)]; | |
var p = h$stack[(h$sp - 3)]; | |
var q = h$stack[(h$sp - 2)]; | |
var r = h$stack[(h$sp - 1)]; | |
h$sp -= 19; | |
if((((p >>> 1) > 120) || (((p >>> 1) == 120) && ((p & 1) >= 1)))) | |
{ | |
if((((p >>> 1) < 121) || (((p >>> 1) == 121) && ((p & 1) <= 1)))) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 95) || (((q >>> 1) == 95) && ((q & 1) <= 1)))) | |
{ | |
if((((r >>> 1) > 64) || (((r >>> 1) == 64) && ((r & 1) >= 0)))) | |
{ | |
if((((r >>> 1) < 95) || (((r >>> 1) == 95) && ((r & 1) <= 1)))) | |
{ | |
var s = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var t; | |
if((n === f)) | |
{ | |
t = m; | |
} | |
else | |
{ | |
t = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, t, s); | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kF; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kF; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kF; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kF; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kF; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kF; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kD() | |
{ | |
var a = h$stack[(h$sp - 16)]; | |
var b = h$stack[(h$sp - 15)]; | |
var c = h$stack[(h$sp - 14)]; | |
var d = h$stack[(h$sp - 13)]; | |
var e = h$stack[(h$sp - 12)]; | |
var f = h$stack[(h$sp - 11)]; | |
var g = h$stack[(h$sp - 10)]; | |
var h = h$stack[(h$sp - 9)]; | |
var i = h$stack[(h$sp - 8)]; | |
var j = h$stack[(h$sp - 7)]; | |
var k = h$stack[(h$sp - 6)]; | |
var l = h$stack[(h$sp - 5)]; | |
var m = h$stack[(h$sp - 4)]; | |
var n = h$stack[(h$sp - 3)]; | |
var o = h$stack[(h$sp - 2)]; | |
var p = h$stack[(h$sp - 1)]; | |
h$sp -= 17; | |
if((((p >>> 1) > 120) || (((p >>> 1) == 120) && ((p & 1) >= 0)))) | |
{ | |
switch (((f - n) | 0)) | |
{ | |
case (1): | |
var q = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var r; | |
if((n === f)) | |
{ | |
r = m; | |
} | |
else | |
{ | |
r = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, r, q); | |
break; | |
case (2): | |
var s = ((n + 1) | 0); | |
var t; | |
var u; | |
t = a; | |
u = (b + s); | |
var v = t.u8[(u + 0)]; | |
var w = p; | |
if((w === 240)) | |
{ | |
if((((v >>> 1) > 72) || (((v >>> 1) == 72) && ((v & 1) >= 0)))) | |
{ | |
if((((v >>> 1) < 95) || (((v >>> 1) == 95) && ((v & 1) <= 1)))) | |
{ | |
var x = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var y; | |
if((n === f)) | |
{ | |
y = m; | |
} | |
else | |
{ | |
y = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, y, x); | |
} | |
else | |
{ | |
h$sp += 17; | |
h$stack[h$sp] = v; | |
++h$sp; | |
return h$$kG; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
h$stack[h$sp] = v; | |
++h$sp; | |
return h$$kG; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
h$stack[h$sp] = v; | |
++h$sp; | |
return h$$kG; | |
}; | |
break; | |
case (3): | |
var z = ((n + 1) | 0); | |
var A; | |
var B; | |
A = a; | |
B = (b + z); | |
var C = A.u8[(B + 0)]; | |
var D = ((n + 2) | 0); | |
var E; | |
var F; | |
E = a; | |
F = (b + D); | |
var G = E.u8[(F + 0)]; | |
var H = p; | |
if((H === 240)) | |
{ | |
if((((C >>> 1) > 72) || (((C >>> 1) == 72) && ((C & 1) >= 0)))) | |
{ | |
if((((C >>> 1) < 95) || (((C >>> 1) == 95) && ((C & 1) <= 1)))) | |
{ | |
if((((G >>> 1) > 64) || (((G >>> 1) == 64) && ((G & 1) >= 0)))) | |
{ | |
if((((G >>> 1) < 95) || (((G >>> 1) == 95) && ((G & 1) <= 1)))) | |
{ | |
var I = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var J; | |
if((n === f)) | |
{ | |
J = m; | |
} | |
else | |
{ | |
J = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, J, I); | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kE; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kE; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kE; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kE; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kE; | |
}; | |
break; | |
default: | |
var K = ((n + 1) | 0); | |
var L; | |
var M; | |
L = a; | |
M = (b + K); | |
var N = L.u8[(M + 0)]; | |
var O = ((n + 2) | 0); | |
var P; | |
var Q; | |
P = a; | |
Q = (b + O); | |
var R = P.u8[(Q + 0)]; | |
var S = ((n + 3) | 0); | |
var T; | |
var U; | |
T = a; | |
U = (b + S); | |
var V = T.u8[(U + 0)]; | |
var W = p; | |
if((W === 240)) | |
{ | |
if((((N >>> 1) > 72) || (((N >>> 1) == 72) && ((N & 1) >= 0)))) | |
{ | |
if((((N >>> 1) < 95) || (((N >>> 1) == 95) && ((N & 1) <= 1)))) | |
{ | |
if((((R >>> 1) > 64) || (((R >>> 1) == 64) && ((R & 1) >= 0)))) | |
{ | |
if((((R >>> 1) < 95) || (((R >>> 1) == 95) && ((R & 1) <= 1)))) | |
{ | |
if((((V >>> 1) > 64) || (((V >>> 1) == 64) && ((V & 1) >= 0)))) | |
{ | |
if((((V >>> 1) < 95) || (((V >>> 1) == 95) && ((V & 1) <= 1)))) | |
{ | |
var X = V; | |
var Y = ((X - 128) | 0); | |
var Z = R; | |
var aa = ((Z - 128) | 0); | |
var ab = (aa << 6); | |
var ac = N; | |
var ad = ((ac - 128) | 0); | |
var ae = (ad << 12); | |
var af = ((ae + ab) | 0); | |
var ag = ((af + Y) | 0); | |
g.dv.setUint32((h + (o << 2)), ag, true); | |
h$l2(((o + 1) | 0), ((n + 4) | 0)); | |
h$sp += 13; | |
++h$sp; | |
return h$$ku; | |
} | |
else | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 2)] = N; | |
h$stack[(h$sp - 1)] = R; | |
h$stack[h$sp] = V; | |
++h$sp; | |
return h$$kI; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 2)] = N; | |
h$stack[(h$sp - 1)] = R; | |
h$stack[h$sp] = V; | |
++h$sp; | |
return h$$kI; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 2)] = N; | |
h$stack[(h$sp - 1)] = R; | |
h$stack[h$sp] = V; | |
++h$sp; | |
return h$$kI; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 2)] = N; | |
h$stack[(h$sp - 1)] = R; | |
h$stack[h$sp] = V; | |
++h$sp; | |
return h$$kI; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 2)] = N; | |
h$stack[(h$sp - 1)] = R; | |
h$stack[h$sp] = V; | |
++h$sp; | |
return h$$kI; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 2)] = N; | |
h$stack[(h$sp - 1)] = R; | |
h$stack[h$sp] = V; | |
++h$sp; | |
return h$$kI; | |
}; | |
} | |
else | |
{ | |
h$sp += 19; | |
h$stack[(h$sp - 2)] = N; | |
h$stack[(h$sp - 1)] = R; | |
h$stack[h$sp] = V; | |
++h$sp; | |
return h$$kI; | |
}; | |
}; | |
} | |
else | |
{ | |
var ah = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var ai; | |
if((n === f)) | |
{ | |
ai = m; | |
} | |
else | |
{ | |
ai = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, ai, ah); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kC() | |
{ | |
var a = h$stack[(h$sp - 18)]; | |
var b = h$stack[(h$sp - 17)]; | |
var c = h$stack[(h$sp - 16)]; | |
var d = h$stack[(h$sp - 15)]; | |
var e = h$stack[(h$sp - 14)]; | |
var f = h$stack[(h$sp - 13)]; | |
var g = h$stack[(h$sp - 12)]; | |
var h = h$stack[(h$sp - 11)]; | |
var i = h$stack[(h$sp - 10)]; | |
var j = h$stack[(h$sp - 9)]; | |
var k = h$stack[(h$sp - 8)]; | |
var l = h$stack[(h$sp - 7)]; | |
var m = h$stack[(h$sp - 6)]; | |
var n = h$stack[(h$sp - 5)]; | |
var o = h$stack[(h$sp - 4)]; | |
var p = h$stack[(h$sp - 3)]; | |
var q = h$stack[(h$sp - 2)]; | |
var r = h$stack[(h$sp - 1)]; | |
h$sp -= 19; | |
if((((p >>> 1) > 119) || (((p >>> 1) == 119) && ((p & 1) >= 0)))) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 95) || (((q >>> 1) == 95) && ((q & 1) <= 1)))) | |
{ | |
if((((r >>> 1) > 64) || (((r >>> 1) == 64) && ((r & 1) >= 0)))) | |
{ | |
if((((r >>> 1) < 95) || (((r >>> 1) == 95) && ((r & 1) <= 1)))) | |
{ | |
var s = r; | |
var t = ((s - 128) | 0); | |
var u = q; | |
var v = ((u - 128) | 0); | |
var w = (v << 6); | |
var x = p; | |
var y = ((x - 224) | 0); | |
var z = (y << 12); | |
var A = ((z + w) | 0); | |
var B = ((A + t) | 0); | |
g.dv.setUint32((h + (o << 2)), B, true); | |
h$l2(((o + 1) | 0), ((n + 3) | 0)); | |
h$sp += 13; | |
++h$sp; | |
return h$$ku; | |
} | |
else | |
{ | |
var C = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var D; | |
if((n === f)) | |
{ | |
D = m; | |
} | |
else | |
{ | |
D = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, D, C); | |
}; | |
} | |
else | |
{ | |
var E = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var F; | |
if((n === f)) | |
{ | |
F = m; | |
} | |
else | |
{ | |
F = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, F, E); | |
}; | |
} | |
else | |
{ | |
var G = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var H; | |
if((n === f)) | |
{ | |
H = m; | |
} | |
else | |
{ | |
H = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, H, G); | |
}; | |
} | |
else | |
{ | |
var I = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var J; | |
if((n === f)) | |
{ | |
J = m; | |
} | |
else | |
{ | |
J = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, J, I); | |
}; | |
} | |
else | |
{ | |
var K = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var L; | |
if((n === f)) | |
{ | |
L = m; | |
} | |
else | |
{ | |
L = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, L, K); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kB() | |
{ | |
var a = h$stack[(h$sp - 12)]; | |
var b = h$stack[(h$sp - 11)]; | |
var c = h$stack[(h$sp - 5)]; | |
var d = h$stack[(h$sp - 4)]; | |
var e = h$stack[(h$sp - 3)]; | |
var f = h$stack[(h$sp - 2)]; | |
var g = h$stack[(h$sp - 1)]; | |
h$sp -= 19; | |
var h = e; | |
if((h === 237)) | |
{ | |
if((((f >>> 1) > 64) || (((f >>> 1) == 64) && ((f & 1) >= 0)))) | |
{ | |
if((((f >>> 1) < 79) || (((f >>> 1) == 79) && ((f & 1) <= 1)))) | |
{ | |
if((((g >>> 1) > 64) || (((g >>> 1) == 64) && ((g & 1) >= 0)))) | |
{ | |
if((((g >>> 1) < 95) || (((g >>> 1) == 95) && ((g & 1) <= 1)))) | |
{ | |
var i = g; | |
var j = ((i - 128) | 0); | |
var k = f; | |
var l = ((k - 128) | 0); | |
var m = (l << 6); | |
var n = ((53248 + m) | 0); | |
var o = ((n + j) | 0); | |
a.dv.setUint32((b + (d << 2)), o, true); | |
h$l2(((d + 1) | 0), ((c + 3) | 0)); | |
h$sp += 13; | |
++h$sp; | |
return h$$ku; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kC; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kC; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kC; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kC; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kC; | |
}; | |
}; | |
function h$$kA() | |
{ | |
var a = h$stack[(h$sp - 12)]; | |
var b = h$stack[(h$sp - 11)]; | |
var c = h$stack[(h$sp - 5)]; | |
var d = h$stack[(h$sp - 4)]; | |
var e = h$stack[(h$sp - 3)]; | |
var f = h$stack[(h$sp - 2)]; | |
var g = h$stack[(h$sp - 1)]; | |
h$sp -= 19; | |
if((((e >>> 1) > 112) || (((e >>> 1) == 112) && ((e & 1) >= 1)))) | |
{ | |
if((((e >>> 1) < 118) || (((e >>> 1) == 118) && ((e & 1) <= 0)))) | |
{ | |
if((((f >>> 1) > 64) || (((f >>> 1) == 64) && ((f & 1) >= 0)))) | |
{ | |
if((((f >>> 1) < 95) || (((f >>> 1) == 95) && ((f & 1) <= 1)))) | |
{ | |
if((((g >>> 1) > 64) || (((g >>> 1) == 64) && ((g & 1) >= 0)))) | |
{ | |
if((((g >>> 1) < 95) || (((g >>> 1) == 95) && ((g & 1) <= 1)))) | |
{ | |
var h = g; | |
var i = ((h - 128) | 0); | |
var j = f; | |
var k = ((j - 128) | 0); | |
var l = (k << 6); | |
var m = e; | |
var n = ((m - 224) | 0); | |
var o = (n << 12); | |
var p = ((o + l) | 0); | |
var q = ((p + i) | 0); | |
a.dv.setUint32((b + (d << 2)), q, true); | |
h$l2(((d + 1) | 0), ((c + 3) | 0)); | |
h$sp += 13; | |
++h$sp; | |
return h$$ku; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kB; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kB; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kB; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kB; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kB; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
++h$sp; | |
return h$$kB; | |
}; | |
}; | |
function h$$kz() | |
{ | |
var a = h$stack[(h$sp - 17)]; | |
var b = h$stack[(h$sp - 16)]; | |
var c = h$stack[(h$sp - 15)]; | |
var d = h$stack[(h$sp - 14)]; | |
var e = h$stack[(h$sp - 13)]; | |
var f = h$stack[(h$sp - 12)]; | |
var g = h$stack[(h$sp - 11)]; | |
var h = h$stack[(h$sp - 10)]; | |
var i = h$stack[(h$sp - 9)]; | |
var j = h$stack[(h$sp - 8)]; | |
var k = h$stack[(h$sp - 7)]; | |
var l = h$stack[(h$sp - 6)]; | |
var m = h$stack[(h$sp - 5)]; | |
var n = h$stack[(h$sp - 4)]; | |
var o = h$stack[(h$sp - 3)]; | |
var p = h$stack[(h$sp - 2)]; | |
var q = h$stack[(h$sp - 1)]; | |
h$sp -= 18; | |
if((((p >>> 1) > 119) || (((p >>> 1) == 119) && ((p & 1) >= 0)))) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 95) || (((q >>> 1) == 95) && ((q & 1) <= 1)))) | |
{ | |
var r = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var s; | |
if((n === f)) | |
{ | |
s = m; | |
} | |
else | |
{ | |
s = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, s, r); | |
} | |
else | |
{ | |
var t = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var u; | |
if((n === f)) | |
{ | |
u = m; | |
} | |
else | |
{ | |
u = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, u, t); | |
}; | |
} | |
else | |
{ | |
var v = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var w; | |
if((n === f)) | |
{ | |
w = m; | |
} | |
else | |
{ | |
w = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, w, v); | |
}; | |
} | |
else | |
{ | |
var x = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var y; | |
if((n === f)) | |
{ | |
y = m; | |
} | |
else | |
{ | |
y = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInvalidSequence, y, x); | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$ky() | |
{ | |
var a = h$stack[(h$sp - 17)]; | |
var b = h$stack[(h$sp - 16)]; | |
var c = h$stack[(h$sp - 15)]; | |
var d = h$stack[(h$sp - 14)]; | |
var e = h$stack[(h$sp - 13)]; | |
var f = h$stack[(h$sp - 12)]; | |
var g = h$stack[(h$sp - 11)]; | |
var h = h$stack[(h$sp - 10)]; | |
var i = h$stack[(h$sp - 9)]; | |
var j = h$stack[(h$sp - 8)]; | |
var k = h$stack[(h$sp - 7)]; | |
var l = h$stack[(h$sp - 6)]; | |
var m = h$stack[(h$sp - 5)]; | |
var n = h$stack[(h$sp - 4)]; | |
var o = h$stack[(h$sp - 3)]; | |
var p = h$stack[(h$sp - 2)]; | |
var q = h$stack[(h$sp - 1)]; | |
h$sp -= 18; | |
var r = p; | |
if((r === 237)) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 79) || (((q >>> 1) == 79) && ((q & 1) <= 1)))) | |
{ | |
var s = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var t; | |
if((n === f)) | |
{ | |
t = m; | |
} | |
else | |
{ | |
t = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, t, s); | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$kz; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$kz; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$kz; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kx() | |
{ | |
var a = h$stack[(h$sp - 17)]; | |
var b = h$stack[(h$sp - 16)]; | |
var c = h$stack[(h$sp - 15)]; | |
var d = h$stack[(h$sp - 14)]; | |
var e = h$stack[(h$sp - 13)]; | |
var f = h$stack[(h$sp - 12)]; | |
var g = h$stack[(h$sp - 11)]; | |
var h = h$stack[(h$sp - 10)]; | |
var i = h$stack[(h$sp - 9)]; | |
var j = h$stack[(h$sp - 8)]; | |
var k = h$stack[(h$sp - 7)]; | |
var l = h$stack[(h$sp - 6)]; | |
var m = h$stack[(h$sp - 5)]; | |
var n = h$stack[(h$sp - 4)]; | |
var o = h$stack[(h$sp - 3)]; | |
var p = h$stack[(h$sp - 2)]; | |
var q = h$stack[(h$sp - 1)]; | |
h$sp -= 18; | |
if((((p >>> 1) > 112) || (((p >>> 1) == 112) && ((p & 1) >= 1)))) | |
{ | |
if((((p >>> 1) < 118) || (((p >>> 1) == 118) && ((p & 1) <= 0)))) | |
{ | |
if((((q >>> 1) > 64) || (((q >>> 1) == 64) && ((q & 1) >= 0)))) | |
{ | |
if((((q >>> 1) < 95) || (((q >>> 1) == 95) && ((q & 1) <= 1)))) | |
{ | |
var r = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var s; | |
if((n === f)) | |
{ | |
s = m; | |
} | |
else | |
{ | |
s = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, s, r); | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$ky; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$ky; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$ky; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
++h$sp; | |
return h$$ky; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kw() | |
{ | |
var a = h$stack[(h$sp - 16)]; | |
var b = h$stack[(h$sp - 15)]; | |
var c = h$stack[(h$sp - 14)]; | |
var d = h$stack[(h$sp - 13)]; | |
var e = h$stack[(h$sp - 12)]; | |
var f = h$stack[(h$sp - 11)]; | |
var g = h$stack[(h$sp - 10)]; | |
var h = h$stack[(h$sp - 9)]; | |
var i = h$stack[(h$sp - 8)]; | |
var j = h$stack[(h$sp - 7)]; | |
var k = h$stack[(h$sp - 6)]; | |
var l = h$stack[(h$sp - 5)]; | |
var m = h$stack[(h$sp - 4)]; | |
var n = h$stack[(h$sp - 3)]; | |
var o = h$stack[(h$sp - 2)]; | |
var p = h$stack[(h$sp - 1)]; | |
h$sp -= 17; | |
if((((p >>> 1) > 112) || (((p >>> 1) == 112) && ((p & 1) >= 0)))) | |
{ | |
if((((p >>> 1) < 119) || (((p >>> 1) == 119) && ((p & 1) <= 1)))) | |
{ | |
switch (((f - n) | 0)) | |
{ | |
case (1): | |
var q = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var r; | |
if((n === f)) | |
{ | |
r = m; | |
} | |
else | |
{ | |
r = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, r, q); | |
break; | |
case (2): | |
var s = ((n + 1) | 0); | |
var t; | |
var u; | |
t = a; | |
u = (b + s); | |
var v = t.u8[(u + 0)]; | |
var w = p; | |
if((w === 224)) | |
{ | |
if((((v >>> 1) > 80) || (((v >>> 1) == 80) && ((v & 1) >= 0)))) | |
{ | |
if((((v >>> 1) < 95) || (((v >>> 1) == 95) && ((v & 1) <= 1)))) | |
{ | |
var x = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, g, h, i, j, k, l, o); | |
var y; | |
if((n === f)) | |
{ | |
y = m; | |
} | |
else | |
{ | |
y = h$c7(h$baseZCGHCziIOziBufferziBuffer_con_e, a, b, c, d, e, n, f); | |
}; | |
h$r1 = h$c3(h$ghczmprimZCGHCziTupleziZLz2cUz2cUZR_con_e, h$baseZCGHCziIOziEncodingziTypesziInputUnderflow, y, x); | |
} | |
else | |
{ | |
h$sp += 17; | |
h$stack[h$sp] = v; | |
++h$sp; | |
return h$$kx; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
h$stack[h$sp] = v; | |
++h$sp; | |
return h$$kx; | |
}; | |
} | |
else | |
{ | |
h$sp += 17; | |
h$stack[h$sp] = v; | |
++h$sp; | |
return h$$kx; | |
}; | |
break; | |
default: | |
var z = ((n + 1) | 0); | |
var A; | |
var B; | |
A = a; | |
B = (b + z); | |
var C = A.u8[(B + 0)]; | |
var D = ((n + 2) | 0); | |
var E; | |
var F; | |
E = a; | |
F = (b + D); | |
var G = E.u8[(F + 0)]; | |
var H = p; | |
if((H === 224)) | |
{ | |
if((((C >>> 1) > 80) || (((C >>> 1) == 80) && ((C & 1) >= 0)))) | |
{ | |
if((((C >>> 1) < 95) || (((C >>> 1) == 95) && ((C & 1) <= 1)))) | |
{ | |
if((((G >>> 1) > 64) || (((G >>> 1) == 64) && ((G & 1) >= 0)))) | |
{ | |
if((((G >>> 1) < 95) || (((G >>> 1) == 95) && ((G & 1) <= 1)))) | |
{ | |
var I = G; | |
var J = ((I - 128) | 0); | |
var K = C; | |
var L = ((K - 128) | 0); | |
var M = (L << 6); | |
var N = ((M + J) | 0); | |
g.dv.setUint32((h + (o << 2)), N, true); | |
h$l2(((o + 1) | 0), ((n + 3) | 0)); | |
h$sp += 13; | |
++h$sp; | |
return h$$ku; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kA; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kA; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kA; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kA; | |
}; | |
} | |
else | |
{ | |
h$sp += 18; | |
h$stack[(h$sp - 1)] = C; | |
h$stack[h$sp] = G; | |
++h$sp; | |
return h$$kA; | |
}; | |
}; | |
} | |
else | |
{ | |
h$sp += 16; | |
++h$sp; | |
return h$$kD; | |
}; | |
} | |
else | |
{ | |
h$sp += 16; | |
++h$sp; | |
return h$$kD; | |
}; | |
return h$stack[h$sp]; | |
}; | |
function h$$kv() | |
{ | |
var a = h$stack[(h$sp - 16)]; | |
var b = h$stack[(h$sp - 15)]; | |
var c = h$stack[(h$sp - 14)]; | |
var d = h$stack[(h$sp - 13)]; | |
var e = h$stack[(h$sp - 12)]; | |
var f = h$stack[(h$sp - 11)]; | |
var g = h$stack[(h$sp - 10)]; | |
var h = h$stack[(h$sp - 9)]; | |
var i = h$stack[(h$sp - 8)]; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment