2013-07-17 03:24:37 +04:00
|
|
|
function lin() {
|
2013-07-17 23:06:49 +04:00
|
|
|
var sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 136 | 0;
|
2013-07-17 03:24:37 +04:00
|
|
|
c(1);
|
|
|
|
c(2);
|
|
|
|
c(3);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 16 >> 2] = 0;
|
|
|
|
HEAP32[sp + 20 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
lin$1(sp);
|
2013-07-19 05:44:33 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
lin$0(sp);
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 03:24:37 +04:00
|
|
|
}
|
2013-07-17 03:40:56 +04:00
|
|
|
function lin2() {
|
2013-07-17 23:06:49 +04:00
|
|
|
var sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 136 | 0;
|
2013-07-17 03:40:56 +04:00
|
|
|
while (1) {
|
|
|
|
c(1);
|
|
|
|
c(2);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 16 >> 2] = 0;
|
|
|
|
HEAP32[sp + 20 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
lin2$1(sp);
|
2013-07-19 05:44:33 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
lin2$0(sp);
|
2013-07-17 03:40:56 +04:00
|
|
|
}
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 03:40:56 +04:00
|
|
|
}
|
2013-07-17 03:46:06 +04:00
|
|
|
function lin3() {
|
2013-07-17 23:06:49 +04:00
|
|
|
var sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 152 | 0;
|
2013-07-17 03:46:06 +04:00
|
|
|
while (1) {
|
|
|
|
c(1);
|
|
|
|
c(2);
|
|
|
|
c(3);
|
|
|
|
c(4);
|
|
|
|
c(5);
|
2013-08-10 04:19:33 +04:00
|
|
|
c(6);
|
|
|
|
c(7);
|
|
|
|
c(8);
|
|
|
|
c(9);
|
|
|
|
c(10);
|
|
|
|
c(11);
|
|
|
|
c(12);
|
|
|
|
c(13);
|
2013-07-19 05:44:33 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
lin3$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
tempValue = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
tempInt = HEAP32[sp + 12 >> 2] | 0;
|
|
|
|
tempDouble = +HEAPF32[sp + 12 >> 2];
|
2013-07-21 21:33:44 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-21 21:33:44 +04:00
|
|
|
if ((tempValue | 0) == 6) {
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-21 21:33:44 +04:00
|
|
|
return tempInt | 0;
|
2013-07-17 03:46:06 +04:00
|
|
|
}
|
|
|
|
}
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 03:46:06 +04:00
|
|
|
return 20;
|
|
|
|
}
|
2013-07-17 04:42:40 +04:00
|
|
|
function lin4() {
|
2013-07-17 23:06:49 +04:00
|
|
|
var sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 152 | 0;
|
2013-07-17 04:42:40 +04:00
|
|
|
while (1) {
|
|
|
|
c(1);
|
|
|
|
c(2);
|
|
|
|
c(3);
|
|
|
|
c(4);
|
2013-08-10 04:19:33 +04:00
|
|
|
c(5);
|
|
|
|
c(6);
|
|
|
|
c(7);
|
|
|
|
c(8);
|
|
|
|
c(9);
|
|
|
|
c(10);
|
|
|
|
c(11);
|
|
|
|
c(12);
|
|
|
|
c(13);
|
2013-07-19 05:44:33 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
lin4$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
tempValue = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
tempInt = HEAP32[sp + 12 >> 2] | 0;
|
|
|
|
tempDouble = +HEAPF32[sp + 12 >> 2];
|
2013-07-21 21:33:44 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-21 21:33:44 +04:00
|
|
|
if ((tempValue | 0) == 1) {
|
2013-07-17 04:42:40 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 04:42:40 +04:00
|
|
|
return 20;
|
|
|
|
}
|
2013-07-17 04:49:40 +04:00
|
|
|
function lin5() {
|
2013-07-17 23:06:49 +04:00
|
|
|
var sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 152 | 0;
|
2013-07-17 04:49:40 +04:00
|
|
|
while (1) {
|
|
|
|
c(1);
|
|
|
|
c(2);
|
|
|
|
c(3);
|
|
|
|
c(4);
|
2013-08-10 04:19:33 +04:00
|
|
|
c(5);
|
|
|
|
c(6);
|
|
|
|
c(7);
|
|
|
|
c(8);
|
|
|
|
c(9);
|
|
|
|
c(10);
|
|
|
|
c(11);
|
|
|
|
c(12);
|
|
|
|
c(13);
|
2013-07-19 05:44:33 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
lin5$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
tempValue = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
tempInt = HEAP32[sp + 12 >> 2] | 0;
|
|
|
|
tempDouble = +HEAPF32[sp + 12 >> 2];
|
2013-07-21 21:33:44 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-21 21:33:44 +04:00
|
|
|
if ((tempValue | 0) == 3) {
|
2013-07-17 04:49:40 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 04:49:40 +04:00
|
|
|
return 20;
|
|
|
|
}
|
2013-07-17 05:14:49 +04:00
|
|
|
function mix() {
|
2013-07-17 23:06:49 +04:00
|
|
|
var sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 168 | 0;
|
2013-07-17 05:14:49 +04:00
|
|
|
main : while (1) {
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 16 >> 2] = 0;
|
|
|
|
HEAP32[sp + 20 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
mix$1(sp);
|
2013-07-19 05:44:33 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
mix$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
tempValue = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
tempInt = HEAP32[sp + 12 >> 2] | 0;
|
|
|
|
tempDouble = +HEAPF32[sp + 12 >> 2];
|
2013-07-21 21:33:44 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 0;
|
2013-07-21 21:33:44 +04:00
|
|
|
if ((tempValue | 0) == 1) {
|
2013-07-17 05:14:49 +04:00
|
|
|
break;
|
|
|
|
}
|
2013-07-21 21:33:44 +04:00
|
|
|
if ((tempValue | 0) == 2) {
|
|
|
|
switch (tempInt | 0) {
|
2013-07-17 05:17:54 +04:00
|
|
|
case 2:
|
2013-07-21 08:46:30 +04:00
|
|
|
{
|
|
|
|
break main;
|
|
|
|
}
|
2013-07-17 05:14:49 +04:00
|
|
|
}
|
|
|
|
}
|
2013-07-21 21:33:44 +04:00
|
|
|
if ((tempValue | 0) == 3) {
|
2013-07-17 05:14:49 +04:00
|
|
|
continue;
|
|
|
|
}
|
2013-07-21 21:33:44 +04:00
|
|
|
if ((tempValue | 0) == 4) {
|
|
|
|
switch (tempInt | 0) {
|
2013-07-17 05:17:54 +04:00
|
|
|
case 3:
|
2013-07-21 08:46:30 +04:00
|
|
|
{
|
|
|
|
continue main;
|
|
|
|
}
|
2013-07-17 05:14:49 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 05:14:49 +04:00
|
|
|
return 20;
|
|
|
|
}
|
2013-07-17 05:24:44 +04:00
|
|
|
function vars(x, y) {
|
|
|
|
x = x | 0;
|
|
|
|
y = +y;
|
2013-07-26 06:37:57 +04:00
|
|
|
var sp = 0;
|
2013-07-17 23:06:49 +04:00
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 152 | 0;
|
2013-08-10 04:19:33 +04:00
|
|
|
c(1 + (x + y));
|
|
|
|
c(2 + y * x);
|
|
|
|
c(3 + (x + y));
|
|
|
|
c(4 + y * x);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = x;
|
|
|
|
HEAPF32[sp + 16 >> 2] = y;
|
2013-07-26 06:37:57 +04:00
|
|
|
HEAP32[sp + 24 >> 2] = 0;
|
|
|
|
HEAP32[sp + 28 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
vars$0(sp);
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 05:24:44 +04:00
|
|
|
}
|
2013-07-17 22:01:03 +04:00
|
|
|
function vars2(x, y) {
|
|
|
|
x = x | 0;
|
|
|
|
y = +y;
|
2013-07-17 23:06:49 +04:00
|
|
|
var a = 0, b = +0, sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 152 | 0;
|
2013-07-17 22:01:03 +04:00
|
|
|
a = x + y;
|
|
|
|
b = y * x;
|
|
|
|
a = c(1 + a);
|
|
|
|
b = c(2 + b);
|
2013-08-10 04:19:33 +04:00
|
|
|
a = c(3 + a);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 24 >> 2] = a;
|
|
|
|
HEAPF32[sp + 32 >> 2] = b;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 40 >> 2] = 0;
|
|
|
|
HEAP32[sp + 44 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
vars2$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 24 >> 2] | 0;
|
|
|
|
b = +HEAPF32[sp + 32 >> 2];
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 22:01:03 +04:00
|
|
|
}
|
2013-07-17 22:03:46 +04:00
|
|
|
function vars3(x, y) {
|
|
|
|
x = x | 0;
|
|
|
|
y = +y;
|
2013-07-26 06:37:57 +04:00
|
|
|
var a = 0, sp = 0;
|
2013-07-17 23:06:49 +04:00
|
|
|
sp = STACKTOP;
|
2013-07-26 06:37:57 +04:00
|
|
|
STACKTOP = STACKTOP + 160 | 0;
|
2013-08-10 04:19:33 +04:00
|
|
|
a = x + y;
|
|
|
|
a = c(1 + a);
|
|
|
|
a = c(2 + y * x);
|
|
|
|
a = c(3 + a);
|
|
|
|
a = c(4 + y * x);
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = x;
|
|
|
|
HEAPF32[sp + 16 >> 2] = y;
|
|
|
|
HEAP32[sp + 24 >> 2] = a;
|
2013-07-26 06:37:57 +04:00
|
|
|
HEAP32[sp + 32 >> 2] = 0;
|
|
|
|
HEAP32[sp + 36 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
vars3$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 24 >> 2] | 0;
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 22:03:46 +04:00
|
|
|
}
|
2013-07-17 22:10:35 +04:00
|
|
|
function vars4(x, y) {
|
|
|
|
x = x | 0;
|
|
|
|
y = +y;
|
2013-07-17 23:06:49 +04:00
|
|
|
var a = 0, b = +0, sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 168 | 0;
|
2013-07-17 22:10:35 +04:00
|
|
|
a = x + y;
|
2013-08-10 04:19:33 +04:00
|
|
|
b = y * x;
|
|
|
|
a = c(1 + a);
|
|
|
|
a = c(2 + a);
|
|
|
|
a = c(3 + a);
|
|
|
|
a = c(4 + a);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = x;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 24 >> 2] = a;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAPF32[sp + 32 >> 2] = b;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 40 >> 2] = 0;
|
|
|
|
HEAP32[sp + 44 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
vars4$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 24 >> 2] | 0;
|
|
|
|
b = +HEAPF32[sp + 32 >> 2];
|
2013-07-17 23:06:49 +04:00
|
|
|
STACKTOP = sp;
|
2013-07-17 22:10:35 +04:00
|
|
|
}
|
2013-07-17 23:42:48 +04:00
|
|
|
function vars_w_stack(x, y) {
|
|
|
|
x = x | 0;
|
|
|
|
y = +y;
|
|
|
|
var a = 0, b = +0, sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-07-26 02:05:00 +04:00
|
|
|
STACKTOP = STACKTOP + 208 | 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 24 >> 2] = x;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAPF32[sp + 32 >> 2] = y;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 40 >> 2] = a;
|
|
|
|
HEAPF32[sp + 48 >> 2] = b;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 72 >> 2] = 0;
|
|
|
|
HEAP32[sp + 76 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
vars_w_stack$1(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 40 >> 2] | 0;
|
2013-08-10 03:30:13 +04:00
|
|
|
b = +HEAPF32[sp + 48 >> 2];
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 40 >> 2] = a;
|
|
|
|
HEAPF32[sp + 48 >> 2] = b;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 64 >> 2] = 0;
|
|
|
|
HEAP32[sp + 68 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
vars_w_stack$0(sp);
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 40 >> 2] | 0;
|
|
|
|
b = +HEAPF32[sp + 48 >> 2];
|
2013-07-17 23:42:48 +04:00
|
|
|
}
|
2013-07-25 07:06:54 +04:00
|
|
|
function chain() {
|
|
|
|
var helper$0 = 0, sp = 0;
|
|
|
|
sp = STACKTOP;
|
2013-08-14 04:33:02 +04:00
|
|
|
STACKTOP = STACKTOP + 464 | 0;
|
2013-07-25 07:06:54 +04:00
|
|
|
helper$0 = 1;
|
2013-08-14 04:33:02 +04:00
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 1) {
|
|
|
|
print(1);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 2) {
|
|
|
|
print(2);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
HEAP32[sp + 48 >> 2] = 0;
|
|
|
|
HEAP32[sp + 52 >> 2] = 0;
|
|
|
|
chain$4(sp);
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
2013-07-25 07:06:54 +04:00
|
|
|
HEAP32[sp + 40 >> 2] = 0;
|
|
|
|
HEAP32[sp + 44 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
chain$3(sp);
|
2013-07-25 07:06:54 +04:00
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
2013-07-25 07:06:54 +04:00
|
|
|
HEAP32[sp + 32 >> 2] = 0;
|
|
|
|
HEAP32[sp + 36 >> 2] = 0;
|
2013-07-26 00:00:53 +04:00
|
|
|
chain$2(sp);
|
2013-07-25 07:06:54 +04:00
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-08-14 04:33:02 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
HEAP32[sp + 24 >> 2] = 0;
|
|
|
|
HEAP32[sp + 28 >> 2] = 0;
|
|
|
|
chain$1(sp);
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
HEAP32[sp + 16 >> 2] = 0;
|
|
|
|
HEAP32[sp + 20 >> 2] = 0;
|
|
|
|
chain$0(sp);
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-07-25 07:06:54 +04:00
|
|
|
STACKTOP = sp;
|
|
|
|
}
|
2013-08-24 03:53:46 +04:00
|
|
|
function switchh() {
|
|
|
|
var helper$0 = 0, helper$1 = 0, sp = 0;
|
|
|
|
sp = STACKTOP;
|
|
|
|
STACKTOP = STACKTOP + 296 | 0;
|
|
|
|
helper$0 = 1;
|
|
|
|
helper$1 = x;
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 0:
|
|
|
|
{
|
|
|
|
f(0);
|
|
|
|
g();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
HEAP32[sp + 16 >> 2] = helper$1;
|
|
|
|
HEAP32[sp + 40 >> 2] = 0;
|
|
|
|
HEAP32[sp + 44 >> 2] = 0;
|
|
|
|
switchh$2(sp);
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-08-27 22:57:19 +04:00
|
|
|
tempValue = HEAP32[sp + 40 >> 2] | 0;
|
|
|
|
tempInt = HEAP32[sp + 44 >> 2] | 0;
|
|
|
|
tempDouble = +HEAPF32[sp + 44 >> 2];
|
|
|
|
HEAP32[sp + 40 >> 2] = 0;
|
|
|
|
HEAP32[sp + 44 >> 2] = 0;
|
|
|
|
if ((tempValue | 0) == 5) {
|
|
|
|
STACKTOP = sp;
|
|
|
|
return;
|
|
|
|
}
|
2013-08-24 03:53:46 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
HEAP32[sp + 16 >> 2] = helper$1;
|
|
|
|
HEAP32[sp + 32 >> 2] = 0;
|
|
|
|
HEAP32[sp + 36 >> 2] = 0;
|
|
|
|
switchh$1(sp);
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
HEAP32[sp + 16 >> 2] = helper$1;
|
|
|
|
HEAP32[sp + 24 >> 2] = 0;
|
|
|
|
HEAP32[sp + 28 >> 2] = 0;
|
|
|
|
switchh$0(sp);
|
|
|
|
}
|
|
|
|
STACKTOP = sp;
|
|
|
|
}
|
2013-09-07 08:56:41 +04:00
|
|
|
function switchh2() {
|
|
|
|
var helper$0 = 0, helper$1 = 0, sp = 0;
|
|
|
|
sp = STACKTOP;
|
|
|
|
STACKTOP = STACKTOP + 280 | 0;
|
|
|
|
while (1) {
|
|
|
|
helper$0 = 1;
|
|
|
|
helper$1 = x;
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 0:
|
|
|
|
f(0);
|
|
|
|
g();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
HEAP32[sp + 16 >> 2] = helper$1;
|
|
|
|
HEAP32[sp + 40 >> 2] = 0;
|
|
|
|
HEAP32[sp + 44 >> 2] = 0;
|
|
|
|
switchh2$2(sp);
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
tempValue = HEAP32[sp + 40 >> 2] | 0;
|
|
|
|
tempInt = HEAP32[sp + 44 >> 2] | 0;
|
|
|
|
tempDouble = +HEAPF32[sp + 44 >> 2];
|
|
|
|
HEAP32[sp + 40 >> 2] = 0;
|
|
|
|
HEAP32[sp + 44 >> 2] = 0;
|
|
|
|
if ((tempValue | 0) == 5) {
|
|
|
|
STACKTOP = sp;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
HEAP32[sp + 16 >> 2] = helper$1;
|
|
|
|
HEAP32[sp + 32 >> 2] = 0;
|
|
|
|
HEAP32[sp + 36 >> 2] = 0;
|
|
|
|
switchh2$1(sp);
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
HEAP32[sp + 16 >> 2] = helper$1;
|
|
|
|
HEAP32[sp + 24 >> 2] = 0;
|
|
|
|
HEAP32[sp + 28 >> 2] = 0;
|
|
|
|
switchh2$0(sp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
STACKTOP = sp;
|
|
|
|
}
|
2013-07-17 03:24:37 +04:00
|
|
|
function lin$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
c(14);
|
|
|
|
c(15);
|
|
|
|
c(16);
|
|
|
|
c(17);
|
|
|
|
c(18);
|
|
|
|
c(19);
|
|
|
|
c(20);
|
|
|
|
}
|
|
|
|
function lin$1(sp) {
|
|
|
|
sp = sp | 0;
|
2013-08-10 04:19:33 +04:00
|
|
|
c(4);
|
2013-07-17 03:24:37 +04:00
|
|
|
c(5);
|
|
|
|
c(6);
|
|
|
|
c(7);
|
|
|
|
c(8);
|
|
|
|
c(9);
|
|
|
|
c(10);
|
|
|
|
c(11);
|
|
|
|
c(12);
|
2013-08-10 04:19:33 +04:00
|
|
|
c(13);
|
2013-07-17 03:24:37 +04:00
|
|
|
}
|
2013-07-17 03:40:56 +04:00
|
|
|
function lin2$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
c(14);
|
|
|
|
c(15);
|
|
|
|
c(16);
|
|
|
|
c(17);
|
|
|
|
c(18);
|
|
|
|
c(19);
|
|
|
|
c(20);
|
|
|
|
}
|
|
|
|
function lin2$1(sp) {
|
|
|
|
sp = sp | 0;
|
2013-08-10 04:19:33 +04:00
|
|
|
c(3);
|
|
|
|
c(4);
|
2013-07-17 03:40:56 +04:00
|
|
|
c(5);
|
|
|
|
c(6);
|
|
|
|
c(7);
|
|
|
|
c(8);
|
|
|
|
c(9);
|
|
|
|
c(10);
|
|
|
|
c(11);
|
|
|
|
c(12);
|
2013-08-10 04:19:33 +04:00
|
|
|
c(13);
|
2013-07-17 03:40:56 +04:00
|
|
|
}
|
2013-07-17 03:46:06 +04:00
|
|
|
function lin3$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
OL : do {
|
|
|
|
c(14);
|
|
|
|
c(15);
|
|
|
|
c(16);
|
|
|
|
c(17);
|
|
|
|
c(18);
|
|
|
|
c(19);
|
|
|
|
c(20);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 6;
|
|
|
|
HEAP32[sp + 12 >> 2] = 10;
|
2013-07-18 03:45:32 +04:00
|
|
|
break OL;
|
2013-07-17 03:46:06 +04:00
|
|
|
} while (0);
|
|
|
|
}
|
2013-07-17 04:42:40 +04:00
|
|
|
function lin4$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
OL : do {
|
|
|
|
c(14);
|
|
|
|
c(15);
|
|
|
|
c(16);
|
|
|
|
c(17);
|
|
|
|
c(18);
|
|
|
|
c(19);
|
|
|
|
c(20);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 1;
|
2013-07-18 03:45:32 +04:00
|
|
|
break OL;
|
2013-07-17 04:42:40 +04:00
|
|
|
} while (0);
|
|
|
|
}
|
2013-07-17 04:49:40 +04:00
|
|
|
function lin5$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
OL : do {
|
|
|
|
c(14);
|
|
|
|
c(15);
|
|
|
|
c(16);
|
|
|
|
c(17);
|
|
|
|
c(18);
|
|
|
|
c(19);
|
|
|
|
c(20);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 3;
|
2013-07-18 03:45:32 +04:00
|
|
|
break OL;
|
2013-07-17 04:49:40 +04:00
|
|
|
} while (0);
|
|
|
|
}
|
2013-07-17 05:14:49 +04:00
|
|
|
function mix$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
OL : do {
|
2013-07-18 03:45:32 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 2;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 12 >> 2] = 2;
|
2013-07-18 03:45:32 +04:00
|
|
|
break OL;
|
2013-07-17 05:14:49 +04:00
|
|
|
c(18);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 1;
|
2013-07-18 03:45:32 +04:00
|
|
|
break OL;
|
2013-07-17 05:14:49 +04:00
|
|
|
while (1) {
|
|
|
|
break;
|
|
|
|
}
|
2013-07-17 05:17:54 +04:00
|
|
|
inner : while (1) {
|
|
|
|
break inner;
|
|
|
|
}
|
2013-07-17 05:14:49 +04:00
|
|
|
c(19);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 3;
|
2013-07-18 03:45:32 +04:00
|
|
|
break OL;
|
2013-07-17 05:14:49 +04:00
|
|
|
c(20);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = 4;
|
|
|
|
HEAP32[sp + 12 >> 2] = 3;
|
2013-07-18 03:45:32 +04:00
|
|
|
break OL;
|
2013-07-17 05:14:49 +04:00
|
|
|
} while (0);
|
|
|
|
}
|
|
|
|
function mix$1(sp) {
|
|
|
|
sp = sp | 0;
|
2013-08-10 04:19:33 +04:00
|
|
|
c(1);
|
|
|
|
c(2);
|
|
|
|
c(3);
|
|
|
|
c(4);
|
|
|
|
c(5);
|
|
|
|
c(6);
|
|
|
|
c(7);
|
2013-07-17 05:14:49 +04:00
|
|
|
c(8);
|
|
|
|
c(9);
|
|
|
|
c(10);
|
|
|
|
c(11);
|
|
|
|
c(12);
|
|
|
|
c(13);
|
|
|
|
c(14);
|
2013-07-17 05:17:54 +04:00
|
|
|
c(15);
|
2013-08-10 04:19:33 +04:00
|
|
|
c(16);
|
|
|
|
c(17);
|
2013-07-17 05:14:49 +04:00
|
|
|
}
|
2013-07-17 05:24:44 +04:00
|
|
|
function vars$0(sp) {
|
|
|
|
sp = sp | 0;
|
2013-07-26 06:37:57 +04:00
|
|
|
var x = 0, y = +0;
|
|
|
|
x = HEAP32[sp + 8 >> 2] | 0;
|
2013-08-10 03:30:13 +04:00
|
|
|
y = +HEAPF32[sp + 16 >> 2];
|
2013-07-26 06:37:57 +04:00
|
|
|
c(5 + (x + y));
|
|
|
|
c(6 + y * x);
|
|
|
|
c(7 + (x + y));
|
|
|
|
c(8 + y * x);
|
2013-07-17 05:24:44 +04:00
|
|
|
}
|
2013-07-17 22:01:03 +04:00
|
|
|
function vars2$0(sp) {
|
|
|
|
sp = sp | 0;
|
2013-08-10 04:19:33 +04:00
|
|
|
var b = +0, a = 0;
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 24 >> 2] | 0;
|
2013-08-10 03:30:13 +04:00
|
|
|
b = +HEAPF32[sp + 32 >> 2];
|
2013-07-17 22:01:03 +04:00
|
|
|
b = c(4 + b);
|
|
|
|
a = c(5 + a);
|
|
|
|
b = c(6 + b);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 24 >> 2] = a;
|
|
|
|
HEAPF32[sp + 32 >> 2] = b;
|
2013-07-17 22:01:03 +04:00
|
|
|
}
|
2013-07-17 22:03:46 +04:00
|
|
|
function vars3$0(sp) {
|
|
|
|
sp = sp | 0;
|
2013-07-26 06:37:57 +04:00
|
|
|
var a = 0, y = +0, x = 0;
|
|
|
|
x = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
y = +HEAPF32[sp + 16 >> 2];
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 24 >> 2] | 0;
|
2013-07-17 22:03:46 +04:00
|
|
|
a = c(5 + a);
|
2013-07-26 06:37:57 +04:00
|
|
|
a = c(6 + y * x);
|
2013-07-17 22:03:46 +04:00
|
|
|
a = c(7 + a);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 24 >> 2] = a;
|
2013-07-17 22:03:46 +04:00
|
|
|
}
|
2013-07-17 22:10:35 +04:00
|
|
|
function vars4$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var a = 0, x = 0, b = +0;
|
2013-07-24 01:36:51 +04:00
|
|
|
x = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
a = HEAP32[sp + 24 >> 2] | 0;
|
2013-08-10 03:30:13 +04:00
|
|
|
b = +HEAPF32[sp + 32 >> 2];
|
2013-07-17 22:10:35 +04:00
|
|
|
a = c(5 + a);
|
|
|
|
a = c(6 + a);
|
|
|
|
b = c(7 + a + x);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 24 >> 2] = a;
|
|
|
|
HEAPF32[sp + 32 >> 2] = b;
|
2013-07-17 22:10:35 +04:00
|
|
|
}
|
2013-07-17 23:42:48 +04:00
|
|
|
function vars_w_stack$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var a = 0, b = +0;
|
2013-07-24 01:36:51 +04:00
|
|
|
a = HEAP32[sp + 40 >> 2] | 0;
|
2013-08-10 03:30:13 +04:00
|
|
|
b = +HEAPF32[sp + 48 >> 2];
|
2013-07-17 23:42:48 +04:00
|
|
|
a = c(5 + a);
|
|
|
|
a = c(6 + a);
|
|
|
|
b = c(7 + a);
|
|
|
|
STACKTOP = sp;
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 40 >> 2] = a;
|
|
|
|
HEAPF32[sp + 48 >> 2] = b;
|
2013-07-17 23:42:48 +04:00
|
|
|
}
|
|
|
|
function vars_w_stack$1(sp) {
|
|
|
|
sp = sp | 0;
|
2013-08-10 04:19:33 +04:00
|
|
|
var a = 0, x = 0, y = +0, b = +0;
|
2013-07-24 01:36:51 +04:00
|
|
|
x = HEAP32[sp + 24 >> 2] | 0;
|
|
|
|
y = +HEAPF32[sp + 32 >> 2];
|
2013-08-10 03:30:13 +04:00
|
|
|
a = HEAP32[sp + 40 >> 2] | 0;
|
|
|
|
b = +HEAPF32[sp + 48 >> 2];
|
2013-08-10 04:19:33 +04:00
|
|
|
a = x + y;
|
2013-07-19 03:07:46 +04:00
|
|
|
b = y * x;
|
2013-07-17 23:42:48 +04:00
|
|
|
a = c(1 + a);
|
|
|
|
a = c(2 + a);
|
|
|
|
a = c(3 + a);
|
2013-08-10 04:19:33 +04:00
|
|
|
a = c(4 + a);
|
2013-07-24 01:36:51 +04:00
|
|
|
HEAP32[sp + 40 >> 2] = a;
|
2013-08-10 03:30:13 +04:00
|
|
|
HEAPF32[sp + 48 >> 2] = b;
|
2013-07-17 23:42:48 +04:00
|
|
|
}
|
2013-07-25 07:06:54 +04:00
|
|
|
function chain$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-08-14 04:33:02 +04:00
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 12) {
|
|
|
|
print(12);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (1) {
|
|
|
|
print(99);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
2013-07-25 07:06:54 +04:00
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
|
|
|
function chain$1(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-08-14 04:33:02 +04:00
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 10) {
|
|
|
|
print(10);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 11) {
|
|
|
|
print(11);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
2013-07-25 07:06:54 +04:00
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
|
|
|
function chain$2(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-07-27 01:44:16 +04:00
|
|
|
if (helper$0) {
|
2013-07-25 07:06:54 +04:00
|
|
|
helper$0 = 0;
|
2013-08-14 04:33:02 +04:00
|
|
|
if (x == 8) {
|
|
|
|
print(8);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 9) {
|
|
|
|
print(9);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
2013-07-25 07:06:54 +04:00
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
|
|
|
function chain$3(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
2013-07-27 01:44:16 +04:00
|
|
|
if (helper$0) {
|
2013-07-25 07:06:54 +04:00
|
|
|
helper$0 = 0;
|
2013-08-14 04:33:02 +04:00
|
|
|
if (x == 6) {
|
|
|
|
print(6);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 7) {
|
|
|
|
print(7);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
|
|
|
function chain$4(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 3) {
|
|
|
|
print(3);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 4) {
|
|
|
|
print(4);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
if (x == 5) {
|
|
|
|
print(5);
|
|
|
|
} else {
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
2013-07-25 07:06:54 +04:00
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
2013-08-24 03:53:46 +04:00
|
|
|
function switchh$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$1 = 0;
|
|
|
|
helper$1 = HEAP32[sp + 16 >> 2] | 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 4:
|
|
|
|
{
|
|
|
|
f(4);
|
|
|
|
g();
|
|
|
|
}
|
|
|
|
case 5:
|
|
|
|
{
|
|
|
|
f(5);
|
|
|
|
g();
|
|
|
|
}
|
|
|
|
case 6:
|
|
|
|
{
|
|
|
|
f(6);
|
|
|
|
g();
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
print(9);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function switchh$1(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0, helper$1 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
helper$1 = HEAP32[sp + 16 >> 2] | 0;
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 21:
|
|
|
|
case 22:
|
|
|
|
case 23:
|
|
|
|
case 24:
|
|
|
|
case 25:
|
|
|
|
case 26:
|
|
|
|
case 27:
|
|
|
|
case 28:
|
|
|
|
case 29:
|
|
|
|
case 3:
|
|
|
|
{
|
|
|
|
f(3);
|
|
|
|
g();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
|
|
|
function switchh$2(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0, helper$1 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
helper$1 = HEAP32[sp + 16 >> 2] | 0;
|
2013-08-27 22:57:19 +04:00
|
|
|
OL : do {
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 1:
|
|
|
|
{
|
|
|
|
f(1);
|
|
|
|
g();
|
|
|
|
HEAP32[sp + 40 >> 2] = 5;
|
|
|
|
break OL;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
2013-08-24 03:53:46 +04:00
|
|
|
}
|
|
|
|
}
|
2013-08-27 22:57:19 +04:00
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 2:
|
|
|
|
{
|
|
|
|
f(2);
|
|
|
|
g();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
2013-08-24 03:53:46 +04:00
|
|
|
}
|
|
|
|
}
|
2013-08-27 22:57:19 +04:00
|
|
|
} while (0);
|
2013-08-24 03:53:46 +04:00
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
2013-09-07 08:56:41 +04:00
|
|
|
function switchh2$0(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$1 = 0;
|
|
|
|
helper$1 = HEAP32[sp + 16 >> 2] | 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 4:
|
|
|
|
f(4);
|
|
|
|
g();
|
|
|
|
case 5:
|
|
|
|
f(5);
|
|
|
|
g();
|
|
|
|
case 6:
|
|
|
|
f(6);
|
|
|
|
g();
|
|
|
|
default:
|
|
|
|
print(9);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function switchh2$1(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0, helper$1 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
helper$1 = HEAP32[sp + 16 >> 2] | 0;
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 21:
|
|
|
|
case 22:
|
|
|
|
case 23:
|
|
|
|
case 24:
|
|
|
|
case 25:
|
|
|
|
case 26:
|
|
|
|
case 27:
|
|
|
|
case 28:
|
|
|
|
case 29:
|
|
|
|
case 3:
|
|
|
|
f(3);
|
|
|
|
g();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
|
|
|
function switchh2$2(sp) {
|
|
|
|
sp = sp | 0;
|
|
|
|
var helper$0 = 0, helper$1 = 0;
|
|
|
|
helper$0 = HEAP32[sp + 8 >> 2] | 0;
|
|
|
|
helper$1 = HEAP32[sp + 16 >> 2] | 0;
|
|
|
|
OL : do {
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 1:
|
|
|
|
f(1);
|
|
|
|
g();
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (helper$0) {
|
|
|
|
helper$0 = 0;
|
|
|
|
switch (helper$1 | 0) {
|
|
|
|
case 2:
|
|
|
|
f(2);
|
|
|
|
g();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
helper$0 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (0);
|
|
|
|
HEAP32[sp + 8 >> 2] = helper$0;
|
|
|
|
}
|
2013-07-17 03:24:37 +04:00
|
|
|
|