• R/O
  • SSH
  • HTTPS

jpl: コミット


コミットメタ情報

リビジョン238 (tree)
日時2018-10-12 05:29:23
作者jakobthomsen

ログメッセージ

implement struct types

変更サマリ

差分

--- trunk/experimental/compiler.compiled.c (revision 237)
+++ trunk/experimental/compiler.compiled.c (revision 238)
@@ -930,7 +930,7 @@
930930 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
931931 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
932932 /* function requires 10LLU 64-bit chunks of memory (including 0LLU for parameters) */
933-case /*comment___'*/0x7AAA28829BC00001LLU:/* SP = 0LLU */
933+case /*comments__*/0x7AAA28829BEE0000LLU:/* SP = 0LLU */
934934 case 0xFFFFFFFFFFFFFFD0LLU: /* loop to here *//* predicate */
935935
936936 {
@@ -1146,8 +1146,8 @@
11461146 /*CALLEND*/
11471147 stackbase += 2LLU;
11481148 stack[stackbase - 1] = 0xFFFFFFFFFFFFFFBDLLU;
1149- fnaddr = /*comment___'*/0x7AAA28829BC00001LLU;/* SP = 0LLU */
1150-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*comment___'*/\n"); exit(-1); }
1149+ fnaddr = /*comments__*/0x7AAA28829BEE0000LLU;/* SP = 0LLU */
1150+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*comments__*/\n"); exit(-1); }
11511151 break;
11521152 }
11531153 case 0xFFFFFFFFFFFFFFBDLLU:
@@ -1256,7 +1256,382 @@
12561256 case /*printhexnr*/0xAED929BE3833A6D0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */fprintf(stdout, "0x%0llXLLU", (long long unsigned int)ACCESS_VAR(0));/* SP = 1LLU *//* SP - 0LLU = 1LLU */
12571257 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
12581258 /* function requires 1LLU 64-bit chunks of memory (including 1LLU for parameters) */
1259-case /*commentid_*/0x7AAA28829BE47C00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */fputs("/*", stdout);
1259+case /*markclear_*/0xA1CB667A781CB400LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1260+ {
1261+ /* CALLBEGIN */
1262+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1263+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1264+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1265+ }
1266+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1267+ {
1268+ /* CALLBEGIN */
1269+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1270+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1271+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1272+ }
1273+{ /* PUSH */ stack[stackbase + 8LLU] = 3LLU; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1274+ {
1275+ /*CALLEND*/
1276+ stackbase += 8LLU;
1277+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB6LLU;
1278+ fnaddr = /*bitnot____*/0x764BE9AAF0000000LLU;/* SP = 0LLU */
1279+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitnot____*/\n"); exit(-1); }
1280+ break;
1281+ }
1282+case 0xFFFFFFFFFFFFFFB6LLU:
1283+/* SP = 6LLU */
1284+ {
1285+ /*CALLEND*/
1286+ stackbase += 4LLU;
1287+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB5LLU;
1288+ fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
1289+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
1290+ break;
1291+ }
1292+case 0xFFFFFFFFFFFFFFB5LLU:
1293+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1294+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1295+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1296+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1297+/* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
1298+case /*markstruct*/0xA1CB66BAFB707AF0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1299+ {
1300+ /* CALLBEGIN */
1301+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1302+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1303+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1304+ }
1305+ {
1306+ /* CALLBEGIN */
1307+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1308+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1309+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1310+ }
1311+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1312+ {
1313+ /*CALLEND*/
1314+ stackbase += 7LLU;
1315+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB4LLU;
1316+ fnaddr = /*markclear_*/0xA1CB667A781CB400LLU;/* SP = 0LLU */
1317+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*markclear_*/\n"); exit(-1); }
1318+ break;
1319+ }
1320+case 0xFFFFFFFFFFFFFFB4LLU:
1321+/* SP = 5LLU */
1322+{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU */
1323+ {
1324+ /*CALLEND*/
1325+ stackbase += 4LLU;
1326+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB3LLU;
1327+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
1328+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
1329+ break;
1330+ }
1331+case 0xFFFFFFFFFFFFFFB3LLU:
1332+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1333+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1334+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1335+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1336+/* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
1337+case /*markunion_*/0xA1CB66C2992AA400LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1338+ {
1339+ /* CALLBEGIN */
1340+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1341+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1342+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1343+ }
1344+ {
1345+ /* CALLBEGIN */
1346+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1347+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1348+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1349+ }
1350+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1351+ {
1352+ /*CALLEND*/
1353+ stackbase += 7LLU;
1354+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB2LLU;
1355+ fnaddr = /*markclear_*/0xA1CB667A781CB400LLU;/* SP = 0LLU */
1356+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*markclear_*/\n"); exit(-1); }
1357+ break;
1358+ }
1359+case 0xFFFFFFFFFFFFFFB2LLU:
1360+/* SP = 5LLU */
1361+{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU */
1362+ {
1363+ /*CALLEND*/
1364+ stackbase += 4LLU;
1365+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB1LLU;
1366+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
1367+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
1368+ break;
1369+ }
1370+case 0xFFFFFFFFFFFFFFB1LLU:
1371+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1372+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1373+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1374+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1375+/* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
1376+case /*markdata__*/0xA1CB667DCBDC0000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1377+ {
1378+ /* CALLBEGIN */
1379+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1380+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1381+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1382+ }
1383+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1384+{ /* PUSH */ stack[stackbase + 5LLU] = 3LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1385+ {
1386+ /*CALLEND*/
1387+ stackbase += 4LLU;
1388+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB0LLU;
1389+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
1390+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
1391+ break;
1392+ }
1393+case 0xFFFFFFFFFFFFFFB0LLU:
1394+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1395+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1396+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1397+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1398+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
1399+case /*isclear___*/0x92E7A781CB400000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1400+ {
1401+ /* CALLBEGIN */
1402+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1403+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1404+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1405+ }
1406+{ /* PUSH */ stack[stackbase + 4LLU] = 0LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1407+ {
1408+ /* CALLBEGIN */
1409+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1410+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1411+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1412+ }
1413+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1414+{ /* PUSH */ stack[stackbase + 9LLU] = 3LLU; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
1415+ {
1416+ /*CALLEND*/
1417+ stackbase += 8LLU;
1418+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAFLLU;
1419+ fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
1420+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
1421+ break;
1422+ }
1423+case 0xFFFFFFFFFFFFFFAFLLU:
1424+/* SP = 6LLU */
1425+ {
1426+ /*CALLEND*/
1427+ stackbase += 4LLU;
1428+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAELLU;
1429+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
1430+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
1431+ break;
1432+ }
1433+case 0xFFFFFFFFFFFFFFAELLU:
1434+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1435+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1436+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1437+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1438+/* function requires 10LLU 64-bit chunks of memory (including 1LLU for parameters) */
1439+case /*isstruct__*/0x92EBAFB707AF0000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1440+ {
1441+ /* CALLBEGIN */
1442+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1443+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1444+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1445+ }
1446+{ /* PUSH */ stack[stackbase + 4LLU] = 1LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1447+ {
1448+ /* CALLBEGIN */
1449+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1450+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1451+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1452+ }
1453+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1454+{ /* PUSH */ stack[stackbase + 9LLU] = 3LLU; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
1455+ {
1456+ /*CALLEND*/
1457+ stackbase += 8LLU;
1458+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFADLLU;
1459+ fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
1460+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
1461+ break;
1462+ }
1463+case 0xFFFFFFFFFFFFFFADLLU:
1464+/* SP = 6LLU */
1465+ {
1466+ /*CALLEND*/
1467+ stackbase += 4LLU;
1468+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFACLLU;
1469+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
1470+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
1471+ break;
1472+ }
1473+case 0xFFFFFFFFFFFFFFACLLU:
1474+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1475+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1476+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1477+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1478+/* function requires 10LLU 64-bit chunks of memory (including 1LLU for parameters) */
1479+case /*isunit____*/0x92EC2992F0000000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1480+ {
1481+ /* CALLBEGIN */
1482+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1483+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1484+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1485+ }
1486+{ /* PUSH */ stack[stackbase + 4LLU] = 2LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1487+ {
1488+ /* CALLBEGIN */
1489+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1490+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1491+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1492+ }
1493+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1494+{ /* PUSH */ stack[stackbase + 9LLU] = 3LLU; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
1495+ {
1496+ /*CALLEND*/
1497+ stackbase += 8LLU;
1498+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFABLLU;
1499+ fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
1500+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
1501+ break;
1502+ }
1503+case 0xFFFFFFFFFFFFFFABLLU:
1504+/* SP = 6LLU */
1505+ {
1506+ /*CALLEND*/
1507+ stackbase += 4LLU;
1508+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAALLU;
1509+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
1510+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
1511+ break;
1512+ }
1513+case 0xFFFFFFFFFFFFFFAALLU:
1514+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1515+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1516+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1517+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1518+/* function requires 10LLU 64-bit chunks of memory (including 1LLU for parameters) */
1519+case /*isdata____*/0x92E7DCBDC0000000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1520+ {
1521+ /* CALLBEGIN */
1522+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1523+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1524+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1525+ }
1526+{ /* PUSH */ stack[stackbase + 4LLU] = 3LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1527+ {
1528+ /* CALLBEGIN */
1529+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1530+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1531+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1532+ }
1533+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1534+{ /* PUSH */ stack[stackbase + 9LLU] = 3LLU; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
1535+ {
1536+ /*CALLEND*/
1537+ stackbase += 8LLU;
1538+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA9LLU;
1539+ fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
1540+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
1541+ break;
1542+ }
1543+case 0xFFFFFFFFFFFFFFA9LLU:
1544+/* SP = 6LLU */
1545+ {
1546+ /*CALLEND*/
1547+ stackbase += 4LLU;
1548+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA8LLU;
1549+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
1550+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
1551+ break;
1552+ }
1553+case 0xFFFFFFFFFFFFFFA8LLU:
1554+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1555+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1556+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1557+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1558+/* function requires 10LLU 64-bit chunks of memory (including 1LLU for parameters) */
1559+case /*commentid_*/0x7AAA28829BE47C00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */fputs("/*", stdout); /* predicate */
1560+
1561+ {
1562+ /* CALLBEGIN */
1563+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1564+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1565+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1566+ }
1567+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1568+ {
1569+ /*CALLEND*/
1570+ stackbase += 4LLU;
1571+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA5LLU;
1572+ fnaddr = /*isstruct__*/0x92EBAFB707AF0000LLU;/* SP = 0LLU */
1573+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isstruct__*/\n"); exit(-1); }
1574+ break;
1575+ }
1576+case 0xFFFFFFFFFFFFFFA5LLU:
1577+/* SP = 2LLU */
1578+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
1579+{ /* JUMP */ fnaddr = 18446744073709551527LLU; break; } /* skip consequent */
1580+/* consequent */fputs("struct ", stdout); /* SP = 1LLU *//* SP = 1LLU */
1581+{ /* JUMP */ fnaddr = 18446744073709551526LLU; break; } /* skip alternative */
1582+case 18446744073709551527LLU: /* alternative *//* predicate */
1583+
1584+ {
1585+ /* CALLBEGIN */
1586+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
1587+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
1588+ /* leave place for return addr *//* SP + 1LLU = 4LLU */
1589+ }
1590+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
1591+ {
1592+ /*CALLEND*/
1593+ stackbase += 4LLU;
1594+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA2LLU;
1595+ fnaddr = /*isunit____*/0x92EC2992F0000000LLU;/* SP = 0LLU */
1596+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isunit____*/\n"); exit(-1); }
1597+ break;
1598+ }
1599+case 0xFFFFFFFFFFFFFFA2LLU:
1600+/* SP = 2LLU */
1601+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
1602+{ /* JUMP */ fnaddr = 18446744073709551524LLU; break; } /* skip consequent */
1603+/* consequent */fputs("unit ", stdout); /* SP = 1LLU *//* SP = 1LLU */
1604+{ /* JUMP */ fnaddr = 18446744073709551523LLU; break; } /* skip alternative */
1605+case 18446744073709551524LLU: /* alternative *//* predicate */
1606+
1607+ {
1608+ /* CALLBEGIN */
1609+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
1610+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
1611+ /* leave place for return addr *//* SP + 1LLU = 4LLU */
1612+ }
1613+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
1614+ {
1615+ /*CALLEND*/
1616+ stackbase += 4LLU;
1617+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9FLLU;
1618+ fnaddr = /*isdata____*/0x92E7DCBDC0000000LLU;/* SP = 0LLU */
1619+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isdata____*/\n"); exit(-1); }
1620+ break;
1621+ }
1622+case 0xFFFFFFFFFFFFFF9FLLU:
1623+/* SP = 2LLU */
1624+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
1625+{ /* JUMP */ fnaddr = 18446744073709551521LLU; break; } /* skip consequent */
1626+/* consequent */fputs("data ", stdout); /* SP = 1LLU *//* SP = 1LLU */
1627+{ /* JUMP */ fnaddr = 18446744073709551520LLU; break; } /* skip alternative */
1628+case 18446744073709551521LLU: /* alternative *//* SP = 1LLU */
1629+case 18446744073709551520LLU: /* skip to here */
1630+
1631+case 18446744073709551523LLU: /* skip to here */
1632+
1633+case 18446744073709551526LLU: /* skip to here */
1634+
12601635 for(register uint64_t i = 10; i > 0; i--)
12611636 {
12621637 if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 1)
@@ -1270,11 +1645,11 @@
12701645 else // if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 64)
12711646 fputc('0' + ((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) - 54, stdout);
12721647 }
1273- for(register uint64_t i = 0; i < (ACCESS_VAR(0) & 0xF); i++)
1274- fputc('\'', stdout);
1648+ //for(register uint64_t i = 0; i < (ACCESS_VAR(0) & 0xF); i++)
1649+ // fputc('\'', stdout);
12751650 fputs("*/", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
12761651 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1277-/* function requires 1LLU 64-bit chunks of memory (including 1LLU for parameters) */
1652+/* function requires 5LLU 64-bit chunks of memory (including 1LLU for parameters) */
12781653 case /*printid___*/0xAED929BE47C00000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
12791654 {
12801655 /* CALLBEGIN */
@@ -1286,12 +1661,12 @@
12861661 {
12871662 /*CALLEND*/
12881663 stackbase += 3LLU;
1289- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB6LLU;
1664+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9ELLU;
12901665 fnaddr = /*commentid_*/0x7AAA28829BE47C00LLU;/* SP = 0LLU */
12911666 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*commentid_*/\n"); exit(-1); }
12921667 break;
12931668 }
1294-case 0xFFFFFFFFFFFFFFB6LLU:
1669+case 0xFFFFFFFFFFFFFF9ELLU:
12951670 /* SP = 1LLU */
12961671 {
12971672 /* CALLBEGIN */
@@ -1303,17 +1678,92 @@
13031678 {
13041679 /*CALLEND*/
13051680 stackbase += 3LLU;
1306- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB5LLU;
1681+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9DLLU;
13071682 fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
13081683 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); }
13091684 break;
13101685 }
1311-case 0xFFFFFFFFFFFFFFB5LLU:
1686+case 0xFFFFFFFFFFFFFF9DLLU:
13121687 /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
13131688 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
13141689 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
1315-case /*debugid___*/0x7E07708A47C00000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */for(register uint64_t i = 10; i > 0; i--)
1690+case /*debugid___*/0x7E07708A47C00000LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
1691+
13161692 {
1693+ /* CALLBEGIN */
1694+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1695+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1696+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1697+ }
1698+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1699+ {
1700+ /*CALLEND*/
1701+ stackbase += 4LLU;
1702+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9ALLU;
1703+ fnaddr = /*isstruct__*/0x92EBAFB707AF0000LLU;/* SP = 0LLU */
1704+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isstruct__*/\n"); exit(-1); }
1705+ break;
1706+ }
1707+case 0xFFFFFFFFFFFFFF9ALLU:
1708+/* SP = 2LLU */
1709+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
1710+{ /* JUMP */ fnaddr = 18446744073709551516LLU; break; } /* skip consequent */
1711+/* consequent */fputs("struct ", stderr); /* SP = 1LLU *//* SP = 1LLU */
1712+{ /* JUMP */ fnaddr = 18446744073709551515LLU; break; } /* skip alternative */
1713+case 18446744073709551516LLU: /* alternative *//* predicate */
1714+
1715+ {
1716+ /* CALLBEGIN */
1717+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
1718+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
1719+ /* leave place for return addr *//* SP + 1LLU = 4LLU */
1720+ }
1721+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
1722+ {
1723+ /*CALLEND*/
1724+ stackbase += 4LLU;
1725+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF97LLU;
1726+ fnaddr = /*isunit____*/0x92EC2992F0000000LLU;/* SP = 0LLU */
1727+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isunit____*/\n"); exit(-1); }
1728+ break;
1729+ }
1730+case 0xFFFFFFFFFFFFFF97LLU:
1731+/* SP = 2LLU */
1732+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
1733+{ /* JUMP */ fnaddr = 18446744073709551513LLU; break; } /* skip consequent */
1734+/* consequent */fputs("unit ", stderr); /* SP = 1LLU *//* SP = 1LLU */
1735+{ /* JUMP */ fnaddr = 18446744073709551512LLU; break; } /* skip alternative */
1736+case 18446744073709551513LLU: /* alternative *//* predicate */
1737+
1738+ {
1739+ /* CALLBEGIN */
1740+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
1741+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
1742+ /* leave place for return addr *//* SP + 1LLU = 4LLU */
1743+ }
1744+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
1745+ {
1746+ /*CALLEND*/
1747+ stackbase += 4LLU;
1748+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF94LLU;
1749+ fnaddr = /*isdata____*/0x92E7DCBDC0000000LLU;/* SP = 0LLU */
1750+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isdata____*/\n"); exit(-1); }
1751+ break;
1752+ }
1753+case 0xFFFFFFFFFFFFFF94LLU:
1754+/* SP = 2LLU */
1755+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
1756+{ /* JUMP */ fnaddr = 18446744073709551510LLU; break; } /* skip consequent */
1757+/* consequent */fputs("data ", stderr); /* SP = 1LLU *//* SP = 1LLU */
1758+{ /* JUMP */ fnaddr = 18446744073709551509LLU; break; } /* skip alternative */
1759+case 18446744073709551510LLU: /* alternative *//* SP = 1LLU */
1760+case 18446744073709551509LLU: /* skip to here */
1761+
1762+case 18446744073709551512LLU: /* skip to here */
1763+
1764+case 18446744073709551515LLU: /* skip to here */
1765+for(register uint64_t i = 10; i > 0; i--)
1766+ {
13171767 if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 1)
13181768 fputc('_' + ((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) - 0, stderr);
13191769 else if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 27)
@@ -1325,10 +1775,10 @@
13251775 else // if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 64)
13261776 fputc('0' + ((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) - 54, stderr);
13271777 }
1328- for(register uint64_t i = 0; i < (ACCESS_VAR(0) & 0xF); i++)
1329- fputc('\'', stderr);/* SP = 1LLU *//* SP - 0LLU = 1LLU */
1778+ //for(register uint64_t i = 0; i < (ACCESS_VAR(0) & 0xF); i++)
1779+ // fputc('\'', stderr);/* SP = 1LLU *//* SP - 0LLU = 1LLU */
13301780 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1331-/* function requires 1LLU 64-bit chunks of memory (including 1LLU for parameters) */
1781+/* function requires 5LLU 64-bit chunks of memory (including 1LLU for parameters) */
13321782 case /*encodeval_*/0x8297AA7E0C5C9C00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
13331783 {
13341784 /* CALLBEGIN */
@@ -1336,17 +1786,17 @@
13361786 { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
13371787 /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
13381788 }
1339-{ /* PUSH */ stack[stackbase + 4LLU] = 2LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1789+{ /* PUSH */ stack[stackbase + 4LLU] = 16LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
13401790 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
13411791 {
13421792 /*CALLEND*/
13431793 stackbase += 4LLU;
1344- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB4LLU;
1794+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF93LLU;
13451795 fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
13461796 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
13471797 break;
13481798 }
1349-case 0xFFFFFFFFFFFFFFB4LLU:
1799+case 0xFFFFFFFFFFFFFF93LLU:
13501800 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
13511801 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
13521802 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
@@ -1365,33 +1815,159 @@
13651815 { /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
13661816 /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
13671817 }
1368-{ /* PUSH */ stack[stackbase + 7LLU] = 2LLU; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1818+{ /* PUSH */ stack[stackbase + 7LLU] = 16LLU; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
13691819 { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
13701820 {
13711821 /*CALLEND*/
13721822 stackbase += 7LLU;
1373- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB3LLU;
1823+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF92LLU;
13741824 fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
13751825 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
13761826 break;
13771827 }
1378-case 0xFFFFFFFFFFFFFFB3LLU:
1828+case 0xFFFFFFFFFFFFFF92LLU:
13791829 /* SP = 5LLU */
1380-{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU */
1830+{ /* PUSH */ stack[stackbase + 5LLU] = 4LLU; }/* SP + 1LLU = 6LLU */
13811831 {
13821832 /*CALLEND*/
13831833 stackbase += 4LLU;
1384- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB2LLU;
1834+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF91LLU;
13851835 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
13861836 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
13871837 break;
13881838 }
1389-case 0xFFFFFFFFFFFFFFB2LLU:
1839+case 0xFFFFFFFFFFFFFF91LLU:
13901840 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
13911841 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
13921842 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
13931843 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
13941844 /* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
1845+case /*encodeVAL_*/0x8297AA7E05813000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1846+ {
1847+ /* CALLBEGIN */
1848+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1849+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1850+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1851+ }
1852+{ /* PUSH */ stack[stackbase + 4LLU] = 8LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1853+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1854+ {
1855+ /*CALLEND*/
1856+ stackbase += 4LLU;
1857+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF90LLU;
1858+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
1859+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
1860+ break;
1861+ }
1862+case 0xFFFFFFFFFFFFFF90LLU:
1863+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1864+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1865+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1866+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1867+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
1868+case /*encodeLIST*/0x8297AA7E03094D40LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1869+ {
1870+ /* CALLBEGIN */
1871+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1872+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1873+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1874+ }
1875+ {
1876+ /* CALLBEGIN */
1877+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1878+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1879+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1880+ }
1881+{ /* PUSH */ stack[stackbase + 7LLU] = 8LLU; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1882+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1883+ {
1884+ /*CALLEND*/
1885+ stackbase += 7LLU;
1886+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8FLLU;
1887+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
1888+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
1889+ break;
1890+ }
1891+case 0xFFFFFFFFFFFFFF8FLLU:
1892+/* SP = 5LLU */
1893+{ /* PUSH */ stack[stackbase + 5LLU] = 4LLU; }/* SP + 1LLU = 6LLU */
1894+ {
1895+ /*CALLEND*/
1896+ stackbase += 4LLU;
1897+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8ELLU;
1898+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
1899+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
1900+ break;
1901+ }
1902+case 0xFFFFFFFFFFFFFF8ELLU:
1903+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1904+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1905+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1906+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1907+/* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
1908+case /*subtypeval*/0xBB076FD2B8317270LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1909+ {
1910+ /* CALLBEGIN */
1911+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1912+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1913+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1914+ }
1915+{ /* PUSH */ stack[stackbase + 4LLU] = 8LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1916+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1917+ {
1918+ /*CALLEND*/
1919+ stackbase += 4LLU;
1920+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8DLLU;
1921+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
1922+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
1923+ break;
1924+ }
1925+case 0xFFFFFFFFFFFFFF8DLLU:
1926+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1927+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1928+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1929+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1930+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
1931+case /*subtyplist*/0xBB076FD2B9E4BAF0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
1932+ {
1933+ /* CALLBEGIN */
1934+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
1935+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1936+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1937+ }
1938+ {
1939+ /* CALLBEGIN */
1940+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1941+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1942+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1943+ }
1944+{ /* PUSH */ stack[stackbase + 7LLU] = 8LLU; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1945+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1946+ {
1947+ /*CALLEND*/
1948+ stackbase += 7LLU;
1949+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8CLLU;
1950+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
1951+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
1952+ break;
1953+ }
1954+case 0xFFFFFFFFFFFFFF8CLLU:
1955+/* SP = 5LLU */
1956+{ /* PUSH */ stack[stackbase + 5LLU] = 4LLU; }/* SP + 1LLU = 6LLU */
1957+ {
1958+ /*CALLEND*/
1959+ stackbase += 4LLU;
1960+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8BLLU;
1961+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
1962+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
1963+ break;
1964+ }
1965+case 0xFFFFFFFFFFFFFF8BLLU:
1966+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1967+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1968+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
1969+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1970+/* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
13951971 case /*typeislist*/0xBF4AE092E9E4BAF0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
13961972 {
13971973 /* CALLBEGIN */
@@ -1399,22 +1975,39 @@
13991975 { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
14001976 /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
14011977 }
1402-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1403-{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
14041978 {
1979+ /* CALLBEGIN */
1980+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
1981+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
1982+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
1983+ }
1984+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
1985+{ /* PUSH */ stack[stackbase + 8LLU] = 4LLU; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
1986+ {
14051987 /*CALLEND*/
1988+ stackbase += 7LLU;
1989+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8ALLU;
1990+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
1991+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
1992+ break;
1993+ }
1994+case 0xFFFFFFFFFFFFFF8ALLU:
1995+/* SP = 5LLU */
1996+{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU */
1997+ {
1998+ /*CALLEND*/
14061999 stackbase += 4LLU;
1407- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB1LLU;
2000+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF89LLU;
14082001 fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
14092002 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
14102003 break;
14112004 }
1412-case 0xFFFFFFFFFFFFFFB1LLU:
2005+case 0xFFFFFFFFFFFFFF89LLU:
14132006 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
14142007 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
14152008 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
14162009 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1417-/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
2010+/* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
14182011 case /*typeisval_*/0xBF4AE092EC5C9C00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
14192012 {
14202013 /* CALLBEGIN */
@@ -1432,28 +2025,28 @@
14322025 {
14332026 /*CALLEND*/
14342027 stackbase += 7LLU;
1435- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB0LLU;
2028+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF88LLU;
14362029 fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
14372030 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); }
14382031 break;
14392032 }
1440-case 0xFFFFFFFFFFFFFFB0LLU:
2033+case 0xFFFFFFFFFFFFFF88LLU:
14412034 /* SP = 5LLU */
14422035 {
14432036 /*CALLEND*/
14442037 stackbase += 4LLU;
1445- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAFLLU;
2038+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF87LLU;
14462039 fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
14472040 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
14482041 break;
14492042 }
1450-case 0xFFFFFFFFFFFFFFAFLLU:
2043+case 0xFFFFFFFFFFFFFF87LLU:
14512044 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
14522045 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
14532046 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
14542047 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
14552048 /* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
1456-case /*typetosize*/0xBF4AE0BEABA4D600LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2049+case /*subisid___*/0xBB0764BA47C00000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
14572050 {
14582051 /* CALLBEGIN */
14592052 /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
@@ -1461,21 +2054,270 @@
14612054 /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
14622055 }
14632056 { /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2057+{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2058+ {
2059+ /*CALLEND*/
2060+ stackbase += 4LLU;
2061+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF86LLU;
2062+ fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
2063+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
2064+ break;
2065+ }
2066+case 0xFFFFFFFFFFFFFF86LLU:
2067+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2068+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2069+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2070+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2071+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
2072+case /*subisnr___*/0xBB0764BA9B400000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2073+ {
2074+ /* CALLBEGIN */
2075+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2076+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2077+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2078+ }
2079+ {
2080+ /* CALLBEGIN */
2081+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2082+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2083+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
2084+ }
2085+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
2086+ {
2087+ /*CALLEND*/
2088+ stackbase += 7LLU;
2089+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF85LLU;
2090+ fnaddr = /*subisid___*/0xBB0764BA47C00000LLU;/* SP = 0LLU */
2091+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subisid___*/\n"); exit(-1); }
2092+ break;
2093+ }
2094+case 0xFFFFFFFFFFFFFF85LLU:
2095+/* SP = 5LLU */
2096+ {
2097+ /*CALLEND*/
2098+ stackbase += 4LLU;
2099+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF84LLU;
2100+ fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
2101+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
2102+ break;
2103+ }
2104+case 0xFFFFFFFFFFFFFF84LLU:
2105+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2106+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2107+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2108+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2109+/* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
2110+case /*idtosub___*/0x91FBEABB07400000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2111+ {
2112+ /* CALLBEGIN */
2113+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2114+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2115+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2116+ }
2117+ {
2118+ /* CALLBEGIN */
2119+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2120+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2121+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
2122+ }
2123+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
2124+{ /* PUSH */ stack[stackbase + 8LLU] = 8LLU; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
2125+ {
2126+ /*CALLEND*/
2127+ stackbase += 7LLU;
2128+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF83LLU;
2129+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
2130+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
2131+ break;
2132+ }
2133+case 0xFFFFFFFFFFFFFF83LLU:
2134+/* SP = 5LLU */
2135+{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU */
2136+ {
2137+ /*CALLEND*/
2138+ stackbase += 4LLU;
2139+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF82LLU;
2140+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
2141+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
2142+ break;
2143+ }
2144+case 0xFFFFFFFFFFFFFF82LLU:
2145+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2146+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2147+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2148+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2149+/* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
2150+case /*subtoid___*/0xBB076FAA47C00000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2151+ {
2152+ /* CALLBEGIN */
2153+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2154+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2155+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2156+ }
2157+ {
2158+ /* CALLBEGIN */
2159+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2160+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2161+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
2162+ }
2163+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
2164+ {
2165+ /* CALLBEGIN */
2166+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
2167+{ /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
2168+ /* leave place for return addr *//* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
2169+ }
2170+{ /* PUSH */ stack[stackbase + 11LLU] = 1LLU; }/* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
2171+ {
2172+ /*CALLEND*/
2173+ stackbase += 11LLU;
2174+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF81LLU;
2175+ fnaddr = /*bitnot____*/0x764BE9AAF0000000LLU;/* SP = 0LLU */
2176+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitnot____*/\n"); exit(-1); }
2177+ break;
2178+ }
2179+case 0xFFFFFFFFFFFFFF81LLU:
2180+/* SP = 9LLU */
2181+ {
2182+ /*CALLEND*/
2183+ stackbase += 7LLU;
2184+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF80LLU;
2185+ fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */
2186+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); }
2187+ break;
2188+ }
2189+case 0xFFFFFFFFFFFFFF80LLU:
2190+/* SP = 5LLU */
2191+{ /* PUSH */ stack[stackbase + 5LLU] = 8LLU; }/* SP + 1LLU = 6LLU */
2192+ {
2193+ /*CALLEND*/
2194+ stackbase += 4LLU;
2195+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7FLLU;
2196+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
2197+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
2198+ break;
2199+ }
2200+case 0xFFFFFFFFFFFFFF7FLLU:
2201+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2202+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2203+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2204+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2205+/* function requires 12LLU 64-bit chunks of memory (including 1LLU for parameters) */
2206+case /*subtonr___*/0xBB076FAA9B400000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2207+ {
2208+ /* CALLBEGIN */
2209+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2210+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2211+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2212+ }
2213+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
14642214 { /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
14652215 {
14662216 /*CALLEND*/
14672217 stackbase += 4LLU;
1468- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAELLU;
2218+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7ELLU;
14692219 fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
14702220 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
14712221 break;
14722222 }
1473-case 0xFFFFFFFFFFFFFFAELLU:
2223+case 0xFFFFFFFFFFFFFF7ELLU:
14742224 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
14752225 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
14762226 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
14772227 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
14782228 /* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
2229+case /*typetosub_*/0xBF4AE0BEABB07400LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2230+ {
2231+ /* CALLBEGIN */
2232+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2233+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2234+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2235+ }
2236+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2237+{ /* PUSH */ stack[stackbase + 5LLU] = 8LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2238+ {
2239+ /*CALLEND*/
2240+ stackbase += 4LLU;
2241+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7DLLU;
2242+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
2243+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
2244+ break;
2245+ }
2246+case 0xFFFFFFFFFFFFFF7DLLU:
2247+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2248+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2249+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2250+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2251+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
2252+case /*subtosize_*/0xBB076FAAE9358000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2253+ {
2254+ /* CALLBEGIN */
2255+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2256+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2257+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2258+ }
2259+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2260+{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2261+ {
2262+ /*CALLEND*/
2263+ stackbase += 4LLU;
2264+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7CLLU;
2265+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
2266+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
2267+ break;
2268+ }
2269+case 0xFFFFFFFFFFFFFF7CLLU:
2270+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2271+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2272+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2273+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2274+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
2275+case /*nrtosub___*/0xA6DBEABB07400000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2276+ {
2277+ /* CALLBEGIN */
2278+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2279+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2280+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2281+ }
2282+{ /* PUSH */ stack[stackbase + 4LLU] = 2LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2283+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2284+ {
2285+ /*CALLEND*/
2286+ stackbase += 4LLU;
2287+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7BLLU;
2288+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
2289+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
2290+ break;
2291+ }
2292+case 0xFFFFFFFFFFFFFF7BLLU:
2293+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2294+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2295+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2296+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2297+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
2298+case /*typetosize*/0xBF4AE0BEABA4D600LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
2299+ {
2300+ /* CALLBEGIN */
2301+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2302+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2303+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2304+ }
2305+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2306+{ /* PUSH */ stack[stackbase + 5LLU] = 16LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2307+ {
2308+ /*CALLEND*/
2309+ stackbase += 4LLU;
2310+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7ALLU;
2311+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
2312+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
2313+ break;
2314+ }
2315+case 0xFFFFFFFFFFFFFF7ALLU:
2316+/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2317+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
2318+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
2319+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2320+/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
14792321 case /*typelistel*/0xBF4AE09E4BAF8270LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
14802322 {
14812323 /* CALLBEGIN */
@@ -1493,22 +2335,22 @@
14932335 {
14942336 /*CALLEND*/
14952337 stackbase += 7LLU;
1496- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFADLLU;
2338+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF79LLU;
14972339 fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */
14982340 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); }
14992341 break;
15002342 }
1501-case 0xFFFFFFFFFFFFFFADLLU:
2343+case 0xFFFFFFFFFFFFFF79LLU:
15022344 /* SP = 5LLU */
15032345 {
15042346 /*CALLEND*/
15052347 stackbase += 4LLU;
1506- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFACLLU;
2348+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF78LLU;
15072349 fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
15082350 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); }
15092351 break;
15102352 }
1511-case 0xFFFFFFFFFFFFFFACLLU:
2353+case 0xFFFFFFFFFFFFFF78LLU:
15122354 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
15132355 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
15142356 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
@@ -1531,85 +2373,1522 @@
15312373 {
15322374 /*CALLEND*/
15332375 stackbase += 7LLU;
1534- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFABLLU;
2376+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF77LLU;
15352377 fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */
15362378 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); }
15372379 break;
15382380 }
1539-case 0xFFFFFFFFFFFFFFABLLU:
2381+case 0xFFFFFFFFFFFFFF77LLU:
15402382 /* SP = 5LLU */
15412383 {
15422384 /*CALLEND*/
15432385 stackbase += 4LLU;
1544- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAALLU;
2386+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF76LLU;
15452387 fnaddr = /*encodelist*/0x8297AA7E09E4BAF0LLU;/* SP = 0LLU */
15462388 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodelist*/\n"); exit(-1); }
15472389 break;
15482390 }
1549-case 0xFFFFFFFFFFFFFFAALLU:
2391+case 0xFFFFFFFFFFFFFF76LLU:
15502392 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
15512393 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
15522394 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
15532395 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
15542396 /* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
1555-case /*typestore_*/0xBF4AE0BAFAAD8000LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
2397+case /*parsechar_*/0xADCB6E81E8DCB400LLU:/* SP = 0LLU */
2398+ {
2399+ /* CALLBEGIN */
2400+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 1LLU *//* SPMAX = 1LLU */
2401+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2402+ /* leave place for return addr *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2403+ }
2404+ {
2405+ /*CALLEND*/
2406+ stackbase += 3LLU;
2407+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF75LLU;
2408+ fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
2409+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
2410+ break;
2411+ }
2412+case 0xFFFFFFFFFFFFFF75LLU:
2413+/* SP = 1LLU */
2414+ {
2415+ /* CALLBEGIN */
2416+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
2417+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
2418+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
2419+ }
2420+{ /* PUSH */ stack[stackbase + 3LLU] = 39LLU; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2421+ {
2422+ /*CALLEND*/
2423+ stackbase += 3LLU;
2424+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF74LLU;
2425+ fnaddr = /*match_____*/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
2426+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*match_____*/\n"); exit(-1); }
2427+ break;
2428+ }
2429+case 0xFFFFFFFFFFFFFF74LLU:
2430+/* SP = 1LLU */
2431+{ /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
2432+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
2433+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
2434+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2435+/* function requires 4LLU 64-bit chunks of memory (including 0LLU for parameters) */
2436+case /*parsenr___*/0xADCB6E829B400000LLU:/* SP = 0LLU */
2437+{ /* PUSH */ stack[stackbase + 0LLU] = 0LLU; }/* SP + 1LLU = 1LLU *//* SPMAX = 1LLU */
2438+ {
2439+ /* CALLBEGIN */
2440+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
2441+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
2442+ /* leave place for return addr *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2443+ }
2444+ {
2445+ /*CALLEND*/
2446+ stackbase += 3LLU;
2447+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF73LLU;
2448+ fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
2449+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
2450+ break;
2451+ }
2452+case 0xFFFFFFFFFFFFFF73LLU:
2453+/* SP = 1LLU */
2454+case 0xFFFFFFFFFFFFFF72LLU: /* loop to here *//* predicate */
15562455
15572456 {
15582457 /* CALLBEGIN */
2458+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
2459+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
2460+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
2461+ }
2462+ {
2463+ /* CALLBEGIN */
2464+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2465+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2466+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
2467+ }
2468+ {
2469+ /*CALLEND*/
2470+ stackbase += 7LLU;
2471+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF70LLU;
2472+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
2473+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
2474+ break;
2475+ }
2476+case 0xFFFFFFFFFFFFFF70LLU:
2477+/* SP = 5LLU */
2478+ {
2479+ /*CALLEND*/
2480+ stackbase += 4LLU;
2481+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6FLLU;
2482+ fnaddr = /*isdigit___*/0x92E7E48A4BC00000LLU;/* SP = 0LLU */
2483+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isdigit___*/\n"); exit(-1); }
2484+ break;
2485+ }
2486+case 0xFFFFFFFFFFFFFF6FLLU:
2487+/* SP = 2LLU */
2488+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
2489+{ /* JUMP */ fnaddr = 18446744073709551473LLU; break; } /* skip loop */
2490+/* loop */
2491+ {
2492+ /* CALLBEGIN */
2493+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
2494+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
2495+ /* leave place for return addr *//* SP + 1LLU = 4LLU */
2496+ }
2497+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
2498+{ /* PUSH */ stack[stackbase + 5LLU] = 10LLU; }/* SP + 1LLU = 6LLU */
2499+ {
2500+ /*CALLEND*/
2501+ stackbase += 4LLU;
2502+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6ELLU;
2503+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
2504+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
2505+ break;
2506+ }
2507+case 0xFFFFFFFFFFFFFF6ELLU:
2508+/* SP = 2LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
2509+
2510+ {
2511+ /* CALLBEGIN */
2512+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
2513+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
2514+ /* leave place for return addr *//* SP + 1LLU = 4LLU */
2515+ }
2516+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
2517+ {
2518+ /* CALLBEGIN */
2519+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
2520+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
2521+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
2522+ }
2523+ {
2524+ /* CALLBEGIN */
2525+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
2526+{ /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
2527+ /* leave place for return addr *//* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
2528+ }
2529+ {
2530+ /*CALLEND*/
2531+ stackbase += 11LLU;
2532+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6DLLU;
2533+ fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
2534+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
2535+ break;
2536+ }
2537+case 0xFFFFFFFFFFFFFF6DLLU:
2538+/* SP = 9LLU */
2539+{ /* PUSH */ stack[stackbase + 9LLU] = 48LLU; }/* SP + 1LLU = 10LLU */
2540+ {
2541+ /*CALLEND*/
2542+ stackbase += 8LLU;
2543+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6CLLU;
2544+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
2545+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
2546+ break;
2547+ }
2548+case 0xFFFFFFFFFFFFFF6CLLU:
2549+/* SP = 6LLU */
2550+ {
2551+ /*CALLEND*/
2552+ stackbase += 4LLU;
2553+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6BLLU;
2554+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
2555+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
2556+ break;
2557+ }
2558+case 0xFFFFFFFFFFFFFF6BLLU:
2559+/* SP = 2LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
2560+/* SP = 1LLU */
2561+{ /* JUMP */ fnaddr = 18446744073709551474LLU; break; } /* loop */
2562+case 18446744073709551473LLU: /* skip to here */
2563+{ /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
2564+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
2565+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
2566+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2567+/* function requires 11LLU 64-bit chunks of memory (including 0LLU for parameters) */
2568+case /*parseid___*/0xADCB6E8247C00000LLU:/* SP = 0LLU */
2569+{ /* PUSH */ stack[stackbase + 0LLU] = 0LLU; }/* SP + 1LLU = 1LLU *//* SPMAX = 1LLU *//* predicate */
2570+
2571+ {
2572+ /* CALLBEGIN */
15592573 /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
15602574 { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
15612575 /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
15622576 }
2577+ {
2578+ /* CALLBEGIN */
2579+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
2580+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
2581+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
2582+ }
2583+ {
2584+ /*CALLEND*/
2585+ stackbase += 7LLU;
2586+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF69LLU;
2587+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
2588+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
2589+ break;
2590+ }
2591+case 0xFFFFFFFFFFFFFF69LLU:
2592+/* SP = 5LLU */
2593+ {
2594+ /*CALLEND*/
2595+ stackbase += 4LLU;
2596+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF68LLU;
2597+ fnaddr = /*isalpha___*/0x92E727AE37000000LLU;/* SP = 0LLU */
2598+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isalpha___*/\n"); exit(-1); }
2599+ break;
2600+ }
2601+case 0xFFFFFFFFFFFFFF68LLU:
2602+/* SP = 2LLU */
2603+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
2604+{ /* JUMP */ fnaddr = 18446744073709551466LLU; break; } /* skip consequent */
2605+/* consequent */
2606+{ /* PUSH */ stack[stackbase + 1LLU] = 10LLU; }/* SP + 1LLU = 2LLU */
2607+case 0xFFFFFFFFFFFFFF67LLU: /* loop to here *//* predicate */
2608+
2609+ {
2610+ /* CALLBEGIN */
2611+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
2612+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
2613+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
2614+ }
2615+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
2616+{ /* PUSH */ stack[stackbase + 6LLU] = 0LLU; }/* SP + 1LLU = 7LLU */
2617+ {
2618+ /*CALLEND*/
2619+ stackbase += 5LLU;
2620+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF65LLU;
2621+ fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
2622+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
2623+ break;
2624+ }
2625+case 0xFFFFFFFFFFFFFF65LLU:
2626+/* SP = 3LLU */
2627+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
2628+{ /* JUMP */ fnaddr = 18446744073709551462LLU; break; } /* skip loop */
2629+/* loop *//* predicate */
2630+
2631+ {
2632+ /* CALLBEGIN */
2633+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
2634+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
2635+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
2636+ }
2637+{ /* PUSH */ stack[stackbase + 5LLU] = 95LLU; }/* SP + 1LLU = 6LLU */
2638+ {
2639+ /* CALLBEGIN */
2640+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
2641+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
2642+ /* leave place for return addr *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
2643+ }
2644+ {
2645+ /*CALLEND*/
2646+ stackbase += 9LLU;
2647+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF62LLU;
2648+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
2649+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
2650+ break;
2651+ }
2652+case 0xFFFFFFFFFFFFFF62LLU:
2653+/* SP = 7LLU */
2654+ {
2655+ /*CALLEND*/
2656+ stackbase += 5LLU;
2657+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF61LLU;
2658+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
2659+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
2660+ break;
2661+ }
2662+case 0xFFFFFFFFFFFFFF61LLU:
2663+/* SP = 3LLU */
2664+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
2665+{ /* JUMP */ fnaddr = 18446744073709551460LLU; break; } /* skip consequent */
2666+/* consequent */
2667+ {
2668+ /* CALLBEGIN */
2669+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
2670+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
2671+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
2672+ }
2673+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
2674+ {
2675+ /* CALLBEGIN */
2676+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
2677+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
2678+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
2679+ }
2680+ {
2681+ /* CALLBEGIN */
2682+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
2683+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
2684+ /* leave place for return addr *//* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
2685+ }
2686+ {
2687+ /* CALLBEGIN */
2688+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU *//* SPMAX = 13LLU */
2689+{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU *//* SPMAX = 14LLU */
2690+ /* leave place for return addr *//* SP + 1LLU = 15LLU *//* SPMAX = 15LLU */
2691+ }
2692+ {
2693+ /* CALLBEGIN */
2694+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU *//* SPMAX = 16LLU */
2695+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU *//* SPMAX = 17LLU */
2696+ /* leave place for return addr *//* SP + 1LLU = 18LLU *//* SPMAX = 18LLU */
2697+ }
2698+ {
2699+ /*CALLEND*/
2700+ stackbase += 18LLU;
2701+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF60LLU;
2702+ fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
2703+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
2704+ break;
2705+ }
2706+case 0xFFFFFFFFFFFFFF60LLU:
2707+/* SP = 16LLU */
2708+{ /* PUSH */ stack[stackbase + 16LLU] = 95LLU; }/* SP + 1LLU = 17LLU */
2709+ {
2710+ /*CALLEND*/
2711+ stackbase += 15LLU;
2712+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5FLLU;
2713+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
2714+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
2715+ break;
2716+ }
2717+case 0xFFFFFFFFFFFFFF5FLLU:
2718+/* SP = 13LLU */
2719+{ /* PUSH */ stack[stackbase + 13LLU] = 0LLU; }/* SP + 1LLU = 14LLU */
2720+ {
2721+ /*CALLEND*/
2722+ stackbase += 12LLU;
2723+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5ELLU;
2724+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
2725+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
2726+ break;
2727+ }
2728+case 0xFFFFFFFFFFFFFF5ELLU:
2729+/* SP = 10LLU */
2730+ {
2731+ /* CALLBEGIN */
2732+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
2733+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
2734+ /* leave place for return addr *//* SP + 1LLU = 13LLU */
2735+ }
2736+ {
2737+ /* CALLBEGIN */
2738+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
2739+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
2740+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
2741+ }
2742+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
2743+{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
2744+ {
2745+ /*CALLEND*/
2746+ stackbase += 16LLU;
2747+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5DLLU;
2748+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
2749+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
2750+ break;
2751+ }
2752+case 0xFFFFFFFFFFFFFF5DLLU:
2753+/* SP = 14LLU */
2754+{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
2755+ {
2756+ /*CALLEND*/
2757+ stackbase += 13LLU;
2758+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5CLLU;
2759+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
2760+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
2761+ break;
2762+ }
2763+case 0xFFFFFFFFFFFFFF5CLLU:
2764+/* SP = 11LLU */
2765+ {
2766+ /*CALLEND*/
2767+ stackbase += 9LLU;
2768+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5BLLU;
2769+ fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
2770+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
2771+ break;
2772+ }
2773+case 0xFFFFFFFFFFFFFF5BLLU:
2774+/* SP = 7LLU */
2775+ {
2776+ /*CALLEND*/
2777+ stackbase += 5LLU;
2778+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5ALLU;
2779+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
2780+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
2781+ break;
2782+ }
2783+case 0xFFFFFFFFFFFFFF5ALLU:
2784+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
2785+/* SP = 2LLU *//* SP = 2LLU */
2786+{ /* JUMP */ fnaddr = 18446744073709551459LLU; break; } /* skip alternative */
2787+case 18446744073709551460LLU: /* alternative *//* predicate */
2788+
2789+ {
2790+ /* CALLBEGIN */
2791+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
2792+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
2793+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
2794+ }
2795+ {
2796+ /* CALLBEGIN */
2797+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
2798+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
2799+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
2800+ }
2801+ {
2802+ /*CALLEND*/
2803+ stackbase += 8LLU;
2804+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF57LLU;
2805+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
2806+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
2807+ break;
2808+ }
2809+case 0xFFFFFFFFFFFFFF57LLU:
2810+/* SP = 6LLU */
2811+ {
2812+ /*CALLEND*/
2813+ stackbase += 5LLU;
2814+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF56LLU;
2815+ fnaddr = /*isupper___*/0x92EC2BAE0B400000LLU;/* SP = 0LLU */
2816+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isupper___*/\n"); exit(-1); }
2817+ break;
2818+ }
2819+case 0xFFFFFFFFFFFFFF56LLU:
2820+/* SP = 3LLU */
2821+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
2822+{ /* JUMP */ fnaddr = 18446744073709551449LLU; break; } /* skip consequent */
2823+/* consequent */
2824+ {
2825+ /* CALLBEGIN */
2826+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
2827+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
2828+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
2829+ }
2830+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
2831+ {
2832+ /* CALLBEGIN */
2833+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
2834+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
2835+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
2836+ }
2837+ {
2838+ /* CALLBEGIN */
2839+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
2840+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
2841+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
2842+ }
2843+ {
2844+ /* CALLBEGIN */
2845+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
2846+{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
2847+ /* leave place for return addr *//* SP + 1LLU = 15LLU */
2848+ }
2849+ {
2850+ /* CALLBEGIN */
2851+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
2852+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
2853+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
2854+ }
2855+ {
2856+ /*CALLEND*/
2857+ stackbase += 18LLU;
2858+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF55LLU;
2859+ fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
2860+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
2861+ break;
2862+ }
2863+case 0xFFFFFFFFFFFFFF55LLU:
2864+/* SP = 16LLU */
2865+{ /* PUSH */ stack[stackbase + 16LLU] = 65LLU; }/* SP + 1LLU = 17LLU */
2866+ {
2867+ /*CALLEND*/
2868+ stackbase += 15LLU;
2869+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF54LLU;
2870+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
2871+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
2872+ break;
2873+ }
2874+case 0xFFFFFFFFFFFFFF54LLU:
2875+/* SP = 13LLU */
2876+{ /* PUSH */ stack[stackbase + 13LLU] = 1LLU; }/* SP + 1LLU = 14LLU */
2877+ {
2878+ /*CALLEND*/
2879+ stackbase += 12LLU;
2880+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF53LLU;
2881+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
2882+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
2883+ break;
2884+ }
2885+case 0xFFFFFFFFFFFFFF53LLU:
2886+/* SP = 10LLU */
2887+ {
2888+ /* CALLBEGIN */
2889+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
2890+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
2891+ /* leave place for return addr *//* SP + 1LLU = 13LLU */
2892+ }
2893+ {
2894+ /* CALLBEGIN */
2895+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
2896+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
2897+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
2898+ }
2899+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
2900+{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
2901+ {
2902+ /*CALLEND*/
2903+ stackbase += 16LLU;
2904+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF52LLU;
2905+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
2906+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
2907+ break;
2908+ }
2909+case 0xFFFFFFFFFFFFFF52LLU:
2910+/* SP = 14LLU */
2911+{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
2912+ {
2913+ /*CALLEND*/
2914+ stackbase += 13LLU;
2915+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF51LLU;
2916+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
2917+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
2918+ break;
2919+ }
2920+case 0xFFFFFFFFFFFFFF51LLU:
2921+/* SP = 11LLU */
2922+ {
2923+ /*CALLEND*/
2924+ stackbase += 9LLU;
2925+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF50LLU;
2926+ fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
2927+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
2928+ break;
2929+ }
2930+case 0xFFFFFFFFFFFFFF50LLU:
2931+/* SP = 7LLU */
2932+ {
2933+ /*CALLEND*/
2934+ stackbase += 5LLU;
2935+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4FLLU;
2936+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
2937+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
2938+ break;
2939+ }
2940+case 0xFFFFFFFFFFFFFF4FLLU:
2941+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
2942+/* SP = 2LLU *//* SP = 2LLU */
2943+{ /* JUMP */ fnaddr = 18446744073709551448LLU; break; } /* skip alternative */
2944+case 18446744073709551449LLU: /* alternative *//* predicate */
2945+
2946+ {
2947+ /* CALLBEGIN */
2948+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
2949+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
2950+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
2951+ }
2952+{ /* PUSH */ stack[stackbase + 5LLU] = 36LLU; }/* SP + 1LLU = 6LLU */
2953+ {
2954+ /* CALLBEGIN */
2955+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
2956+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
2957+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
2958+ }
2959+ {
2960+ /*CALLEND*/
2961+ stackbase += 9LLU;
2962+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4CLLU;
2963+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
2964+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
2965+ break;
2966+ }
2967+case 0xFFFFFFFFFFFFFF4CLLU:
2968+/* SP = 7LLU */
2969+ {
2970+ /*CALLEND*/
2971+ stackbase += 5LLU;
2972+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4BLLU;
2973+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
2974+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
2975+ break;
2976+ }
2977+case 0xFFFFFFFFFFFFFF4BLLU:
2978+/* SP = 3LLU */
2979+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
2980+{ /* JUMP */ fnaddr = 18446744073709551438LLU; break; } /* skip consequent */
2981+/* consequent */
2982+ {
2983+ /* CALLBEGIN */
2984+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
2985+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
2986+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
2987+ }
2988+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
2989+ {
2990+ /* CALLBEGIN */
2991+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
2992+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
2993+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
2994+ }
2995+ {
2996+ /* CALLBEGIN */
2997+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
2998+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
2999+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
3000+ }
3001+ {
3002+ /* CALLBEGIN */
3003+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
3004+{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
3005+ /* leave place for return addr *//* SP + 1LLU = 15LLU */
3006+ }
3007+ {
3008+ /* CALLBEGIN */
3009+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
3010+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
3011+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
3012+ }
3013+ {
3014+ /*CALLEND*/
3015+ stackbase += 18LLU;
3016+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4ALLU;
3017+ fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
3018+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
3019+ break;
3020+ }
3021+case 0xFFFFFFFFFFFFFF4ALLU:
3022+/* SP = 16LLU */
3023+{ /* PUSH */ stack[stackbase + 16LLU] = 36LLU; }/* SP + 1LLU = 17LLU */
3024+ {
3025+ /*CALLEND*/
3026+ stackbase += 15LLU;
3027+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF49LLU;
3028+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3029+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3030+ break;
3031+ }
3032+case 0xFFFFFFFFFFFFFF49LLU:
3033+/* SP = 13LLU */
3034+{ /* PUSH */ stack[stackbase + 13LLU] = 27LLU; }/* SP + 1LLU = 14LLU */
3035+ {
3036+ /*CALLEND*/
3037+ stackbase += 12LLU;
3038+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF48LLU;
3039+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
3040+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
3041+ break;
3042+ }
3043+case 0xFFFFFFFFFFFFFF48LLU:
3044+/* SP = 10LLU */
3045+ {
3046+ /* CALLBEGIN */
3047+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
3048+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
3049+ /* leave place for return addr *//* SP + 1LLU = 13LLU */
3050+ }
3051+ {
3052+ /* CALLBEGIN */
3053+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
3054+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
3055+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
3056+ }
3057+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
3058+{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
3059+ {
3060+ /*CALLEND*/
3061+ stackbase += 16LLU;
3062+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF47LLU;
3063+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
3064+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
3065+ break;
3066+ }
3067+case 0xFFFFFFFFFFFFFF47LLU:
3068+/* SP = 14LLU */
3069+{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
3070+ {
3071+ /*CALLEND*/
3072+ stackbase += 13LLU;
3073+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF46LLU;
3074+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3075+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3076+ break;
3077+ }
3078+case 0xFFFFFFFFFFFFFF46LLU:
3079+/* SP = 11LLU */
3080+ {
3081+ /*CALLEND*/
3082+ stackbase += 9LLU;
3083+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF45LLU;
3084+ fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
3085+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
3086+ break;
3087+ }
3088+case 0xFFFFFFFFFFFFFF45LLU:
3089+/* SP = 7LLU */
3090+ {
3091+ /*CALLEND*/
3092+ stackbase += 5LLU;
3093+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF44LLU;
3094+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
3095+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
3096+ break;
3097+ }
3098+case 0xFFFFFFFFFFFFFF44LLU:
3099+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
3100+/* SP = 2LLU *//* SP = 2LLU */
3101+{ /* JUMP */ fnaddr = 18446744073709551437LLU; break; } /* skip alternative */
3102+case 18446744073709551438LLU: /* alternative *//* predicate */
3103+
3104+ {
3105+ /* CALLBEGIN */
3106+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
3107+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
3108+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
3109+ }
3110+ {
3111+ /* CALLBEGIN */
3112+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
3113+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
3114+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
3115+ }
3116+ {
3117+ /*CALLEND*/
3118+ stackbase += 8LLU;
3119+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF41LLU;
3120+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
3121+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
3122+ break;
3123+ }
3124+case 0xFFFFFFFFFFFFFF41LLU:
3125+/* SP = 6LLU */
3126+ {
3127+ /*CALLEND*/
3128+ stackbase += 5LLU;
3129+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF40LLU;
3130+ fnaddr = /*islower___*/0x92E9EACA0B400000LLU;/* SP = 0LLU */
3131+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*islower___*/\n"); exit(-1); }
3132+ break;
3133+ }
3134+case 0xFFFFFFFFFFFFFF40LLU:
3135+/* SP = 3LLU */
3136+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
3137+{ /* JUMP */ fnaddr = 18446744073709551427LLU; break; } /* skip consequent */
3138+/* consequent */
3139+ {
3140+ /* CALLBEGIN */
3141+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
3142+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
3143+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
3144+ }
3145+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
3146+ {
3147+ /* CALLBEGIN */
3148+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
3149+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
3150+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
3151+ }
3152+ {
3153+ /* CALLBEGIN */
3154+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
3155+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
3156+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
3157+ }
3158+ {
3159+ /* CALLBEGIN */
3160+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
3161+{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
3162+ /* leave place for return addr *//* SP + 1LLU = 15LLU */
3163+ }
3164+ {
3165+ /* CALLBEGIN */
3166+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
3167+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
3168+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
3169+ }
3170+ {
3171+ /*CALLEND*/
3172+ stackbase += 18LLU;
3173+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3FLLU;
3174+ fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
3175+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
3176+ break;
3177+ }
3178+case 0xFFFFFFFFFFFFFF3FLLU:
3179+/* SP = 16LLU */
3180+{ /* PUSH */ stack[stackbase + 16LLU] = 97LLU; }/* SP + 1LLU = 17LLU */
3181+ {
3182+ /*CALLEND*/
3183+ stackbase += 15LLU;
3184+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3ELLU;
3185+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3186+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3187+ break;
3188+ }
3189+case 0xFFFFFFFFFFFFFF3ELLU:
3190+/* SP = 13LLU */
3191+{ /* PUSH */ stack[stackbase + 13LLU] = 28LLU; }/* SP + 1LLU = 14LLU */
3192+ {
3193+ /*CALLEND*/
3194+ stackbase += 12LLU;
3195+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3DLLU;
3196+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
3197+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
3198+ break;
3199+ }
3200+case 0xFFFFFFFFFFFFFF3DLLU:
3201+/* SP = 10LLU */
3202+ {
3203+ /* CALLBEGIN */
3204+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
3205+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
3206+ /* leave place for return addr *//* SP + 1LLU = 13LLU */
3207+ }
3208+ {
3209+ /* CALLBEGIN */
3210+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
3211+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
3212+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
3213+ }
3214+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
3215+{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
3216+ {
3217+ /*CALLEND*/
3218+ stackbase += 16LLU;
3219+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3CLLU;
3220+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
3221+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
3222+ break;
3223+ }
3224+case 0xFFFFFFFFFFFFFF3CLLU:
3225+/* SP = 14LLU */
3226+{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
3227+ {
3228+ /*CALLEND*/
3229+ stackbase += 13LLU;
3230+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3BLLU;
3231+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3232+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3233+ break;
3234+ }
3235+case 0xFFFFFFFFFFFFFF3BLLU:
3236+/* SP = 11LLU */
3237+ {
3238+ /*CALLEND*/
3239+ stackbase += 9LLU;
3240+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3ALLU;
3241+ fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
3242+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
3243+ break;
3244+ }
3245+case 0xFFFFFFFFFFFFFF3ALLU:
3246+/* SP = 7LLU */
3247+ {
3248+ /*CALLEND*/
3249+ stackbase += 5LLU;
3250+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF39LLU;
3251+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
3252+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
3253+ break;
3254+ }
3255+case 0xFFFFFFFFFFFFFF39LLU:
3256+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
3257+/* SP = 2LLU *//* SP = 2LLU */
3258+{ /* JUMP */ fnaddr = 18446744073709551426LLU; break; } /* skip alternative */
3259+case 18446744073709551427LLU: /* alternative *//* predicate */
3260+
3261+ {
3262+ /* CALLBEGIN */
3263+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
3264+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
3265+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
3266+ }
3267+ {
3268+ /* CALLBEGIN */
3269+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
3270+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
3271+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
3272+ }
3273+ {
3274+ /*CALLEND*/
3275+ stackbase += 8LLU;
3276+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF36LLU;
3277+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
3278+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
3279+ break;
3280+ }
3281+case 0xFFFFFFFFFFFFFF36LLU:
3282+/* SP = 6LLU */
3283+ {
3284+ /*CALLEND*/
3285+ stackbase += 5LLU;
3286+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF35LLU;
3287+ fnaddr = /*isdigit___*/0x92E7E48A4BC00000LLU;/* SP = 0LLU */
3288+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isdigit___*/\n"); exit(-1); }
3289+ break;
3290+ }
3291+case 0xFFFFFFFFFFFFFF35LLU:
3292+/* SP = 3LLU */
3293+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
3294+{ /* JUMP */ fnaddr = 18446744073709551416LLU; break; } /* skip consequent */
3295+/* consequent */
3296+ {
3297+ /* CALLBEGIN */
3298+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
3299+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
3300+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
3301+ }
3302+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
3303+ {
3304+ /* CALLBEGIN */
3305+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
3306+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
3307+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
3308+ }
3309+ {
3310+ /* CALLBEGIN */
3311+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
3312+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
3313+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
3314+ }
3315+ {
3316+ /* CALLBEGIN */
3317+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
3318+{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
3319+ /* leave place for return addr *//* SP + 1LLU = 15LLU */
3320+ }
3321+ {
3322+ /* CALLBEGIN */
3323+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
3324+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
3325+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
3326+ }
3327+ {
3328+ /*CALLEND*/
3329+ stackbase += 18LLU;
3330+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF34LLU;
3331+ fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
3332+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
3333+ break;
3334+ }
3335+case 0xFFFFFFFFFFFFFF34LLU:
3336+/* SP = 16LLU */
3337+{ /* PUSH */ stack[stackbase + 16LLU] = 48LLU; }/* SP + 1LLU = 17LLU */
3338+ {
3339+ /*CALLEND*/
3340+ stackbase += 15LLU;
3341+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF33LLU;
3342+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3343+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3344+ break;
3345+ }
3346+case 0xFFFFFFFFFFFFFF33LLU:
3347+/* SP = 13LLU */
3348+{ /* PUSH */ stack[stackbase + 13LLU] = 54LLU; }/* SP + 1LLU = 14LLU */
3349+ {
3350+ /*CALLEND*/
3351+ stackbase += 12LLU;
3352+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF32LLU;
3353+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
3354+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
3355+ break;
3356+ }
3357+case 0xFFFFFFFFFFFFFF32LLU:
3358+/* SP = 10LLU */
3359+ {
3360+ /* CALLBEGIN */
3361+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
3362+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
3363+ /* leave place for return addr *//* SP + 1LLU = 13LLU */
3364+ }
3365+ {
3366+ /* CALLBEGIN */
3367+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
3368+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
3369+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
3370+ }
3371+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
3372+{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
3373+ {
3374+ /*CALLEND*/
3375+ stackbase += 16LLU;
3376+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF31LLU;
3377+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
3378+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
3379+ break;
3380+ }
3381+case 0xFFFFFFFFFFFFFF31LLU:
3382+/* SP = 14LLU */
3383+{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
3384+ {
3385+ /*CALLEND*/
3386+ stackbase += 13LLU;
3387+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF30LLU;
3388+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3389+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3390+ break;
3391+ }
3392+case 0xFFFFFFFFFFFFFF30LLU:
3393+/* SP = 11LLU */
3394+ {
3395+ /*CALLEND*/
3396+ stackbase += 9LLU;
3397+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2FLLU;
3398+ fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
3399+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
3400+ break;
3401+ }
3402+case 0xFFFFFFFFFFFFFF2FLLU:
3403+/* SP = 7LLU */
3404+ {
3405+ /*CALLEND*/
3406+ stackbase += 5LLU;
3407+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2ELLU;
3408+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
3409+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
3410+ break;
3411+ }
3412+case 0xFFFFFFFFFFFFFF2ELLU:
3413+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
3414+/* SP = 2LLU *//* SP = 2LLU */
3415+{ /* JUMP */ fnaddr = 18446744073709551415LLU; break; } /* skip alternative */
3416+case 18446744073709551416LLU: /* alternative */
3417+{ /* PUSH */ stack[stackbase + 2LLU] = 1LLU; }/* SP + 1LLU = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
3418+/* SP = 2LLU */
3419+case 18446744073709551415LLU: /* skip to here */
3420+
3421+case 18446744073709551426LLU: /* skip to here */
3422+
3423+case 18446744073709551437LLU: /* skip to here */
3424+
3425+case 18446744073709551448LLU: /* skip to here */
3426+
3427+case 18446744073709551459LLU: /* skip to here */
3428+
3429+ {
3430+ /* CALLBEGIN */
3431+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
3432+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
3433+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
3434+ }
3435+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
3436+{ /* PUSH */ stack[stackbase + 6LLU] = 1LLU; }/* SP + 1LLU = 7LLU */
3437+ {
3438+ /*CALLEND*/
3439+ stackbase += 5LLU;
3440+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2DLLU;
3441+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3442+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3443+ break;
3444+ }
3445+case 0xFFFFFFFFFFFFFF2DLLU:
3446+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
3447+/* SP = 2LLU */
3448+{ /* JUMP */ fnaddr = 18446744073709551463LLU; break; } /* loop */
3449+case 18446744073709551462LLU: /* skip to here *//* SP = 1LLU */
3450+case 18446744073709551466LLU: /* alternative */
3451+{ /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
3452+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
3453+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
3454+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3455+/* function requires 18LLU 64-bit chunks of memory (including 0LLU for parameters) */
3456+case /*printstype*/0xAED929BEEBF4AE00LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
3457+
3458+ {
3459+ /* CALLBEGIN */
3460+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
3461+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
3462+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
3463+ }
15633464 { /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
15643465 {
15653466 /*CALLEND*/
15663467 stackbase += 4LLU;
1567- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA7LLU;
3468+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2ALLU;
3469+ fnaddr = /*subisnr___*/0xBB0764BA9B400000LLU;/* SP = 0LLU */
3470+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subisnr___*/\n"); exit(-1); }
3471+ break;
3472+ }
3473+case 0xFFFFFFFFFFFFFF2ALLU:
3474+/* SP = 2LLU */
3475+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
3476+{ /* JUMP */ fnaddr = 18446744073709551404LLU; break; } /* skip consequent */
3477+/* consequent *//* predicate */
3478+
3479+ {
3480+ /* CALLBEGIN */
3481+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
3482+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
3483+ /* leave place for return addr *//* SP + 1LLU = 4LLU */
3484+ }
3485+ {
3486+ /* CALLBEGIN */
3487+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */
3488+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
3489+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
3490+ }
3491+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
3492+ {
3493+ /*CALLEND*/
3494+ stackbase += 7LLU;
3495+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF27LLU;
3496+ fnaddr = /*subtonr___*/0xBB076FAA9B400000LLU;/* SP = 0LLU */
3497+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtonr___*/\n"); exit(-1); }
3498+ break;
3499+ }
3500+case 0xFFFFFFFFFFFFFF27LLU:
3501+/* SP = 5LLU */
3502+{ /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU */
3503+ {
3504+ /*CALLEND*/
3505+ stackbase += 4LLU;
3506+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF26LLU;
3507+ fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
3508+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
3509+ break;
3510+ }
3511+case 0xFFFFFFFFFFFFFF26LLU:
3512+/* SP = 2LLU */
3513+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
3514+{ /* JUMP */ fnaddr = 18446744073709551401LLU; break; } /* skip consequent */
3515+/* consequent */fputs("u64^", stdout);
3516+ {
3517+ /* CALLBEGIN */
3518+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3519+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3520+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3521+ }
3522+{ /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU */
3523+ {
3524+ /*CALLEND*/
3525+ stackbase += 3LLU;
3526+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF25LLU;
3527+ fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
3528+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
3529+ break;
3530+ }
3531+case 0xFFFFFFFFFFFFFF25LLU:
3532+/* SP = 1LLU *//* SP = 1LLU *//* SP = 1LLU */
3533+{ /* JUMP */ fnaddr = 18446744073709551400LLU; break; } /* skip alternative */
3534+case 18446744073709551401LLU: /* alternative */fputs("unit", stdout); /* SP = 1LLU */
3535+case 18446744073709551400LLU: /* skip to here */
3536+/* SP = 1LLU *//* SP = 1LLU */
3537+{ /* JUMP */ fnaddr = 18446744073709551403LLU; break; } /* skip alternative */
3538+case 18446744073709551404LLU: /* alternative */
3539+ {
3540+ /* CALLBEGIN */
3541+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3542+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3543+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3544+ }
3545+{ /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU */
3546+ {
3547+ /*CALLEND*/
3548+ stackbase += 3LLU;
3549+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF24LLU;
3550+ fnaddr = /*printid___*/0xAED929BE47C00000LLU;/* SP = 0LLU */
3551+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printid___*/\n"); exit(-1); }
3552+ break;
3553+ }
3554+case 0xFFFFFFFFFFFFFF24LLU:
3555+/* SP = 1LLU *//* SP = 1LLU */
3556+case 18446744073709551403LLU: /* skip to here */
3557+/* SP = 1LLU *//* SP - 0LLU = 1LLU */
3558+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3559+/* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
3560+case /*printtype_*/0xAED929BEFD2B8000LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
3561+
3562+ {
3563+ /* CALLBEGIN */
3564+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
3565+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
3566+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
3567+ }
3568+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
3569+ {
3570+ /*CALLEND*/
3571+ stackbase += 4LLU;
3572+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF21LLU;
15683573 fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
15693574 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); }
15703575 break;
15713576 }
1572-case 0xFFFFFFFFFFFFFFA7LLU:
3577+case 0xFFFFFFFFFFFFFF21LLU:
15733578 /* SP = 2LLU */
15743579 if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
1575-{ /* JUMP */ fnaddr = 18446744073709551529LLU; break; } /* skip consequent */
1576-/* consequent */
1577-{ /* PUSH */ stack[stackbase + 1LLU] = 1LLU; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
1578-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP = 1LLU */
1579-{ /* JUMP */ fnaddr = 18446744073709551528LLU; break; } /* skip alternative */
1580-case 18446744073709551529LLU: /* alternative */
3580+{ /* JUMP */ fnaddr = 18446744073709551395LLU; break; } /* skip consequent */
3581+/* consequent */fputs("[", stdout);
15813582 {
15823583 /* CALLBEGIN */
3584+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3585+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3586+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3587+ }
3588+ {
3589+ /* CALLBEGIN */
3590+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
3591+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
3592+ /* leave place for return addr *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
3593+ }
3594+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
3595+ {
3596+ /*CALLEND*/
3597+ stackbase += 6LLU;
3598+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF20LLU;
3599+ fnaddr = /*typetosub_*/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3600+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosub_*/\n"); exit(-1); }
3601+ break;
3602+ }
3603+case 0xFFFFFFFFFFFFFF20LLU:
3604+/* SP = 4LLU */
3605+ {
3606+ /*CALLEND*/
3607+ stackbase += 3LLU;
3608+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1FLLU;
3609+ fnaddr = /*printstype*/0xAED929BEEBF4AE00LLU;/* SP = 0LLU */
3610+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printstype*/\n"); exit(-1); }
3611+ break;
3612+ }
3613+case 0xFFFFFFFFFFFFFF1FLLU:
3614+/* SP = 1LLU */fputs("]", stdout); /* SP = 1LLU *//* SP = 1LLU */
3615+{ /* JUMP */ fnaddr = 18446744073709551394LLU; break; } /* skip alternative */
3616+case 18446744073709551395LLU: /* alternative */
3617+ {
3618+ /* CALLBEGIN */
3619+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3620+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3621+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3622+ }
3623+ {
3624+ /* CALLBEGIN */
3625+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
3626+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
3627+ /* leave place for return addr *//* SP + 1LLU = 6LLU */
3628+ }
3629+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
3630+ {
3631+ /*CALLEND*/
3632+ stackbase += 6LLU;
3633+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ELLU;
3634+ fnaddr = /*typetosub_*/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3635+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosub_*/\n"); exit(-1); }
3636+ break;
3637+ }
3638+case 0xFFFFFFFFFFFFFF1ELLU:
3639+/* SP = 4LLU */
3640+ {
3641+ /*CALLEND*/
3642+ stackbase += 3LLU;
3643+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1DLLU;
3644+ fnaddr = /*printstype*/0xAED929BEEBF4AE00LLU;/* SP = 0LLU */
3645+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printstype*/\n"); exit(-1); }
3646+ break;
3647+ }
3648+case 0xFFFFFFFFFFFFFF1DLLU:
3649+/* SP = 1LLU *//* SP = 1LLU */
3650+case 18446744073709551394LLU: /* skip to here */
3651+/* SP = 1LLU *//* SP - 0LLU = 1LLU */
3652+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3653+/* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */
3654+case /*debugstype*/0x7E07708AEBF4AE00LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
3655+
3656+ {
3657+ /* CALLBEGIN */
3658+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
3659+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
3660+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
3661+ }
3662+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
3663+ {
3664+ /*CALLEND*/
3665+ stackbase += 4LLU;
3666+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ALLU;
3667+ fnaddr = /*subisnr___*/0xBB0764BA9B400000LLU;/* SP = 0LLU */
3668+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subisnr___*/\n"); exit(-1); }
3669+ break;
3670+ }
3671+case 0xFFFFFFFFFFFFFF1ALLU:
3672+/* SP = 2LLU */
3673+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
3674+{ /* JUMP */ fnaddr = 18446744073709551388LLU; break; } /* skip consequent */
3675+/* consequent *//* predicate */
3676+
3677+ {
3678+ /* CALLBEGIN */
15833679 /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
15843680 { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
15853681 /* leave place for return addr *//* SP + 1LLU = 4LLU */
15863682 }
1587-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
15883683 {
3684+ /* CALLBEGIN */
3685+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */
3686+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
3687+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
3688+ }
3689+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
3690+ {
15893691 /*CALLEND*/
3692+ stackbase += 7LLU;
3693+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF17LLU;
3694+ fnaddr = /*subtonr___*/0xBB076FAA9B400000LLU;/* SP = 0LLU */
3695+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtonr___*/\n"); exit(-1); }
3696+ break;
3697+ }
3698+case 0xFFFFFFFFFFFFFF17LLU:
3699+/* SP = 5LLU */
3700+{ /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU */
3701+ {
3702+ /*CALLEND*/
15903703 stackbase += 4LLU;
1591- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA6LLU;
1592- fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */
1593-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); }
3704+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF16LLU;
3705+ fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
3706+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
15943707 break;
15953708 }
1596-case 0xFFFFFFFFFFFFFFA6LLU:
1597-/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1598-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU */
1599-case 18446744073709551528LLU: /* skip to here */
1600-/* SP - 1LLU = 1LLU */
1601-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
1602-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
3709+case 0xFFFFFFFFFFFFFF16LLU:
3710+/* SP = 2LLU */
3711+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
3712+{ /* JUMP */ fnaddr = 18446744073709551385LLU; break; } /* skip consequent */
3713+/* consequent */fputs("u64^", stderr);
3714+ {
3715+ /* CALLBEGIN */
3716+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3717+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3718+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3719+ }
3720+ {
3721+ /* CALLBEGIN */
3722+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
3723+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
3724+ /* leave place for return addr *//* SP + 1LLU = 6LLU */
3725+ }
3726+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
3727+ {
3728+ /*CALLEND*/
3729+ stackbase += 6LLU;
3730+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF15LLU;
3731+ fnaddr = /*subtonr___*/0xBB076FAA9B400000LLU;/* SP = 0LLU */
3732+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtonr___*/\n"); exit(-1); }
3733+ break;
3734+ }
3735+case 0xFFFFFFFFFFFFFF15LLU:
3736+/* SP = 4LLU */
3737+ {
3738+ /*CALLEND*/
3739+ stackbase += 3LLU;
3740+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF14LLU;
3741+ fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
3742+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
3743+ break;
3744+ }
3745+case 0xFFFFFFFFFFFFFF14LLU:
3746+/* SP = 1LLU *//* SP = 1LLU *//* SP = 1LLU */
3747+{ /* JUMP */ fnaddr = 18446744073709551384LLU; break; } /* skip alternative */
3748+case 18446744073709551385LLU: /* alternative */fputs("unit", stderr); /* SP = 1LLU */
3749+case 18446744073709551384LLU: /* skip to here */
3750+/* SP = 1LLU *//* SP = 1LLU */
3751+{ /* JUMP */ fnaddr = 18446744073709551387LLU; break; } /* skip alternative */
3752+case 18446744073709551388LLU: /* alternative */
3753+ {
3754+ /* CALLBEGIN */
3755+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3756+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3757+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3758+ }
3759+ {
3760+ /* CALLBEGIN */
3761+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
3762+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
3763+ /* leave place for return addr *//* SP + 1LLU = 6LLU */
3764+ }
3765+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
3766+ {
3767+ /*CALLEND*/
3768+ stackbase += 6LLU;
3769+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF13LLU;
3770+ fnaddr = /*subtoid___*/0xBB076FAA47C00000LLU;/* SP = 0LLU */
3771+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtoid___*/\n"); exit(-1); }
3772+ break;
3773+ }
3774+case 0xFFFFFFFFFFFFFF13LLU:
3775+/* SP = 4LLU */
3776+ {
3777+ /*CALLEND*/
3778+ stackbase += 3LLU;
3779+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF12LLU;
3780+ fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
3781+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
3782+ break;
3783+ }
3784+case 0xFFFFFFFFFFFFFF12LLU:
3785+/* SP = 1LLU *//* SP = 1LLU */
3786+case 18446744073709551387LLU: /* skip to here */
3787+/* SP = 1LLU *//* SP - 0LLU = 1LLU */
16033788 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
1604-/* function requires 5LLU 64-bit chunks of memory (including 1LLU for parameters) */
3789+/* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
3790+case /*debugtype_*/0x7E07708AFD2B8000LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
3791+
3792+ {
3793+ /* CALLBEGIN */
3794+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
3795+{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
3796+ /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
3797+ }
3798+{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
3799+ {
3800+ /*CALLEND*/
3801+ stackbase += 4LLU;
3802+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0FLLU;
3803+ fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
3804+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); }
3805+ break;
3806+ }
3807+case 0xFFFFFFFFFFFFFF0FLLU:
3808+/* SP = 2LLU */
3809+if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
3810+{ /* JUMP */ fnaddr = 18446744073709551377LLU; break; } /* skip consequent */
3811+/* consequent */fputs("[", stderr);
3812+ {
3813+ /* CALLBEGIN */
3814+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3815+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3816+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3817+ }
3818+ {
3819+ /* CALLBEGIN */
3820+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
3821+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
3822+ /* leave place for return addr *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
3823+ }
3824+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
3825+ {
3826+ /*CALLEND*/
3827+ stackbase += 6LLU;
3828+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0ELLU;
3829+ fnaddr = /*typetosub_*/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3830+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosub_*/\n"); exit(-1); }
3831+ break;
3832+ }
3833+case 0xFFFFFFFFFFFFFF0ELLU:
3834+/* SP = 4LLU */
3835+ {
3836+ /*CALLEND*/
3837+ stackbase += 3LLU;
3838+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0DLLU;
3839+ fnaddr = /*debugstype*/0x7E07708AEBF4AE00LLU;/* SP = 0LLU */
3840+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugstype*/\n"); exit(-1); }
3841+ break;
3842+ }
3843+case 0xFFFFFFFFFFFFFF0DLLU:
3844+/* SP = 1LLU */fputs("]", stderr); /* SP = 1LLU *//* SP = 1LLU */
3845+{ /* JUMP */ fnaddr = 18446744073709551376LLU; break; } /* skip alternative */
3846+case 18446744073709551377LLU: /* alternative */
3847+ {
3848+ /* CALLBEGIN */
3849+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3850+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3851+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
3852+ }
3853+ {
3854+ /* CALLBEGIN */
3855+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
3856+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
3857+ /* leave place for return addr *//* SP + 1LLU = 6LLU */
3858+ }
3859+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
3860+ {
3861+ /*CALLEND*/
3862+ stackbase += 6LLU;
3863+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0CLLU;
3864+ fnaddr = /*typetosub_*/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3865+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosub_*/\n"); exit(-1); }
3866+ break;
3867+ }
3868+case 0xFFFFFFFFFFFFFF0CLLU:
3869+/* SP = 4LLU */
3870+ {
3871+ /*CALLEND*/
3872+ stackbase += 3LLU;
3873+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0BLLU;
3874+ fnaddr = /*debugstype*/0x7E07708AEBF4AE00LLU;/* SP = 0LLU */
3875+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugstype*/\n"); exit(-1); }
3876+ break;
3877+ }
3878+case 0xFFFFFFFFFFFFFF0BLLU:
3879+/* SP = 1LLU *//* SP = 1LLU */
3880+case 18446744073709551376LLU: /* skip to here */
3881+/* SP = 1LLU *//* SP - 0LLU = 1LLU */
3882+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3883+/* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */
16053884 case /*debugdefs_*/0x7E077089F821B800LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
16063885 { /* PUSH */ stack[stackbase + 1LLU] = 0LLU; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
16073886 { /* PUSH */ stack[stackbase + 2LLU] = 0LLU; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
1608-case 0xFFFFFFFFFFFFFFA5LLU: /* loop to here *//* predicate: list non-empty? */
3887+case 0xFFFFFFFFFFFFFF0ALLU: /* loop to here *//* predicate: list non-empty? */
16093888
16103889 { /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
16113890 if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
1612-{ /* JUMP */ fnaddr = 18446744073709551524LLU; break; } /* skip loop */
3891+{ /* JUMP */ fnaddr = 18446744073709551369LLU; break; } /* skip loop */
16133892 /* loop *//* predicate */
16143893
16153894 {
@@ -1623,15 +3902,15 @@
16233902 {
16243903 /*CALLEND*/
16253904 stackbase += 6LLU;
1626- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA1LLU;
3905+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF06LLU;
16273906 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
16283907 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
16293908 break;
16303909 }
1631-case 0xFFFFFFFFFFFFFFA1LLU:
3910+case 0xFFFFFFFFFFFFFF06LLU:
16323911 /* SP = 4LLU */
16333912 if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
1634-{ /* JUMP */ fnaddr = 18446744073709551523LLU; break; } /* skip consequent */
3913+{ /* JUMP */ fnaddr = 18446744073709551368LLU; break; } /* skip consequent */
16353914 /* consequent */
16363915 {
16373916 /* CALLBEGIN */
@@ -1644,12 +3923,12 @@
16443923 {
16453924 /*CALLEND*/
16463925 stackbase += 6LLU;
1647- stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA0LLU;
3926+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF05LLU;
16483927 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
16493928 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
16503929 break;
16513930 }
1652-case 0xFFFFFFFFFFFFFFA0LLU:
3931+case 0xFFFFFFFFFFFFFF05LLU:
16533932 /* SP = 4LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */
16543933 fputs(" ", stderr);
16553934 {
@@ -1662,15 +3941,15 @@
16623941 {
16633942 /*CALLEND*/
16643943 stackbase += 5LLU;
1665- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9FLLU;
3944+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF04LLU;
16663945 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
16673946 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
16683947 break;
16693948 }
1670-case 0xFFFFFFFFFFFFFF9FLLU:
3949+case 0xFFFFFFFFFFFFFF04LLU:
16713950 /* SP = 3LLU *//* SP = 3LLU *//* SP = 3LLU */
1672-{ /* JUMP */ fnaddr = 18446744073709551522LLU; break; } /* skip alternative */
1673-case 18446744073709551523LLU: /* alternative */
3951+{ /* JUMP */ fnaddr = 18446744073709551367LLU; break; } /* skip alternative */
3952+case 18446744073709551368LLU: /* alternative */
16743953 { /* PUSH */ stack[stackbase + 3LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 4LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */
16753954 fputs("\n", stderr);
16763955 {
@@ -1683,12 +3962,12 @@
16833962 {
16843963 /*CALLEND*/
16853964 stackbase += 5LLU;
1686- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9ELLU;
3965+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF03LLU;
16873966 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
16883967 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
16893968 break;
16903969 }
1691-case 0xFFFFFFFFFFFFFF9ELLU:
3970+case 0xFFFFFFFFFFFFFF03LLU:
16923971 /* SP = 3LLU */fputs(" ", stderr);
16933972 {
16943973 /* CALLBEGIN */
@@ -1700,12 +3979,12 @@
17003979 {
17013980 /*CALLEND*/
17023981 stackbase += 5LLU;
1703- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9DLLU;
3982+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF02LLU;
17043983 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
17053984 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
17063985 break;
17073986 }
1708-case 0xFFFFFFFFFFFFFF9DLLU:
3987+case 0xFFFFFFFFFFFFFF02LLU:
17093988 /* SP = 3LLU */
17103989 {
17113990 /* CALLBEGIN */
@@ -1718,29 +3997,29 @@
17183997 {
17193998 /*CALLEND*/
17203999 stackbase += 6LLU;
1721- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9CLLU;
4000+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF01LLU;
17224001 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
17234002 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
17244003 break;
17254004 }
1726-case 0xFFFFFFFFFFFFFF9CLLU:
4005+case 0xFFFFFFFFFFFFFF01LLU:
17274006 /* SP = 4LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */
17284007 /* SP = 3LLU */
1729-case 18446744073709551522LLU: /* skip to here */
4008+case 18446744073709551367LLU: /* skip to here */
17304009 /* SP = 3LLU */
17314010 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
1732-{ /* JUMP */ fnaddr = 18446744073709551525LLU; break; } /* loop */
1733-case 18446744073709551524LLU: /* skip to here */fputs("\n", stderr); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
4011+{ /* JUMP */ fnaddr = 18446744073709551370LLU; break; } /* loop */
4012+case 18446744073709551369LLU: /* skip to here */fputs("\n", stderr); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
17344013 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
17354014 /* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
17364015 case /*existsdef_*/0x83392EBEE7E08400LLU:/* SP = 2LLU *//* SPMAX = 2LLU */
17374016 { /* PUSH */ stack[stackbase + 2LLU] = 0LLU; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
17384017 { /* PUSH */ stack[stackbase + 3LLU] = 0LLU; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
1739-case 0xFFFFFFFFFFFFFF9BLLU: /* loop to here *//* predicate: list non-empty? */
4018+case 0xFFFFFFFFFFFFFF00LLU: /* loop to here *//* predicate: list non-empty? */
17404019
17414020 { /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
17424021 if(!/* SP - 1LLU = 4LLU */stack[stackbase + 4LLU])
1743-{ /* JUMP */ fnaddr = 18446744073709551514LLU; break; } /* skip loop */
4022+{ /* JUMP */ fnaddr = 18446744073709551359LLU; break; } /* skip loop */
17444023 /* loop *//* predicate */
17454024
17464025 {
@@ -1754,15 +4033,15 @@
17544033 {
17554034 /*CALLEND*/
17564035 stackbase += 7LLU;
1757- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF97LLU;
4036+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFCLLU;
17584037 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
17594038 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
17604039 break;
17614040 }
1762-case 0xFFFFFFFFFFFFFF97LLU:
4041+case 0xFFFFFFFFFFFFFEFCLLU:
17634042 /* SP = 5LLU */
17644043 if(!/* SP - 1LLU = 4LLU */stack[stackbase + 4LLU])
1765-{ /* JUMP */ fnaddr = 18446744073709551513LLU; break; } /* skip consequent */
4044+{ /* JUMP */ fnaddr = 18446744073709551358LLU; break; } /* skip consequent */
17664045 /* consequent */
17674046 {
17684047 /* CALLBEGIN */
@@ -1775,16 +4054,16 @@
17754054 {
17764055 /*CALLEND*/
17774056 stackbase += 7LLU;
1778- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF96LLU;
4057+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFBLLU;
17794058 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
17804059 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
17814060 break;
17824061 }
1783-case 0xFFFFFFFFFFFFFF96LLU:
4062+case 0xFFFFFFFFFFFFFEFBLLU:
17844063 /* SP = 5LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]; /* POP */
17854064 /* SP = 4LLU *//* SP = 4LLU */
1786-{ /* JUMP */ fnaddr = 18446744073709551512LLU; break; } /* skip alternative */
1787-case 18446744073709551513LLU: /* alternative *//* predicate */
4065+{ /* JUMP */ fnaddr = 18446744073709551357LLU; break; } /* skip alternative */
4066+case 18446744073709551358LLU: /* alternative *//* predicate */
17884067
17894068 {
17904069 /* CALLBEGIN */
@@ -1797,30 +4076,30 @@
17974076 {
17984077 /*CALLEND*/
17994078 stackbase += 7LLU;
1800- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF93LLU;
4079+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF8LLU;
18014080 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
18024081 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
18034082 break;
18044083 }
1805-case 0xFFFFFFFFFFFFFF93LLU:
4084+case 0xFFFFFFFFFFFFFEF8LLU:
18064085 /* SP = 5LLU */
18074086 if(!/* SP - 1LLU = 4LLU */stack[stackbase + 4LLU])
1808-{ /* JUMP */ fnaddr = 18446744073709551509LLU; break; } /* skip consequent */
4087+{ /* JUMP */ fnaddr = 18446744073709551354LLU; break; } /* skip consequent */
18094088 /* consequent */
18104089 { /* PUSH */ stack[stackbase + 4LLU] = 1LLU; }/* SP + 1LLU = 5LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]; /* POP */
18114090
18124091 {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 4LLU *//* SP = 4LLU */
1813-{ /* JUMP */ fnaddr = 18446744073709551508LLU; break; } /* skip alternative */
1814-case 18446744073709551509LLU: /* alternative */
4092+{ /* JUMP */ fnaddr = 18446744073709551353LLU; break; } /* skip alternative */
4093+case 18446744073709551354LLU: /* alternative */
18154094 { /* PUSH */ stack[stackbase + 4LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 5LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]; /* POP */
18164095 /* SP = 4LLU */
1817-case 18446744073709551508LLU: /* skip to here */
4096+case 18446744073709551353LLU: /* skip to here */
18184097
1819-case 18446744073709551512LLU: /* skip to here */
4098+case 18446744073709551357LLU: /* skip to here */
18204099 /* SP = 4LLU */
18214100 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
1822-{ /* JUMP */ fnaddr = 18446744073709551515LLU; break; } /* loop */
1823-case 18446744073709551514LLU: /* skip to here */
4101+{ /* JUMP */ fnaddr = 18446744073709551360LLU; break; } /* loop */
4102+case 18446744073709551359LLU: /* skip to here */
18244103 { /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 5LLU *//* SP - 1LLU = 4LLU */
18254104 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */
18264105 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }
@@ -1848,28 +4127,86 @@
18484127 {
18494128 /*CALLEND*/
18504129 stackbase += 11LLU;
1851- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF90LLU;
4130+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF5LLU;
18524131 fnaddr = /*existsdef_*/0x83392EBEE7E08400LLU;/* SP = 0LLU */
18534132 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*existsdef_*/\n"); exit(-1); }
18544133 break;
18554134 }
1856-case 0xFFFFFFFFFFFFFF90LLU:
4135+case 0xFFFFFFFFFFFFFEF5LLU:
18574136 /* SP = 9LLU */
18584137 {
18594138 /*CALLEND*/
18604139 stackbase += 8LLU;
1861- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8FLLU;
4140+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF4LLU;
18624141 fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
18634142 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
18644143 break;
18654144 }
1866-case 0xFFFFFFFFFFFFFF8FLLU:
4145+case 0xFFFFFFFFFFFFFEF4LLU:
18674146 /* SP = 6LLU */
18684147 if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
1869-{ /* JUMP */ fnaddr = 18446744073709551506LLU; break; } /* skip consequent */
4148+{ /* JUMP */ fnaddr = 18446744073709551351LLU; break; } /* skip consequent */
4149+/* consequent *//* predicate */
4150+
4151+ {
4152+ /* CALLBEGIN */
4153+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
4154+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
4155+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
4156+ }
4157+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU */
4158+ {
4159+ /* CALLBEGIN */
4160+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
4161+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
4162+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
4163+ }
4164+{ /* PUSH */ stack[stackbase + 12LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 13LLU */
4165+ {
4166+ /*CALLEND*/
4167+ stackbase += 12LLU;
4168+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF1LLU;
4169+ fnaddr = /*markstruct*/0xA1CB66BAFB707AF0LLU;/* SP = 0LLU */
4170+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*markstruct*/\n"); exit(-1); }
4171+ break;
4172+ }
4173+case 0xFFFFFFFFFFFFFEF1LLU:
4174+/* SP = 10LLU */
4175+ {
4176+ /*CALLEND*/
4177+ stackbase += 8LLU;
4178+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF0LLU;
4179+ fnaddr = /*existsdef_*/0x83392EBEE7E08400LLU;/* SP = 0LLU */
4180+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*existsdef_*/\n"); exit(-1); }
4181+ break;
4182+ }
4183+case 0xFFFFFFFFFFFFFEF0LLU:
4184+/* SP = 6LLU */
4185+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
4186+{ /* JUMP */ fnaddr = 18446744073709551347LLU; break; } /* skip consequent */
18704187 /* consequent */
18714188 {
18724189 /* CALLBEGIN */
4190+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
4191+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
4192+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
4193+ }
4194+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 9LLU */
4195+ {
4196+ /*CALLEND*/
4197+ stackbase += 8LLU;
4198+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEFLLU;
4199+ fnaddr = /*markstruct*/0xA1CB66BAFB707AF0LLU;/* SP = 0LLU */
4200+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*markstruct*/\n"); exit(-1); }
4201+ break;
4202+ }
4203+case 0xFFFFFFFFFFFFFEEFLLU:
4204+/* SP = 6LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
4205+/* SP = 5LLU *//* SP = 5LLU */
4206+{ /* JUMP */ fnaddr = 18446744073709551346LLU; break; } /* skip alternative */
4207+case 18446744073709551347LLU: /* alternative */
4208+ {
4209+ /* CALLBEGIN */
18734210 /* reserve space for 0LLU returned values *//* SP + 0LLU = 5LLU */
18744211 { /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
18754212 /* leave place for return addr *//* SP + 1LLU = 7LLU */
@@ -1877,12 +4214,12 @@
18774214 {
18784215 /*CALLEND*/
18794216 stackbase += 7LLU;
1880- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8ELLU;
4217+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEELLU;
18814218 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
18824219 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
18834220 break;
18844221 }
1885-case 0xFFFFFFFFFFFFFF8ELLU:
4222+case 0xFFFFFFFFFFFFFEEELLU:
18864223 /* SP = 5LLU */fputs("undefined function ", stderr);
18874224 {
18884225 /* CALLBEGIN */
@@ -1894,12 +4231,12 @@
18944231 {
18954232 /*CALLEND*/
18964233 stackbase += 7LLU;
1897- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8DLLU;
4234+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEDLLU;
18984235 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
18994236 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
19004237 break;
19014238 }
1902-case 0xFFFFFFFFFFFFFF8DLLU:
4239+case 0xFFFFFFFFFFFFFEEDLLU:
19034240 /* SP = 5LLU */fputs("\n", stderr); fputs("defined functions\n", stderr);
19044241 {
19054242 /* CALLBEGIN */
@@ -1911,21 +4248,23 @@
19114248 {
19124249 /*CALLEND*/
19134250 stackbase += 7LLU;
1914- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8CLLU;
4251+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEECLLU;
19154252 fnaddr = /*debugdefs_*/0x7E077089F821B800LLU;/* SP = 0LLU */
19164253 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugdefs_*/\n"); exit(-1); }
19174254 break;
19184255 }
1919-case 0xFFFFFFFFFFFFFF8CLLU:
1920-/* SP = 5LLU */exit(-1);/* SP = 5LLU *//* SP = 5LLU */
1921-{ /* JUMP */ fnaddr = 18446744073709551505LLU; break; } /* skip alternative */
1922-case 18446744073709551506LLU: /* alternative */
4256+case 0xFFFFFFFFFFFFFEECLLU:
4257+/* SP = 5LLU */exit(-1);/* SP = 5LLU */
4258+case 18446744073709551346LLU: /* skip to here */
4259+/* SP = 5LLU *//* SP = 5LLU */
4260+{ /* JUMP */ fnaddr = 18446744073709551350LLU; break; } /* skip alternative */
4261+case 18446744073709551351LLU: /* alternative */
19234262 { /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU */
1924-case 0xFFFFFFFFFFFFFF8BLLU: /* loop to here *//* predicate: list non-empty? */
4263+case 0xFFFFFFFFFFFFFEEBLLU: /* loop to here *//* predicate: list non-empty? */
19254264
19264265 { /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
19274266 if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
1928-{ /* JUMP */ fnaddr = 18446744073709551498LLU; break; } /* skip loop */
4267+{ /* JUMP */ fnaddr = 18446744073709551338LLU; break; } /* skip loop */
19294268 /* loop *//* predicate */
19304269
19314270 {
@@ -1939,15 +4278,15 @@
19394278 {
19404279 /*CALLEND*/
19414280 stackbase += 9LLU;
1942- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF87LLU;
4281+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE7LLU;
19434282 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
19444283 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
19454284 break;
19464285 }
1947-case 0xFFFFFFFFFFFFFF87LLU:
4286+case 0xFFFFFFFFFFFFFEE7LLU:
19484287 /* SP = 7LLU */
19494288 if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
1950-{ /* JUMP */ fnaddr = 18446744073709551497LLU; break; } /* skip consequent */
4289+{ /* JUMP */ fnaddr = 18446744073709551337LLU; break; } /* skip consequent */
19514290 /* consequent */
19524291 {
19534292 /* CALLBEGIN */
@@ -1960,16 +4299,16 @@
19604299 {
19614300 /*CALLEND*/
19624301 stackbase += 9LLU;
1963- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF86LLU;
4302+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE6LLU;
19644303 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
19654304 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
19664305 break;
19674306 }
1968-case 0xFFFFFFFFFFFFFF86LLU:
4307+case 0xFFFFFFFFFFFFFEE6LLU:
19694308 /* SP = 7LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
19704309 /* SP = 6LLU *//* SP = 6LLU */
1971-{ /* JUMP */ fnaddr = 18446744073709551496LLU; break; } /* skip alternative */
1972-case 18446744073709551497LLU: /* alternative *//* predicate */
4310+{ /* JUMP */ fnaddr = 18446744073709551336LLU; break; } /* skip alternative */
4311+case 18446744073709551337LLU: /* alternative *//* predicate */
19734312
19744313 {
19754314 /* CALLBEGIN */
@@ -1982,15 +4321,15 @@
19824321 {
19834322 /*CALLEND*/
19844323 stackbase += 9LLU;
1985- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF83LLU;
4324+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE3LLU;
19864325 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
19874326 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
19884327 break;
19894328 }
1990-case 0xFFFFFFFFFFFFFF83LLU:
4329+case 0xFFFFFFFFFFFFFEE3LLU:
19914330 /* SP = 7LLU */
19924331 if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
1993-{ /* JUMP */ fnaddr = 18446744073709551493LLU; break; } /* skip consequent */
4332+{ /* JUMP */ fnaddr = 18446744073709551333LLU; break; } /* skip consequent */
19944333 /* consequent */
19954334 { /* PUSH */ stack[stackbase + 6LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 2LLU]; }/* SP + 1LLU = 7LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
19964335
@@ -1999,18 +4338,18 @@
19994338 { /* PUSH */ stack[stackbase + 6LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 7LLU *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
20004339
20014340 {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 6LLU *//* SP = 6LLU */
2002-{ /* JUMP */ fnaddr = 18446744073709551492LLU; break; } /* skip alternative */
2003-case 18446744073709551493LLU: /* alternative */
4341+{ /* JUMP */ fnaddr = 18446744073709551332LLU; break; } /* skip alternative */
4342+case 18446744073709551333LLU: /* alternative */
20044343 { /* PUSH */ stack[stackbase + 6LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 7LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
20054344 /* SP = 6LLU */
2006-case 18446744073709551492LLU: /* skip to here */
4345+case 18446744073709551332LLU: /* skip to here */
20074346
2008-case 18446744073709551496LLU: /* skip to here */
4347+case 18446744073709551336LLU: /* skip to here */
20094348 /* SP = 6LLU */
20104349 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
2011-{ /* JUMP */ fnaddr = 18446744073709551499LLU; break; } /* loop */
2012-case 18446744073709551498LLU: /* skip to here *//* SP = 5LLU */
2013-case 18446744073709551505LLU: /* skip to here */
4350+{ /* JUMP */ fnaddr = 18446744073709551339LLU; break; } /* loop */
4351+case 18446744073709551338LLU: /* skip to here *//* SP = 5LLU */
4352+case 18446744073709551350LLU: /* skip to here */
20144353
20154354 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU */
20164355 { /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 7LLU */
@@ -2044,25 +4383,25 @@
20444383 {
20454384 /*CALLEND*/
20464385 stackbase += 11LLU;
2047- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF80LLU;
4386+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE0LLU;
20484387 fnaddr = /*existsdef_*/0x83392EBEE7E08400LLU;/* SP = 0LLU */
20494388 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*existsdef_*/\n"); exit(-1); }
20504389 break;
20514390 }
2052-case 0xFFFFFFFFFFFFFF80LLU:
4391+case 0xFFFFFFFFFFFFFEE0LLU:
20534392 /* SP = 9LLU */
20544393 {
20554394 /*CALLEND*/
20564395 stackbase += 8LLU;
2057- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7FLLU;
4396+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDFLLU;
20584397 fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
20594398 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
20604399 break;
20614400 }
2062-case 0xFFFFFFFFFFFFFF7FLLU:
4401+case 0xFFFFFFFFFFFFFEDFLLU:
20634402 /* SP = 6LLU */
20644403 if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
2065-{ /* JUMP */ fnaddr = 18446744073709551490LLU; break; } /* skip consequent */
4404+{ /* JUMP */ fnaddr = 18446744073709551330LLU; break; } /* skip consequent */
20664405 /* consequent */
20674406 {
20684407 /* CALLBEGIN */
@@ -2073,12 +4412,12 @@
20734412 {
20744413 /*CALLEND*/
20754414 stackbase += 7LLU;
2076- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7ELLU;
4415+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDELLU;
20774416 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
20784417 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
20794418 break;
20804419 }
2081-case 0xFFFFFFFFFFFFFF7ELLU:
4420+case 0xFFFFFFFFFFFFFEDELLU:
20824421 /* SP = 5LLU */fputs("undefined function ", stderr);
20834422 {
20844423 /* CALLBEGIN */
@@ -2090,12 +4429,12 @@
20904429 {
20914430 /*CALLEND*/
20924431 stackbase += 7LLU;
2093- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7DLLU;
4432+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDDLLU;
20944433 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
20954434 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
20964435 break;
20974436 }
2098-case 0xFFFFFFFFFFFFFF7DLLU:
4437+case 0xFFFFFFFFFFFFFEDDLLU:
20994438 /* SP = 5LLU */fputs("\n", stderr); fputs("defined functions\n", stderr);
21004439 {
21014440 /* CALLBEGIN */
@@ -2107,34 +4446,34 @@
21074446 {
21084447 /*CALLEND*/
21094448 stackbase += 7LLU;
2110- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7CLLU;
4449+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDCLLU;
21114450 fnaddr = /*debugdefs_*/0x7E077089F821B800LLU;/* SP = 0LLU */
21124451 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugdefs_*/\n"); exit(-1); }
21134452 break;
21144453 }
2115-case 0xFFFFFFFFFFFFFF7CLLU:
4454+case 0xFFFFFFFFFFFFFEDCLLU:
21164455 /* SP = 5LLU */exit(-1);/* SP = 5LLU *//* SP = 5LLU */
2117-{ /* JUMP */ fnaddr = 18446744073709551489LLU; break; } /* skip alternative */
2118-case 18446744073709551490LLU: /* alternative */
4456+{ /* JUMP */ fnaddr = 18446744073709551329LLU; break; } /* skip alternative */
4457+case 18446744073709551330LLU: /* alternative */
21194458 { /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU */
21204459 { /* PUSH */ stack[stackbase + 6LLU] = 0LLU; }/* SP + 1LLU = 7LLU */
21214460 { /* PUSH */ stack[stackbase + 7LLU] = 0LLU; }/* SP + 1LLU = 8LLU */
2122-case 0xFFFFFFFFFFFFFF7BLLU: /* loop to here *//* predicate: list non-empty? */
4461+case 0xFFFFFFFFFFFFFEDBLLU: /* loop to here *//* predicate: list non-empty? */
21234462
21244463 { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU */
21254464 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
2126-{ /* JUMP */ fnaddr = 18446744073709551482LLU; break; } /* skip loop */
4465+{ /* JUMP */ fnaddr = 18446744073709551322LLU; break; } /* skip loop */
21274466 /* loop *//* predicate */
21284467
21294468 { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 9LLU */
21304469 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
2131-{ /* JUMP */ fnaddr = 18446744073709551481LLU; break; } /* skip consequent */
4470+{ /* JUMP */ fnaddr = 18446744073709551321LLU; break; } /* skip consequent */
21324471 /* consequent */
2133-case 0xFFFFFFFFFFFFFF77LLU: /* loop to here *//* predicate: list non-empty? */
4472+case 0xFFFFFFFFFFFFFED7LLU: /* loop to here *//* predicate: list non-empty? */
21344473
21354474 { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU */
21364475 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
2137-{ /* JUMP */ fnaddr = 18446744073709551478LLU; break; } /* skip loop */
4476+{ /* JUMP */ fnaddr = 18446744073709551318LLU; break; } /* skip loop */
21384477 /* loop *//* predicate */
21394478
21404479 {
@@ -2148,15 +4487,15 @@
21484487 {
21494488 /*CALLEND*/
21504489 stackbase += 11LLU;
2151- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF73LLU;
4490+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFED3LLU;
21524491 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
21534492 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
21544493 break;
21554494 }
2156-case 0xFFFFFFFFFFFFFF73LLU:
4495+case 0xFFFFFFFFFFFFFED3LLU:
21574496 /* SP = 9LLU */
21584497 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
2159-{ /* JUMP */ fnaddr = 18446744073709551477LLU; break; } /* skip consequent */
4498+{ /* JUMP */ fnaddr = 18446744073709551317LLU; break; } /* skip consequent */
21604499 /* consequent */
21614500 { /* PUSH */ stack[stackbase + 8LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 2LLU]; }/* SP + 1LLU = 9LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */
21624501
@@ -2165,8 +4504,8 @@
21654504 {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}
21664505 { /* PUSH */ stack[stackbase + 8LLU] = 2LLU; }/* SP + 1LLU = 9LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */
21674506 /* SP = 8LLU *//* SP = 8LLU */
2168-{ /* JUMP */ fnaddr = 18446744073709551476LLU; break; } /* skip alternative */
2169-case 18446744073709551477LLU: /* alternative */
4507+{ /* JUMP */ fnaddr = 18446744073709551316LLU; break; } /* skip alternative */
4508+case 18446744073709551317LLU: /* alternative */
21704509 {
21714510 /* CALLBEGIN */
21724511 /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU */
@@ -2178,19 +4517,19 @@
21784517 {
21794518 /*CALLEND*/
21804519 stackbase += 11LLU;
2181- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF72LLU;
4520+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFED2LLU;
21824521 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
21834522 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
21844523 break;
21854524 }
2186-case 0xFFFFFFFFFFFFFF72LLU:
4525+case 0xFFFFFFFFFFFFFED2LLU:
21874526 /* SP = 9LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */
21884527 /* SP = 8LLU */
2189-case 18446744073709551476LLU: /* skip to here */
4528+case 18446744073709551316LLU: /* skip to here */
21904529 /* SP = 8LLU */
21914530 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
2192-{ /* JUMP */ fnaddr = 18446744073709551479LLU; break; } /* loop */
2193-case 18446744073709551478LLU: /* skip to here *//* predicate */
4531+{ /* JUMP */ fnaddr = 18446744073709551319LLU; break; } /* loop */
4532+case 18446744073709551318LLU: /* skip to here *//* predicate */
21944533
21954534 {
21964535 /* CALLBEGIN */
@@ -2203,15 +4542,15 @@
22034542 {
22044543 /*CALLEND*/
22054544 stackbase += 11LLU;
2206- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF70LLU;
4545+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFED0LLU;
22074546 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
22084547 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
22094548 break;
22104549 }
2211-case 0xFFFFFFFFFFFFFF70LLU:
4550+case 0xFFFFFFFFFFFFFED0LLU:
22124551 /* SP = 9LLU */
22134552 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
2214-{ /* JUMP */ fnaddr = 18446744073709551473LLU; break; } /* skip consequent */
4553+{ /* JUMP */ fnaddr = 18446744073709551313LLU; break; } /* skip consequent */
22154554 /* consequent */
22164555 {
22174556 /* CALLBEGIN */
@@ -2222,12 +4561,12 @@
22224561 {
22234562 /*CALLEND*/
22244563 stackbase += 10LLU;
2225- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6FLLU;
4564+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFECFLLU;
22264565 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
22274566 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
22284567 break;
22294568 }
2230-case 0xFFFFFFFFFFFFFF6FLLU:
4569+case 0xFFFFFFFFFFFFFECFLLU:
22314570 /* SP = 8LLU */fputs("call to ", stderr);
22324571 {
22334572 /* CALLBEGIN */
@@ -2239,12 +4578,12 @@
22394578 {
22404579 /*CALLEND*/
22414580 stackbase += 10LLU;
2242- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6ELLU;
4581+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFECELLU;
22434582 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
22444583 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
22454584 break;
22464585 }
2247-case 0xFFFFFFFFFFFFFF6ELLU:
4586+case 0xFFFFFFFFFFFFFECELLU:
22484587 /* SP = 8LLU */fputs(" argument-count ", stderr); fputs("exceeds parameter-count ", stderr);
22494588 {
22504589 /* CALLBEGIN */
@@ -2256,16 +4595,16 @@
22564595 {
22574596 /*CALLEND*/
22584597 stackbase += 10LLU;
2259- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6DLLU;
4598+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFECDLLU;
22604599 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
22614600 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
22624601 break;
22634602 }
2264-case 0xFFFFFFFFFFFFFF6DLLU:
4603+case 0xFFFFFFFFFFFFFECDLLU:
22654604 /* SP = 8LLU */fputs("\n", stderr); exit(-1);/* SP = 8LLU */
2266-case 18446744073709551473LLU: /* alternative *//* SP = 8LLU *//* SP = 8LLU */
2267-{ /* JUMP */ fnaddr = 18446744073709551480LLU; break; } /* skip alternative */
2268-case 18446744073709551481LLU: /* alternative *//* predicate */
4605+case 18446744073709551313LLU: /* alternative *//* SP = 8LLU *//* SP = 8LLU */
4606+{ /* JUMP */ fnaddr = 18446744073709551320LLU; break; } /* skip alternative */
4607+case 18446744073709551321LLU: /* alternative *//* predicate */
22694608
22704609 {
22714610 /* CALLBEGIN */
@@ -2278,15 +4617,15 @@
22784617 {
22794618 /*CALLEND*/
22804619 stackbase += 11LLU;
2281- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6ALLU;
4620+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFECALLU;
22824621 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
22834622 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
22844623 break;
22854624 }
2286-case 0xFFFFFFFFFFFFFF6ALLU:
4625+case 0xFFFFFFFFFFFFFECALLU:
22874626 /* SP = 9LLU */
22884627 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
2289-{ /* JUMP */ fnaddr = 18446744073709551468LLU; break; } /* skip consequent */
4628+{ /* JUMP */ fnaddr = 18446744073709551308LLU; break; } /* skip consequent */
22904629 /* consequent */
22914630 {
22924631 /* CALLBEGIN */
@@ -2299,16 +4638,16 @@
22994638 {
23004639 /*CALLEND*/
23014640 stackbase += 11LLU;
2302- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF69LLU;
4641+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC9LLU;
23034642 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
23044643 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
23054644 break;
23064645 }
2307-case 0xFFFFFFFFFFFFFF69LLU:
4646+case 0xFFFFFFFFFFFFFEC9LLU:
23084647 /* SP = 9LLU *//* LOCAL VAR */ stack[stackbase + 7LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */
23094648 /* SP = 8LLU *//* SP = 8LLU */
2310-{ /* JUMP */ fnaddr = 18446744073709551467LLU; break; } /* skip alternative */
2311-case 18446744073709551468LLU: /* alternative *//* predicate */
4649+{ /* JUMP */ fnaddr = 18446744073709551307LLU; break; } /* skip alternative */
4650+case 18446744073709551308LLU: /* alternative *//* predicate */
23124651
23134652 {
23144653 /* CALLBEGIN */
@@ -2321,47 +4660,929 @@
23214660 {
23224661 /*CALLEND*/
23234662 stackbase += 11LLU;
2324- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF66LLU;
4663+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC6LLU;
23254664 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
23264665 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
23274666 break;
23284667 }
2329-case 0xFFFFFFFFFFFFFF66LLU:
4668+case 0xFFFFFFFFFFFFFEC6LLU:
23304669 /* SP = 9LLU */
23314670 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
2332-{ /* JUMP */ fnaddr = 18446744073709551464LLU; break; } /* skip consequent */
4671+{ /* JUMP */ fnaddr = 18446744073709551304LLU; break; } /* skip consequent */
23334672 /* consequent */
23344673 { /* PUSH */ stack[stackbase + 8LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 9LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */
23354674
23364675 { /* PUSH */ stack[stackbase + 8LLU] = 1LLU; }/* SP + 1LLU = 9LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */
23374676 /* SP = 8LLU *//* SP = 8LLU */
2338-{ /* JUMP */ fnaddr = 18446744073709551463LLU; break; } /* skip alternative */
2339-case 18446744073709551464LLU: /* alternative */
4677+{ /* JUMP */ fnaddr = 18446744073709551303LLU; break; } /* skip alternative */
4678+case 18446744073709551304LLU: /* alternative */
23404679 { /* PUSH */ stack[stackbase + 8LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 9LLU *//* LOCAL VAR */ stack[stackbase + 7LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */
23414680 /* SP = 8LLU */
2342-case 18446744073709551463LLU: /* skip to here */
4681+case 18446744073709551303LLU: /* skip to here */
23434682
2344-case 18446744073709551467LLU: /* skip to here */
4683+case 18446744073709551307LLU: /* skip to here */
23454684 /* SP = 8LLU */
2346-case 18446744073709551480LLU: /* skip to here */
4685+case 18446744073709551320LLU: /* skip to here */
23474686 /* SP = 8LLU */
23484687 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
2349-{ /* JUMP */ fnaddr = 18446744073709551483LLU; break; } /* loop */
2350-case 18446744073709551482LLU: /* skip to here *//* SP = 5LLU */
2351-case 18446744073709551489LLU: /* skip to here */
4688+{ /* JUMP */ fnaddr = 18446744073709551323LLU; break; } /* loop */
4689+case 18446744073709551322LLU: /* skip to here *//* SP = 5LLU */
4690+case 18446744073709551329LLU: /* skip to here */
23524691
2353-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */
2354-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 4LLU *//* SP - 1LLU = 3LLU */
2355-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }
4692+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 6LLU */
4693+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 7LLU *//* SP - 2LLU = 5LLU */
4694+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }
4695+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP = 5LLU *//* SP - 2LLU = 3LLU */
4696+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551612LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }
4697+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }
23564698 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
23574699 /* function requires 13LLU 64-bit chunks of memory (including 3LLU for parameters) */
4700+case /*getdefelem*/0x8A0BDF8218278280LLU:/* SP = 3LLU *//* SPMAX = 3LLU */
4701+{ /* PUSH */ stack[stackbase + 3LLU] = 0LLU; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
4702+{ /* PUSH */ stack[stackbase + 4LLU] = 0LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
4703+{ /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
4704+{ /* PUSH */ stack[stackbase + 6LLU] = 0LLU; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
4705+case 0xFFFFFFFFFFFFFEC5LLU: /* loop to here *//* predicate: list non-empty? */
4706+
4707+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
4708+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4709+{ /* JUMP */ fnaddr = 18446744073709551300LLU; break; } /* skip loop */
4710+/* loop *//* predicate */
4711+
4712+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP + 1LLU = 8LLU */
4713+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4714+{ /* JUMP */ fnaddr = 18446744073709551299LLU; break; } /* skip consequent */
4715+/* consequent */
4716+case 0xFFFFFFFFFFFFFEC1LLU: /* loop to here *//* predicate: list non-empty? */
4717+
4718+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU */
4719+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4720+{ /* JUMP */ fnaddr = 18446744073709551296LLU; break; } /* skip loop */
4721+/* loop *//* predicate */
4722+
4723+ {
4724+ /* CALLBEGIN */
4725+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4726+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
4727+ /* leave place for return addr *//* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
4728+ }
4729+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
4730+{ /* PUSH */ stack[stackbase + 11LLU] = 0LLU; }/* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
4731+ {
4732+ /*CALLEND*/
4733+ stackbase += 10LLU;
4734+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBDLLU;
4735+ fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
4736+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
4737+ break;
4738+ }
4739+case 0xFFFFFFFFFFFFFEBDLLU:
4740+/* SP = 8LLU */
4741+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4742+{ /* JUMP */ fnaddr = 18446744073709551295LLU; break; } /* skip consequent */
4743+/* consequent */
4744+ {
4745+ /* CALLBEGIN */
4746+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4747+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
4748+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
4749+ }
4750+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 11LLU */
4751+{ /* PUSH */ stack[stackbase + 11LLU] = 1LLU; }/* SP + 1LLU = 12LLU */
4752+ {
4753+ /*CALLEND*/
4754+ stackbase += 10LLU;
4755+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBCLLU;
4756+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4757+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4758+ break;
4759+ }
4760+case 0xFFFFFFFFFFFFFEBCLLU:
4761+/* SP = 8LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4762+/* predicate */
4763+
4764+ {
4765+ /* CALLBEGIN */
4766+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4767+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
4768+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
4769+ }
4770+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 11LLU */
4771+{ /* PUSH */ stack[stackbase + 11LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 1LLU]; }/* SP + 1LLU = 12LLU */
4772+ {
4773+ /*CALLEND*/
4774+ stackbase += 10LLU;
4775+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBALLU;
4776+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
4777+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
4778+ break;
4779+ }
4780+case 0xFFFFFFFFFFFFFEBALLU:
4781+/* SP = 8LLU */
4782+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4783+{ /* JUMP */ fnaddr = 18446744073709551291LLU; break; } /* skip consequent */
4784+/* consequent */
4785+{ /* PUSH */ stack[stackbase + 7LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 2LLU]; }/* SP + 1LLU = 8LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4786+
4787+{ /* PUSH */ stack[stackbase + 7LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 3LLU]; }/* SP + 1LLU = 8LLU *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4788+
4789+{/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}
4790+{ /* PUSH */ stack[stackbase + 7LLU] = 2LLU; }/* SP + 1LLU = 8LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4791+/* SP = 7LLU */
4792+case 18446744073709551291LLU: /* alternative *//* SP = 7LLU *//* SP = 7LLU */
4793+{ /* JUMP */ fnaddr = 18446744073709551294LLU; break; } /* skip alternative */
4794+case 18446744073709551295LLU: /* alternative */
4795+{/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 7LLU */
4796+case 18446744073709551294LLU: /* skip to here */
4797+/* SP = 7LLU */
4798+{ /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
4799+{ /* JUMP */ fnaddr = 18446744073709551297LLU; break; } /* loop */
4800+case 18446744073709551296LLU: /* skip to here *//* predicate */
4801+
4802+ {
4803+ /* CALLBEGIN */
4804+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4805+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
4806+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
4807+ }
4808+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP + 1LLU = 11LLU */
4809+{ /* PUSH */ stack[stackbase + 11LLU] = 1LLU; }/* SP + 1LLU = 12LLU */
4810+ {
4811+ /*CALLEND*/
4812+ stackbase += 10LLU;
4813+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB8LLU;
4814+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
4815+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
4816+ break;
4817+ }
4818+case 0xFFFFFFFFFFFFFEB8LLU:
4819+/* SP = 8LLU */
4820+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4821+{ /* JUMP */ fnaddr = 18446744073709551289LLU; break; } /* skip consequent */
4822+/* consequent */
4823+ {
4824+ /* CALLBEGIN */
4825+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
4826+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4827+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
4828+ }
4829+ {
4830+ /*CALLEND*/
4831+ stackbase += 9LLU;
4832+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB7LLU;
4833+ fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
4834+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
4835+ break;
4836+ }
4837+case 0xFFFFFFFFFFFFFEB7LLU:
4838+/* SP = 7LLU */fputs("struct ", stderr);
4839+ {
4840+ /* CALLBEGIN */
4841+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
4842+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4843+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
4844+ }
4845+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 10LLU */
4846+ {
4847+ /*CALLEND*/
4848+ stackbase += 9LLU;
4849+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB6LLU;
4850+ fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
4851+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
4852+ break;
4853+ }
4854+case 0xFFFFFFFFFFFFFEB6LLU:
4855+/* SP = 7LLU */fputs(" has no element ", stderr);
4856+ {
4857+ /* CALLBEGIN */
4858+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
4859+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4860+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
4861+ }
4862+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 10LLU */
4863+ {
4864+ /*CALLEND*/
4865+ stackbase += 9LLU;
4866+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB5LLU;
4867+ fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
4868+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
4869+ break;
4870+ }
4871+case 0xFFFFFFFFFFFFFEB5LLU:
4872+/* SP = 7LLU */fputs("\n", stderr); exit(-1);/* SP = 7LLU */
4873+case 18446744073709551289LLU: /* alternative *//* SP = 7LLU *//* SP = 7LLU */
4874+{ /* JUMP */ fnaddr = 18446744073709551298LLU; break; } /* skip alternative */
4875+case 18446744073709551299LLU: /* alternative *//* predicate */
4876+
4877+ {
4878+ /* CALLBEGIN */
4879+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4880+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
4881+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
4882+ }
4883+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 11LLU */
4884+{ /* PUSH */ stack[stackbase + 11LLU] = 0LLU; }/* SP + 1LLU = 12LLU */
4885+ {
4886+ /*CALLEND*/
4887+ stackbase += 10LLU;
4888+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB2LLU;
4889+ fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
4890+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
4891+ break;
4892+ }
4893+case 0xFFFFFFFFFFFFFEB2LLU:
4894+/* SP = 8LLU */
4895+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4896+{ /* JUMP */ fnaddr = 18446744073709551284LLU; break; } /* skip consequent */
4897+/* consequent */
4898+ {
4899+ /* CALLBEGIN */
4900+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4901+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
4902+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
4903+ }
4904+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 11LLU */
4905+{ /* PUSH */ stack[stackbase + 11LLU] = 1LLU; }/* SP + 1LLU = 12LLU */
4906+ {
4907+ /*CALLEND*/
4908+ stackbase += 10LLU;
4909+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB1LLU;
4910+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4911+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4912+ break;
4913+ }
4914+case 0xFFFFFFFFFFFFFEB1LLU:
4915+/* SP = 8LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4916+/* SP = 7LLU *//* SP = 7LLU */
4917+{ /* JUMP */ fnaddr = 18446744073709551283LLU; break; } /* skip alternative */
4918+case 18446744073709551284LLU: /* alternative *//* predicate */
4919+
4920+ {
4921+ /* CALLBEGIN */
4922+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4923+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
4924+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
4925+ }
4926+ {
4927+ /* CALLBEGIN */
4928+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
4929+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
4930+ /* leave place for return addr *//* SP + 1LLU = 13LLU *//* SPMAX = 13LLU */
4931+ }
4932+{ /* PUSH */ stack[stackbase + 13LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 14LLU *//* SPMAX = 14LLU */
4933+{ /* PUSH */ stack[stackbase + 14LLU] = 16LLU; }/* SP + 1LLU = 15LLU *//* SPMAX = 15LLU */
4934+ {
4935+ /*CALLEND*/
4936+ stackbase += 13LLU;
4937+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEAELLU;
4938+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
4939+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
4940+ break;
4941+ }
4942+case 0xFFFFFFFFFFFFFEAELLU:
4943+/* SP = 11LLU */
4944+ {
4945+ /* CALLBEGIN */
4946+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 12LLU */
4947+{ /* PUSH */ stack[stackbase + 12LLU] = stackbase; }/* SP + 1LLU = 13LLU */
4948+ /* leave place for return addr *//* SP + 1LLU = 14LLU */
4949+ }
4950+{ /* PUSH */ stack[stackbase + 14LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 1LLU]; }/* SP + 1LLU = 15LLU */
4951+{ /* PUSH */ stack[stackbase + 15LLU] = 16LLU; }/* SP + 1LLU = 16LLU *//* SPMAX = 16LLU */
4952+ {
4953+ /*CALLEND*/
4954+ stackbase += 14LLU;
4955+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEADLLU;
4956+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
4957+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
4958+ break;
4959+ }
4960+case 0xFFFFFFFFFFFFFEADLLU:
4961+/* SP = 12LLU */
4962+ {
4963+ /*CALLEND*/
4964+ stackbase += 10LLU;
4965+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEACLLU;
4966+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
4967+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
4968+ break;
4969+ }
4970+case 0xFFFFFFFFFFFFFEACLLU:
4971+/* SP = 8LLU */
4972+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
4973+{ /* JUMP */ fnaddr = 18446744073709551280LLU; break; } /* skip consequent */
4974+/* consequent */
4975+{ /* PUSH */ stack[stackbase + 7LLU] = 1LLU; }/* SP + 1LLU = 8LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4976+
4977+{ /* PUSH */ stack[stackbase + 7LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 8LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4978+/* SP = 7LLU *//* SP = 7LLU */
4979+{ /* JUMP */ fnaddr = 18446744073709551279LLU; break; } /* skip alternative */
4980+case 18446744073709551280LLU: /* alternative */
4981+{ /* PUSH */ stack[stackbase + 7LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 8LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]; /* POP */
4982+/* SP = 7LLU */
4983+case 18446744073709551279LLU: /* skip to here */
4984+
4985+case 18446744073709551283LLU: /* skip to here */
4986+/* SP = 7LLU */
4987+case 18446744073709551298LLU: /* skip to here */
4988+/* SP = 7LLU */
4989+{ /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
4990+{ /* JUMP */ fnaddr = 18446744073709551301LLU; break; } /* loop */
4991+case 18446744073709551300LLU: /* skip to here *//* predicate */
4992+
4993+ {
4994+ /* CALLBEGIN */
4995+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
4996+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
4997+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
4998+ }
4999+{ /* PUSH */ stack[stackbase + 10LLU] = 2LLU; }/* SP + 1LLU = 11LLU */
5000+{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP + 1LLU = 12LLU */
5001+ {
5002+ /*CALLEND*/
5003+ stackbase += 10LLU;
5004+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEAALLU;
5005+ fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
5006+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
5007+ break;
5008+ }
5009+case 0xFFFFFFFFFFFFFEAALLU:
5010+/* SP = 8LLU */
5011+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
5012+{ /* JUMP */ fnaddr = 18446744073709551275LLU; break; } /* skip consequent */
5013+/* consequent */
5014+ {
5015+ /* CALLBEGIN */
5016+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
5017+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
5018+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
5019+ }
5020+ {
5021+ /*CALLEND*/
5022+ stackbase += 9LLU;
5023+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA9LLU;
5024+ fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
5025+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
5026+ break;
5027+ }
5028+case 0xFFFFFFFFFFFFFEA9LLU:
5029+/* SP = 7LLU */fputs("undefined struct ", stderr);
5030+ {
5031+ /* CALLBEGIN */
5032+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
5033+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
5034+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
5035+ }
5036+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 10LLU */
5037+ {
5038+ /*CALLEND*/
5039+ stackbase += 9LLU;
5040+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA8LLU;
5041+ fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
5042+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
5043+ break;
5044+ }
5045+case 0xFFFFFFFFFFFFFEA8LLU:
5046+/* SP = 7LLU */fputs("\n", stderr); fputs("defined functions\n", stderr);
5047+ {
5048+ /* CALLBEGIN */
5049+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
5050+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
5051+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
5052+ }
5053+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 10LLU */
5054+ {
5055+ /*CALLEND*/
5056+ stackbase += 9LLU;
5057+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA7LLU;
5058+ fnaddr = /*debugdefs_*/0x7E077089F821B800LLU;/* SP = 0LLU */
5059+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugdefs_*/\n"); exit(-1); }
5060+ break;
5061+ }
5062+case 0xFFFFFFFFFFFFFEA7LLU:
5063+/* SP = 7LLU */exit(-1);/* SP = 7LLU */
5064+case 18446744073709551275LLU: /* alternative */
5065+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 8LLU */
5066+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 9LLU *//* SP - 2LLU = 7LLU */
5067+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }
5068+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 8LLU]; }/* SP = 5LLU *//* SP - 2LLU = 3LLU */
5069+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551612LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }
5070+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }
5071+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5072+/* function requires 16LLU 64-bit chunks of memory (including 3LLU for parameters) */
5073+case /*typesize__*/0xBF4AE0BA4D600000LLU:/* SP = 2LLU *//* SPMAX = 2LLU *//* predicate */
5074+
5075+ {
5076+ /* CALLBEGIN */
5077+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
5078+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
5079+ /* leave place for return addr *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
5080+ }
5081+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
5082+ {
5083+ /*CALLEND*/
5084+ stackbase += 5LLU;
5085+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA4LLU;
5086+ fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
5087+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); }
5088+ break;
5089+ }
5090+case 0xFFFFFFFFFFFFFEA4LLU:
5091+/* SP = 3LLU */
5092+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
5093+{ /* JUMP */ fnaddr = 18446744073709551270LLU; break; } /* skip consequent */
5094+/* consequent */
5095+{ /* PUSH */ stack[stackbase + 2LLU] = 1LLU; }/* SP + 1LLU = 3LLU *//* SP - 1LLU = 2LLU */
5096+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 3LLU *//* SP = 2LLU */
5097+{ /* JUMP */ fnaddr = 18446744073709551269LLU; break; } /* skip alternative */
5098+case 18446744073709551270LLU: /* alternative *//* predicate */
5099+
5100+ {
5101+ /* CALLBEGIN */
5102+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
5103+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
5104+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
5105+ }
5106+ {
5107+ /* CALLBEGIN */
5108+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5109+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
5110+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
5111+ }
5112+ {
5113+ /* CALLBEGIN */
5114+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
5115+{ /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
5116+ /* leave place for return addr *//* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
5117+ }
5118+{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
5119+ {
5120+ /*CALLEND*/
5121+ stackbase += 11LLU;
5122+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA1LLU;
5123+ fnaddr = /*typetosub_*/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
5124+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosub_*/\n"); exit(-1); }
5125+ break;
5126+ }
5127+case 0xFFFFFFFFFFFFFEA1LLU:
5128+/* SP = 9LLU */
5129+ {
5130+ /*CALLEND*/
5131+ stackbase += 8LLU;
5132+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA0LLU;
5133+ fnaddr = /*subisid___*/0xBB0764BA47C00000LLU;/* SP = 0LLU */
5134+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subisid___*/\n"); exit(-1); }
5135+ break;
5136+ }
5137+case 0xFFFFFFFFFFFFFEA0LLU:
5138+/* SP = 6LLU */
5139+ {
5140+ /*CALLEND*/
5141+ stackbase += 5LLU;
5142+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9FLLU;
5143+ fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
5144+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
5145+ break;
5146+ }
5147+case 0xFFFFFFFFFFFFFE9FLLU:
5148+/* SP = 3LLU */
5149+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
5150+{ /* JUMP */ fnaddr = 18446744073709551267LLU; break; } /* skip consequent */
5151+/* consequent */
5152+ {
5153+ /* CALLBEGIN */
5154+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
5155+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
5156+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
5157+ }
5158+ {
5159+ /* CALLBEGIN */
5160+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5161+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5162+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5163+ }
5164+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 9LLU */
5165+ {
5166+ /*CALLEND*/
5167+ stackbase += 8LLU;
5168+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ELLU;
5169+ fnaddr = /*typetosub_*/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
5170+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosub_*/\n"); exit(-1); }
5171+ break;
5172+ }
5173+case 0xFFFFFFFFFFFFFE9ELLU:
5174+/* SP = 6LLU */
5175+ {
5176+ /*CALLEND*/
5177+ stackbase += 5LLU;
5178+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9DLLU;
5179+ fnaddr = /*subtosize_*/0xBB076FAAE9358000LLU;/* SP = 0LLU */
5180+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtosize_*/\n"); exit(-1); }
5181+ break;
5182+ }
5183+case 0xFFFFFFFFFFFFFE9DLLU:
5184+/* SP = 3LLU *//* SP - 1LLU = 2LLU */
5185+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 3LLU *//* SP = 2LLU */
5186+{ /* JUMP */ fnaddr = 18446744073709551266LLU; break; } /* skip alternative */
5187+case 18446744073709551267LLU: /* alternative */
5188+{ /* PUSH */ stack[stackbase + 2LLU] = 0LLU; }/* SP + 1LLU = 3LLU */
5189+{ /* PUSH */ stack[stackbase + 3LLU] = 0LLU; }/* SP + 1LLU = 4LLU */
5190+{ /* PUSH */ stack[stackbase + 4LLU] = 0LLU; }/* SP + 1LLU = 5LLU */
5191+case 0xFFFFFFFFFFFFFE9CLLU: /* loop to here *//* predicate: list non-empty? */
5192+
5193+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
5194+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
5195+{ /* JUMP */ fnaddr = 18446744073709551259LLU; break; } /* skip loop */
5196+/* loop *//* predicate */
5197+
5198+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 6LLU */
5199+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
5200+{ /* JUMP */ fnaddr = 18446744073709551258LLU; break; } /* skip consequent */
5201+/* consequent */
5202+case 0xFFFFFFFFFFFFFE98LLU: /* loop to here *//* predicate: list non-empty? */
5203+
5204+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
5205+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
5206+{ /* JUMP */ fnaddr = 18446744073709551255LLU; break; } /* skip loop */
5207+/* loop *//* predicate */
5208+
5209+ {
5210+ /* CALLBEGIN */
5211+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5212+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5213+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5214+ }
5215+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 9LLU */
5216+{ /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */
5217+ {
5218+ /*CALLEND*/
5219+ stackbase += 8LLU;
5220+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE94LLU;
5221+ fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
5222+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
5223+ break;
5224+ }
5225+case 0xFFFFFFFFFFFFFE94LLU:
5226+/* SP = 6LLU */
5227+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
5228+{ /* JUMP */ fnaddr = 18446744073709551254LLU; break; } /* skip consequent */
5229+/* consequent */
5230+ {
5231+ /* CALLBEGIN */
5232+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5233+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5234+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5235+ }
5236+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 9LLU */
5237+{ /* PUSH */ stack[stackbase + 9LLU] = 1LLU; }/* SP + 1LLU = 10LLU */
5238+ {
5239+ /*CALLEND*/
5240+ stackbase += 8LLU;
5241+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE93LLU;
5242+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
5243+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
5244+ break;
5245+ }
5246+case 0xFFFFFFFFFFFFFE93LLU:
5247+/* SP = 6LLU *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
5248+
5249+ {
5250+ /* CALLBEGIN */
5251+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5252+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5253+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5254+ }
5255+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 9LLU */
5256+ {
5257+ /* CALLBEGIN */
5258+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
5259+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
5260+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
5261+ }
5262+{ /* PUSH */ stack[stackbase + 12LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 13LLU *//* SPMAX = 13LLU */
5263+{ /* PUSH */ stack[stackbase + 13LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 3LLU]; }/* SP + 1LLU = 14LLU *//* SPMAX = 14LLU */
5264+ {
5265+ /*CALLEND*/
5266+ stackbase += 12LLU;
5267+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE92LLU;
5268+ fnaddr = /*typesize__*/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
5269+if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typesize__*/\n"); exit(-1); }
5270+ break;
5271+ }
5272+case 0xFFFFFFFFFFFFFE92LLU:
5273+/* SP = 10LLU */
5274+ {
5275+ /*CALLEND*/
5276+ stackbase += 8LLU;
5277+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE91LLU;
5278+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
5279+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
5280+ break;
5281+ }
5282+case 0xFFFFFFFFFFFFFE91LLU:
5283+/* SP = 6LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
5284+/* SP = 5LLU *//* SP = 5LLU */
5285+{ /* JUMP */ fnaddr = 18446744073709551253LLU; break; } /* skip alternative */
5286+case 18446744073709551254LLU: /* alternative */
5287+{/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 5LLU */
5288+case 18446744073709551253LLU: /* skip to here */
5289+/* SP = 5LLU */
5290+{ /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
5291+{ /* JUMP */ fnaddr = 18446744073709551256LLU; break; } /* loop */
5292+case 18446744073709551255LLU: /* skip to here */
5293+{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
5294+/* SP = 5LLU *//* SP = 5LLU */
5295+{ /* JUMP */ fnaddr = 18446744073709551257LLU; break; } /* skip alternative */
5296+case 18446744073709551258LLU: /* alternative *//* predicate */
5297+
5298+ {
5299+ /* CALLBEGIN */
5300+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5301+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5302+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5303+ }
5304+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 9LLU */
5305+{ /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */
5306+ {
5307+ /*CALLEND*/
5308+ stackbase += 8LLU;
5309+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ELLU;
5310+ fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
5311+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
5312+ break;
5313+ }
5314+case 0xFFFFFFFFFFFFFE8ELLU:
5315+/* SP = 6LLU */
5316+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
5317+{ /* JUMP */ fnaddr = 18446744073709551248LLU; break; } /* skip consequent */
5318+/* consequent */
5319+ {
5320+ /* CALLBEGIN */
5321+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5322+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5323+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5324+ }
5325+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 9LLU */
5326+{ /* PUSH */ stack[stackbase + 9LLU] = 1LLU; }/* SP + 1LLU = 10LLU */
5327+ {
5328+ /*CALLEND*/
5329+ stackbase += 8LLU;
5330+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8DLLU;
5331+ fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
5332+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
5333+ break;
5334+ }
5335+case 0xFFFFFFFFFFFFFE8DLLU:
5336+/* SP = 6LLU *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
5337+/* SP = 5LLU *//* SP = 5LLU */
5338+{ /* JUMP */ fnaddr = 18446744073709551247LLU; break; } /* skip alternative */
5339+case 18446744073709551248LLU: /* alternative *//* predicate */
5340+
5341+ {
5342+ /* CALLBEGIN */
5343+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5344+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5345+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5346+ }
5347+ {
5348+ /* CALLBEGIN */
5349+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU */
5350+{ /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU */
5351+ /* leave place for return addr *//* SP + 1LLU = 11LLU */
5352+ }
5353+{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 12LLU */
5354+{ /* PUSH */ stack[stackbase + 12LLU] = 16LLU; }/* SP + 1LLU = 13LLU */
5355+ {
5356+ /*CALLEND*/
5357+ stackbase += 11LLU;
5358+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ALLU;
5359+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
5360+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
5361+ break;
5362+ }
5363+case 0xFFFFFFFFFFFFFE8ALLU:
5364+/* SP = 9LLU */
5365+ {
5366+ /* CALLBEGIN */
5367+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
5368+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
5369+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
5370+ }
5371+{ /* PUSH */ stack[stackbase + 12LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 1LLU]; }/* SP + 1LLU = 13LLU */
5372+{ /* PUSH */ stack[stackbase + 13LLU] = 16LLU; }/* SP + 1LLU = 14LLU */
5373+ {
5374+ /*CALLEND*/
5375+ stackbase += 12LLU;
5376+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE89LLU;
5377+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
5378+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
5379+ break;
5380+ }
5381+case 0xFFFFFFFFFFFFFE89LLU:
5382+/* SP = 10LLU */
5383+ {
5384+ /*CALLEND*/
5385+ stackbase += 8LLU;
5386+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE88LLU;
5387+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
5388+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
5389+ break;
5390+ }
5391+case 0xFFFFFFFFFFFFFE88LLU:
5392+/* SP = 6LLU */
5393+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
5394+{ /* JUMP */ fnaddr = 18446744073709551244LLU; break; } /* skip consequent */
5395+/* consequent */
5396+{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
5397+
5398+{ /* PUSH */ stack[stackbase + 5LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 6LLU *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
5399+/* SP = 5LLU *//* SP = 5LLU */
5400+{ /* JUMP */ fnaddr = 18446744073709551243LLU; break; } /* skip alternative */
5401+case 18446744073709551244LLU: /* alternative */
5402+{ /* PUSH */ stack[stackbase + 5LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 6LLU *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
5403+/* SP = 5LLU */
5404+case 18446744073709551243LLU: /* skip to here */
5405+
5406+case 18446744073709551247LLU: /* skip to here */
5407+/* SP = 5LLU */
5408+case 18446744073709551257LLU: /* skip to here */
5409+/* SP = 5LLU */
5410+{ /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
5411+{ /* JUMP */ fnaddr = 18446744073709551260LLU; break; } /* loop */
5412+case 18446744073709551259LLU: /* skip to here *//* predicate */
5413+
5414+ {
5415+ /* CALLBEGIN */
5416+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
5417+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
5418+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
5419+ }
5420+{ /* PUSH */ stack[stackbase + 8LLU] = 2LLU; }/* SP + 1LLU = 9LLU */
5421+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 10LLU */
5422+ {
5423+ /*CALLEND*/
5424+ stackbase += 8LLU;
5425+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE86LLU;
5426+ fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
5427+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
5428+ break;
5429+ }
5430+case 0xFFFFFFFFFFFFFE86LLU:
5431+/* SP = 6LLU */
5432+if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
5433+{ /* JUMP */ fnaddr = 18446744073709551239LLU; break; } /* skip consequent */
5434+/* consequent */
5435+ {
5436+ /* CALLBEGIN */
5437+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 5LLU */
5438+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
5439+ /* leave place for return addr *//* SP + 1LLU = 7LLU */
5440+ }
5441+ {
5442+ /*CALLEND*/
5443+ stackbase += 7LLU;
5444+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE85LLU;
5445+ fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
5446+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
5447+ break;
5448+ }
5449+case 0xFFFFFFFFFFFFFE85LLU:
5450+/* SP = 5LLU */fputs("undefined struct' ", stderr);
5451+ {
5452+ /* CALLBEGIN */
5453+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 5LLU */
5454+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
5455+ /* leave place for return addr *//* SP + 1LLU = 7LLU */
5456+ }
5457+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 8LLU */
5458+ {
5459+ /*CALLEND*/
5460+ stackbase += 7LLU;
5461+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE84LLU;
5462+ fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
5463+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
5464+ break;
5465+ }
5466+case 0xFFFFFFFFFFFFFE84LLU:
5467+/* SP = 5LLU */fputs("\n", stderr); fputs("defined functions\n", stderr);
5468+ {
5469+ /* CALLBEGIN */
5470+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 5LLU */
5471+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
5472+ /* leave place for return addr *//* SP + 1LLU = 7LLU */
5473+ }
5474+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 8LLU */
5475+ {
5476+ /*CALLEND*/
5477+ stackbase += 7LLU;
5478+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE83LLU;
5479+ fnaddr = /*debugdefs_*/0x7E077089F821B800LLU;/* SP = 0LLU */
5480+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugdefs_*/\n"); exit(-1); }
5481+ break;
5482+ }
5483+case 0xFFFFFFFFFFFFFE83LLU:
5484+/* SP = 5LLU */exit(-1);/* SP = 5LLU */
5485+case 18446744073709551239LLU: /* alternative */
5486+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */
5487+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 3LLU */
5488+case 18446744073709551266LLU: /* skip to here */
5489+
5490+case 18446744073709551269LLU: /* skip to here */
5491+/* SP - 1LLU = 2LLU */
5492+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */
5493+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }
5494+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5495+/* function requires 14LLU 64-bit chunks of memory (including 2LLU for parameters) */
5496+case /*subsize___*/0xBB076E9358000000LLU:/* SP = 2LLU *//* SPMAX = 2LLU *//* predicate */
5497+
5498+ {
5499+ /* CALLBEGIN */
5500+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
5501+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
5502+ /* leave place for return addr *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
5503+ }
5504+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
5505+ {
5506+ /*CALLEND*/
5507+ stackbase += 5LLU;
5508+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE80LLU;
5509+ fnaddr = /*subisid___*/0xBB0764BA47C00000LLU;/* SP = 0LLU */
5510+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subisid___*/\n"); exit(-1); }
5511+ break;
5512+ }
5513+case 0xFFFFFFFFFFFFFE80LLU:
5514+/* SP = 3LLU */
5515+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
5516+{ /* JUMP */ fnaddr = 18446744073709551234LLU; break; } /* skip consequent */
5517+/* consequent */
5518+ {
5519+ /* CALLBEGIN */
5520+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
5521+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
5522+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
5523+ }
5524+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
5525+ {
5526+ /* CALLBEGIN */
5527+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
5528+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
5529+ /* leave place for return addr *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
5530+ }
5531+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
5532+ {
5533+ /*CALLEND*/
5534+ stackbase += 9LLU;
5535+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7FLLU;
5536+ fnaddr = /*subtypeval*/0xBB076FD2B8317270LLU;/* SP = 0LLU */
5537+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtypeval*/\n"); exit(-1); }
5538+ break;
5539+ }
5540+case 0xFFFFFFFFFFFFFE7FLLU:
5541+/* SP = 7LLU */
5542+ {
5543+ /*CALLEND*/
5544+ stackbase += 5LLU;
5545+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ELLU;
5546+ fnaddr = /*typesize__*/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
5547+if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typesize__*/\n"); exit(-1); }
5548+ break;
5549+ }
5550+case 0xFFFFFFFFFFFFFE7ELLU:
5551+/* SP = 3LLU *//* SP - 1LLU = 2LLU */
5552+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 3LLU *//* SP = 2LLU */
5553+{ /* JUMP */ fnaddr = 18446744073709551233LLU; break; } /* skip alternative */
5554+case 18446744073709551234LLU: /* alternative */
5555+ {
5556+ /* CALLBEGIN */
5557+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
5558+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
5559+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
5560+ }
5561+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
5562+ {
5563+ /*CALLEND*/
5564+ stackbase += 5LLU;
5565+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7DLLU;
5566+ fnaddr = /*subtosize_*/0xBB076FAAE9358000LLU;/* SP = 0LLU */
5567+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtosize_*/\n"); exit(-1); }
5568+ break;
5569+ }
5570+case 0xFFFFFFFFFFFFFE7DLLU:
5571+/* SP = 3LLU *//* SP - 1LLU = 2LLU */
5572+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 3LLU */
5573+case 18446744073709551233LLU: /* skip to here */
5574+/* SP - 1LLU = 2LLU */
5575+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */
5576+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }
5577+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5578+/* function requires 10LLU 64-bit chunks of memory (including 2LLU for parameters) */
23585579 case /*debugvars_*/0x7E07708B172DB800LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
23595580 { /* PUSH */ stack[stackbase + 1LLU] = 0LLU; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */fputs("[", stderr);
2360-case 0xFFFFFFFFFFFFFF65LLU: /* loop to here *//* predicate: list non-empty? */
5581+case 0xFFFFFFFFFFFFFE7CLLU: /* loop to here *//* predicate: list non-empty? */
23615582
23625583 { /* PUSH */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
23635584 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
2364-{ /* JUMP */ fnaddr = 18446744073709551460LLU; break; } /* skip loop */
5585+{ /* JUMP */ fnaddr = 18446744073709551227LLU; break; } /* skip loop */
23655586 /* loop */
23665587 {
23675588 /* CALLBEGIN */
@@ -2373,12 +5594,12 @@
23735594 {
23745595 /*CALLEND*/
23755596 stackbase += 4LLU;
2376- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF63LLU;
5597+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ALLU;
23775598 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
23785599 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
23795600 break;
23805601 }
2381-case 0xFFFFFFFFFFFFFF63LLU:
5602+case 0xFFFFFFFFFFFFFE7ALLU:
23825603 /* SP = 2LLU */fputs(" ", stderr);
23835604 {
23845605 /* CALLBEGIN */
@@ -2391,12 +5612,12 @@
23915612 {
23925613 /*CALLEND*/
23935614 stackbase += 5LLU;
2394- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF62LLU;
5615+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE79LLU;
23955616 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
23965617 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
23975618 break;
23985619 }
2399-case 0xFFFFFFFFFFFFFF62LLU:
5620+case 0xFFFFFFFFFFFFFE79LLU:
24005621 /* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
24015622
24025623 {
@@ -2409,25 +5630,25 @@
24095630 {
24105631 /*CALLEND*/
24115632 stackbase += 4LLU;
2412- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF61LLU;
5633+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE78LLU;
24135634 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
24145635 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
24155636 break;
24165637 }
2417-case 0xFFFFFFFFFFFFFF61LLU:
5638+case 0xFFFFFFFFFFFFFE78LLU:
24185639 /* SP = 2LLU */fputs(";", stderr); /* SP = 2LLU */
24195640 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
2420-{ /* JUMP */ fnaddr = 18446744073709551461LLU; break; } /* loop */
2421-case 18446744073709551460LLU: /* skip to here */fputs("]\n", stderr); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
5641+{ /* JUMP */ fnaddr = 18446744073709551228LLU; break; } /* loop */
5642+case 18446744073709551227LLU: /* skip to here */fputs("]\n", stderr); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
24225643 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
24235644 /* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */
24245645 case /*existsvar_*/0x83392EBEEC5CB400LLU:/* SP = 2LLU *//* SPMAX = 2LLU */
24255646 { /* PUSH */ stack[stackbase + 2LLU] = 0LLU; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
2426-case 0xFFFFFFFFFFFFFF60LLU: /* loop to here *//* predicate: list non-empty? */
5647+case 0xFFFFFFFFFFFFFE77LLU: /* loop to here *//* predicate: list non-empty? */
24275648
24285649 { /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
24295650 if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
2430-{ /* JUMP */ fnaddr = 18446744073709551455LLU; break; } /* skip loop */
5651+{ /* JUMP */ fnaddr = 18446744073709551222LLU; break; } /* skip loop */
24315652 /* loop *//* predicate */
24325653
24335654 {
@@ -2441,23 +5662,23 @@
24415662 {
24425663 /*CALLEND*/
24435664 stackbase += 6LLU;
2444- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5DLLU;
5665+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE74LLU;
24455666 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
24465667 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
24475668 break;
24485669 }
2449-case 0xFFFFFFFFFFFFFF5DLLU:
5670+case 0xFFFFFFFFFFFFFE74LLU:
24505671 /* SP = 4LLU */
24515672 if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
2452-{ /* JUMP */ fnaddr = 18446744073709551454LLU; break; } /* skip consequent */
5673+{ /* JUMP */ fnaddr = 18446744073709551221LLU; break; } /* skip consequent */
24535674 /* consequent */
24545675 { /* PUSH */ stack[stackbase + 3LLU] = 1LLU; }/* SP + 1LLU = 4LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */
24555676
24565677 {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 3LLU */
2457-case 18446744073709551454LLU: /* alternative *//* SP = 3LLU */
5678+case 18446744073709551221LLU: /* alternative *//* SP = 3LLU */
24585679 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
2459-{ /* JUMP */ fnaddr = 18446744073709551456LLU; break; } /* loop */
2460-case 18446744073709551455LLU: /* skip to here */
5680+{ /* JUMP */ fnaddr = 18446744073709551223LLU; break; } /* loop */
5681+case 18446744073709551222LLU: /* skip to here */
24615682 { /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 4LLU *//* SP - 1LLU = 3LLU */
24625683 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */
24635684 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }
@@ -2485,25 +5706,25 @@
24855706 {
24865707 /*CALLEND*/
24875708 stackbase += 11LLU;
2488- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5ALLU;
5709+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE71LLU;
24895710 fnaddr = /*existsvar_*/0x83392EBEEC5CB400LLU;/* SP = 0LLU */
24905711 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*existsvar_*/\n"); exit(-1); }
24915712 break;
24925713 }
2493-case 0xFFFFFFFFFFFFFF5ALLU:
5714+case 0xFFFFFFFFFFFFFE71LLU:
24945715 /* SP = 9LLU */
24955716 {
24965717 /*CALLEND*/
24975718 stackbase += 8LLU;
2498- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF59LLU;
5719+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE70LLU;
24995720 fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
25005721 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
25015722 break;
25025723 }
2503-case 0xFFFFFFFFFFFFFF59LLU:
5724+case 0xFFFFFFFFFFFFFE70LLU:
25045725 /* SP = 6LLU */
25055726 if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
2506-{ /* JUMP */ fnaddr = 18446744073709551452LLU; break; } /* skip consequent */
5727+{ /* JUMP */ fnaddr = 18446744073709551219LLU; break; } /* skip consequent */
25075728 /* consequent */
25085729 {
25095730 /* CALLBEGIN */
@@ -2514,12 +5735,12 @@
25145735 {
25155736 /*CALLEND*/
25165737 stackbase += 7LLU;
2517- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF58LLU;
5738+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6FLLU;
25185739 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
25195740 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
25205741 break;
25215742 }
2522-case 0xFFFFFFFFFFFFFF58LLU:
5743+case 0xFFFFFFFFFFFFFE6FLLU:
25235744 /* SP = 5LLU */fputs("undefined variable ", stderr);
25245745 {
25255746 /* CALLBEGIN */
@@ -2531,12 +5752,12 @@
25315752 {
25325753 /*CALLEND*/
25335754 stackbase += 7LLU;
2534- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF57LLU;
5755+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6ELLU;
25355756 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
25365757 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
25375758 break;
25385759 }
2539-case 0xFFFFFFFFFFFFFF57LLU:
5760+case 0xFFFFFFFFFFFFFE6ELLU:
25405761 /* SP = 5LLU */fputs("\n", stderr); fputs("defined variables\n", stderr);
25415762 {
25425763 /* CALLBEGIN */
@@ -2548,20 +5769,20 @@
25485769 {
25495770 /*CALLEND*/
25505771 stackbase += 7LLU;
2551- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF56LLU;
5772+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6DLLU;
25525773 fnaddr = /*debugvars_*/0x7E07708B172DB800LLU;/* SP = 0LLU */
25535774 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugvars_*/\n"); exit(-1); }
25545775 break;
25555776 }
2556-case 0xFFFFFFFFFFFFFF56LLU:
5777+case 0xFFFFFFFFFFFFFE6DLLU:
25575778 /* SP = 5LLU */exit(-1);/* SP = 5LLU *//* SP = 5LLU */
2558-{ /* JUMP */ fnaddr = 18446744073709551451LLU; break; } /* skip alternative */
2559-case 18446744073709551452LLU: /* alternative */
2560-case 0xFFFFFFFFFFFFFF55LLU: /* loop to here *//* predicate: list non-empty? */
5779+{ /* JUMP */ fnaddr = 18446744073709551218LLU; break; } /* skip alternative */
5780+case 18446744073709551219LLU: /* alternative */
5781+case 0xFFFFFFFFFFFFFE6CLLU: /* loop to here *//* predicate: list non-empty? */
25615782
25625783 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
25635784 if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
2564-{ /* JUMP */ fnaddr = 18446744073709551444LLU; break; } /* skip loop */
5785+{ /* JUMP */ fnaddr = 18446744073709551211LLU; break; } /* skip loop */
25655786 /* loop *//* predicate */
25665787
25675788 {
@@ -2575,15 +5796,15 @@
25755796 {
25765797 /*CALLEND*/
25775798 stackbase += 8LLU;
2578- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF52LLU;
5799+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE69LLU;
25795800 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
25805801 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
25815802 break;
25825803 }
2583-case 0xFFFFFFFFFFFFFF52LLU:
5804+case 0xFFFFFFFFFFFFFE69LLU:
25845805 /* SP = 6LLU */
25855806 if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU])
2586-{ /* JUMP */ fnaddr = 18446744073709551443LLU; break; } /* skip consequent */
5807+{ /* JUMP */ fnaddr = 18446744073709551210LLU; break; } /* skip consequent */
25875808 /* consequent */
25885809 { /* PUSH */ stack[stackbase + 5LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 2LLU]; }/* SP + 1LLU = 6LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
25895810
@@ -2592,11 +5813,11 @@
25925813 { /* PUSH */ stack[stackbase + 5LLU] = /* DEREF-LIST */ stack[/* LOCAL VAR */ stack[stackbase + 0LLU] + 4LLU]; }/* SP + 1LLU = 6LLU *//* LOCAL VAR */ stack[stackbase + 4LLU] = /* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]; /* POP */
25935814
25945815 {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 5LLU */
2595-case 18446744073709551443LLU: /* alternative *//* SP = 5LLU */
5816+case 18446744073709551210LLU: /* alternative *//* SP = 5LLU */
25965817 { /* NEXT LIST ELEM */ if(/* LOCAL VAR */ stack[stackbase + 0LLU]) /* LOCAL VAR */ stack[stackbase + 0LLU] = /* DEREF */stack[/* LOCAL VAR */ stack[stackbase + 0LLU]]; }
2597-{ /* JUMP */ fnaddr = 18446744073709551445LLU; break; } /* loop */
2598-case 18446744073709551444LLU: /* skip to here *//* SP = 5LLU */
2599-case 18446744073709551451LLU: /* skip to here */
5818+{ /* JUMP */ fnaddr = 18446744073709551212LLU; break; } /* loop */
5819+case 18446744073709551211LLU: /* skip to here *//* SP = 5LLU */
5820+case 18446744073709551218LLU: /* skip to here */
26005821
26015822 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU */
26025823 { /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 7LLU */
@@ -2621,12 +5842,12 @@
26215842 {
26225843 /*CALLEND*/
26235844 stackbase += 7LLU;
2624- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF51LLU;
5845+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE68LLU;
26255846 fnaddr = /*findvar___*/0x864A5FC5CB400000LLU;/* SP = 0LLU */
26265847 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvar___*/\n"); exit(-1); }
26275848 break;
26285849 }
2629-case 0xFFFFFFFFFFFFFF51LLU:
5850+case 0xFFFFFFFFFFFFFE68LLU:
26305851 /* SP = 5LLU */
26315852 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */
26325853 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */
@@ -2645,12 +5866,12 @@
26455866 {
26465867 /*CALLEND*/
26475868 stackbase += 7LLU;
2648- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF50LLU;
5869+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE67LLU;
26495870 fnaddr = /*findvar___*/0x864A5FC5CB400000LLU;/* SP = 0LLU */
26505871 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvar___*/\n"); exit(-1); }
26515872 break;
26525873 }
2653-case 0xFFFFFFFFFFFFFF50LLU:
5874+case 0xFFFFFFFFFFFFFE67LLU:
26545875 /* SP = 5LLU */
26555876 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */
26565877 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */
@@ -2669,12 +5890,12 @@
26695890 {
26705891 /*CALLEND*/
26715892 stackbase += 7LLU;
2672- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4FLLU;
5893+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE66LLU;
26735894 fnaddr = /*findvar___*/0x864A5FC5CB400000LLU;/* SP = 0LLU */
26745895 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvar___*/\n"); exit(-1); }
26755896 break;
26765897 }
2677-case 0xFFFFFFFFFFFFFF4FLLU:
5898+case 0xFFFFFFFFFFFFFE66LLU:
26785899 /* SP = 5LLU */
26795900 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */
26805901 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */
@@ -2748,12 +5969,12 @@
27485969 {
27495970 /*CALLEND*/
27505971 stackbase += 6LLU;
2751- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4DLLU;
5972+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE64LLU;
27525973 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
27535974 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
27545975 break;
27555976 }
2756-case 0xFFFFFFFFFFFFFF4DLLU:
5977+case 0xFFFFFFFFFFFFFE64LLU:
27575978 /* SP = 4LLU */
27585979 {
27595980 /* CALLBEGIN */
@@ -2764,27 +5985,27 @@
27645985 {
27655986 /*CALLEND*/
27665987 stackbase += 7LLU;
2767- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4CLLU;
5988+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE63LLU;
27685989 fnaddr = /*SPMAX_GET_*/0x4D03416001C55000LLU;/* SP = 0LLU */
27695990 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SPMAX_GET_*/\n"); exit(-1); }
27705991 break;
27715992 }
2772-case 0xFFFFFFFFFFFFFF4CLLU:
5993+case 0xFFFFFFFFFFFFFE63LLU:
27735994 /* SP = 5LLU */
27745995 {
27755996 /*CALLEND*/
27765997 stackbase += 3LLU;
2777- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4BLLU;
5998+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE62LLU;
27785999 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
27796000 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
27806001 break;
27816002 }
2782-case 0xFFFFFFFFFFFFFF4BLLU:
6003+case 0xFFFFFFFFFFFFFE62LLU:
27836004 /* SP = 1LLU */
27846005 if(!/* SP - 1LLU = 0LLU */stack[stackbase + 0LLU])
2785-{ /* JUMP */ fnaddr = 18446744073709551438LLU; break; } /* skip consequent */
6006+{ /* JUMP */ fnaddr = 18446744073709551205LLU; break; } /* skip consequent */
27866007 /* consequent */stack[3] = stack[2];fprintf(stdout, "/* SPMAX = %lluLLU */", (long long unsigned int)stack[3]);/* SP = 0LLU */
2787-case 18446744073709551438LLU: /* alternative *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
6008+case 18446744073709551205LLU: /* alternative *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
27886009 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
27896010 /* function requires 7LLU 64-bit chunks of memory (including 0LLU for parameters) */
27906011 case /*SP_SET____*/0x4D00131540000000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */stack[2] = ACCESS_VAR(0);fputs("/* SP = ", stdout);
@@ -2798,12 +6019,12 @@
27986019 {
27996020 /*CALLEND*/
28006021 stackbase += 3LLU;
2801- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4ALLU;
6022+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE61LLU;
28026023 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
28036024 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
28046025 break;
28056026 }
2806-case 0xFFFFFFFFFFFFFF4ALLU:
6027+case 0xFFFFFFFFFFFFFE61LLU:
28076028 /* SP = 1LLU */fputs(" */", stdout);
28086029 {
28096030 /* CALLBEGIN */
@@ -2814,12 +6035,12 @@
28146035 {
28156036 /*CALLEND*/
28166037 stackbase += 3LLU;
2817- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF49LLU;
6038+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE60LLU;
28186039 fnaddr = /*SPMAXCHECK*/0x4D03416032050CB0LLU;/* SP = 0LLU */
28196040 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SPMAXCHECK*/\n"); exit(-1); }
28206041 break;
28216042 }
2822-case 0xFFFFFFFFFFFFFF49LLU:
6043+case 0xFFFFFFFFFFFFFE60LLU:
28236044 /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
28246045 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
28256046 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -2834,12 +6055,12 @@
28346055 {
28356056 /*CALLEND*/
28366057 stackbase += 3LLU;
2837- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF48LLU;
6058+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5FLLU;
28386059 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
28396060 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
28406061 break;
28416062 }
2842-case 0xFFFFFFFFFFFFFF48LLU:
6063+case 0xFFFFFFFFFFFFFE5FLLU:
28436064 /* SP = 1LLU */fputs(" = ", stdout);
28446065 {
28456066 /* CALLBEGIN */
@@ -2856,22 +6077,22 @@
28566077 {
28576078 /*CALLEND*/
28586079 stackbase += 6LLU;
2859- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF47LLU;
6080+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ELLU;
28606081 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
28616082 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
28626083 break;
28636084 }
2864-case 0xFFFFFFFFFFFFFF47LLU:
6085+case 0xFFFFFFFFFFFFFE5ELLU:
28656086 /* SP = 4LLU */
28666087 {
28676088 /*CALLEND*/
28686089 stackbase += 3LLU;
2869- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF46LLU;
6090+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5DLLU;
28706091 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
28716092 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
28726093 break;
28736094 }
2874-case 0xFFFFFFFFFFFFFF46LLU:
6095+case 0xFFFFFFFFFFFFFE5DLLU:
28756096 /* SP = 1LLU */fputs(" */", stdout);
28766097 {
28776098 /* CALLBEGIN */
@@ -2882,12 +6103,12 @@
28826103 {
28836104 /*CALLEND*/
28846105 stackbase += 3LLU;
2885- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF45LLU;
6106+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5CLLU;
28866107 fnaddr = /*SPMAXCHECK*/0x4D03416032050CB0LLU;/* SP = 0LLU */
28876108 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SPMAXCHECK*/\n"); exit(-1); }
28886109 break;
28896110 }
2890-case 0xFFFFFFFFFFFFFF45LLU:
6111+case 0xFFFFFFFFFFFFFE5CLLU:
28916112 /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
28926113 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
28936114 /* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -2902,12 +6123,12 @@
29026123 {
29036124 /*CALLEND*/
29046125 stackbase += 3LLU;
2905- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF44LLU;
6126+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5BLLU;
29066127 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
29076128 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
29086129 break;
29096130 }
2910-case 0xFFFFFFFFFFFFFF44LLU:
6131+case 0xFFFFFFFFFFFFFE5BLLU:
29116132 /* SP = 1LLU */fputs(" = ", stdout);
29126133 {
29136134 /* CALLBEGIN */
@@ -2924,22 +6145,22 @@
29246145 {
29256146 /*CALLEND*/
29266147 stackbase += 6LLU;
2927- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF43LLU;
6148+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ALLU;
29286149 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
29296150 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
29306151 break;
29316152 }
2932-case 0xFFFFFFFFFFFFFF43LLU:
6153+case 0xFFFFFFFFFFFFFE5ALLU:
29336154 /* SP = 4LLU */
29346155 {
29356156 /*CALLEND*/
29366157 stackbase += 3LLU;
2937- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF42LLU;
6158+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE59LLU;
29386159 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
29396160 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
29406161 break;
29416162 }
2942-case 0xFFFFFFFFFFFFFF42LLU:
6163+case 0xFFFFFFFFFFFFFE59LLU:
29436164 /* SP = 1LLU */fputs(" */", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
29446165 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
29456166 /* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -2967,12 +6188,12 @@
29676188 {
29686189 /*CALLEND*/
29696190 stackbase += 3LLU;
2970- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF41LLU;
6191+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE58LLU;
29716192 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
29726193 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
29736194 break;
29746195 }
2975-case 0xFFFFFFFFFFFFFF41LLU:
6196+case 0xFFFFFFFFFFFFFE58LLU:
29766197 /* SP = 1LLU */fputs("]", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
29776198 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
29786199 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -2993,12 +6214,12 @@
29936214 {
29946215 /*CALLEND*/
29956216 stackbase += 3LLU;
2996- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF40LLU;
6217+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE57LLU;
29976218 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
29986219 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
29996220 break;
30006221 }
3001-case 0xFFFFFFFFFFFFFF40LLU:
6222+case 0xFFFFFFFFFFFFFE57LLU:
30026223 /* SP = 1LLU */fputs("]", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
30036224 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
30046225 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -3013,12 +6234,12 @@
30136234 {
30146235 /*CALLEND*/
30156236 stackbase += 3LLU;
3016- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3FLLU;
6237+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE56LLU;
30176238 fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */
30186239 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); }
30196240 break;
30206241 }
3021-case 0xFFFFFFFFFFFFFF3FLLU:
6242+case 0xFFFFFFFFFFFFFE56LLU:
30226243 /* SP = 1LLU */fputs(") ", stdout);
30236244 {
30246245 /* CALLBEGIN */
@@ -3030,12 +6251,12 @@
30306251 {
30316252 /*CALLEND*/
30326253 stackbase += 3LLU;
3033- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3ELLU;
6254+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE55LLU;
30346255 fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */
30356256 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); }
30366257 break;
30376258 }
3038-case 0xFFFFFFFFFFFFFF3ELLU:
6259+case 0xFFFFFFFFFFFFFE55LLU:
30396260 /* SP = 1LLU */fputs(" = ", stdout);
30406261 {
30416262 /* CALLBEGIN */
@@ -3046,12 +6267,12 @@
30466267 {
30476268 /*CALLEND*/
30486269 stackbase += 3LLU;
3049- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3DLLU;
6270+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE54LLU;
30506271 fnaddr = /*DEREFSTART*/0x1054851935014940LLU;/* SP = 0LLU */
30516272 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEREFSTART*/\n"); exit(-1); }
30526273 break;
30536274 }
3054-case 0xFFFFFFFFFFFFFF3DLLU:
6275+case 0xFFFFFFFFFFFFFE54LLU:
30556276 /* SP = 1LLU */
30566277 {
30576278 /* CALLBEGIN */
@@ -3063,12 +6284,12 @@
30636284 {
30646285 /*CALLEND*/
30656286 stackbase += 3LLU;
3066- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3CLLU;
6287+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE53LLU;
30676288 fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */
30686289 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); }
30696290 break;
30706291 }
3071-case 0xFFFFFFFFFFFFFF3CLLU:
6292+case 0xFFFFFFFFFFFFFE53LLU:
30726293 /* SP = 1LLU */
30736294 {
30746295 /* CALLBEGIN */
@@ -3079,12 +6300,12 @@
30796300 {
30806301 /*CALLEND*/
30816302 stackbase += 3LLU;
3082- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3BLLU;
6303+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE52LLU;
30836304 fnaddr = /*DEREFEND__*/0x1054851853840000LLU;/* SP = 0LLU */
30846305 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEREFEND__*/\n"); exit(-1); }
30856306 break;
30866307 }
3087-case 0xFFFFFFFFFFFFFF3BLLU:
6308+case 0xFFFFFFFFFFFFFE52LLU:
30886309 /* SP = 1LLU */fputs("; }", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
30896310 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
30906311 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -3104,22 +6325,22 @@
31046325 {
31056326 /*CALLEND*/
31066327 stackbase += 5LLU;
3107- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3ALLU;
6328+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE51LLU;
31086329 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
31096330 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
31106331 break;
31116332 }
3112-case 0xFFFFFFFFFFFFFF3ALLU:
6333+case 0xFFFFFFFFFFFFFE51LLU:
31136334 /* SP = 3LLU */
31146335 {
31156336 /*CALLEND*/
31166337 stackbase += 2LLU;
3117- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF39LLU;
6338+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE50LLU;
31186339 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
31196340 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
31206341 break;
31216342 }
3122-case 0xFFFFFFFFFFFFFF39LLU:
6343+case 0xFFFFFFFFFFFFFE50LLU:
31236344 /* SP = 0LLU */fputs("] = ", stdout); /* SP = 0LLU *//* SP - 0LLU = 0LLU */
31246345 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
31256346 /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -3134,12 +6355,12 @@
31346355 {
31356356 /*CALLEND*/
31366357 stackbase += 2LLU;
3137- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF38LLU;
6358+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4FLLU;
31386359 fnaddr = /*SP_ADD____*/0x4D00011040000000LLU;/* SP = 0LLU */
31396360 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_ADD____*/\n"); exit(-1); }
31406361 break;
31416362 }
3142-case 0xFFFFFFFFFFFFFF38LLU:
6363+case 0xFFFFFFFFFFFFFE4FLLU:
31436364 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
31446365 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
31456366 /* function requires 3LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -3153,12 +6374,12 @@
31536374 {
31546375 /*CALLEND*/
31556376 stackbase += 3LLU;
3156- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF37LLU;
6377+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ELLU;
31576378 fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */
31586379 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); }
31596380 break;
31606381 }
3161-case 0xFFFFFFFFFFFFFF37LLU:
6382+case 0xFFFFFFFFFFFFFE4ELLU:
31626383 /* SP = 1LLU */
31636384 {
31646385 /* CALLBEGIN */
@@ -3170,12 +6391,12 @@
31706391 {
31716392 /*CALLEND*/
31726393 stackbase += 3LLU;
3173- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF36LLU;
6394+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4DLLU;
31746395 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
31756396 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
31766397 break;
31776398 }
3178-case 0xFFFFFFFFFFFFFF36LLU:
6399+case 0xFFFFFFFFFFFFFE4DLLU:
31796400 /* SP = 1LLU */
31806401 {
31816402 /* CALLBEGIN */
@@ -3186,12 +6407,12 @@
31866407 {
31876408 /*CALLEND*/
31886409 stackbase += 3LLU;
3189- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF35LLU;
6410+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4CLLU;
31906411 fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */
31916412 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); }
31926413 break;
31936414 }
3194-case 0xFFFFFFFFFFFFFF35LLU:
6415+case 0xFFFFFFFFFFFFFE4CLLU:
31956416 /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
31966417 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
31976418 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -3206,12 +6427,12 @@
32066427 {
32076428 /*CALLEND*/
32086429 stackbase += 2LLU;
3209- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF34LLU;
6430+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4BLLU;
32106431 fnaddr = /*SP_SUB____*/0x4D00135420000000LLU;/* SP = 0LLU */
32116432 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SUB____*/\n"); exit(-1); }
32126433 break;
32136434 }
3214-case 0xFFFFFFFFFFFFFF34LLU:
6435+case 0xFFFFFFFFFFFFFE4BLLU:
32156436 /* SP = 0LLU */fputs("stack[stackbase + ", stdout);
32166437 {
32176438 /* CALLBEGIN */
@@ -3228,22 +6449,22 @@
32286449 {
32296450 /*CALLEND*/
32306451 stackbase += 5LLU;
3231- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF33LLU;
6452+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ALLU;
32326453 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
32336454 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
32346455 break;
32356456 }
3236-case 0xFFFFFFFFFFFFFF33LLU:
6457+case 0xFFFFFFFFFFFFFE4ALLU:
32376458 /* SP = 3LLU */
32386459 {
32396460 /*CALLEND*/
32406461 stackbase += 2LLU;
3241- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF32LLU;
6462+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE49LLU;
32426463 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
32436464 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
32446465 break;
32456466 }
3246-case 0xFFFFFFFFFFFFFF32LLU:
6467+case 0xFFFFFFFFFFFFFE49LLU:
32476468 /* SP = 0LLU */fputs("]", stdout); /* SP = 0LLU *//* SP - 0LLU = 0LLU */
32486469 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
32496470 /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -3260,12 +6481,12 @@
32606481 {
32616482 /*CALLEND*/
32626483 stackbase += 2LLU;
3263- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF31LLU;
6484+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE48LLU;
32646485 fnaddr = /*POP_START_*/0x40F4004D40525000LLU;/* SP = 0LLU */
32656486 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_START_*/\n"); exit(-1); }
32666487 break;
32676488 }
3268-case 0xFFFFFFFFFFFFFF31LLU:
6489+case 0xFFFFFFFFFFFFFE48LLU:
32696490 /* SP = 0LLU */
32706491 {
32716492 /* CALLBEGIN */
@@ -3276,12 +6497,12 @@
32766497 {
32776498 /*CALLEND*/
32786499 stackbase += 2LLU;
3279- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF30LLU;
6500+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE47LLU;
32806501 fnaddr = /*POP_END___*/0x40F40014E1000000LLU;/* SP = 0LLU */
32816502 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_END___*/\n"); exit(-1); }
32826503 break;
32836504 }
3284-case 0xFFFFFFFFFFFFFF30LLU:
6505+case 0xFFFFFFFFFFFFFE47LLU:
32856506 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
32866507 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
32876508 /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -3301,22 +6522,22 @@
33016522 {
33026523 /*CALLEND*/
33036524 stackbase += 5LLU;
3304- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2FLLU;
6525+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE46LLU;
33056526 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
33066527 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
33076528 break;
33086529 }
3309-case 0xFFFFFFFFFFFFFF2FLLU:
6530+case 0xFFFFFFFFFFFFFE46LLU:
33106531 /* SP = 3LLU */
33116532 {
33126533 /*CALLEND*/
33136534 stackbase += 2LLU;
3314- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2ELLU;
6535+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE45LLU;
33156536 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
33166537 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
33176538 break;
33186539 }
3319-case 0xFFFFFFFFFFFFFF2ELLU:
6540+case 0xFFFFFFFFFFFFFE45LLU:
33206541 /* SP = 0LLU */fputs(" - 1]", stdout); /* SP = 0LLU *//* SP - 0LLU = 0LLU */
33216542 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
33226543 /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -3333,12 +6554,12 @@
33336554 {
33346555 /*CALLEND*/
33356556 stackbase += 2LLU;
3336- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2DLLU;
6557+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE44LLU;
33376558 fnaddr = /*TOP_START_*/0x50F4004D40525000LLU;/* SP = 0LLU */
33386559 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*TOP_START_*/\n"); exit(-1); }
33396560 break;
33406561 }
3341-case 0xFFFFFFFFFFFFFF2DLLU:
6562+case 0xFFFFFFFFFFFFFE44LLU:
33426563 /* SP = 0LLU */
33436564 {
33446565 /* CALLBEGIN */
@@ -3349,12 +6570,12 @@
33496570 {
33506571 /*CALLEND*/
33516572 stackbase += 2LLU;
3352- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2CLLU;
6573+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE43LLU;
33536574 fnaddr = /*TOP_END___*/0x50F40014E1000000LLU;/* SP = 0LLU */
33546575 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*TOP_END___*/\n"); exit(-1); }
33556576 break;
33566577 }
3357-case 0xFFFFFFFFFFFFFF2CLLU:
6578+case 0xFFFFFFFFFFFFFE43LLU:
33586579 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
33596580 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
33606581 /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -3369,12 +6590,12 @@
33696590 {
33706591 /*CALLEND*/
33716592 stackbase += 4LLU;
3372- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2BLLU;
6593+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE42LLU;
33736594 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
33746595 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
33756596 break;
33766597 }
3377-case 0xFFFFFFFFFFFFFF2BLLU:
6598+case 0xFFFFFFFFFFFFFE42LLU:
33786599 /* SP = 2LLU */fputs(" >= ", stdout);
33796600 {
33806601 /* CALLBEGIN */
@@ -3391,22 +6612,22 @@
33916612 {
33926613 /*CALLEND*/
33936614 stackbase += 7LLU;
3394- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2ALLU;
6615+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE41LLU;
33956616 fnaddr = /*MEMSIZEGET*/0x34535325A1471540LLU;/* SP = 0LLU */
33966617 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*MEMSIZEGET*/\n"); exit(-1); }
33976618 break;
33986619 }
3399-case 0xFFFFFFFFFFFFFF2ALLU:
6620+case 0xFFFFFFFFFFFFFE41LLU:
34006621 /* SP = 5LLU */
34016622 {
34026623 /*CALLEND*/
34036624 stackbase += 4LLU;
3404- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF29LLU;
6625+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE40LLU;
34056626 fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
34066627 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); }
34076628 break;
34086629 }
3409-case 0xFFFFFFFFFFFFFF29LLU:
6630+case 0xFFFFFFFFFFFFFE40LLU:
34106631 /* SP = 2LLU */fputs(") { fprintf(stderr, \"STACKOVERFLOW calling ", stdout);
34116632 {
34126633 /* CALLBEGIN */
@@ -3418,12 +6639,12 @@
34186639 {
34196640 /*CALLEND*/
34206641 stackbase += 4LLU;
3421- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF28LLU;
6642+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3FLLU;
34226643 fnaddr = /*commentid_*/0x7AAA28829BE47C00LLU;/* SP = 0LLU */
34236644 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*commentid_*/\n"); exit(-1); }
34246645 break;
34256646 }
3426-case 0xFFFFFFFFFFFFFF28LLU:
6647+case 0xFFFFFFFFFFFFFE3FLLU:
34276648 /* SP = 2LLU */fputs("\\n\"); exit(-1); } ", stdout); /* SP = 2LLU *//* SP - 0LLU = 2LLU */
34286649 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
34296650 /* function requires 7LLU 64-bit chunks of memory (including 2LLU for parameters) */
@@ -3443,23 +6664,23 @@
34436664 {
34446665 /*CALLEND*/
34456666 stackbase += 7LLU;
3446- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF27LLU;
6667+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ELLU;
34476668 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
34486669 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
34496670 break;
34506671 }
3451-case 0xFFFFFFFFFFFFFF27LLU:
6672+case 0xFFFFFFFFFFFFFE3ELLU:
34526673 /* SP = 5LLU */
34536674 { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
34546675 {
34556676 /*CALLEND*/
34566677 stackbase += 4LLU;
3457- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF26LLU;
6678+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3DLLU;
34586679 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
34596680 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
34606681 break;
34616682 }
3462-case 0xFFFFFFFFFFFFFF26LLU:
6683+case 0xFFFFFFFFFFFFFE3DLLU:
34636684 /* SP = 2LLU */fputs("\n {", stdout); fputs("\n /* CALLBEGIN */", stdout); fputs("\n /* reserve space for ", stdout);
34646685 {
34656686 /* CALLBEGIN */
@@ -3471,12 +6692,12 @@
34716692 {
34726693 /*CALLEND*/
34736694 stackbase += 4LLU;
3474- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF25LLU;
6695+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3CLLU;
34756696 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
34766697 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
34776698 break;
34786699 }
3479-case 0xFFFFFFFFFFFFFF25LLU:
6700+case 0xFFFFFFFFFFFFFE3CLLU:
34806701 /* SP = 2LLU */fputs(" returned values */", stdout);
34816702 {
34826703 /* CALLBEGIN */
@@ -3488,12 +6709,12 @@
34886709 {
34896710 /*CALLEND*/
34906711 stackbase += 4LLU;
3491- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF24LLU;
6712+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3BLLU;
34926713 fnaddr = /*SP_ADD____*/0x4D00011040000000LLU;/* SP = 0LLU */
34936714 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_ADD____*/\n"); exit(-1); }
34946715 break;
34956716 }
3496-case 0xFFFFFFFFFFFFFF24LLU:
6717+case 0xFFFFFFFFFFFFFE3BLLU:
34976718 /* SP = 2LLU */
34986719 {
34996720 /* CALLBEGIN */
@@ -3504,12 +6725,12 @@
35046725 {
35056726 /*CALLEND*/
35066727 stackbase += 4LLU;
3507- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF23LLU;
6728+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ALLU;
35086729 fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */
35096730 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); }
35106731 break;
35116732 }
3512-case 0xFFFFFFFFFFFFFF23LLU:
6733+case 0xFFFFFFFFFFFFFE3ALLU:
35136734 /* SP = 2LLU */fputs("stackbase", stdout);
35146735 {
35156736 /* CALLBEGIN */
@@ -3520,12 +6741,12 @@
35206741 {
35216742 /*CALLEND*/
35226743 stackbase += 4LLU;
3523- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF22LLU;
6744+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE39LLU;
35246745 fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */
35256746 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); }
35266747 break;
35276748 }
3528-case 0xFFFFFFFFFFFFFF22LLU:
6749+case 0xFFFFFFFFFFFFFE39LLU:
35296750 /* SP = 2LLU */fputs("\n /* leave place for return addr */", stdout);
35306751 {
35316752 /* CALLBEGIN */
@@ -3537,12 +6758,12 @@
35376758 {
35386759 /*CALLEND*/
35396760 stackbase += 4LLU;
3540- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF21LLU;
6761+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE38LLU;
35416762 fnaddr = /*SP_ADD____*/0x4D00011040000000LLU;/* SP = 0LLU */
35426763 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_ADD____*/\n"); exit(-1); }
35436764 break;
35446765 }
3545-case 0xFFFFFFFFFFFFFF21LLU:
6766+case 0xFFFFFFFFFFFFFE38LLU:
35466767 /* SP = 2LLU */fputs("\n }", stdout);
35476768 { /* PUSH */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 3LLU *//* SP - 1LLU = 2LLU */
35486769 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
@@ -3571,33 +6792,33 @@
35716792 {
35726793 /*CALLEND*/
35736794 stackbase += 12LLU;
3574- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF20LLU;
6795+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE37LLU;
35756796 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
35766797 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
35776798 break;
35786799 }
3579-case 0xFFFFFFFFFFFFFF20LLU:
6800+case 0xFFFFFFFFFFFFFE37LLU:
35806801 /* SP = 10LLU */
35816802 { /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 11LLU */
35826803 {
35836804 /*CALLEND*/
35846805 stackbase += 9LLU;
3585- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1FLLU;
6806+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE36LLU;
35866807 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
35876808 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
35886809 break;
35896810 }
3590-case 0xFFFFFFFFFFFFFF1FLLU:
6811+case 0xFFFFFFFFFFFFFE36LLU:
35916812 /* SP = 7LLU */
35926813 {
35936814 /*CALLEND*/
35946815 stackbase += 6LLU;
3595- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ELLU;
6816+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE35LLU;
35966817 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
35976818 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
35986819 break;
35996820 }
3600-case 0xFFFFFFFFFFFFFF1ELLU:
6821+case 0xFFFFFFFFFFFFFE35LLU:
36016822 /* SP = 4LLU */fputs(";", stdout); fputs("\n stack[stackbase - 1] = ", stdout);
36026823 {
36036824 /* CALLBEGIN */
@@ -3620,33 +6841,33 @@
36206841 {
36216842 /*CALLEND*/
36226843 stackbase += 12LLU;
3623- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1DLLU;
6844+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE34LLU;
36246845 fnaddr = /*ADDRGET___*/0x441121C55000000LLU;/* SP = 0LLU */
36256846 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRGET___*/\n"); exit(-1); }
36266847 break;
36276848 }
3628-case 0xFFFFFFFFFFFFFF1DLLU:
6849+case 0xFFFFFFFFFFFFFE34LLU:
36296850 /* SP = 10LLU */
36306851 { /* PUSH */ stack[stackbase + 10LLU] = 1LLU; }/* SP + 1LLU = 11LLU */
36316852 {
36326853 /*CALLEND*/
36336854 stackbase += 9LLU;
3634- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1CLLU;
6855+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE33LLU;
36356856 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
36366857 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
36376858 break;
36386859 }
3639-case 0xFFFFFFFFFFFFFF1CLLU:
6860+case 0xFFFFFFFFFFFFFE33LLU:
36406861 /* SP = 7LLU */
36416862 {
36426863 /*CALLEND*/
36436864 stackbase += 6LLU;
3644- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1BLLU;
6865+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE32LLU;
36456866 fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
36466867 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); }
36476868 break;
36486869 }
3649-case 0xFFFFFFFFFFFFFF1BLLU:
6870+case 0xFFFFFFFFFFFFFE32LLU:
36506871 /* SP = 4LLU */fputs(";", stdout); fputs("\n fnaddr = ", stdout);
36516872 {
36526873 /* CALLBEGIN */
@@ -3658,12 +6879,12 @@
36586879 {
36596880 /*CALLEND*/
36606881 stackbase += 6LLU;
3661- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ALLU;
6882+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE31LLU;
36626883 fnaddr = /*printid___*/0xAED929BE47C00000LLU;/* SP = 0LLU */
36636884 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printid___*/\n"); exit(-1); }
36646885 break;
36656886 }
3666-case 0xFFFFFFFFFFFFFF1ALLU:
6887+case 0xFFFFFFFFFFFFFE31LLU:
36676888 /* SP = 4LLU */fputs(";", stdout);
36686889 {
36696890 /* CALLBEGIN */
@@ -3675,12 +6896,12 @@
36756896 {
36766897 /*CALLEND*/
36776898 stackbase += 6LLU;
3678- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF19LLU;
6899+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE30LLU;
36796900 fnaddr = /*SP_SET____*/0x4D00131540000000LLU;/* SP = 0LLU */
36806901 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SET____*/\n"); exit(-1); }
36816902 break;
36826903 }
3683-case 0xFFFFFFFFFFFFFF19LLU:
6904+case 0xFFFFFFFFFFFFFE30LLU:
36846905 /* SP = 4LLU */
36856906 {
36866907 /* CALLBEGIN */
@@ -3693,12 +6914,12 @@
36936914 {
36946915 /*CALLEND*/
36956916 stackbase += 6LLU;
3696- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF18LLU;
6917+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2FLLU;
36976918 fnaddr = /*STACKCHECK*/0x4D40432C32050CB0LLU;/* SP = 0LLU */
36986919 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*STACKCHECK*/\n"); exit(-1); }
36996920 break;
37006921 }
3701-case 0xFFFFFFFFFFFFFF18LLU:
6922+case 0xFFFFFFFFFFFFFE2FLLU:
37026923 /* SP = 4LLU */fputs("\n break;", stdout); fputs("\n }", stdout); fputs("\ncase ", stdout);
37036924 {
37046925 /* CALLBEGIN */
@@ -3715,22 +6936,22 @@
37156936 {
37166937 /*CALLEND*/
37176938 stackbase += 9LLU;
3718- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF17LLU;
6939+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ELLU;
37196940 fnaddr = /*ADDRNEXT__*/0x441123856140000LLU;/* SP = 0LLU */
37206941 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRNEXT__*/\n"); exit(-1); }
37216942 break;
37226943 }
3723-case 0xFFFFFFFFFFFFFF17LLU:
6944+case 0xFFFFFFFFFFFFFE2ELLU:
37246945 /* SP = 7LLU */
37256946 {
37266947 /*CALLEND*/
37276948 stackbase += 6LLU;
3728- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF16LLU;
6949+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2DLLU;
37296950 fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
37306951 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); }
37316952 break;
37326953 }
3733-case 0xFFFFFFFFFFFFFF16LLU:
6954+case 0xFFFFFFFFFFFFFE2DLLU:
37346955 /* SP = 4LLU */fputs(":\n", stdout);
37356956 {
37366957 /* CALLBEGIN */
@@ -3742,12 +6963,12 @@
37426963 {
37436964 /*CALLEND*/
37446965 stackbase += 6LLU;
3745- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF15LLU;
6966+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2CLLU;
37466967 fnaddr = /*SP_SET____*/0x4D00131540000000LLU;/* SP = 0LLU */
37476968 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SET____*/\n"); exit(-1); }
37486969 break;
37496970 }
3750-case 0xFFFFFFFFFFFFFF15LLU:
6971+case 0xFFFFFFFFFFFFFE2CLLU:
37516972 /* SP = 4LLU *//* SP = 4LLU *//* SP - 0LLU = 4LLU */
37526973 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
37536974 /* function requires 12LLU 64-bit chunks of memory (including 4LLU for parameters) */
@@ -3765,1624 +6986,15 @@
37656986 {
37666987 /*CALLEND*/
37676988 stackbase += 3LLU;
3768- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF14LLU;
6989+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2BLLU;
37696990 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
37706991 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
37716992 break;
37726993 }
3773-case 0xFFFFFFFFFFFFFF14LLU:
6994+case 0xFFFFFFFFFFFFFE2BLLU:
37746995 /* SP = 1LLU */fputs("; break; }", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
37756996 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
37766997 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
3777-case /*parsechar_*/0xADCB6E81E8DCB400LLU:/* SP = 0LLU */
3778- {
3779- /* CALLBEGIN */
3780- /* reserve space for 1LLU returned values *//* SP + 1LLU = 1LLU *//* SPMAX = 1LLU */
3781-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
3782- /* leave place for return addr *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
3783- }
3784- {
3785- /*CALLEND*/
3786- stackbase += 3LLU;
3787- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF13LLU;
3788- fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
3789-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
3790- break;
3791- }
3792-case 0xFFFFFFFFFFFFFF13LLU:
3793-/* SP = 1LLU */
3794- {
3795- /* CALLBEGIN */
3796- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3797-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
3798- /* leave place for return addr *//* SP + 1LLU = 3LLU */
3799- }
3800-{ /* PUSH */ stack[stackbase + 3LLU] = 39LLU; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
3801- {
3802- /*CALLEND*/
3803- stackbase += 3LLU;
3804- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF12LLU;
3805- fnaddr = /*match_____*/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
3806-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*match_____*/\n"); exit(-1); }
3807- break;
3808- }
3809-case 0xFFFFFFFFFFFFFF12LLU:
3810-/* SP = 1LLU */
3811-{ /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
3812-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
3813-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
3814-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3815-/* function requires 4LLU 64-bit chunks of memory (including 0LLU for parameters) */
3816-case /*parsenr___*/0xADCB6E829B400000LLU:/* SP = 0LLU */
3817-{ /* PUSH */ stack[stackbase + 0LLU] = 0LLU; }/* SP + 1LLU = 1LLU *//* SPMAX = 1LLU */
3818- {
3819- /* CALLBEGIN */
3820- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
3821-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
3822- /* leave place for return addr *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
3823- }
3824- {
3825- /*CALLEND*/
3826- stackbase += 3LLU;
3827- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF11LLU;
3828- fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
3829-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
3830- break;
3831- }
3832-case 0xFFFFFFFFFFFFFF11LLU:
3833-/* SP = 1LLU */
3834-case 0xFFFFFFFFFFFFFF10LLU: /* loop to here *//* predicate */
3835-
3836- {
3837- /* CALLBEGIN */
3838- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
3839-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
3840- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
3841- }
3842- {
3843- /* CALLBEGIN */
3844- /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
3845-{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
3846- /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
3847- }
3848- {
3849- /*CALLEND*/
3850- stackbase += 7LLU;
3851- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0ELLU;
3852- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
3853-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
3854- break;
3855- }
3856-case 0xFFFFFFFFFFFFFF0ELLU:
3857-/* SP = 5LLU */
3858- {
3859- /*CALLEND*/
3860- stackbase += 4LLU;
3861- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0DLLU;
3862- fnaddr = /*isdigit___*/0x92E7E48A4BC00000LLU;/* SP = 0LLU */
3863-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isdigit___*/\n"); exit(-1); }
3864- break;
3865- }
3866-case 0xFFFFFFFFFFFFFF0DLLU:
3867-/* SP = 2LLU */
3868-if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
3869-{ /* JUMP */ fnaddr = 18446744073709551375LLU; break; } /* skip loop */
3870-/* loop */
3871- {
3872- /* CALLBEGIN */
3873- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
3874-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
3875- /* leave place for return addr *//* SP + 1LLU = 4LLU */
3876- }
3877-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
3878-{ /* PUSH */ stack[stackbase + 5LLU] = 10LLU; }/* SP + 1LLU = 6LLU */
3879- {
3880- /*CALLEND*/
3881- stackbase += 4LLU;
3882- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0CLLU;
3883- fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
3884-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
3885- break;
3886- }
3887-case 0xFFFFFFFFFFFFFF0CLLU:
3888-/* SP = 2LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
3889-
3890- {
3891- /* CALLBEGIN */
3892- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
3893-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
3894- /* leave place for return addr *//* SP + 1LLU = 4LLU */
3895- }
3896-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
3897- {
3898- /* CALLBEGIN */
3899- /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
3900-{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
3901- /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
3902- }
3903- {
3904- /* CALLBEGIN */
3905- /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
3906-{ /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
3907- /* leave place for return addr *//* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
3908- }
3909- {
3910- /*CALLEND*/
3911- stackbase += 11LLU;
3912- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0BLLU;
3913- fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
3914-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
3915- break;
3916- }
3917-case 0xFFFFFFFFFFFFFF0BLLU:
3918-/* SP = 9LLU */
3919-{ /* PUSH */ stack[stackbase + 9LLU] = 48LLU; }/* SP + 1LLU = 10LLU */
3920- {
3921- /*CALLEND*/
3922- stackbase += 8LLU;
3923- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0ALLU;
3924- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
3925-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
3926- break;
3927- }
3928-case 0xFFFFFFFFFFFFFF0ALLU:
3929-/* SP = 6LLU */
3930- {
3931- /*CALLEND*/
3932- stackbase += 4LLU;
3933- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF09LLU;
3934- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
3935-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
3936- break;
3937- }
3938-case 0xFFFFFFFFFFFFFF09LLU:
3939-/* SP = 2LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
3940-/* SP = 1LLU */
3941-{ /* JUMP */ fnaddr = 18446744073709551376LLU; break; } /* loop */
3942-case 18446744073709551375LLU: /* skip to here */
3943-{ /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
3944-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
3945-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
3946-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3947-/* function requires 11LLU 64-bit chunks of memory (including 0LLU for parameters) */
3948-case /*parseid___*/0xADCB6E8247C00000LLU:/* SP = 0LLU */
3949-{ /* PUSH */ stack[stackbase + 0LLU] = 0LLU; }/* SP + 1LLU = 1LLU *//* SPMAX = 1LLU *//* predicate */
3950-
3951- {
3952- /* CALLBEGIN */
3953- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
3954-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
3955- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
3956- }
3957- {
3958- /* CALLBEGIN */
3959- /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
3960-{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
3961- /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
3962- }
3963- {
3964- /*CALLEND*/
3965- stackbase += 7LLU;
3966- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF07LLU;
3967- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
3968-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
3969- break;
3970- }
3971-case 0xFFFFFFFFFFFFFF07LLU:
3972-/* SP = 5LLU */
3973- {
3974- /*CALLEND*/
3975- stackbase += 4LLU;
3976- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF06LLU;
3977- fnaddr = /*isalpha___*/0x92E727AE37000000LLU;/* SP = 0LLU */
3978-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isalpha___*/\n"); exit(-1); }
3979- break;
3980- }
3981-case 0xFFFFFFFFFFFFFF06LLU:
3982-/* SP = 2LLU */
3983-if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
3984-{ /* JUMP */ fnaddr = 18446744073709551368LLU; break; } /* skip consequent */
3985-/* consequent */
3986-{ /* PUSH */ stack[stackbase + 1LLU] = 10LLU; }/* SP + 1LLU = 2LLU */
3987-case 0xFFFFFFFFFFFFFF05LLU: /* loop to here *//* predicate */
3988-
3989- {
3990- /* CALLBEGIN */
3991- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
3992-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
3993- /* leave place for return addr *//* SP + 1LLU = 5LLU */
3994- }
3995-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
3996-{ /* PUSH */ stack[stackbase + 6LLU] = 0LLU; }/* SP + 1LLU = 7LLU */
3997- {
3998- /*CALLEND*/
3999- stackbase += 5LLU;
4000- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF03LLU;
4001- fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
4002-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
4003- break;
4004- }
4005-case 0xFFFFFFFFFFFFFF03LLU:
4006-/* SP = 3LLU */
4007-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4008-{ /* JUMP */ fnaddr = 18446744073709551364LLU; break; } /* skip loop */
4009-/* loop *//* predicate */
4010-
4011- {
4012- /* CALLBEGIN */
4013- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4014-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4015- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4016- }
4017-{ /* PUSH */ stack[stackbase + 5LLU] = 95LLU; }/* SP + 1LLU = 6LLU */
4018- {
4019- /* CALLBEGIN */
4020- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
4021-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
4022- /* leave place for return addr *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
4023- }
4024- {
4025- /*CALLEND*/
4026- stackbase += 9LLU;
4027- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF00LLU;
4028- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
4029-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
4030- break;
4031- }
4032-case 0xFFFFFFFFFFFFFF00LLU:
4033-/* SP = 7LLU */
4034- {
4035- /*CALLEND*/
4036- stackbase += 5LLU;
4037- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFFLLU;
4038- fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
4039-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
4040- break;
4041- }
4042-case 0xFFFFFFFFFFFFFEFFLLU:
4043-/* SP = 3LLU */
4044-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4045-{ /* JUMP */ fnaddr = 18446744073709551362LLU; break; } /* skip consequent */
4046-/* consequent */
4047- {
4048- /* CALLBEGIN */
4049- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4050-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4051- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4052- }
4053-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
4054- {
4055- /* CALLBEGIN */
4056- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
4057-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4058- /* leave place for return addr *//* SP + 1LLU = 9LLU */
4059- }
4060- {
4061- /* CALLBEGIN */
4062- /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
4063-{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
4064- /* leave place for return addr *//* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
4065- }
4066- {
4067- /* CALLBEGIN */
4068- /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU *//* SPMAX = 13LLU */
4069-{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU *//* SPMAX = 14LLU */
4070- /* leave place for return addr *//* SP + 1LLU = 15LLU *//* SPMAX = 15LLU */
4071- }
4072- {
4073- /* CALLBEGIN */
4074- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU *//* SPMAX = 16LLU */
4075-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU *//* SPMAX = 17LLU */
4076- /* leave place for return addr *//* SP + 1LLU = 18LLU *//* SPMAX = 18LLU */
4077- }
4078- {
4079- /*CALLEND*/
4080- stackbase += 18LLU;
4081- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFELLU;
4082- fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
4083-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
4084- break;
4085- }
4086-case 0xFFFFFFFFFFFFFEFELLU:
4087-/* SP = 16LLU */
4088-{ /* PUSH */ stack[stackbase + 16LLU] = 95LLU; }/* SP + 1LLU = 17LLU */
4089- {
4090- /*CALLEND*/
4091- stackbase += 15LLU;
4092- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFDLLU;
4093- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4094-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4095- break;
4096- }
4097-case 0xFFFFFFFFFFFFFEFDLLU:
4098-/* SP = 13LLU */
4099-{ /* PUSH */ stack[stackbase + 13LLU] = 0LLU; }/* SP + 1LLU = 14LLU */
4100- {
4101- /*CALLEND*/
4102- stackbase += 12LLU;
4103- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFCLLU;
4104- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
4105-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
4106- break;
4107- }
4108-case 0xFFFFFFFFFFFFFEFCLLU:
4109-/* SP = 10LLU */
4110- {
4111- /* CALLBEGIN */
4112- /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
4113-{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
4114- /* leave place for return addr *//* SP + 1LLU = 13LLU */
4115- }
4116- {
4117- /* CALLBEGIN */
4118- /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
4119-{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
4120- /* leave place for return addr *//* SP + 1LLU = 16LLU */
4121- }
4122-{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
4123-{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
4124- {
4125- /*CALLEND*/
4126- stackbase += 16LLU;
4127- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFBLLU;
4128- fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
4129-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
4130- break;
4131- }
4132-case 0xFFFFFFFFFFFFFEFBLLU:
4133-/* SP = 14LLU */
4134-{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
4135- {
4136- /*CALLEND*/
4137- stackbase += 13LLU;
4138- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFALLU;
4139- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4140-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4141- break;
4142- }
4143-case 0xFFFFFFFFFFFFFEFALLU:
4144-/* SP = 11LLU */
4145- {
4146- /*CALLEND*/
4147- stackbase += 9LLU;
4148- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF9LLU;
4149- fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
4150-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
4151- break;
4152- }
4153-case 0xFFFFFFFFFFFFFEF9LLU:
4154-/* SP = 7LLU */
4155- {
4156- /*CALLEND*/
4157- stackbase += 5LLU;
4158- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF8LLU;
4159- fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
4160-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
4161- break;
4162- }
4163-case 0xFFFFFFFFFFFFFEF8LLU:
4164-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4165-/* SP = 2LLU *//* SP = 2LLU */
4166-{ /* JUMP */ fnaddr = 18446744073709551361LLU; break; } /* skip alternative */
4167-case 18446744073709551362LLU: /* alternative *//* predicate */
4168-
4169- {
4170- /* CALLBEGIN */
4171- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4172-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4173- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4174- }
4175- {
4176- /* CALLBEGIN */
4177- /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
4178-{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
4179- /* leave place for return addr *//* SP + 1LLU = 8LLU */
4180- }
4181- {
4182- /*CALLEND*/
4183- stackbase += 8LLU;
4184- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF5LLU;
4185- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
4186-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
4187- break;
4188- }
4189-case 0xFFFFFFFFFFFFFEF5LLU:
4190-/* SP = 6LLU */
4191- {
4192- /*CALLEND*/
4193- stackbase += 5LLU;
4194- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF4LLU;
4195- fnaddr = /*isupper___*/0x92EC2BAE0B400000LLU;/* SP = 0LLU */
4196-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isupper___*/\n"); exit(-1); }
4197- break;
4198- }
4199-case 0xFFFFFFFFFFFFFEF4LLU:
4200-/* SP = 3LLU */
4201-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4202-{ /* JUMP */ fnaddr = 18446744073709551351LLU; break; } /* skip consequent */
4203-/* consequent */
4204- {
4205- /* CALLBEGIN */
4206- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4207-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4208- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4209- }
4210-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
4211- {
4212- /* CALLBEGIN */
4213- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
4214-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4215- /* leave place for return addr *//* SP + 1LLU = 9LLU */
4216- }
4217- {
4218- /* CALLBEGIN */
4219- /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
4220-{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
4221- /* leave place for return addr *//* SP + 1LLU = 12LLU */
4222- }
4223- {
4224- /* CALLBEGIN */
4225- /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
4226-{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
4227- /* leave place for return addr *//* SP + 1LLU = 15LLU */
4228- }
4229- {
4230- /* CALLBEGIN */
4231- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
4232-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
4233- /* leave place for return addr *//* SP + 1LLU = 18LLU */
4234- }
4235- {
4236- /*CALLEND*/
4237- stackbase += 18LLU;
4238- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF3LLU;
4239- fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
4240-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
4241- break;
4242- }
4243-case 0xFFFFFFFFFFFFFEF3LLU:
4244-/* SP = 16LLU */
4245-{ /* PUSH */ stack[stackbase + 16LLU] = 65LLU; }/* SP + 1LLU = 17LLU */
4246- {
4247- /*CALLEND*/
4248- stackbase += 15LLU;
4249- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF2LLU;
4250- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4251-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4252- break;
4253- }
4254-case 0xFFFFFFFFFFFFFEF2LLU:
4255-/* SP = 13LLU */
4256-{ /* PUSH */ stack[stackbase + 13LLU] = 1LLU; }/* SP + 1LLU = 14LLU */
4257- {
4258- /*CALLEND*/
4259- stackbase += 12LLU;
4260- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF1LLU;
4261- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
4262-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
4263- break;
4264- }
4265-case 0xFFFFFFFFFFFFFEF1LLU:
4266-/* SP = 10LLU */
4267- {
4268- /* CALLBEGIN */
4269- /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
4270-{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
4271- /* leave place for return addr *//* SP + 1LLU = 13LLU */
4272- }
4273- {
4274- /* CALLBEGIN */
4275- /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
4276-{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
4277- /* leave place for return addr *//* SP + 1LLU = 16LLU */
4278- }
4279-{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
4280-{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
4281- {
4282- /*CALLEND*/
4283- stackbase += 16LLU;
4284- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF0LLU;
4285- fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
4286-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
4287- break;
4288- }
4289-case 0xFFFFFFFFFFFFFEF0LLU:
4290-/* SP = 14LLU */
4291-{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
4292- {
4293- /*CALLEND*/
4294- stackbase += 13LLU;
4295- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEFLLU;
4296- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4297-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4298- break;
4299- }
4300-case 0xFFFFFFFFFFFFFEEFLLU:
4301-/* SP = 11LLU */
4302- {
4303- /*CALLEND*/
4304- stackbase += 9LLU;
4305- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEELLU;
4306- fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
4307-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
4308- break;
4309- }
4310-case 0xFFFFFFFFFFFFFEEELLU:
4311-/* SP = 7LLU */
4312- {
4313- /*CALLEND*/
4314- stackbase += 5LLU;
4315- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEDLLU;
4316- fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
4317-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
4318- break;
4319- }
4320-case 0xFFFFFFFFFFFFFEEDLLU:
4321-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4322-/* SP = 2LLU *//* SP = 2LLU */
4323-{ /* JUMP */ fnaddr = 18446744073709551350LLU; break; } /* skip alternative */
4324-case 18446744073709551351LLU: /* alternative *//* predicate */
4325-
4326- {
4327- /* CALLBEGIN */
4328- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4329-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4330- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4331- }
4332-{ /* PUSH */ stack[stackbase + 5LLU] = 36LLU; }/* SP + 1LLU = 6LLU */
4333- {
4334- /* CALLBEGIN */
4335- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
4336-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4337- /* leave place for return addr *//* SP + 1LLU = 9LLU */
4338- }
4339- {
4340- /*CALLEND*/
4341- stackbase += 9LLU;
4342- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEALLU;
4343- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
4344-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
4345- break;
4346- }
4347-case 0xFFFFFFFFFFFFFEEALLU:
4348-/* SP = 7LLU */
4349- {
4350- /*CALLEND*/
4351- stackbase += 5LLU;
4352- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE9LLU;
4353- fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
4354-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
4355- break;
4356- }
4357-case 0xFFFFFFFFFFFFFEE9LLU:
4358-/* SP = 3LLU */
4359-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4360-{ /* JUMP */ fnaddr = 18446744073709551340LLU; break; } /* skip consequent */
4361-/* consequent */
4362- {
4363- /* CALLBEGIN */
4364- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4365-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4366- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4367- }
4368-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
4369- {
4370- /* CALLBEGIN */
4371- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
4372-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4373- /* leave place for return addr *//* SP + 1LLU = 9LLU */
4374- }
4375- {
4376- /* CALLBEGIN */
4377- /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
4378-{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
4379- /* leave place for return addr *//* SP + 1LLU = 12LLU */
4380- }
4381- {
4382- /* CALLBEGIN */
4383- /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
4384-{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
4385- /* leave place for return addr *//* SP + 1LLU = 15LLU */
4386- }
4387- {
4388- /* CALLBEGIN */
4389- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
4390-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
4391- /* leave place for return addr *//* SP + 1LLU = 18LLU */
4392- }
4393- {
4394- /*CALLEND*/
4395- stackbase += 18LLU;
4396- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE8LLU;
4397- fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
4398-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
4399- break;
4400- }
4401-case 0xFFFFFFFFFFFFFEE8LLU:
4402-/* SP = 16LLU */
4403-{ /* PUSH */ stack[stackbase + 16LLU] = 36LLU; }/* SP + 1LLU = 17LLU */
4404- {
4405- /*CALLEND*/
4406- stackbase += 15LLU;
4407- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE7LLU;
4408- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4409-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4410- break;
4411- }
4412-case 0xFFFFFFFFFFFFFEE7LLU:
4413-/* SP = 13LLU */
4414-{ /* PUSH */ stack[stackbase + 13LLU] = 27LLU; }/* SP + 1LLU = 14LLU */
4415- {
4416- /*CALLEND*/
4417- stackbase += 12LLU;
4418- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE6LLU;
4419- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
4420-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
4421- break;
4422- }
4423-case 0xFFFFFFFFFFFFFEE6LLU:
4424-/* SP = 10LLU */
4425- {
4426- /* CALLBEGIN */
4427- /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
4428-{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
4429- /* leave place for return addr *//* SP + 1LLU = 13LLU */
4430- }
4431- {
4432- /* CALLBEGIN */
4433- /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
4434-{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
4435- /* leave place for return addr *//* SP + 1LLU = 16LLU */
4436- }
4437-{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
4438-{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
4439- {
4440- /*CALLEND*/
4441- stackbase += 16LLU;
4442- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE5LLU;
4443- fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
4444-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
4445- break;
4446- }
4447-case 0xFFFFFFFFFFFFFEE5LLU:
4448-/* SP = 14LLU */
4449-{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
4450- {
4451- /*CALLEND*/
4452- stackbase += 13LLU;
4453- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE4LLU;
4454- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4455-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4456- break;
4457- }
4458-case 0xFFFFFFFFFFFFFEE4LLU:
4459-/* SP = 11LLU */
4460- {
4461- /*CALLEND*/
4462- stackbase += 9LLU;
4463- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE3LLU;
4464- fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
4465-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
4466- break;
4467- }
4468-case 0xFFFFFFFFFFFFFEE3LLU:
4469-/* SP = 7LLU */
4470- {
4471- /*CALLEND*/
4472- stackbase += 5LLU;
4473- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE2LLU;
4474- fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
4475-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
4476- break;
4477- }
4478-case 0xFFFFFFFFFFFFFEE2LLU:
4479-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4480-/* SP = 2LLU *//* SP = 2LLU */
4481-{ /* JUMP */ fnaddr = 18446744073709551339LLU; break; } /* skip alternative */
4482-case 18446744073709551340LLU: /* alternative *//* predicate */
4483-
4484- {
4485- /* CALLBEGIN */
4486- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4487-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4488- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4489- }
4490- {
4491- /* CALLBEGIN */
4492- /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
4493-{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
4494- /* leave place for return addr *//* SP + 1LLU = 8LLU */
4495- }
4496- {
4497- /*CALLEND*/
4498- stackbase += 8LLU;
4499- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDFLLU;
4500- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
4501-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
4502- break;
4503- }
4504-case 0xFFFFFFFFFFFFFEDFLLU:
4505-/* SP = 6LLU */
4506- {
4507- /*CALLEND*/
4508- stackbase += 5LLU;
4509- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDELLU;
4510- fnaddr = /*islower___*/0x92E9EACA0B400000LLU;/* SP = 0LLU */
4511-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*islower___*/\n"); exit(-1); }
4512- break;
4513- }
4514-case 0xFFFFFFFFFFFFFEDELLU:
4515-/* SP = 3LLU */
4516-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4517-{ /* JUMP */ fnaddr = 18446744073709551329LLU; break; } /* skip consequent */
4518-/* consequent */
4519- {
4520- /* CALLBEGIN */
4521- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4522-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4523- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4524- }
4525-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
4526- {
4527- /* CALLBEGIN */
4528- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
4529-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4530- /* leave place for return addr *//* SP + 1LLU = 9LLU */
4531- }
4532- {
4533- /* CALLBEGIN */
4534- /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
4535-{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
4536- /* leave place for return addr *//* SP + 1LLU = 12LLU */
4537- }
4538- {
4539- /* CALLBEGIN */
4540- /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
4541-{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
4542- /* leave place for return addr *//* SP + 1LLU = 15LLU */
4543- }
4544- {
4545- /* CALLBEGIN */
4546- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
4547-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
4548- /* leave place for return addr *//* SP + 1LLU = 18LLU */
4549- }
4550- {
4551- /*CALLEND*/
4552- stackbase += 18LLU;
4553- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDDLLU;
4554- fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
4555-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
4556- break;
4557- }
4558-case 0xFFFFFFFFFFFFFEDDLLU:
4559-/* SP = 16LLU */
4560-{ /* PUSH */ stack[stackbase + 16LLU] = 97LLU; }/* SP + 1LLU = 17LLU */
4561- {
4562- /*CALLEND*/
4563- stackbase += 15LLU;
4564- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDCLLU;
4565- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4566-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4567- break;
4568- }
4569-case 0xFFFFFFFFFFFFFEDCLLU:
4570-/* SP = 13LLU */
4571-{ /* PUSH */ stack[stackbase + 13LLU] = 28LLU; }/* SP + 1LLU = 14LLU */
4572- {
4573- /*CALLEND*/
4574- stackbase += 12LLU;
4575- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDBLLU;
4576- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
4577-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
4578- break;
4579- }
4580-case 0xFFFFFFFFFFFFFEDBLLU:
4581-/* SP = 10LLU */
4582- {
4583- /* CALLBEGIN */
4584- /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
4585-{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
4586- /* leave place for return addr *//* SP + 1LLU = 13LLU */
4587- }
4588- {
4589- /* CALLBEGIN */
4590- /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
4591-{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
4592- /* leave place for return addr *//* SP + 1LLU = 16LLU */
4593- }
4594-{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
4595-{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
4596- {
4597- /*CALLEND*/
4598- stackbase += 16LLU;
4599- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDALLU;
4600- fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
4601-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
4602- break;
4603- }
4604-case 0xFFFFFFFFFFFFFEDALLU:
4605-/* SP = 14LLU */
4606-{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
4607- {
4608- /*CALLEND*/
4609- stackbase += 13LLU;
4610- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED9LLU;
4611- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4612-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4613- break;
4614- }
4615-case 0xFFFFFFFFFFFFFED9LLU:
4616-/* SP = 11LLU */
4617- {
4618- /*CALLEND*/
4619- stackbase += 9LLU;
4620- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED8LLU;
4621- fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
4622-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
4623- break;
4624- }
4625-case 0xFFFFFFFFFFFFFED8LLU:
4626-/* SP = 7LLU */
4627- {
4628- /*CALLEND*/
4629- stackbase += 5LLU;
4630- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED7LLU;
4631- fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
4632-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
4633- break;
4634- }
4635-case 0xFFFFFFFFFFFFFED7LLU:
4636-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4637-/* SP = 2LLU *//* SP = 2LLU */
4638-{ /* JUMP */ fnaddr = 18446744073709551328LLU; break; } /* skip alternative */
4639-case 18446744073709551329LLU: /* alternative *//* predicate */
4640-
4641- {
4642- /* CALLBEGIN */
4643- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4644-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4645- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4646- }
4647- {
4648- /* CALLBEGIN */
4649- /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
4650-{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
4651- /* leave place for return addr *//* SP + 1LLU = 8LLU */
4652- }
4653- {
4654- /*CALLEND*/
4655- stackbase += 8LLU;
4656- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED4LLU;
4657- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
4658-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
4659- break;
4660- }
4661-case 0xFFFFFFFFFFFFFED4LLU:
4662-/* SP = 6LLU */
4663- {
4664- /*CALLEND*/
4665- stackbase += 5LLU;
4666- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED3LLU;
4667- fnaddr = /*isdigit___*/0x92E7E48A4BC00000LLU;/* SP = 0LLU */
4668-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isdigit___*/\n"); exit(-1); }
4669- break;
4670- }
4671-case 0xFFFFFFFFFFFFFED3LLU:
4672-/* SP = 3LLU */
4673-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4674-{ /* JUMP */ fnaddr = 18446744073709551318LLU; break; } /* skip consequent */
4675-/* consequent */
4676- {
4677- /* CALLBEGIN */
4678- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4679-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4680- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4681- }
4682-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
4683- {
4684- /* CALLBEGIN */
4685- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
4686-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
4687- /* leave place for return addr *//* SP + 1LLU = 9LLU */
4688- }
4689- {
4690- /* CALLBEGIN */
4691- /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
4692-{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
4693- /* leave place for return addr *//* SP + 1LLU = 12LLU */
4694- }
4695- {
4696- /* CALLBEGIN */
4697- /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
4698-{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
4699- /* leave place for return addr *//* SP + 1LLU = 15LLU */
4700- }
4701- {
4702- /* CALLBEGIN */
4703- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
4704-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
4705- /* leave place for return addr *//* SP + 1LLU = 18LLU */
4706- }
4707- {
4708- /*CALLEND*/
4709- stackbase += 18LLU;
4710- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED2LLU;
4711- fnaddr = /*get_______*/0x8A0BC00000000000LLU;/* SP = 0LLU */
4712-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*get_______*/\n"); exit(-1); }
4713- break;
4714- }
4715-case 0xFFFFFFFFFFFFFED2LLU:
4716-/* SP = 16LLU */
4717-{ /* PUSH */ stack[stackbase + 16LLU] = 48LLU; }/* SP + 1LLU = 17LLU */
4718- {
4719- /*CALLEND*/
4720- stackbase += 15LLU;
4721- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED1LLU;
4722- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4723-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4724- break;
4725- }
4726-case 0xFFFFFFFFFFFFFED1LLU:
4727-/* SP = 13LLU */
4728-{ /* PUSH */ stack[stackbase + 13LLU] = 54LLU; }/* SP + 1LLU = 14LLU */
4729- {
4730- /*CALLEND*/
4731- stackbase += 12LLU;
4732- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED0LLU;
4733- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
4734-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
4735- break;
4736- }
4737-case 0xFFFFFFFFFFFFFED0LLU:
4738-/* SP = 10LLU */
4739- {
4740- /* CALLBEGIN */
4741- /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
4742-{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
4743- /* leave place for return addr *//* SP + 1LLU = 13LLU */
4744- }
4745- {
4746- /* CALLBEGIN */
4747- /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
4748-{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
4749- /* leave place for return addr *//* SP + 1LLU = 16LLU */
4750- }
4751-{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 17LLU */
4752-{ /* PUSH */ stack[stackbase + 17LLU] = 6LLU; }/* SP + 1LLU = 18LLU */
4753- {
4754- /*CALLEND*/
4755- stackbase += 16LLU;
4756- stack[stackbase - 1] = 0xFFFFFFFFFFFFFECFLLU;
4757- fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
4758-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
4759- break;
4760- }
4761-case 0xFFFFFFFFFFFFFECFLLU:
4762-/* SP = 14LLU */
4763-{ /* PUSH */ stack[stackbase + 14LLU] = 2LLU; }/* SP + 1LLU = 15LLU */
4764- {
4765- /*CALLEND*/
4766- stackbase += 13LLU;
4767- stack[stackbase - 1] = 0xFFFFFFFFFFFFFECELLU;
4768- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4769-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4770- break;
4771- }
4772-case 0xFFFFFFFFFFFFFECELLU:
4773-/* SP = 11LLU */
4774- {
4775- /*CALLEND*/
4776- stackbase += 9LLU;
4777- stack[stackbase - 1] = 0xFFFFFFFFFFFFFECDLLU;
4778- fnaddr = /*shiftleft_*/0xBA3921BE7821BC00LLU;/* SP = 0LLU */
4779-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*shiftleft_*/\n"); exit(-1); }
4780- break;
4781- }
4782-case 0xFFFFFFFFFFFFFECDLLU:
4783-/* SP = 7LLU */
4784- {
4785- /*CALLEND*/
4786- stackbase += 5LLU;
4787- stack[stackbase - 1] = 0xFFFFFFFFFFFFFECCLLU;
4788- fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
4789-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
4790- break;
4791- }
4792-case 0xFFFFFFFFFFFFFECCLLU:
4793-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4794-/* SP = 2LLU *//* SP = 2LLU */
4795-{ /* JUMP */ fnaddr = 18446744073709551317LLU; break; } /* skip alternative */
4796-case 18446744073709551318LLU: /* alternative */
4797-{ /* PUSH */ stack[stackbase + 2LLU] = 1LLU; }/* SP + 1LLU = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4798-/* SP = 2LLU */
4799-case 18446744073709551317LLU: /* skip to here */
4800-
4801-case 18446744073709551328LLU: /* skip to here */
4802-
4803-case 18446744073709551339LLU: /* skip to here */
4804-
4805-case 18446744073709551350LLU: /* skip to here */
4806-
4807-case 18446744073709551361LLU: /* skip to here */
4808-
4809- {
4810- /* CALLBEGIN */
4811- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4812-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4813- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4814- }
4815-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
4816-{ /* PUSH */ stack[stackbase + 6LLU] = 1LLU; }/* SP + 1LLU = 7LLU */
4817- {
4818- /*CALLEND*/
4819- stackbase += 5LLU;
4820- stack[stackbase - 1] = 0xFFFFFFFFFFFFFECBLLU;
4821- fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
4822-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
4823- break;
4824- }
4825-case 0xFFFFFFFFFFFFFECBLLU:
4826-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4827-/* SP = 2LLU */
4828-{ /* JUMP */ fnaddr = 18446744073709551365LLU; break; } /* loop */
4829-case 18446744073709551364LLU: /* skip to here */
4830-case 0xFFFFFFFFFFFFFECALLU: /* loop to here *//* predicate */
4831-
4832- {
4833- /* CALLBEGIN */
4834- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4835-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4836- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4837- }
4838-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
4839-{ /* PUSH */ stack[stackbase + 6LLU] = 16LLU; }/* SP + 1LLU = 7LLU */
4840- {
4841- /*CALLEND*/
4842- stackbase += 5LLU;
4843- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC8LLU;
4844- fnaddr = /*lss_______*/0x9EEB800000000000LLU;/* SP = 0LLU */
4845-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*lss_______*/\n"); exit(-1); }
4846- break;
4847- }
4848-case 0xFFFFFFFFFFFFFEC8LLU:
4849-/* SP = 3LLU */
4850-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4851-{ /* JUMP */ fnaddr = 18446744073709551305LLU; break; } /* skip loop */
4852-/* loop *//* predicate */
4853-
4854- {
4855- /* CALLBEGIN */
4856- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4857-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4858- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4859- }
4860-{ /* PUSH */ stack[stackbase + 5LLU] = 39LLU; }/* SP + 1LLU = 6LLU */
4861- {
4862- /*CALLEND*/
4863- stackbase += 5LLU;
4864- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC5LLU;
4865- fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
4866-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
4867- break;
4868- }
4869-case 0xFFFFFFFFFFFFFEC5LLU:
4870-/* SP = 3LLU */
4871-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
4872-{ /* JUMP */ fnaddr = 18446744073709551303LLU; break; } /* skip consequent */
4873-/* consequent */
4874- {
4875- /* CALLBEGIN */
4876- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4877-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4878- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4879- }
4880-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
4881-{ /* PUSH */ stack[stackbase + 6LLU] = 1LLU; }/* SP + 1LLU = 7LLU */
4882- {
4883- /*CALLEND*/
4884- stackbase += 5LLU;
4885- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC4LLU;
4886- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
4887-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
4888- break;
4889- }
4890-case 0xFFFFFFFFFFFFFEC4LLU:
4891-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4892-/* SP = 2LLU *//* SP = 2LLU */
4893-{ /* JUMP */ fnaddr = 18446744073709551302LLU; break; } /* skip alternative */
4894-case 18446744073709551303LLU: /* alternative */
4895-{ /* PUSH */ stack[stackbase + 2LLU] = 15LLU; }/* SP + 1LLU = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4896-/* SP = 2LLU */
4897-case 18446744073709551302LLU: /* skip to here */
4898-
4899- {
4900- /* CALLBEGIN */
4901- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
4902-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
4903- /* leave place for return addr *//* SP + 1LLU = 5LLU */
4904- }
4905-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
4906-{ /* PUSH */ stack[stackbase + 6LLU] = 1LLU; }/* SP + 1LLU = 7LLU */
4907- {
4908- /*CALLEND*/
4909- stackbase += 5LLU;
4910- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC3LLU;
4911- fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
4912-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
4913- break;
4914- }
4915-case 0xFFFFFFFFFFFFFEC3LLU:
4916-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
4917-/* SP = 2LLU */
4918-{ /* JUMP */ fnaddr = 18446744073709551306LLU; break; } /* loop */
4919-case 18446744073709551305LLU: /* skip to here *//* SP = 1LLU */
4920-case 18446744073709551368LLU: /* alternative */
4921-{ /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
4922-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
4923-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
4924-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4925-/* function requires 18LLU 64-bit chunks of memory (including 0LLU for parameters) */
4926-case /*printetype*/0xAED929BE0BF4AE00LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
4927-
4928- {
4929- /* CALLBEGIN */
4930- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
4931-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
4932- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
4933- }
4934-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
4935-{ /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
4936- {
4937- /*CALLEND*/
4938- stackbase += 4LLU;
4939- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC0LLU;
4940- fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
4941-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
4942- break;
4943- }
4944-case 0xFFFFFFFFFFFFFEC0LLU:
4945-/* SP = 2LLU */
4946-if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
4947-{ /* JUMP */ fnaddr = 18446744073709551298LLU; break; } /* skip consequent */
4948-/* consequent */
4949- {
4950- /* CALLBEGIN */
4951- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
4952-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
4953- /* leave place for return addr *//* SP + 1LLU = 4LLU */
4954- }
4955-{ /* PUSH */ stack[stackbase + 4LLU] = 117LLU; }/* SP + 1LLU = 5LLU */
4956- {
4957- /*CALLEND*/
4958- stackbase += 4LLU;
4959- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBFLLU;
4960- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
4961-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
4962- break;
4963- }
4964-case 0xFFFFFFFFFFFFFEBFLLU:
4965-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
4966-
4967- {
4968- /* CALLBEGIN */
4969- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
4970-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
4971- /* leave place for return addr *//* SP + 1LLU = 4LLU */
4972- }
4973-{ /* PUSH */ stack[stackbase + 4LLU] = 54LLU; }/* SP + 1LLU = 5LLU */
4974- {
4975- /*CALLEND*/
4976- stackbase += 4LLU;
4977- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBELLU;
4978- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
4979-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
4980- break;
4981- }
4982-case 0xFFFFFFFFFFFFFEBELLU:
4983-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
4984-
4985- {
4986- /* CALLBEGIN */
4987- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
4988-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
4989- /* leave place for return addr *//* SP + 1LLU = 4LLU */
4990- }
4991-{ /* PUSH */ stack[stackbase + 4LLU] = 52LLU; }/* SP + 1LLU = 5LLU */
4992- {
4993- /*CALLEND*/
4994- stackbase += 4LLU;
4995- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBDLLU;
4996- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
4997-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
4998- break;
4999- }
5000-case 0xFFFFFFFFFFFFFEBDLLU:
5001-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5002-
5003- {
5004- /* CALLBEGIN */
5005- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
5006-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5007- /* leave place for return addr *//* SP + 1LLU = 4LLU */
5008- }
5009-{ /* PUSH */ stack[stackbase + 4LLU] = 94LLU; }/* SP + 1LLU = 5LLU */
5010- {
5011- /*CALLEND*/
5012- stackbase += 4LLU;
5013- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBCLLU;
5014- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
5015-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
5016- break;
5017- }
5018-case 0xFFFFFFFFFFFFFEBCLLU:
5019-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5020-
5021- {
5022- /* CALLBEGIN */
5023- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
5024-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
5025- /* leave place for return addr *//* SP + 1LLU = 3LLU */
5026- }
5027-{ /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU */
5028- {
5029- /*CALLEND*/
5030- stackbase += 3LLU;
5031- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBBLLU;
5032- fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
5033-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
5034- break;
5035- }
5036-case 0xFFFFFFFFFFFFFEBBLLU:
5037-/* SP = 1LLU *//* SP = 1LLU *//* SP = 1LLU */
5038-{ /* JUMP */ fnaddr = 18446744073709551297LLU; break; } /* skip alternative */
5039-case 18446744073709551298LLU: /* alternative */
5040- {
5041- /* CALLBEGIN */
5042- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
5043-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5044- /* leave place for return addr *//* SP + 1LLU = 4LLU */
5045- }
5046-{ /* PUSH */ stack[stackbase + 4LLU] = 117LLU; }/* SP + 1LLU = 5LLU */
5047- {
5048- /*CALLEND*/
5049- stackbase += 4LLU;
5050- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBALLU;
5051- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
5052-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
5053- break;
5054- }
5055-case 0xFFFFFFFFFFFFFEBALLU:
5056-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5057-
5058- {
5059- /* CALLBEGIN */
5060- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
5061-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5062- /* leave place for return addr *//* SP + 1LLU = 4LLU */
5063- }
5064-{ /* PUSH */ stack[stackbase + 4LLU] = 110LLU; }/* SP + 1LLU = 5LLU */
5065- {
5066- /*CALLEND*/
5067- stackbase += 4LLU;
5068- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB9LLU;
5069- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
5070-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
5071- break;
5072- }
5073-case 0xFFFFFFFFFFFFFEB9LLU:
5074-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5075-
5076- {
5077- /* CALLBEGIN */
5078- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
5079-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5080- /* leave place for return addr *//* SP + 1LLU = 4LLU */
5081- }
5082-{ /* PUSH */ stack[stackbase + 4LLU] = 105LLU; }/* SP + 1LLU = 5LLU */
5083- {
5084- /*CALLEND*/
5085- stackbase += 4LLU;
5086- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB8LLU;
5087- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
5088-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
5089- break;
5090- }
5091-case 0xFFFFFFFFFFFFFEB8LLU:
5092-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5093-
5094- {
5095- /* CALLBEGIN */
5096- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
5097-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5098- /* leave place for return addr *//* SP + 1LLU = 4LLU */
5099- }
5100-{ /* PUSH */ stack[stackbase + 4LLU] = 116LLU; }/* SP + 1LLU = 5LLU */
5101- {
5102- /*CALLEND*/
5103- stackbase += 4LLU;
5104- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB7LLU;
5105- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
5106-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
5107- break;
5108- }
5109-case 0xFFFFFFFFFFFFFEB7LLU:
5110-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5111-/* SP = 1LLU */
5112-case 18446744073709551297LLU: /* skip to here */
5113-/* SP = 1LLU *//* SP - 0LLU = 1LLU */
5114-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5115-/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
5116-case /*printtype_*/0xAED929BEFD2B8000LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
5117-
5118- {
5119- /* CALLBEGIN */
5120- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
5121-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
5122- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
5123- }
5124-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
5125- {
5126- /*CALLEND*/
5127- stackbase += 4LLU;
5128- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB4LLU;
5129- fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
5130-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); }
5131- break;
5132- }
5133-case 0xFFFFFFFFFFFFFEB4LLU:
5134-/* SP = 2LLU */
5135-if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
5136-{ /* JUMP */ fnaddr = 18446744073709551286LLU; break; } /* skip consequent */
5137-/* consequent */
5138- {
5139- /* CALLBEGIN */
5140- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
5141-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5142- /* leave place for return addr *//* SP + 1LLU = 4LLU */
5143- }
5144-{ /* PUSH */ stack[stackbase + 4LLU] = 91LLU; }/* SP + 1LLU = 5LLU */
5145- {
5146- /*CALLEND*/
5147- stackbase += 4LLU;
5148- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB3LLU;
5149- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
5150-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
5151- break;
5152- }
5153-case 0xFFFFFFFFFFFFFEB3LLU:
5154-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5155-
5156- {
5157- /* CALLBEGIN */
5158- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
5159-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
5160- /* leave place for return addr *//* SP + 1LLU = 3LLU */
5161- }
5162- {
5163- /* CALLBEGIN */
5164- /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
5165-{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
5166- /* leave place for return addr *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
5167- }
5168-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
5169- {
5170- /*CALLEND*/
5171- stackbase += 6LLU;
5172- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB2LLU;
5173- fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */
5174-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); }
5175- break;
5176- }
5177-case 0xFFFFFFFFFFFFFEB2LLU:
5178-/* SP = 4LLU */
5179- {
5180- /*CALLEND*/
5181- stackbase += 3LLU;
5182- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB1LLU;
5183- fnaddr = /*printetype*/0xAED929BE0BF4AE00LLU;/* SP = 0LLU */
5184-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printetype*/\n"); exit(-1); }
5185- break;
5186- }
5187-case 0xFFFFFFFFFFFFFEB1LLU:
5188-/* SP = 1LLU */
5189- {
5190- /* CALLBEGIN */
5191- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
5192-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5193- /* leave place for return addr *//* SP + 1LLU = 4LLU */
5194- }
5195-{ /* PUSH */ stack[stackbase + 4LLU] = 93LLU; }/* SP + 1LLU = 5LLU */
5196- {
5197- /*CALLEND*/
5198- stackbase += 4LLU;
5199- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB0LLU;
5200- fnaddr = /*put_______*/0xAF0BC00000000000LLU;/* SP = 0LLU */
5201-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*put_______*/\n"); exit(-1); }
5202- break;
5203- }
5204-case 0xFFFFFFFFFFFFFEB0LLU:
5205-/* SP = 2LLU */(void)/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
5206-/* SP = 1LLU *//* SP = 1LLU */
5207-{ /* JUMP */ fnaddr = 18446744073709551285LLU; break; } /* skip alternative */
5208-case 18446744073709551286LLU: /* alternative */
5209- {
5210- /* CALLBEGIN */
5211- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
5212-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
5213- /* leave place for return addr *//* SP + 1LLU = 3LLU */
5214- }
5215- {
5216- /* CALLBEGIN */
5217- /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
5218-{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
5219- /* leave place for return addr *//* SP + 1LLU = 6LLU */
5220- }
5221-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
5222- {
5223- /*CALLEND*/
5224- stackbase += 6LLU;
5225- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEAFLLU;
5226- fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */
5227-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); }
5228- break;
5229- }
5230-case 0xFFFFFFFFFFFFFEAFLLU:
5231-/* SP = 4LLU */
5232- {
5233- /*CALLEND*/
5234- stackbase += 3LLU;
5235- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEAELLU;
5236- fnaddr = /*printetype*/0xAED929BE0BF4AE00LLU;/* SP = 0LLU */
5237-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printetype*/\n"); exit(-1); }
5238- break;
5239- }
5240-case 0xFFFFFFFFFFFFFEAELLU:
5241-/* SP = 1LLU *//* SP = 1LLU */
5242-case 18446744073709551285LLU: /* skip to here */
5243-/* SP = 1LLU *//* SP - 0LLU = 1LLU */
5244-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5245-/* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */
5246-case /*debugetype*/0x7E07708A0BF4AE00LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
5247-
5248- {
5249- /* CALLBEGIN */
5250- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
5251-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
5252- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
5253- }
5254-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
5255-{ /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
5256- {
5257- /*CALLEND*/
5258- stackbase += 4LLU;
5259- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEABLLU;
5260- fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
5261-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
5262- break;
5263- }
5264-case 0xFFFFFFFFFFFFFEABLLU:
5265-/* SP = 2LLU */
5266-if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
5267-{ /* JUMP */ fnaddr = 18446744073709551277LLU; break; } /* skip consequent */
5268-/* consequent */fputs("u64^", stderr);
5269- {
5270- /* CALLBEGIN */
5271- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
5272-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
5273- /* leave place for return addr *//* SP + 1LLU = 3LLU */
5274- }
5275-{ /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU */
5276- {
5277- /*CALLEND*/
5278- stackbase += 3LLU;
5279- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEAALLU;
5280- fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
5281-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
5282- break;
5283- }
5284-case 0xFFFFFFFFFFFFFEAALLU:
5285-/* SP = 1LLU *//* SP = 1LLU *//* SP = 1LLU */
5286-{ /* JUMP */ fnaddr = 18446744073709551276LLU; break; } /* skip alternative */
5287-case 18446744073709551277LLU: /* alternative */fputs("unit", stderr); /* SP = 1LLU */
5288-case 18446744073709551276LLU: /* skip to here */
5289-/* SP = 1LLU *//* SP - 0LLU = 1LLU */
5290-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5291-/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
5292-case /*debugtype_*/0x7E07708AFD2B8000LLU:/* SP = 1LLU *//* SPMAX = 1LLU *//* predicate */
5293-
5294- {
5295- /* CALLBEGIN */
5296- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
5297-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
5298- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
5299- }
5300-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
5301- {
5302- /*CALLEND*/
5303- stackbase += 4LLU;
5304- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA7LLU;
5305- fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
5306-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); }
5307- break;
5308- }
5309-case 0xFFFFFFFFFFFFFEA7LLU:
5310-/* SP = 2LLU */
5311-if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
5312-{ /* JUMP */ fnaddr = 18446744073709551273LLU; break; } /* skip consequent */
5313-/* consequent */fputs("[", stderr);
5314- {
5315- /* CALLBEGIN */
5316- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
5317-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
5318- /* leave place for return addr *//* SP + 1LLU = 3LLU */
5319- }
5320- {
5321- /* CALLBEGIN */
5322- /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
5323-{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
5324- /* leave place for return addr *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
5325- }
5326-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
5327- {
5328- /*CALLEND*/
5329- stackbase += 6LLU;
5330- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA6LLU;
5331- fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */
5332-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); }
5333- break;
5334- }
5335-case 0xFFFFFFFFFFFFFEA6LLU:
5336-/* SP = 4LLU */
5337- {
5338- /*CALLEND*/
5339- stackbase += 3LLU;
5340- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA5LLU;
5341- fnaddr = /*debugetype*/0x7E07708A0BF4AE00LLU;/* SP = 0LLU */
5342-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugetype*/\n"); exit(-1); }
5343- break;
5344- }
5345-case 0xFFFFFFFFFFFFFEA5LLU:
5346-/* SP = 1LLU */fputs("]", stderr); /* SP = 1LLU *//* SP = 1LLU */
5347-{ /* JUMP */ fnaddr = 18446744073709551272LLU; break; } /* skip alternative */
5348-case 18446744073709551273LLU: /* alternative */
5349- {
5350- /* CALLBEGIN */
5351- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
5352-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
5353- /* leave place for return addr *//* SP + 1LLU = 3LLU */
5354- }
5355- {
5356- /* CALLBEGIN */
5357- /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
5358-{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
5359- /* leave place for return addr *//* SP + 1LLU = 6LLU */
5360- }
5361-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
5362- {
5363- /*CALLEND*/
5364- stackbase += 6LLU;
5365- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA4LLU;
5366- fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */
5367-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); }
5368- break;
5369- }
5370-case 0xFFFFFFFFFFFFFEA4LLU:
5371-/* SP = 4LLU */
5372- {
5373- /*CALLEND*/
5374- stackbase += 3LLU;
5375- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA3LLU;
5376- fnaddr = /*debugetype*/0x7E07708A0BF4AE00LLU;/* SP = 0LLU */
5377-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugetype*/\n"); exit(-1); }
5378- break;
5379- }
5380-case 0xFFFFFFFFFFFFFEA3LLU:
5381-/* SP = 1LLU *//* SP = 1LLU */
5382-case 18446744073709551272LLU: /* skip to here */
5383-/* SP = 1LLU *//* SP - 0LLU = 1LLU */
5384-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5385-/* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */
53866998 case /*parseglob_*/0xADCB6E8229EA7400LLU:/* SP = 0LLU */
53876999 {
53887000 /* CALLBEGIN */
@@ -5399,22 +7011,22 @@
53997011 {
54007012 /*CALLEND*/
54017013 stackbase += 5LLU;
5402- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA2LLU;
7014+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ALLU;
54037015 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
54047016 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
54057017 break;
54067018 }
5407-case 0xFFFFFFFFFFFFFEA2LLU:
7019+case 0xFFFFFFFFFFFFFE2ALLU:
54087020 /* SP = 3LLU */
54097021 {
54107022 /*CALLEND*/
54117023 stackbase += 2LLU;
5412- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA1LLU;
7024+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE29LLU;
54137025 fnaddr = /*ACCESSGLOB*/0x430C54D31CC3C20LLU;/* SP = 0LLU */
54147026 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSGLOB*/\n"); exit(-1); }
54157027 break;
54167028 }
5417-case 0xFFFFFFFFFFFFFEA1LLU:
7029+case 0xFFFFFFFFFFFFFE29LLU:
54187030 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
54197031 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
54207032 /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -5434,22 +7046,22 @@
54347046 {
54357047 /*CALLEND*/
54367048 stackbase += 5LLU;
5437- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA0LLU;
7049+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE28LLU;
54387050 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
54397051 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
54407052 break;
54417053 }
5442-case 0xFFFFFFFFFFFFFEA0LLU:
7054+case 0xFFFFFFFFFFFFFE28LLU:
54437055 /* SP = 3LLU */
54447056 {
54457057 /*CALLEND*/
54467058 stackbase += 2LLU;
5447- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9FLLU;
7059+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE27LLU;
54487060 fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */
54497061 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); }
54507062 break;
54517063 }
5452-case 0xFFFFFFFFFFFFFE9FLLU:
7064+case 0xFFFFFFFFFFFFFE27LLU:
54537065 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
54547066 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
54557067 /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -5463,12 +7075,12 @@
54637075 {
54647076 /*CALLEND*/
54657077 stackbase += 3LLU;
5466- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ELLU;
7078+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE26LLU;
54677079 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
54687080 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
54697081 break;
54707082 }
5471-case 0xFFFFFFFFFFFFFE9ELLU:
7083+case 0xFFFFFFFFFFFFFE26LLU:
54727084 /* SP = 1LLU *//* predicate */
54737085
54747086 {
@@ -5486,25 +7098,25 @@
54867098 {
54877099 /*CALLEND*/
54887100 stackbase += 7LLU;
5489- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9BLLU;
7101+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE23LLU;
54907102 fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
54917103 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
54927104 break;
54937105 }
5494-case 0xFFFFFFFFFFFFFE9BLLU:
7106+case 0xFFFFFFFFFFFFFE23LLU:
54957107 /* SP = 5LLU */
54967108 {
54977109 /*CALLEND*/
54987110 stackbase += 4LLU;
5499- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ALLU;
7111+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE22LLU;
55007112 fnaddr = /*isalpha___*/0x92E727AE37000000LLU;/* SP = 0LLU */
55017113 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isalpha___*/\n"); exit(-1); }
55027114 break;
55037115 }
5504-case 0xFFFFFFFFFFFFFE9ALLU:
7116+case 0xFFFFFFFFFFFFFE22LLU:
55057117 /* SP = 2LLU */
55067118 if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
5507-{ /* JUMP */ fnaddr = 18446744073709551261LLU; break; } /* skip consequent */
7119+{ /* JUMP */ fnaddr = 18446744073709551141LLU; break; } /* skip consequent */
55087120 /* consequent */
55097121 {
55107122 /* CALLBEGIN */
@@ -5522,25 +7134,25 @@
55227134 {
55237135 /*CALLEND*/
55247136 stackbase += 8LLU;
5525- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE99LLU;
7137+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE21LLU;
55267138 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
55277139 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
55287140 break;
55297141 }
5530-case 0xFFFFFFFFFFFFFE99LLU:
7142+case 0xFFFFFFFFFFFFFE21LLU:
55317143 /* SP = 6LLU */
55327144 {
55337145 /*CALLEND*/
55347146 stackbase += 4LLU;
5535- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE98LLU;
7147+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE20LLU;
55367148 fnaddr = /*findvaro__*/0x864A5FC5CB6A0000LLU;/* SP = 0LLU */
55377149 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvaro__*/\n"); exit(-1); }
55387150 break;
55397151 }
5540-case 0xFFFFFFFFFFFFFE98LLU:
7152+case 0xFFFFFFFFFFFFFE20LLU:
55417153 /* SP = 2LLU *//* SP = 1LLU */
5542-{ /* JUMP */ fnaddr = 18446744073709551260LLU; break; } /* skip alternative */
5543-case 18446744073709551261LLU: /* alternative */
7154+{ /* JUMP */ fnaddr = 18446744073709551140LLU; break; } /* skip alternative */
7155+case 18446744073709551141LLU: /* alternative */
55447156 {
55457157 /* CALLBEGIN */
55467158 /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
@@ -5551,12 +7163,12 @@
55517163 {
55527164 /*CALLEND*/
55537165 stackbase += 3LLU;
5554- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE97LLU;
7166+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1FLLU;
55557167 fnaddr = /*match_____*/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
55567168 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*match_____*/\n"); exit(-1); }
55577169 break;
55587170 }
5559-case 0xFFFFFFFFFFFFFE97LLU:
7171+case 0xFFFFFFFFFFFFFE1FLLU:
55607172 /* SP = 1LLU */
55617173 {
55627174 /* CALLBEGIN */
@@ -5567,15 +7179,15 @@
55677179 {
55687180 /*CALLEND*/
55697181 stackbase += 4LLU;
5570- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE96LLU;
7182+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1ELLU;
55717183 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
55727184 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
55737185 break;
55747186 }
5575-case 0xFFFFFFFFFFFFFE96LLU:
7187+case 0xFFFFFFFFFFFFFE1ELLU:
55767188 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
55777189 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU */
5578-case 18446744073709551260LLU: /* skip to here */
7190+case 18446744073709551140LLU: /* skip to here */
55797191 fputs("(/* REF TO LOCAL VAR */ stackbase + ", stdout);
55807192 {
55817193 /* CALLBEGIN */
@@ -5587,12 +7199,12 @@
55877199 {
55887200 /*CALLEND*/
55897201 stackbase += 4LLU;
5590- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE95LLU;
7202+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1DLLU;
55917203 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
55927204 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
55937205 break;
55947206 }
5595-case 0xFFFFFFFFFFFFFE95LLU:
7207+case 0xFFFFFFFFFFFFFE1DLLU:
55967208 /* SP = 2LLU */fputs(")", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */
55977209 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
55987210 /* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -5600,7 +7212,7 @@
56007212
56017213 { /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
56027214 if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
5603-{ /* JUMP */ fnaddr = 18446744073709551252LLU; break; } /* skip consequent */
7215+{ /* JUMP */ fnaddr = 18446744073709551132LLU; break; } /* skip consequent */
56047216 /* consequent */
56057217 {
56067218 /* CALLBEGIN */
@@ -5611,12 +7223,12 @@
56117223 {
56127224 /*CALLEND*/
56137225 stackbase += 4LLU;
5614- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE93LLU;
7226+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1BLLU;
56157227 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
56167228 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
56177229 break;
56187230 }
5619-case 0xFFFFFFFFFFFFFE93LLU:
7231+case 0xFFFFFFFFFFFFFE1BLLU:
56207232 /* SP = 2LLU *//* predicate */
56217233
56227234 {
@@ -5630,15 +7242,15 @@
56307242 {
56317243 /*CALLEND*/
56327244 stackbase += 5LLU;
5633- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE90LLU;
7245+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE18LLU;
56347246 fnaddr = /*geq_______*/0x8A0B000000000000LLU;/* SP = 0LLU */
56357247 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*geq_______*/\n"); exit(-1); }
56367248 break;
56377249 }
5638-case 0xFFFFFFFFFFFFFE90LLU:
7250+case 0xFFFFFFFFFFFFFE18LLU:
56397251 /* SP = 3LLU */
56407252 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
5641-{ /* JUMP */ fnaddr = 18446744073709551250LLU; break; } /* skip consequent */
7253+{ /* JUMP */ fnaddr = 18446744073709551130LLU; break; } /* skip consequent */
56427254 /* consequent */
56437255 {
56447256 /* CALLBEGIN */
@@ -5649,12 +7261,12 @@
56497261 {
56507262 /*CALLEND*/
56517263 stackbase += 4LLU;
5652- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8FLLU;
7264+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE17LLU;
56537265 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
56547266 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
56557267 break;
56567268 }
5657-case 0xFFFFFFFFFFFFFE8FLLU:
7269+case 0xFFFFFFFFFFFFFE17LLU:
56587270 /* SP = 2LLU */fputs("no such parameter ", stderr);
56597271 {
56607272 /* CALLBEGIN */
@@ -5666,15 +7278,15 @@
56667278 {
56677279 /*CALLEND*/
56687280 stackbase += 4LLU;
5669- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ELLU;
7281+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE16LLU;
56707282 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
56717283 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
56727284 break;
56737285 }
5674-case 0xFFFFFFFFFFFFFE8ELLU:
7286+case 0xFFFFFFFFFFFFFE16LLU:
56757287 /* SP = 2LLU */exit(-1);/* SP = 2LLU *//* SP = 2LLU */
5676-{ /* JUMP */ fnaddr = 18446744073709551249LLU; break; } /* skip alternative */
5677-case 18446744073709551250LLU: /* alternative */
7288+{ /* JUMP */ fnaddr = 18446744073709551129LLU; break; } /* skip alternative */
7289+case 18446744073709551130LLU: /* alternative */
56787290 {
56797291 /* CALLBEGIN */
56807292 /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
@@ -5685,16 +7297,16 @@
56857297 {
56867298 /*CALLEND*/
56877299 stackbase += 4LLU;
5688- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8DLLU;
7300+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE15LLU;
56897301 fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */
56907302 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); }
56917303 break;
56927304 }
5693-case 0xFFFFFFFFFFFFFE8DLLU:
7305+case 0xFFFFFFFFFFFFFE15LLU:
56947306 /* SP = 2LLU *//* SP = 2LLU */
5695-case 18446744073709551249LLU: /* skip to here */
7307+case 18446744073709551129LLU: /* skip to here */
56967308 /* SP = 1LLU */
5697-case 18446744073709551252LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
7309+case 18446744073709551132LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
56987310 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
56997311 /* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */
57007312 case /*pushglob__*/0xAF0BA38A7A9D0000LLU:/* SP = 0LLU */
@@ -5707,12 +7319,12 @@
57077319 {
57087320 /*CALLEND*/
57097321 stackbase += 2LLU;
5710- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8CLLU;
7322+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE14LLU;
57117323 fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */
57127324 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); }
57137325 break;
57147326 }
5715-case 0xFFFFFFFFFFFFFE8CLLU:
7327+case 0xFFFFFFFFFFFFFE14LLU:
57167328 /* SP = 0LLU */
57177329 {
57187330 /* CALLBEGIN */
@@ -5723,12 +7335,12 @@
57237335 {
57247336 /*CALLEND*/
57257337 stackbase += 2LLU;
5726- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8BLLU;
7338+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE13LLU;
57277339 fnaddr = /*parseglob_*/0xADCB6E8229EA7400LLU;/* SP = 0LLU */
57287340 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseglob_*/\n"); exit(-1); }
57297341 break;
57307342 }
5731-case 0xFFFFFFFFFFFFFE8BLLU:
7343+case 0xFFFFFFFFFFFFFE13LLU:
57327344 /* SP = 0LLU */
57337345 {
57347346 /* CALLBEGIN */
@@ -5739,12 +7351,12 @@
57397351 {
57407352 /*CALLEND*/
57417353 stackbase += 2LLU;
5742- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ALLU;
7354+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE12LLU;
57437355 fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */
57447356 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); }
57457357 break;
57467358 }
5747-case 0xFFFFFFFFFFFFFE8ALLU:
7359+case 0xFFFFFFFFFFFFFE12LLU:
57487360 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
57497361 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
57507362 /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -5758,12 +7370,12 @@
57587370 {
57597371 /*CALLEND*/
57607372 stackbase += 2LLU;
5761- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE89LLU;
7373+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE11LLU;
57627374 fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */
57637375 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); }
57647376 break;
57657377 }
5766-case 0xFFFFFFFFFFFFFE89LLU:
7378+case 0xFFFFFFFFFFFFFE11LLU:
57677379 /* SP = 0LLU */
57687380 {
57697381 /* CALLBEGIN */
@@ -5774,12 +7386,12 @@
57747386 {
57757387 /*CALLEND*/
57767388 stackbase += 2LLU;
5777- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE88LLU;
7389+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE10LLU;
57787390 fnaddr = /*parsevar__*/0xADCB6E83172D0000LLU;/* SP = 0LLU */
57797391 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsevar__*/\n"); exit(-1); }
57807392 break;
57817393 }
5782-case 0xFFFFFFFFFFFFFE88LLU:
7394+case 0xFFFFFFFFFFFFFE10LLU:
57837395 /* SP = 0LLU */
57847396 {
57857397 /* CALLBEGIN */
@@ -5790,12 +7402,12 @@
57907402 {
57917403 /*CALLEND*/
57927404 stackbase += 2LLU;
5793- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE87LLU;
7405+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0FLLU;
57947406 fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */
57957407 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); }
57967408 break;
57977409 }
5798-case 0xFFFFFFFFFFFFFE87LLU:
7410+case 0xFFFFFFFFFFFFFE0FLLU:
57997411 /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
58007412 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
58017413 /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */
@@ -5809,12 +7421,12 @@
58097421 {
58107422 /*CALLEND*/
58117423 stackbase += 3LLU;
5812- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE86LLU;
7424+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ELLU;
58137425 fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */
58147426 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); }
58157427 break;
58167428 }
5817-case 0xFFFFFFFFFFFFFE86LLU:
7429+case 0xFFFFFFFFFFFFFE0ELLU:
58187430 /* SP = 1LLU */
58197431 {
58207432 /* CALLBEGIN */
@@ -5826,12 +7438,12 @@
58267438 {
58277439 /*CALLEND*/
58287440 stackbase += 3LLU;
5829- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE85LLU;
7441+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0DLLU;
58307442 fnaddr = /*parseref__*/0xADCB6E82D8210000LLU;/* SP = 0LLU */
58317443 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseref__*/\n"); exit(-1); }
58327444 break;
58337445 }
5834-case 0xFFFFFFFFFFFFFE85LLU:
7446+case 0xFFFFFFFFFFFFFE0DLLU:
58357447 /* SP = 1LLU */
58367448 {
58377449 /* CALLBEGIN */
@@ -5842,12 +7454,12 @@
58427454 {
58437455 /*CALLEND*/
58447456 stackbase += 3LLU;
5845- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE84LLU;
7457+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0CLLU;
58467458 fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */
58477459 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); }
58487460 break;
58497461 }
5850-case 0xFFFFFFFFFFFFFE84LLU:
7462+case 0xFFFFFFFFFFFFFE0CLLU:
58517463 /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
58527464 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
58537465 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
@@ -5855,7 +7467,7 @@
58557467
58567468 { /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
58577469 if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
5858-{ /* JUMP */ fnaddr = 18446744073709551235LLU; break; } /* skip consequent */
7470+{ /* JUMP */ fnaddr = 18446744073709551115LLU; break; } /* skip consequent */
58597471 /* consequent */
58607472 {
58617473 /* CALLBEGIN */
@@ -5866,12 +7478,12 @@
58667478 {
58677479 /*CALLEND*/
58687480 stackbase += 3LLU;
5869- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE82LLU;
7481+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ALLU;
58707482 fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */
58717483 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); }
58727484 break;
58737485 }
5874-case 0xFFFFFFFFFFFFFE82LLU:
7486+case 0xFFFFFFFFFFFFFE0ALLU:
58757487 /* SP = 1LLU */
58767488 {
58777489 /* CALLBEGIN */
@@ -5883,12 +7495,12 @@
58837495 {
58847496 /*CALLEND*/
58857497 stackbase += 3LLU;
5886- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE81LLU;
7498+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE09LLU;
58877499 fnaddr = /*parsearg__*/0xADCB6E81CB620000LLU;/* SP = 0LLU */
58887500 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsearg__*/\n"); exit(-1); }
58897501 break;
58907502 }
5891-case 0xFFFFFFFFFFFFFE81LLU:
7503+case 0xFFFFFFFFFFFFFE09LLU:
58927504 /* SP = 1LLU */
58937505 {
58947506 /* CALLBEGIN */
@@ -5899,204 +7511,205 @@
58997511 {
59007512 /*CALLEND*/
59017513 stackbase += 3LLU;
5902- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE80LLU;
7514+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE08LLU;
59037515 fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */
59047516 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); }
59057517 break;
59067518 }
5907-case 0xFFFFFFFFFFFFFE80LLU:
7519+case 0xFFFFFFFFFFFFFE08LLU:
59087520 /* SP = 1LLU *//* SP = 1LLU */
5909-case 18446744073709551235LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
7521+case 18446744073709551115LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
59107522 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
59117523 /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */
5912-case /*pushconst_*/0xAF0BA37AAA6EBC00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
7524+case /*pushconst_*/0xAF0BA37AAA6EBC00LLU:/* SP = 2LLU *//* SPMAX = 2LLU */
59137525 {
59147526 /* CALLBEGIN */
5915- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
5916-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
5917- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
7527+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
7528+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
7529+ /* leave place for return addr *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
59187530 }
59197531 {
59207532 /*CALLEND*/
5921- stackbase += 4LLU;
5922- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7FLLU;
7533+ stackbase += 5LLU;
7534+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE07LLU;
59237535 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
59247536 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
59257537 break;
59267538 }
5927-case 0xFFFFFFFFFFFFFE7FLLU:
5928-/* SP = 2LLU *//* predicate */
7539+case 0xFFFFFFFFFFFFFE07LLU:
7540+/* SP = 3LLU *//* predicate */
59297541
59307542 {
59317543 /* CALLBEGIN */
5932- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
5933-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
5934- /* leave place for return addr *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
7544+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
7545+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
7546+ /* leave place for return addr *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
59357547 }
59367548 {
59377549 /* CALLBEGIN */
5938- /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
5939-{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
5940- /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
7550+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
7551+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
7552+ /* leave place for return addr *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
59417553 }
5942-{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
7554+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
59437555 {
59447556 /*CALLEND*/
5945- stackbase += 8LLU;
5946- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7DLLU;
7557+ stackbase += 9LLU;
7558+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE05LLU;
59477559 fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
59487560 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); }
59497561 break;
59507562 }
5951-case 0xFFFFFFFFFFFFFE7DLLU:
5952-/* SP = 6LLU */
5953-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 7LLU */
7563+case 0xFFFFFFFFFFFFFE05LLU:
7564+/* SP = 7LLU */
7565+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 8LLU */
59547566 {
59557567 /*CALLEND*/
5956- stackbase += 5LLU;
5957- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7CLLU;
7568+ stackbase += 6LLU;
7569+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE04LLU;
59587570 fnaddr = /*and_______*/0x7297C00000000000LLU;/* SP = 0LLU */
59597571 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*and_______*/\n"); exit(-1); }
59607572 break;
59617573 }
5962-case 0xFFFFFFFFFFFFFE7CLLU:
5963-/* SP = 3LLU */
5964-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
5965-{ /* JUMP */ fnaddr = 18446744073709551230LLU; break; } /* skip consequent */
7574+case 0xFFFFFFFFFFFFFE04LLU:
7575+/* SP = 4LLU */
7576+if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
7577+{ /* JUMP */ fnaddr = 18446744073709551110LLU; break; } /* skip consequent */
59667578 /* consequent */
59677579 {
59687580 /* CALLBEGIN */
5969- /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
5970-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5971- /* leave place for return addr *//* SP + 1LLU = 4LLU */
7581+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 3LLU */
7582+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
7583+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
59727584 }
59737585 {
59747586 /*CALLEND*/
5975- stackbase += 4LLU;
5976- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7BLLU;
7587+ stackbase += 5LLU;
7588+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE03LLU;
59777589 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
59787590 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
59797591 break;
59807592 }
5981-case 0xFFFFFFFFFFFFFE7BLLU:
5982-/* SP = 2LLU */fputs("expected type ", stderr);
7593+case 0xFFFFFFFFFFFFFE03LLU:
7594+/* SP = 3LLU */fputs("expected type ", stderr);
59837595 {
59847596 /* CALLBEGIN */
5985- /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
5986-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
5987- /* leave place for return addr *//* SP + 1LLU = 4LLU */
7597+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 3LLU */
7598+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
7599+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
59887600 }
5989-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
7601+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
59907602 {
59917603 /*CALLEND*/
5992- stackbase += 4LLU;
5993- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ALLU;
7604+ stackbase += 5LLU;
7605+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE02LLU;
59947606 fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
59957607 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
59967608 break;
59977609 }
5998-case 0xFFFFFFFFFFFFFE7ALLU:
5999-/* SP = 2LLU */fputs(" but found type u64 - ", stderr); fputs("can't assign non-zero value ", stderr);
7610+case 0xFFFFFFFFFFFFFE02LLU:
7611+/* SP = 3LLU */fputs(" but found type u64 - ", stderr); fputs("can't assign non-zero value ", stderr);
60007612 {
60017613 /* CALLBEGIN */
6002- /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
6003-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
6004- /* leave place for return addr *//* SP + 1LLU = 4LLU */
7614+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 3LLU */
7615+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
7616+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
60057617 }
6006-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 5LLU */
7618+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU */
60077619 {
60087620 /*CALLEND*/
6009- stackbase += 4LLU;
6010- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE79LLU;
7621+ stackbase += 5LLU;
7622+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE01LLU;
60117623 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
60127624 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
60137625 break;
60147626 }
6015-case 0xFFFFFFFFFFFFFE79LLU:
6016-/* SP = 2LLU */fputs(" to list\n", stderr); exit(-1);/* SP = 2LLU */
6017-case 18446744073709551230LLU: /* alternative */
7627+case 0xFFFFFFFFFFFFFE01LLU:
7628+/* SP = 3LLU */fputs(" to list\n", stderr); exit(-1);/* SP = 3LLU */
7629+case 18446744073709551110LLU: /* alternative */
60187630 {
60197631 /* CALLBEGIN */
6020- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
6021-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
6022- /* leave place for return addr *//* SP + 1LLU = 5LLU */
7632+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
7633+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
7634+ /* leave place for return addr *//* SP + 1LLU = 6LLU */
60237635 }
6024-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
7636+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */
7637+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 8LLU */
60257638 {
60267639 /*CALLEND*/
6027- stackbase += 5LLU;
6028- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE78LLU;
6029- fnaddr = /*typestore_*/0xBF4AE0BAFAAD8000LLU;/* SP = 0LLU */
6030-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typestore_*/\n"); exit(-1); }
7640+ stackbase += 6LLU;
7641+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE00LLU;
7642+ fnaddr = /*typesize__*/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
7643+if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typesize__*/\n"); exit(-1); }
60317644 break;
60327645 }
6033-case 0xFFFFFFFFFFFFFE78LLU:
6034-/* SP = 3LLU */
6035-case 0xFFFFFFFFFFFFFE77LLU: /* loop to here *//* predicate */
7646+case 0xFFFFFFFFFFFFFE00LLU:
7647+/* SP = 4LLU */
7648+case 0xFFFFFFFFFFFFFDFFLLU: /* loop to here *//* predicate */
60367649
60377650 {
60387651 /* CALLBEGIN */
6039- /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
6040-{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
6041- /* leave place for return addr *//* SP + 1LLU = 6LLU */
7652+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */
7653+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
7654+ /* leave place for return addr *//* SP + 1LLU = 7LLU */
60427655 }
6043-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 7LLU */
6044-{ /* PUSH */ stack[stackbase + 7LLU] = 0LLU; }/* SP + 1LLU = 8LLU */
7656+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 8LLU */
7657+{ /* PUSH */ stack[stackbase + 8LLU] = 0LLU; }/* SP + 1LLU = 9LLU */
60457658 {
60467659 /*CALLEND*/
6047- stackbase += 6LLU;
6048- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE75LLU;
7660+ stackbase += 7LLU;
7661+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFDLLU;
60497662 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
60507663 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
60517664 break;
60527665 }
6053-case 0xFFFFFFFFFFFFFE75LLU:
6054-/* SP = 4LLU */
6055-if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
6056-{ /* JUMP */ fnaddr = 18446744073709551222LLU; break; } /* skip loop */
7666+case 0xFFFFFFFFFFFFFDFDLLU:
7667+/* SP = 5LLU */
7668+if(!/* SP - 1LLU = 4LLU */stack[stackbase + 4LLU])
7669+{ /* JUMP */ fnaddr = 18446744073709551102LLU; break; } /* skip loop */
60577670 /* loop */
60587671 {
60597672 /* CALLBEGIN */
6060- /* reserve space for 1LLU returned values *//* SP + 1LLU = 4LLU */
6061-{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
6062- /* leave place for return addr *//* SP + 1LLU = 6LLU */
7673+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */
7674+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
7675+ /* leave place for return addr *//* SP + 1LLU = 7LLU */
60637676 }
6064-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 7LLU */
6065-{ /* PUSH */ stack[stackbase + 7LLU] = 1LLU; }/* SP + 1LLU = 8LLU */
7677+{ /* PUSH */ stack[stackbase + 7LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 8LLU */
7678+{ /* PUSH */ stack[stackbase + 8LLU] = 1LLU; }/* SP + 1LLU = 9LLU */
60667679 {
60677680 /*CALLEND*/
6068- stackbase += 6LLU;
6069- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE74LLU;
7681+ stackbase += 7LLU;
7682+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFCLLU;
60707683 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
60717684 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
60727685 break;
60737686 }
6074-case 0xFFFFFFFFFFFFFE74LLU:
6075-/* SP = 4LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */
7687+case 0xFFFFFFFFFFFFFDFCLLU:
7688+/* SP = 5LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]; /* POP */
60767689
60777690 {
60787691 /* CALLBEGIN */
6079- /* reserve space for 0LLU returned values *//* SP + 0LLU = 3LLU */
6080-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
6081- /* leave place for return addr *//* SP + 1LLU = 5LLU */
7692+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 4LLU */
7693+{ /* PUSH */ stack[stackbase + 4LLU] = stackbase; }/* SP + 1LLU = 5LLU */
7694+ /* leave place for return addr *//* SP + 1LLU = 6LLU */
60827695 }
6083-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
7696+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 7LLU */
60847697 {
60857698 /*CALLEND*/
6086- stackbase += 5LLU;
6087- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE73LLU;
7699+ stackbase += 6LLU;
7700+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFBLLU;
60887701 fnaddr = /*PUSH______*/0x4154C80000000000LLU;/* SP = 0LLU */
60897702 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH______*/\n"); exit(-1); }
60907703 break;
60917704 }
6092-case 0xFFFFFFFFFFFFFE73LLU:
6093-/* SP = 3LLU *//* SP = 3LLU */
6094-{ /* JUMP */ fnaddr = 18446744073709551223LLU; break; } /* loop */
6095-case 18446744073709551222LLU: /* skip to here *//* SP = 1LLU *//* SP - 0LLU = 1LLU */
7705+case 0xFFFFFFFFFFFFFDFBLLU:
7706+/* SP = 4LLU *//* SP = 4LLU */
7707+{ /* JUMP */ fnaddr = 18446744073709551103LLU; break; } /* loop */
7708+case 18446744073709551102LLU: /* skip to here *//* SP = 2LLU *//* SP - 0LLU = 2LLU */
60967709 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6097-/* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
7710+/* function requires 10LLU 64-bit chunks of memory (including 2LLU for parameters) */
60987711 case /*verbatim__*/0xC60B5D72F9280000LLU:/* SP = 0LLU */
6099-case 0xFFFFFFFFFFFFFE72LLU: /* loop to here *//* predicate */
7712+case 0xFFFFFFFFFFFFFDFALLU: /* loop to here *//* predicate */
61007713
61017714 {
61027715 /* CALLBEGIN */
@@ -6114,25 +7727,25 @@
61147727 {
61157728 /*CALLEND*/
61167729 stackbase += 6LLU;
6117- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE70LLU;
7730+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF8LLU;
61187731 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
61197732 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
61207733 break;
61217734 }
6122-case 0xFFFFFFFFFFFFFE70LLU:
7735+case 0xFFFFFFFFFFFFFDF8LLU:
61237736 /* SP = 4LLU */
61247737 {
61257738 /*CALLEND*/
61267739 stackbase += 3LLU;
6127- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6FLLU;
7740+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF7LLU;
61287741 fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
61297742 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
61307743 break;
61317744 }
6132-case 0xFFFFFFFFFFFFFE6FLLU:
7745+case 0xFFFFFFFFFFFFFDF7LLU:
61337746 /* SP = 1LLU */
61347747 if(!/* SP - 1LLU = 0LLU */stack[stackbase + 0LLU])
6135-{ /* JUMP */ fnaddr = 18446744073709551217LLU; break; } /* skip loop */
7748+{ /* JUMP */ fnaddr = 18446744073709551097LLU; break; } /* skip loop */
61367749 /* loop *//* predicate */
61377750
61387751 {
@@ -6150,26 +7763,26 @@
61507763 {
61517764 /*CALLEND*/
61527765 stackbase += 6LLU;
6153- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6DLLU;
7766+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF5LLU;
61547767 fnaddr = /*echo______*/0x81E8EA0000000000LLU;/* SP = 0LLU */
61557768 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*echo______*/\n"); exit(-1); }
61567769 break;
61577770 }
6158-case 0xFFFFFFFFFFFFFE6DLLU:
7771+case 0xFFFFFFFFFFFFFDF5LLU:
61597772 /* SP = 4LLU */
61607773 { /* PUSH */ stack[stackbase + 4LLU] = 255LLU; }/* SP + 1LLU = 5LLU */
61617774 {
61627775 /*CALLEND*/
61637776 stackbase += 3LLU;
6164- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6CLLU;
7777+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF4LLU;
61657778 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
61667779 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
61677780 break;
61687781 }
6169-case 0xFFFFFFFFFFFFFE6CLLU:
7782+case 0xFFFFFFFFFFFFFDF4LLU:
61707783 /* SP = 1LLU */
61717784 if(!/* SP - 1LLU = 0LLU */stack[stackbase + 0LLU])
6172-{ /* JUMP */ fnaddr = 18446744073709551214LLU; break; } /* skip consequent */
7785+{ /* JUMP */ fnaddr = 18446744073709551094LLU; break; } /* skip consequent */
61737786 /* consequent */
61747787 {
61757788 /* CALLBEGIN */
@@ -6180,78 +7793,63 @@
61807793 {
61817794 /*CALLEND*/
61827795 stackbase += 2LLU;
6183- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6BLLU;
7796+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF3LLU;
61847797 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
61857798 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
61867799 break;
61877800 }
6188-case 0xFFFFFFFFFFFFFE6BLLU:
7801+case 0xFFFFFFFFFFFFFDF3LLU:
61897802 /* SP = 0LLU */fputs("EOF in verbatim\n", stderr); exit(-1);/* SP = 0LLU */
6190-case 18446744073709551214LLU: /* alternative *//* SP = 0LLU */
6191-{ /* JUMP */ fnaddr = 18446744073709551218LLU; break; } /* loop */
6192-case 18446744073709551217LLU: /* skip to here *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
7803+case 18446744073709551094LLU: /* alternative *//* SP = 0LLU */
7804+{ /* JUMP */ fnaddr = 18446744073709551098LLU; break; } /* loop */
7805+case 18446744073709551097LLU: /* skip to here *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
61937806 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
61947807 /* function requires 7LLU 64-bit chunks of memory (including 0LLU for parameters) */
6195-case /*parseetype*/0xADCB6E820BF4AE00LLU:/* SP = 0LLU */
6196-{ /* PUSH */ stack[stackbase + 0LLU] = 0LLU; }/* SP + 1LLU = 1LLU *//* SPMAX = 1LLU */
7808+case /*parsestype*/0xADCB6E82EBF4AE00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
7809+{ /* PUSH */ stack[stackbase + 1LLU] = 0LLU; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU *//* predicate */
7810+
61977811 {
61987812 /* CALLBEGIN */
6199- /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
6200-{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */
6201- /* leave place for return addr *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
7813+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
7814+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
7815+ /* leave place for return addr *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
62027816 }
7817+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
7818+{ /* PUSH */ stack[stackbase + 6LLU] = 14022290591841255424LLU; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
62037819 {
62047820 /*CALLEND*/
6205- stackbase += 3LLU;
6206- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6ALLU;
6207- fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
6208-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
7821+ stackbase += 5LLU;
7822+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF0LLU;
7823+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
7824+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
62097825 break;
62107826 }
6211-case 0xFFFFFFFFFFFFFE6ALLU:
6212-/* SP = 1LLU */
7827+case 0xFFFFFFFFFFFFFDF0LLU:
7828+/* SP = 3LLU */
7829+if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
7830+{ /* JUMP */ fnaddr = 18446744073709551090LLU; break; } /* skip consequent */
7831+/* consequent */
62137832 {
62147833 /* CALLBEGIN */
6215- /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
6216-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
6217- /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
6218- }
6219- {
6220- /*CALLEND*/
6221- stackbase += 4LLU;
6222- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE69LLU;
6223- fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
6224-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
6225- break;
6226- }
6227-case 0xFFFFFFFFFFFFFE69LLU:
6228-/* SP = 2LLU *//* predicate */
6229-
6230- {
6231- /* CALLBEGIN */
62327834 /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
62337835 { /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
6234- /* leave place for return addr *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
7836+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
62357837 }
6236-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
6237-{ /* PUSH */ stack[stackbase + 6LLU] = 14022290591841255424LLU; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
7838+{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU */
7839+{ /* PUSH */ stack[stackbase + 6LLU] = 0LLU; }/* SP + 1LLU = 7LLU */
62387840 {
62397841 /*CALLEND*/
62407842 stackbase += 5LLU;
6241- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE66LLU;
6242- fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
6243-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
7843+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEFLLU;
7844+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
7845+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
62447846 break;
62457847 }
6246-case 0xFFFFFFFFFFFFFE66LLU:
6247-/* SP = 3LLU */
6248-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
6249-{ /* JUMP */ fnaddr = 18446744073709551208LLU; break; } /* skip consequent */
6250-/* consequent */
6251-{ /* PUSH */ stack[stackbase + 2LLU] = 0LLU; }/* SP + 1LLU = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
7848+case 0xFFFFFFFFFFFFFDEFLLU:
7849+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
62527850 /* SP = 2LLU *//* SP = 2LLU */
6253-{ /* JUMP */ fnaddr = 18446744073709551207LLU; break; } /* skip alternative */
6254-case 18446744073709551208LLU: /* alternative *//* predicate */
7851+{ /* JUMP */ fnaddr = 18446744073709551089LLU; break; } /* skip alternative */
7852+case 18446744073709551090LLU: /* alternative *//* predicate */
62557853
62567854 {
62577855 /* CALLBEGIN */
@@ -6259,20 +7857,20 @@
62597857 { /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
62607858 /* leave place for return addr *//* SP + 1LLU = 5LLU */
62617859 }
6262-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU */
7860+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
62637861 { /* PUSH */ stack[stackbase + 6LLU] = 14109355420086697984LLU; }/* SP + 1LLU = 7LLU */
62647862 {
62657863 /*CALLEND*/
62667864 stackbase += 5LLU;
6267- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE63LLU;
7865+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDECLLU;
62687866 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
62697867 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
62707868 break;
62717869 }
6272-case 0xFFFFFFFFFFFFFE63LLU:
7870+case 0xFFFFFFFFFFFFFDECLLU:
62737871 /* SP = 3LLU */
62747872 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
6275-{ /* JUMP */ fnaddr = 18446744073709551205LLU; break; } /* skip consequent */
7873+{ /* JUMP */ fnaddr = 18446744073709551086LLU; break; } /* skip consequent */
62767874 /* consequent */
62777875 {
62787876 /* CALLBEGIN */
@@ -6283,12 +7881,12 @@
62837881 {
62847882 /*CALLEND*/
62857883 stackbase += 4LLU;
6286- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE62LLU;
7884+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEBLLU;
62877885 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
62887886 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
62897887 break;
62907888 }
6291-case 0xFFFFFFFFFFFFFE62LLU:
7889+case 0xFFFFFFFFFFFFFDEBLLU:
62927890 /* SP = 2LLU *//* predicate */
62937891
62947892 {
@@ -6301,15 +7899,15 @@
63017899 {
63027900 /*CALLEND*/
63037901 stackbase += 5LLU;
6304- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5FLLU;
7902+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE8LLU;
63057903 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
63067904 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
63077905 break;
63087906 }
6309-case 0xFFFFFFFFFFFFFE5FLLU:
7907+case 0xFFFFFFFFFFFFFDE8LLU:
63107908 /* SP = 3LLU */
63117909 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
6312-{ /* JUMP */ fnaddr = 18446744073709551201LLU; break; } /* skip consequent */
7910+{ /* JUMP */ fnaddr = 18446744073709551082LLU; break; } /* skip consequent */
63137911 /* consequent */
63147912 {
63157913 /* CALLBEGIN */
@@ -6320,12 +7918,12 @@
63207918 {
63217919 /*CALLEND*/
63227920 stackbase += 4LLU;
6323- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ELLU;
7921+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE7LLU;
63247922 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
63257923 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
63267924 break;
63277925 }
6328-case 0xFFFFFFFFFFFFFE5ELLU:
7926+case 0xFFFFFFFFFFFFFDE7LLU:
63297927 /* SP = 2LLU */
63307928 {
63317929 /* CALLBEGIN */
@@ -6333,82 +7931,86 @@
63337931 { /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
63347932 /* leave place for return addr *//* SP + 1LLU = 5LLU */
63357933 }
7934+{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU */
63367935 {
7936+ /* CALLBEGIN */
7937+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
7938+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
7939+ /* leave place for return addr *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
7940+ }
7941+ {
63377942 /*CALLEND*/
6338- stackbase += 5LLU;
6339- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5DLLU;
7943+ stackbase += 9LLU;
7944+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE6LLU;
63407945 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
63417946 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
63427947 break;
63437948 }
6344-case 0xFFFFFFFFFFFFFE5DLLU:
6345-/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
7949+case 0xFFFFFFFFFFFFFDE6LLU:
7950+/* SP = 7LLU */
7951+ {
7952+ /*CALLEND*/
7953+ stackbase += 5LLU;
7954+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE5LLU;
7955+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
7956+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
7957+ break;
7958+ }
7959+case 0xFFFFFFFFFFFFFDE5LLU:
7960+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
63467961 /* SP = 2LLU *//* SP = 2LLU */
6347-{ /* JUMP */ fnaddr = 18446744073709551200LLU; break; } /* skip alternative */
6348-case 18446744073709551201LLU: /* alternative */
6349-{ /* PUSH */ stack[stackbase + 2LLU] = 1LLU; }/* SP + 1LLU = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
6350-/* SP = 2LLU */
6351-case 18446744073709551200LLU: /* skip to here */
6352-/* SP = 2LLU *//* SP = 2LLU */
6353-{ /* JUMP */ fnaddr = 18446744073709551204LLU; break; } /* skip alternative */
6354-case 18446744073709551205LLU: /* alternative */
7962+{ /* JUMP */ fnaddr = 18446744073709551081LLU; break; } /* skip alternative */
7963+case 18446744073709551082LLU: /* alternative */
63557964 {
63567965 /* CALLBEGIN */
6357- /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
6358-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
6359- /* leave place for return addr *//* SP + 1LLU = 4LLU */
7966+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
7967+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
7968+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
63607969 }
7970+{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU */
7971+{ /* PUSH */ stack[stackbase + 6LLU] = 1LLU; }/* SP + 1LLU = 7LLU */
63617972 {
63627973 /*CALLEND*/
6363- stackbase += 4LLU;
6364- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5CLLU;
6365- fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
6366-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
7974+ stackbase += 5LLU;
7975+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE4LLU;
7976+ fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */
7977+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); }
63677978 break;
63687979 }
6369-case 0xFFFFFFFFFFFFFE5CLLU:
6370-/* SP = 2LLU */fputs("in parse type, found unexpected char ", stderr);
7980+case 0xFFFFFFFFFFFFFDE4LLU:
7981+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
7982+/* SP = 2LLU */
7983+case 18446744073709551081LLU: /* skip to here */
7984+/* SP = 2LLU *//* SP = 2LLU */
7985+{ /* JUMP */ fnaddr = 18446744073709551085LLU; break; } /* skip alternative */
7986+case 18446744073709551086LLU: /* alternative */
63717987 {
63727988 /* CALLBEGIN */
6373- /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
6374-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
6375- /* leave place for return addr *//* SP + 1LLU = 4LLU */
7989+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */
7990+{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
7991+ /* leave place for return addr *//* SP + 1LLU = 5LLU */
63767992 }
7993+{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */
63777994 {
6378- /* CALLBEGIN */
6379- /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */
6380-{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
6381- /* leave place for return addr *//* SP + 1LLU = 7LLU */
6382- }
6383- {
63847995 /*CALLEND*/
6385- stackbase += 7LLU;
6386- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5BLLU;
6387- fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
6388-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
7996+ stackbase += 5LLU;
7997+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE3LLU;
7998+ fnaddr = /*idtosub___*/0x91FBEABB07400000LLU;/* SP = 0LLU */
7999+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*idtosub___*/\n"); exit(-1); }
63898000 break;
63908001 }
6391-case 0xFFFFFFFFFFFFFE5BLLU:
6392-/* SP = 5LLU */
6393- {
6394- /*CALLEND*/
6395- stackbase += 4LLU;
6396- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ALLU;
6397- fnaddr = /*debugchar_*/0x7E077089E8DCB400LLU;/* SP = 0LLU */
6398-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugchar_*/\n"); exit(-1); }
6399- break;
6400- }
6401-case 0xFFFFFFFFFFFFFE5ALLU:
6402-/* SP = 2LLU */exit(-1);/* SP = 2LLU */
6403-case 18446744073709551204LLU: /* skip to here */
8002+case 0xFFFFFFFFFFFFFDE3LLU:
8003+/* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
8004+/* SP = 2LLU */
8005+case 18446744073709551085LLU: /* skip to here */
64048006
6405-case 18446744073709551207LLU: /* skip to here */
8007+case 18446744073709551089LLU: /* skip to here */
64068008
6407-{ /* PUSH */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 3LLU *//* SP - 1LLU = 2LLU */
6408-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
6409-{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
8009+{ /* PUSH */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 3LLU *//* SP - 1LLU = 2LLU */
8010+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
8011+{ /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
64108012 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6411-/* function requires 7LLU 64-bit chunks of memory (including 0LLU for parameters) */
8013+/* function requires 9LLU 64-bit chunks of memory (including 1LLU for parameters) */
64128014 case /*parsetype_*/0xADCB6E82FD2B8000LLU:/* SP = 0LLU */
64138015 { /* PUSH */ stack[stackbase + 0LLU] = 0LLU; }/* SP + 1LLU = 1LLU *//* SPMAX = 1LLU */
64148016 {
@@ -6420,12 +8022,12 @@
64208022 {
64218023 /*CALLEND*/
64228024 stackbase += 3LLU;
6423- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE59LLU;
8025+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE2LLU;
64248026 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
64258027 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
64268028 break;
64278029 }
6428-case 0xFFFFFFFFFFFFFE59LLU:
8030+case 0xFFFFFFFFFFFFFDE2LLU:
64298031 /* SP = 1LLU *//* predicate */
64308032
64318033 {
@@ -6438,31 +8040,63 @@
64388040 {
64398041 /*CALLEND*/
64408042 stackbase += 4LLU;
6441- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE56LLU;
8043+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDFLLU;
64428044 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
64438045 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
64448046 break;
64458047 }
6446-case 0xFFFFFFFFFFFFFE56LLU:
8048+case 0xFFFFFFFFFFFFFDDFLLU:
64478049 /* SP = 2LLU */
64488050 if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
6449-{ /* JUMP */ fnaddr = 18446744073709551192LLU; break; } /* skip consequent */
8051+{ /* JUMP */ fnaddr = 18446744073709551073LLU; break; } /* skip consequent */
64508052 /* consequent */
64518053 {
64528054 /* CALLBEGIN */
8055+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
8056+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
8057+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
8058+ }
8059+ {
8060+ /*CALLEND*/
8061+ stackbase += 3LLU;
8062+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDELLU;
8063+ fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8064+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
8065+ break;
8066+ }
8067+case 0xFFFFFFFFFFFFFDDELLU:
8068+/* SP = 1LLU */
8069+ {
8070+ /* CALLBEGIN */
64538071 /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
64548072 { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
64558073 /* leave place for return addr *//* SP + 1LLU = 4LLU */
64568074 }
64578075 {
8076+ /* CALLBEGIN */
8077+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */
8078+{ /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
8079+ /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
8080+ }
8081+ {
64588082 /*CALLEND*/
8083+ stackbase += 7LLU;
8084+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDDLLU;
8085+ fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
8086+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
8087+ break;
8088+ }
8089+case 0xFFFFFFFFFFFFFDDDLLU:
8090+/* SP = 5LLU */
8091+ {
8092+ /*CALLEND*/
64598093 stackbase += 4LLU;
6460- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE55LLU;
6461- fnaddr = /*parseetype*/0xADCB6E820BF4AE00LLU;/* SP = 0LLU */
6462-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseetype*/\n"); exit(-1); }
8094+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDCLLU;
8095+ fnaddr = /*parsestype*/0xADCB6E82EBF4AE00LLU;/* SP = 0LLU */
8096+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestype*/\n"); exit(-1); }
64638097 break;
64648098 }
6465-case 0xFFFFFFFFFFFFFE55LLU:
8099+case 0xFFFFFFFFFFFFFDDCLLU:
64668100 /* SP = 2LLU */
64678101 {
64688102 /* CALLBEGIN */
@@ -6473,12 +8107,12 @@
64738107 {
64748108 /*CALLEND*/
64758109 stackbase += 4LLU;
6476- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE54LLU;
8110+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDBLLU;
64778111 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
64788112 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
64798113 break;
64808114 }
6481-case 0xFFFFFFFFFFFFFE54LLU:
8115+case 0xFFFFFFFFFFFFFDDBLLU:
64828116 /* SP = 2LLU */
64838117 {
64848118 /* CALLBEGIN */
@@ -6490,12 +8124,12 @@
64908124 {
64918125 /*CALLEND*/
64928126 stackbase += 4LLU;
6493- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE53LLU;
8127+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDALLU;
64948128 fnaddr = /*match_____*/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
64958129 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*match_____*/\n"); exit(-1); }
64968130 break;
64978131 }
6498-case 0xFFFFFFFFFFFFFE53LLU:
8132+case 0xFFFFFFFFFFFFFDDALLU:
64998133 /* SP = 2LLU */
65008134 {
65018135 /* CALLBEGIN */
@@ -6503,22 +8137,55 @@
65038137 { /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */
65048138 /* leave place for return addr *//* SP + 1LLU = 5LLU */
65058139 }
6506-{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
65078140 {
8141+ /* CALLBEGIN */
8142+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU */
8143+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
8144+ /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
8145+ }
8146+{ /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
8147+{ /* PUSH */ stack[stackbase + 9LLU] = 2LLU; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
8148+ {
65088149 /*CALLEND*/
8150+ stackbase += 8LLU;
8151+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD9LLU;
8152+ fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */
8153+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); }
8154+ break;
8155+ }
8156+case 0xFFFFFFFFFFFFFDD9LLU:
8157+/* SP = 6LLU */
8158+ {
8159+ /*CALLEND*/
65098160 stackbase += 5LLU;
6510- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE52LLU;
8161+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD8LLU;
65118162 fnaddr = /*encodelist*/0x8297AA7E09E4BAF0LLU;/* SP = 0LLU */
65128163 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodelist*/\n"); exit(-1); }
65138164 break;
65148165 }
6515-case 0xFFFFFFFFFFFFFE52LLU:
8166+case 0xFFFFFFFFFFFFFDD8LLU:
65168167 /* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */
65178168 /* SP = 1LLU *//* SP = 1LLU */
6518-{ /* JUMP */ fnaddr = 18446744073709551191LLU; break; } /* skip alternative */
6519-case 18446744073709551192LLU: /* alternative */
8169+{ /* JUMP */ fnaddr = 18446744073709551072LLU; break; } /* skip alternative */
8170+case 18446744073709551073LLU: /* alternative */
65208171 {
65218172 /* CALLBEGIN */
8173+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */
8174+{ /* PUSH */ stack[stackbase + 1LLU] = stackbase; }/* SP + 1LLU = 2LLU */
8175+ /* leave place for return addr *//* SP + 1LLU = 3LLU */
8176+ }
8177+ {
8178+ /*CALLEND*/
8179+ stackbase += 3LLU;
8180+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD7LLU;
8181+ fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8182+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
8183+ break;
8184+ }
8185+case 0xFFFFFFFFFFFFFDD7LLU:
8186+/* SP = 1LLU */
8187+ {
8188+ /* CALLBEGIN */
65228189 /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */
65238190 { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
65248191 /* leave place for return addr *//* SP + 1LLU = 4LLU */
@@ -6527,37 +8194,53 @@
65278194 /* CALLBEGIN */
65288195 /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */
65298196 { /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */
6530- /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
8197+ /* leave place for return addr *//* SP + 1LLU = 7LLU */
65318198 }
65328199 {
8200+ /* CALLBEGIN */
8201+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
8202+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
8203+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
8204+ }
8205+ {
65338206 /*CALLEND*/
8207+ stackbase += 10LLU;
8208+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD6LLU;
8209+ fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
8210+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
8211+ break;
8212+ }
8213+case 0xFFFFFFFFFFFFFDD6LLU:
8214+/* SP = 8LLU */
8215+ {
8216+ /*CALLEND*/
65348217 stackbase += 7LLU;
6535- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE51LLU;
6536- fnaddr = /*parseetype*/0xADCB6E820BF4AE00LLU;/* SP = 0LLU */
6537-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseetype*/\n"); exit(-1); }
8218+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD5LLU;
8219+ fnaddr = /*parsestype*/0xADCB6E82EBF4AE00LLU;/* SP = 0LLU */
8220+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestype*/\n"); exit(-1); }
65388221 break;
65398222 }
6540-case 0xFFFFFFFFFFFFFE51LLU:
8223+case 0xFFFFFFFFFFFFFDD5LLU:
65418224 /* SP = 5LLU */
65428225 {
65438226 /*CALLEND*/
65448227 stackbase += 4LLU;
6545- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE50LLU;
6546- fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
6547-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); }
8228+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD4LLU;
8229+ fnaddr = /*encodeVAL_*/0x8297AA7E05813000LLU;/* SP = 0LLU */
8230+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeVAL_*/\n"); exit(-1); }
65488231 break;
65498232 }
6550-case 0xFFFFFFFFFFFFFE50LLU:
8233+case 0xFFFFFFFFFFFFFDD4LLU:
65518234 /* SP = 2LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */
65528235 /* SP = 1LLU */
6553-case 18446744073709551191LLU: /* skip to here */
8236+case 18446744073709551072LLU: /* skip to here */
65548237
65558238 { /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */
65568239 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */
65578240 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }
65588241 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6559-/* function requires 7LLU 64-bit chunks of memory (including 0LLU for parameters) */
6560-case /*typeecheck*/0xBF4AE081E8E07A60LLU:/* SP = 2LLU *//* SPMAX = 2LLU *//* predicate */
8242+/* function requires 10LLU 64-bit chunks of memory (including 0LLU for parameters) */
8243+case /*typescheck*/0xBF4AE0B9E8E07A60LLU:/* SP = 2LLU *//* SPMAX = 2LLU *//* predicate */
65618244
65628245 {
65638246 /* CALLBEGIN */
@@ -6577,28 +8260,28 @@
65778260 {
65788261 /*CALLEND*/
65798262 stackbase += 9LLU;
6580- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4DLLU;
8263+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD1LLU;
65818264 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
65828265 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
65838266 break;
65848267 }
6585-case 0xFFFFFFFFFFFFFE4DLLU:
8268+case 0xFFFFFFFFFFFFFDD1LLU:
65868269 /* SP = 7LLU */
65878270 {
65888271 /*CALLEND*/
65898272 stackbase += 5LLU;
6590- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4CLLU;
8273+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD0LLU;
65918274 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
65928275 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
65938276 break;
65948277 }
6595-case 0xFFFFFFFFFFFFFE4CLLU:
8278+case 0xFFFFFFFFFFFFFDD0LLU:
65968279 /* SP = 3LLU */
65978280 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
6598-{ /* JUMP */ fnaddr = 18446744073709551183LLU; break; } /* skip consequent */
8281+{ /* JUMP */ fnaddr = 18446744073709551059LLU; break; } /* skip consequent */
65998282 /* consequent *//* SP = 2LLU *//* SP = 2LLU */
6600-{ /* JUMP */ fnaddr = 18446744073709551182LLU; break; } /* skip alternative */
6601-case 18446744073709551183LLU: /* alternative *//* predicate */
8283+{ /* JUMP */ fnaddr = 18446744073709551058LLU; break; } /* skip alternative */
8284+case 18446744073709551059LLU: /* alternative *//* predicate */
66028285
66038286 {
66048287 /* CALLBEGIN */
@@ -6611,15 +8294,15 @@
66118294 {
66128295 /*CALLEND*/
66138296 stackbase += 5LLU;
6614- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ALLU;
8297+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCELLU;
66158298 fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
66168299 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
66178300 break;
66188301 }
6619-case 0xFFFFFFFFFFFFFE4ALLU:
8302+case 0xFFFFFFFFFFFFFDCELLU:
66208303 /* SP = 3LLU */
66218304 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
6622-{ /* JUMP */ fnaddr = 18446744073709551179LLU; break; } /* skip consequent */
8305+{ /* JUMP */ fnaddr = 18446744073709551055LLU; break; } /* skip consequent */
66238306 /* consequent */
66248307 {
66258308 /* CALLBEGIN */
@@ -6630,12 +8313,12 @@
66308313 {
66318314 /*CALLEND*/
66328315 stackbase += 4LLU;
6633- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE49LLU;
8316+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCDLLU;
66348317 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
66358318 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
66368319 break;
66378320 }
6638-case 0xFFFFFFFFFFFFFE49LLU:
8321+case 0xFFFFFFFFFFFFFDCDLLU:
66398322 /* SP = 2LLU */fputs("want type ", stderr);
66408323 {
66418324 /* CALLBEGIN */
@@ -6647,12 +8330,12 @@
66478330 {
66488331 /*CALLEND*/
66498332 stackbase += 4LLU;
6650- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE48LLU;
6651- fnaddr = /*debugetype*/0x7E07708A0BF4AE00LLU;/* SP = 0LLU */
6652-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugetype*/\n"); exit(-1); }
8333+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCCLLU;
8334+ fnaddr = /*debugstype*/0x7E07708AEBF4AE00LLU;/* SP = 0LLU */
8335+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugstype*/\n"); exit(-1); }
66538336 break;
66548337 }
6655-case 0xFFFFFFFFFFFFFE48LLU:
8338+case 0xFFFFFFFFFFFFFDCCLLU:
66568339 /* SP = 2LLU */fputs(" but have type ", stderr);
66578340 {
66588341 /* CALLBEGIN */
@@ -6664,15 +8347,15 @@
66648347 {
66658348 /*CALLEND*/
66668349 stackbase += 4LLU;
6667- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE47LLU;
6668- fnaddr = /*debugetype*/0x7E07708A0BF4AE00LLU;/* SP = 0LLU */
6669-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugetype*/\n"); exit(-1); }
8350+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCBLLU;
8351+ fnaddr = /*debugstype*/0x7E07708AEBF4AE00LLU;/* SP = 0LLU */
8352+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugstype*/\n"); exit(-1); }
66708353 break;
66718354 }
6672-case 0xFFFFFFFFFFFFFE47LLU:
8355+case 0xFFFFFFFFFFFFFDCBLLU:
66738356 /* SP = 2LLU */fputs("\n", stderr); /* SP = 2LLU */
6674-case 18446744073709551179LLU: /* alternative *//* SP = 2LLU */
6675-case 18446744073709551182LLU: /* skip to here */
8357+case 18446744073709551055LLU: /* alternative *//* SP = 2LLU */
8358+case 18446744073709551058LLU: /* skip to here */
66768359 /* SP = 2LLU *//* SP - 0LLU = 2LLU */
66778360 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
66788361 /* function requires 11LLU 64-bit chunks of memory (including 2LLU for parameters) */
@@ -6696,28 +8379,28 @@
66968379 {
66978380 /*CALLEND*/
66988381 stackbase += 9LLU;
6699- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE44LLU;
8382+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC8LLU;
67008383 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
67018384 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
67028385 break;
67038386 }
6704-case 0xFFFFFFFFFFFFFE44LLU:
8387+case 0xFFFFFFFFFFFFFDC8LLU:
67058388 /* SP = 7LLU */
67068389 {
67078390 /*CALLEND*/
67088391 stackbase += 5LLU;
6709- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE43LLU;
8392+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC7LLU;
67108393 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
67118394 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
67128395 break;
67138396 }
6714-case 0xFFFFFFFFFFFFFE43LLU:
8397+case 0xFFFFFFFFFFFFFDC7LLU:
67158398 /* SP = 3LLU */
67168399 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
6717-{ /* JUMP */ fnaddr = 18446744073709551174LLU; break; } /* skip consequent */
8400+{ /* JUMP */ fnaddr = 18446744073709551050LLU; break; } /* skip consequent */
67188401 /* consequent *//* SP = 2LLU *//* SP = 2LLU */
6719-{ /* JUMP */ fnaddr = 18446744073709551173LLU; break; } /* skip alternative */
6720-case 18446744073709551174LLU: /* alternative *//* predicate */
8402+{ /* JUMP */ fnaddr = 18446744073709551049LLU; break; } /* skip alternative */
8403+case 18446744073709551050LLU: /* alternative *//* predicate */
67218404
67228405 {
67238406 /* CALLBEGIN */
@@ -6730,15 +8413,15 @@
67308413 {
67318414 /*CALLEND*/
67328415 stackbase += 5LLU;
6733- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE41LLU;
8416+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC5LLU;
67348417 fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
67358418 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
67368419 break;
67378420 }
6738-case 0xFFFFFFFFFFFFFE41LLU:
8421+case 0xFFFFFFFFFFFFFDC5LLU:
67398422 /* SP = 3LLU */
67408423 if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
6741-{ /* JUMP */ fnaddr = 18446744073709551170LLU; break; } /* skip consequent */
8424+{ /* JUMP */ fnaddr = 18446744073709551046LLU; break; } /* skip consequent */
67428425 /* consequent */
67438426 {
67448427 /* CALLBEGIN */
@@ -6749,12 +8432,12 @@
67498432 {
67508433 /*CALLEND*/
67518434 stackbase += 4LLU;
6752- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE40LLU;
8435+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC4LLU;
67538436 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
67548437 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
67558438 break;
67568439 }
6757-case 0xFFFFFFFFFFFFFE40LLU:
8440+case 0xFFFFFFFFFFFFFDC4LLU:
67588441 /* SP = 2LLU */fputs("want type ", stderr);
67598442 {
67608443 /* CALLBEGIN */
@@ -6766,12 +8449,12 @@
67668449 {
67678450 /*CALLEND*/
67688451 stackbase += 4LLU;
6769- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3FLLU;
8452+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC3LLU;
67708453 fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
67718454 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
67728455 break;
67738456 }
6774-case 0xFFFFFFFFFFFFFE3FLLU:
8457+case 0xFFFFFFFFFFFFFDC3LLU:
67758458 /* SP = 2LLU */fputs(" but have type ", stderr);
67768459 {
67778460 /* CALLBEGIN */
@@ -6783,15 +8466,15 @@
67838466 {
67848467 /*CALLEND*/
67858468 stackbase += 4LLU;
6786- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ELLU;
8469+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC2LLU;
67878470 fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
67888471 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
67898472 break;
67908473 }
6791-case 0xFFFFFFFFFFFFFE3ELLU:
8474+case 0xFFFFFFFFFFFFFDC2LLU:
67928475 /* SP = 2LLU */fputs("\n", stderr); exit(-1);/* SP = 2LLU */
6793-case 18446744073709551170LLU: /* alternative *//* SP = 2LLU */
6794-case 18446744073709551173LLU: /* skip to here */
8476+case 18446744073709551046LLU: /* alternative *//* SP = 2LLU */
8477+case 18446744073709551049LLU: /* skip to here */
67958478 /* SP = 2LLU *//* SP - 0LLU = 2LLU */
67968479 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
67978480 /* function requires 11LLU 64-bit chunks of memory (including 2LLU for parameters) */
@@ -6815,28 +8498,28 @@
68158498 {
68168499 /*CALLEND*/
68178500 stackbase += 10LLU;
6818- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3BLLU;
8501+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBFLLU;
68198502 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
68208503 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
68218504 break;
68228505 }
6823-case 0xFFFFFFFFFFFFFE3BLLU:
8506+case 0xFFFFFFFFFFFFFDBFLLU:
68248507 /* SP = 8LLU */
68258508 {
68268509 /*CALLEND*/
68278510 stackbase += 6LLU;
6828- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ALLU;
8511+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBELLU;
68298512 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
68308513 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
68318514 break;
68328515 }
6833-case 0xFFFFFFFFFFFFFE3ALLU:
8516+case 0xFFFFFFFFFFFFFDBELLU:
68348517 /* SP = 4LLU */
68358518 if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
6836-{ /* JUMP */ fnaddr = 18446744073709551165LLU; break; } /* skip consequent */
8519+{ /* JUMP */ fnaddr = 18446744073709551041LLU; break; } /* skip consequent */
68378520 /* consequent *//* SP = 3LLU *//* SP = 3LLU */
6838-{ /* JUMP */ fnaddr = 18446744073709551164LLU; break; } /* skip alternative */
6839-case 18446744073709551165LLU: /* alternative *//* predicate */
8521+{ /* JUMP */ fnaddr = 18446744073709551040LLU; break; } /* skip alternative */
8522+case 18446744073709551041LLU: /* alternative *//* predicate */
68408523
68418524 {
68428525 /* CALLBEGIN */
@@ -6849,15 +8532,15 @@
68498532 {
68508533 /*CALLEND*/
68518534 stackbase += 6LLU;
6852- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE38LLU;
8535+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBCLLU;
68538536 fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
68548537 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
68558538 break;
68568539 }
6857-case 0xFFFFFFFFFFFFFE38LLU:
8540+case 0xFFFFFFFFFFFFFDBCLLU:
68588541 /* SP = 4LLU */
68598542 if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU])
6860-{ /* JUMP */ fnaddr = 18446744073709551161LLU; break; } /* skip consequent */
8543+{ /* JUMP */ fnaddr = 18446744073709551037LLU; break; } /* skip consequent */
68618544 /* consequent */
68628545 {
68638546 /* CALLBEGIN */
@@ -6868,12 +8551,12 @@
68688551 {
68698552 /*CALLEND*/
68708553 stackbase += 5LLU;
6871- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE37LLU;
8554+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBBLLU;
68728555 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
68738556 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
68748557 break;
68758558 }
6876-case 0xFFFFFFFFFFFFFE37LLU:
8559+case 0xFFFFFFFFFFFFFDBBLLU:
68778560 /* SP = 3LLU */fputs("expected type ", stderr);
68788561 {
68798562 /* CALLBEGIN */
@@ -6885,12 +8568,12 @@
68858568 {
68868569 /*CALLEND*/
68878570 stackbase += 5LLU;
6888- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE36LLU;
8571+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBALLU;
68898572 fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
68908573 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
68918574 break;
68928575 }
6893-case 0xFFFFFFFFFFFFFE36LLU:
8576+case 0xFFFFFFFFFFFFFDBALLU:
68948577 /* SP = 3LLU */fputs(" but variable ", stderr);
68958578 {
68968579 /* CALLBEGIN */
@@ -6902,12 +8585,12 @@
69028585 {
69038586 /*CALLEND*/
69048587 stackbase += 5LLU;
6905- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE35LLU;
8588+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB9LLU;
69068589 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
69078590 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
69088591 break;
69098592 }
6910-case 0xFFFFFFFFFFFFFE35LLU:
8593+case 0xFFFFFFFFFFFFFDB9LLU:
69118594 /* SP = 3LLU */fputs(" has type ", stderr);
69128595 {
69138596 /* CALLBEGIN */
@@ -6919,15 +8602,15 @@
69198602 {
69208603 /*CALLEND*/
69218604 stackbase += 5LLU;
6922- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE34LLU;
8605+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB8LLU;
69238606 fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
69248607 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
69258608 break;
69268609 }
6927-case 0xFFFFFFFFFFFFFE34LLU:
8610+case 0xFFFFFFFFFFFFFDB8LLU:
69288611 /* SP = 3LLU */fputs("\n", stderr); exit(-1);/* SP = 3LLU */
6929-case 18446744073709551161LLU: /* alternative *//* SP = 3LLU */
6930-case 18446744073709551164LLU: /* skip to here */
8612+case 18446744073709551037LLU: /* alternative *//* SP = 3LLU */
8613+case 18446744073709551040LLU: /* skip to here */
69318614 /* SP = 3LLU *//* SP - 0LLU = 3LLU */
69328615 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
69338616 /* function requires 12LLU 64-bit chunks of memory (including 3LLU for parameters) */
@@ -6941,12 +8624,12 @@
69418624 {
69428625 /*CALLEND*/
69438626 stackbase += 3LLU;
6944- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE33LLU;
8627+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB7LLU;
69458628 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
69468629 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
69478630 break;
69488631 }
6949-case 0xFFFFFFFFFFFFFE33LLU:
8632+case 0xFFFFFFFFFFFFFDB7LLU:
69508633 /* SP = 1LLU *//* predicate */
69518634
69528635 {
@@ -6965,25 +8648,25 @@
69658648 {
69668649 /*CALLEND*/
69678650 stackbase += 8LLU;
6968- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE31LLU;
8651+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB5LLU;
69698652 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
69708653 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
69718654 break;
69728655 }
6973-case 0xFFFFFFFFFFFFFE31LLU:
8656+case 0xFFFFFFFFFFFFFDB5LLU:
69748657 /* SP = 6LLU */
69758658 {
69768659 /*CALLEND*/
69778660 stackbase += 4LLU;
6978- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE30LLU;
8661+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB4LLU;
69798662 fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
69808663 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
69818664 break;
69828665 }
6983-case 0xFFFFFFFFFFFFFE30LLU:
8666+case 0xFFFFFFFFFFFFFDB4LLU:
69848667 /* SP = 2LLU */
69858668 if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
6986-{ /* JUMP */ fnaddr = 18446744073709551154LLU; break; } /* skip consequent */
8669+{ /* JUMP */ fnaddr = 18446744073709551030LLU; break; } /* skip consequent */
69878670 /* consequent */
69888671 {
69898672 /* CALLBEGIN */
@@ -6994,12 +8677,12 @@
69948677 {
69958678 /*CALLEND*/
69968679 stackbase += 3LLU;
6997- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2FLLU;
8680+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB3LLU;
69988681 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
69998682 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
70008683 break;
70018684 }
7002-case 0xFFFFFFFFFFFFFE2FLLU:
8685+case 0xFFFFFFFFFFFFFDB3LLU:
70038686 /* SP = 1LLU */fputs("LEVEL ", stderr);
70048687 {
70058688 /* CALLBEGIN */
@@ -7011,12 +8694,12 @@
70118694 {
70128695 /*CALLEND*/
70138696 stackbase += 3LLU;
7014- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ELLU;
8697+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB2LLU;
70158698 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
70168699 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
70178700 break;
70188701 }
7019-case 0xFFFFFFFFFFFFFE2ELLU:
8702+case 0xFFFFFFFFFFFFFDB2LLU:
70208703 /* SP = 1LLU */fputs(" != ", stderr);
70218704 {
70228705 /* CALLBEGIN */
@@ -7033,24 +8716,24 @@
70338716 {
70348717 /*CALLEND*/
70358718 stackbase += 6LLU;
7036- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2DLLU;
8719+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB1LLU;
70378720 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
70388721 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
70398722 break;
70408723 }
7041-case 0xFFFFFFFFFFFFFE2DLLU:
8724+case 0xFFFFFFFFFFFFFDB1LLU:
70428725 /* SP = 4LLU */
70438726 {
70448727 /*CALLEND*/
70458728 stackbase += 3LLU;
7046- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2CLLU;
8729+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB0LLU;
70478730 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
70488731 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
70498732 break;
70508733 }
7051-case 0xFFFFFFFFFFFFFE2CLLU:
8734+case 0xFFFFFFFFFFFFFDB0LLU:
70528735 /* SP = 1LLU */fputs(" SP\n", stderr); exit(-1);/* SP = 1LLU */
7053-case 18446744073709551154LLU: /* alternative *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
8736+case 18446744073709551030LLU: /* alternative *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
70548737 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
70558738 /* function requires 8LLU 64-bit chunks of memory (including 0LLU for parameters) */
70568739 case /*initvar___*/0x92992FC5CB400000LLU:/* SP = 0LLU */
@@ -7063,12 +8746,12 @@
70638746 {
70648747 /*CALLEND*/
70658748 stackbase += 3LLU;
7066- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2BLLU;
8749+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAFLLU;
70678750 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
70688751 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
70698752 break;
70708753 }
7071-case 0xFFFFFFFFFFFFFE2BLLU:
8754+case 0xFFFFFFFFFFFFFDAFLLU:
70728755 /* SP = 1LLU *//* predicate */
70738756
70748757 {
@@ -7087,25 +8770,25 @@
70878770 {
70888771 /*CALLEND*/
70898772 stackbase += 8LLU;
7090- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE29LLU;
8773+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDADLLU;
70918774 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
70928775 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
70938776 break;
70948777 }
7095-case 0xFFFFFFFFFFFFFE29LLU:
8778+case 0xFFFFFFFFFFFFFDADLLU:
70968779 /* SP = 6LLU */
70978780 {
70988781 /*CALLEND*/
70998782 stackbase += 4LLU;
7100- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE28LLU;
8783+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDACLLU;
71018784 fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
71028785 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
71038786 break;
71048787 }
7105-case 0xFFFFFFFFFFFFFE28LLU:
8788+case 0xFFFFFFFFFFFFFDACLLU:
71068789 /* SP = 2LLU */
71078790 if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU])
7108-{ /* JUMP */ fnaddr = 18446744073709551146LLU; break; } /* skip consequent */
8791+{ /* JUMP */ fnaddr = 18446744073709551022LLU; break; } /* skip consequent */
71098792 /* consequent */
71108793 {
71118794 /* CALLBEGIN */
@@ -7116,12 +8799,12 @@
71168799 {
71178800 /*CALLEND*/
71188801 stackbase += 3LLU;
7119- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE27LLU;
8802+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDABLLU;
71208803 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
71218804 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
71228805 break;
71238806 }
7124-case 0xFFFFFFFFFFFFFE27LLU:
8807+case 0xFFFFFFFFFFFFFDABLLU:
71258808 /* SP = 1LLU */fputs("VAR ", stderr);
71268809 {
71278810 /* CALLBEGIN */
@@ -7133,12 +8816,12 @@
71338816 {
71348817 /*CALLEND*/
71358818 stackbase += 3LLU;
7136- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE26LLU;
8819+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAALLU;
71378820 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
71388821 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
71398822 break;
71408823 }
7141-case 0xFFFFFFFFFFFFFE26LLU:
8824+case 0xFFFFFFFFFFFFFDAALLU:
71428825 /* SP = 1LLU */fputs(" != ", stderr);
71438826 {
71448827 /* CALLBEGIN */
@@ -7155,24 +8838,24 @@
71558838 {
71568839 /*CALLEND*/
71578840 stackbase += 6LLU;
7158- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE25LLU;
8841+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA9LLU;
71598842 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
71608843 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
71618844 break;
71628845 }
7163-case 0xFFFFFFFFFFFFFE25LLU:
8846+case 0xFFFFFFFFFFFFFDA9LLU:
71648847 /* SP = 4LLU */
71658848 {
71668849 /*CALLEND*/
71678850 stackbase += 3LLU;
7168- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE24LLU;
8851+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA8LLU;
71698852 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
71708853 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
71718854 break;
71728855 }
7173-case 0xFFFFFFFFFFFFFE24LLU:
8856+case 0xFFFFFFFFFFFFFDA8LLU:
71748857 /* SP = 1LLU */fputs(" SP\n", stderr); exit(-1);/* SP = 1LLU */
7175-case 18446744073709551146LLU: /* alternative *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
8858+case 18446744073709551022LLU: /* alternative *//* SP = 0LLU *//* SP - 0LLU = 0LLU */
71768859 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
71778860 /* function requires 8LLU 64-bit chunks of memory (including 0LLU for parameters) */
71788861 case /*matchoptid*/0xA1CBDE8EAAEF91F0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */
@@ -7192,69 +8875,96 @@
71928875 {
71938876 /*CALLEND*/
71948877 stackbase += 8LLU;
7195- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE23LLU;
8878+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA7LLU;
71968879 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
71978880 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
71988881 break;
71998882 }
7200-case 0xFFFFFFFFFFFFFE23LLU:
8883+case 0xFFFFFFFFFFFFFDA7LLU:
72018884 /* SP = 6LLU */
72028885 {
72038886 /*CALLEND*/
72048887 stackbase += 4LLU;
7205- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE22LLU;
8888+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA6LLU;
72068889 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
72078890 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
72088891 break;
72098892 }
7210-case 0xFFFFFFFFFFFFFE22LLU:
8893+case 0xFFFFFFFFFFFFFDA6LLU:
72118894 /* SP = 2LLU *//* SP - 1LLU = 1LLU */
72128895 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */
72138896 { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }
72148897 { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
72158898 /* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */
7216-case /*assertres_*/0x72EBA0B6FB60B800LLU:/* SP = 2LLU *//* SPMAX = 2LLU *//* predicate */
8899+case /*parsestep_*/0xADCB6E82EBE0AC00LLU:/* SP = 6LLU *//* SPMAX = 6LLU *//* predicate: list non-empty? */
72178900
8901+{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
8902+if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
8903+{ /* JUMP */ fnaddr = 18446744073709551013LLU; break; } /* skip consequent */
8904+/* consequent *//* predicate */
8905+
72188906 {
72198907 /* CALLBEGIN */
7220- /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */
7221-{ /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */
7222- /* leave place for return addr *//* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */
8908+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
8909+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
8910+ /* leave place for return addr *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
72238911 }
8912+{ /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
8913+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
72248914 {
7225- /* CALLBEGIN */
7226- /* reserve space for 1LLU returned values *//* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */
7227-{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
7228- /* leave place for return addr *//* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
8915+ /*CALLEND*/
8916+ stackbase += 9LLU;
8917+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA2LLU;
8918+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
8919+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
8920+ break;
72298921 }
8922+case 0xFFFFFFFFFFFFFDA2LLU:
8923+/* SP = 7LLU */
8924+if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
8925+{ /* JUMP */ fnaddr = 18446744073709551012LLU; break; } /* skip consequent */
8926+/* consequent */
8927+{ /* PUSH */ stack[stackbase + 6LLU] = 9223372036854775808LLU; }/* SP + 1LLU = 7LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
8928+
72308929 {
72318930 /* CALLBEGIN */
7232- /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
7233-{ /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
7234- /* leave place for return addr *//* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
8931+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 6LLU */
8932+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
8933+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
72358934 }
7236-{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
72378935 {
72388936 /*CALLEND*/
7239- stackbase += 11LLU;
7240- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE20LLU;
7241- fnaddr = /*typestore_*/0xBF4AE0BAFAAD8000LLU;/* SP = 0LLU */
7242-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typestore_*/\n"); exit(-1); }
8937+ stackbase += 8LLU;
8938+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA1LLU;
8939+ fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8940+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
72438941 break;
72448942 }
7245-case 0xFFFFFFFFFFFFFE20LLU:
7246-/* SP = 9LLU */
8943+case 0xFFFFFFFFFFFFFDA1LLU:
8944+/* SP = 6LLU *//* predicate */
8945+
8946+ {
8947+ /* CALLBEGIN */
8948+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
8949+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
8950+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
8951+ }
72478952 { /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */
8953+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 11LLU */
72488954 {
72498955 /*CALLEND*/
7250- stackbase += 8LLU;
7251- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1FLLU;
7252- fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
7253-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
8956+ stackbase += 9LLU;
8957+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9ELLU;
8958+ fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
8959+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
72548960 break;
72558961 }
7256-case 0xFFFFFFFFFFFFFE1FLLU:
7257-/* SP = 6LLU */
8962+case 0xFFFFFFFFFFFFFD9ELLU:
8963+/* SP = 7LLU */
8964+if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
8965+{ /* JUMP */ fnaddr = 18446744073709551008LLU; break; } /* skip consequent */
8966+/* consequent *//* predicate */
8967+
72588968 {
72598969 /* CALLBEGIN */
72608970 /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
@@ -7261,134 +8971,194 @@
72618971 { /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
72628972 /* leave place for return addr *//* SP + 1LLU = 9LLU */
72638973 }
7264-{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 10LLU */
8974+{ /* PUSH */ stack[stackbase + 9LLU] = 13473486383523823616LLU; }/* SP + 1LLU = 10LLU */
8975+{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 11LLU */
72658976 {
72668977 /*CALLEND*/
72678978 stackbase += 9LLU;
7268- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1ELLU;
7269- fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
7270-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
8979+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9CLLU;
8980+ fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
8981+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
72718982 break;
72728983 }
7273-case 0xFFFFFFFFFFFFFE1ELLU:
8984+case 0xFFFFFFFFFFFFFD9CLLU:
72748985 /* SP = 7LLU */
8986+if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
8987+{ /* JUMP */ fnaddr = 18446744073709551005LLU; break; } /* skip consequent */
8988+/* consequent */
72758989 {
8990+ /* CALLBEGIN */
8991+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 6LLU */
8992+{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
8993+ /* leave place for return addr *//* SP + 1LLU = 8LLU */
8994+ }
8995+ {
72768996 /*CALLEND*/
7277- stackbase += 5LLU;
7278- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1DLLU;
7279- fnaddr = /*and_______*/0x7297C00000000000LLU;/* SP = 0LLU */
7280-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*and_______*/\n"); exit(-1); }
8997+ stackbase += 8LLU;
8998+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9BLLU;
8999+ fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9000+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
72819001 break;
72829002 }
7283-case 0xFFFFFFFFFFFFFE1DLLU:
7284-/* SP = 3LLU */
7285-if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
7286-{ /* JUMP */ fnaddr = 18446744073709551137LLU; break; } /* skip consequent */
7287-/* consequent */
9003+case 0xFFFFFFFFFFFFFD9BLLU:
9004+/* SP = 6LLU */
72889005 {
72899006 /* CALLBEGIN */
7290- /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
7291-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
7292- /* leave place for return addr *//* SP + 1LLU = 4LLU */
9007+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
9008+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
9009+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
72939010 }
72949011 {
9012+ /* CALLBEGIN */
9013+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 10LLU */
9014+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
9015+ /* leave place for return addr *//* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
9016+ }
9017+ {
72959018 /*CALLEND*/
7296- stackbase += 4LLU;
7297- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1CLLU;
7298- fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
7299-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
9019+ stackbase += 12LLU;
9020+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9ALLU;
9021+ fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
9022+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
73009023 break;
73019024 }
7302-case 0xFFFFFFFFFFFFFE1CLLU:
7303-/* SP = 2LLU */fputs("missing result of type ", stderr);
9025+case 0xFFFFFFFFFFFFFD9ALLU:
9026+/* SP = 10LLU */
9027+{ /* PUSH */ stack[stackbase + 10LLU] = 1LLU; }/* SP + 1LLU = 11LLU */
73049028 {
9029+ /*CALLEND*/
9030+ stackbase += 9LLU;
9031+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD99LLU;
9032+ fnaddr = /*bitor_____*/0x764BEAB400000000LLU;/* SP = 0LLU */
9033+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitor_____*/\n"); exit(-1); }
9034+ break;
9035+ }
9036+case 0xFFFFFFFFFFFFFD99LLU:
9037+/* SP = 7LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
9038+
9039+ {
73059040 /* CALLBEGIN */
7306- /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */
7307-{ /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */
7308- /* leave place for return addr *//* SP + 1LLU = 4LLU */
9041+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
9042+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
9043+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
73099044 }
7310-{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */
9045+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 10LLU */
73119046 {
73129047 /*CALLEND*/
7313- stackbase += 4LLU;
7314- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1BLLU;
7315- fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
7316-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
9048+ stackbase += 9LLU;
9049+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD98LLU;
9050+ fnaddr = /*idtosub___*/0x91FBEABB07400000LLU;/* SP = 0LLU */
9051+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*idtosub___*/\n"); exit(-1); }
73179052 break;
73189053 }
7319-case 0xFFFFFFFFFFFFFE1BLLU:
7320-/* SP = 2LLU */fputs("\n", stderr); exit(-1);/* SP = 2LLU */
7321-case 18446744073709551137LLU: /* alternative *//* SP = 2LLU *//* SP - 0LLU = 2LLU */
7322-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7323-/* function requires 12LLU 64-bit chunks of memory (including 2LLU for parameters) */
7324-case /*parsestep_*/0xADCB6E82EBE0AC00LLU:/* SP = 6LLU *//* SPMAX = 6LLU *//* predicate: list non-empty? */
9054+case 0xFFFFFFFFFFFFFD98LLU:
9055+/* SP = 7LLU *//* predicate */
73259056
7326-{ /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */
7327-if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
7328-{ /* JUMP */ fnaddr = 18446744073709551130LLU; break; } /* skip consequent */
7329-/* consequent *//* predicate */
7330-
73319057 {
73329058 /* CALLBEGIN */
7333- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
7334-{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */
7335- /* leave place for return addr *//* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */
9059+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 8LLU */
9060+{ /* PUSH */ stack[stackbase + 8LLU] = stackbase; }/* SP + 1LLU = 9LLU */
9061+ /* leave place for return addr *//* SP + 1LLU = 10LLU */
73369062 }
7337-{ /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU *//* SPMAX = 10LLU */
7338-{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 11LLU *//* SPMAX = 11LLU */
73399063 {
9064+ /* CALLBEGIN */
9065+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
9066+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
9067+ /* leave place for return addr *//* SP + 1LLU = 13LLU *//* SPMAX = 13LLU */
9068+ }
9069+{ /* PUSH */ stack[stackbase + 13LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 14LLU *//* SPMAX = 14LLU */
9070+ {
73409071 /*CALLEND*/
7341- stackbase += 9LLU;
7342- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE17LLU;
7343- fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
7344-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
9072+ stackbase += 13LLU;
9073+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD96LLU;
9074+ fnaddr = /*encodeVAL_*/0x8297AA7E05813000LLU;/* SP = 0LLU */
9075+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeVAL_*/\n"); exit(-1); }
73459076 break;
73469077 }
7347-case 0xFFFFFFFFFFFFFE17LLU:
7348-/* SP = 7LLU */
7349-if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
7350-{ /* JUMP */ fnaddr = 18446744073709551129LLU; break; } /* skip consequent */
9078+case 0xFFFFFFFFFFFFFD96LLU:
9079+/* SP = 11LLU */
9080+{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 12LLU */
9081+ {
9082+ /*CALLEND*/
9083+ stackbase += 10LLU;
9084+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD95LLU;
9085+ fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
9086+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
9087+ break;
9088+ }
9089+case 0xFFFFFFFFFFFFFD95LLU:
9090+/* SP = 8LLU */
9091+if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
9092+{ /* JUMP */ fnaddr = 18446744073709550999LLU; break; } /* skip consequent */
73519093 /* consequent */
7352-{ /* PUSH */ stack[stackbase + 6LLU] = 9223372036854775808LLU; }/* SP + 1LLU = 7LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
7353-
73549094 {
73559095 /* CALLBEGIN */
7356- /* reserve space for 0LLU returned values *//* SP + 0LLU = 6LLU */
7357-{ /* PUSH */ stack[stackbase + 6LLU] = stackbase; }/* SP + 1LLU = 7LLU */
7358- /* leave place for return addr *//* SP + 1LLU = 8LLU */
9096+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
9097+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
9098+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
73599099 }
73609100 {
73619101 /*CALLEND*/
7362- stackbase += 8LLU;
7363- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE16LLU;
7364- fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
7365-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
9102+ stackbase += 9LLU;
9103+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD94LLU;
9104+ fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
9105+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
73669106 break;
73679107 }
7368-case 0xFFFFFFFFFFFFFE16LLU:
7369-/* SP = 6LLU *//* predicate */
7370-
9108+case 0xFFFFFFFFFFFFFD94LLU:
9109+/* SP = 7LLU */fputs("want ", stderr);
73719110 {
73729111 /* CALLBEGIN */
7373- /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
9112+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
73749113 { /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
73759114 /* leave place for return addr *//* SP + 1LLU = 9LLU */
73769115 }
7377-{ /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */
7378-{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 11LLU */
9116+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 10LLU */
73799117 {
73809118 /*CALLEND*/
73819119 stackbase += 9LLU;
7382- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE13LLU;
7383- fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
7384-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
9120+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD93LLU;
9121+ fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
9122+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
73859123 break;
73869124 }
7387-case 0xFFFFFFFFFFFFFE13LLU:
7388-/* SP = 7LLU */
7389-if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
7390-{ /* JUMP */ fnaddr = 18446744073709551125LLU; break; } /* skip consequent */
7391-/* consequent *//* predicate */
9125+case 0xFFFFFFFFFFFFFD93LLU:
9126+/* SP = 7LLU */fputs(" but have ", stderr);
9127+ {
9128+ /* CALLBEGIN */
9129+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
9130+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
9131+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
9132+ }
9133+{ /* PUSH */ stack[stackbase + 9LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 10LLU */
9134+ {
9135+ /*CALLEND*/
9136+ stackbase += 9LLU;
9137+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD92LLU;
9138+ fnaddr = /*debugstype*/0x7E07708AEBF4AE00LLU;/* SP = 0LLU */
9139+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugstype*/\n"); exit(-1); }
9140+ break;
9141+ }
9142+case 0xFFFFFFFFFFFFFD92LLU:
9143+/* SP = 7LLU */fputs("\n", stderr); exit(-1);/* SP = 7LLU */
9144+case 18446744073709550999LLU: /* alternative */
9145+ {
9146+ /* CALLBEGIN */
9147+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
9148+{ /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */
9149+ /* leave place for return addr *//* SP + 1LLU = 9LLU */
9150+ }
9151+ {
9152+ /*CALLEND*/
9153+ stackbase += 9LLU;
9154+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD91LLU;
9155+ fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9156+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
9157+ break;
9158+ }
9159+case 0xFFFFFFFFFFFFFD91LLU:
9160+/* SP = 7LLU *//* SP = 6LLU */
9161+case 18446744073709551005LLU: /* alternative *//* predicate */
73929162
73939163 {
73949164 /* CALLBEGIN */
@@ -7400,15 +9170,15 @@
74009170 {
74019171 /*CALLEND*/
74029172 stackbase += 9LLU;
7403- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE10LLU;
9173+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ELLU;
74049174 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
74059175 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
74069176 break;
74079177 }
7408-case 0xFFFFFFFFFFFFFE10LLU:
9178+case 0xFFFFFFFFFFFFFD8ELLU:
74099179 /* SP = 7LLU */
74109180 if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
7411-{ /* JUMP */ fnaddr = 18446744073709551122LLU; break; } /* skip consequent */
9181+{ /* JUMP */ fnaddr = 18446744073709550992LLU; break; } /* skip consequent */
74129182 /* consequent */
74139183 {
74149184 /* CALLBEGIN */
@@ -7416,17 +9186,17 @@
74169186 { /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU */
74179187 /* leave place for return addr *//* SP + 1LLU = 11LLU */
74189188 }
7419-{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */
7420-{ /* PUSH */ stack[stackbase + 12LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 13LLU *//* SPMAX = 13LLU */
9189+{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 12LLU */
9190+{ /* PUSH */ stack[stackbase + 12LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 13LLU */
74219191 {
74229192 /*CALLEND*/
74239193 stackbase += 11LLU;
7424- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0FLLU;
9194+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8DLLU;
74259195 fnaddr = /*finddef___*/0x864A5F7E08400000LLU;/* SP = 0LLU */
74269196 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*finddef___*/\n"); exit(-1); }
74279197 break;
74289198 }
7429-case 0xFFFFFFFFFFFFFE0FLLU:
9199+case 0xFFFFFFFFFFFFFD8DLLU:
74309200 /* SP = 9LLU *//* predicate */
74319201
74329202 {
@@ -7438,7 +9208,7 @@
74389208 {
74399209 /* CALLBEGIN */
74409210 /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
7441-{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU *//* SPMAX = 14LLU */
9211+{ /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
74429212 /* leave place for return addr *//* SP + 1LLU = 15LLU *//* SPMAX = 15LLU */
74439213 }
74449214 { /* PUSH */ stack[stackbase + 15LLU] = 0LLU; }/* SP + 1LLU = 16LLU *//* SPMAX = 16LLU */
@@ -7446,12 +9216,12 @@
74469216 {
74479217 /*CALLEND*/
74489218 stackbase += 15LLU;
7449- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0CLLU;
9219+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ALLU;
74509220 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
74519221 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
74529222 break;
74539223 }
7454-case 0xFFFFFFFFFFFFFE0CLLU:
9224+case 0xFFFFFFFFFFFFFD8ALLU:
74559225 /* SP = 13LLU */
74569226 {
74579227 /* CALLBEGIN */
@@ -7464,25 +9234,25 @@
74649234 {
74659235 /*CALLEND*/
74669236 stackbase += 16LLU;
7467- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0BLLU;
9237+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD89LLU;
74689238 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
74699239 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
74709240 break;
74719241 }
7472-case 0xFFFFFFFFFFFFFE0BLLU:
9242+case 0xFFFFFFFFFFFFFD89LLU:
74739243 /* SP = 14LLU */
74749244 {
74759245 /*CALLEND*/
74769246 stackbase += 12LLU;
7477- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ALLU;
9247+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD88LLU;
74789248 fnaddr = /*and_______*/0x7297C00000000000LLU;/* SP = 0LLU */
74799249 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*and_______*/\n"); exit(-1); }
74809250 break;
74819251 }
7482-case 0xFFFFFFFFFFFFFE0ALLU:
9252+case 0xFFFFFFFFFFFFFD88LLU:
74839253 /* SP = 10LLU */
74849254 if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
7485-{ /* JUMP */ fnaddr = 18446744073709551118LLU; break; } /* skip consequent */
9255+{ /* JUMP */ fnaddr = 18446744073709550988LLU; break; } /* skip consequent */
74869256 /* consequent */
74879257 {
74889258 /* CALLBEGIN */
@@ -7493,12 +9263,12 @@
74939263 {
74949264 /*CALLEND*/
74959265 stackbase += 11LLU;
7496- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE09LLU;
9266+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD87LLU;
74979267 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
74989268 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
74999269 break;
75009270 }
7501-case 0xFFFFFFFFFFFFFE09LLU:
9271+case 0xFFFFFFFFFFFFFD87LLU:
75029272 /* SP = 9LLU */fputs("recursive function ", stderr);
75039273 {
75049274 /* CALLBEGIN */
@@ -7510,15 +9280,15 @@
75109280 {
75119281 /*CALLEND*/
75129282 stackbase += 11LLU;
7513- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE08LLU;
9283+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD86LLU;
75149284 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
75159285 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
75169286 break;
75179287 }
7518-case 0xFFFFFFFFFFFFFE08LLU:
9288+case 0xFFFFFFFFFFFFFD86LLU:
75199289 /* SP = 9LLU */fputs("\n", stderr); fputs("requires size-specification\n", stderr); exit(-1);/* SP = 9LLU *//* SP = 9LLU */
7520-{ /* JUMP */ fnaddr = 18446744073709551117LLU; break; } /* skip alternative */
7521-case 18446744073709551118LLU: /* alternative */
9290+{ /* JUMP */ fnaddr = 18446744073709550987LLU; break; } /* skip alternative */
9291+case 18446744073709550988LLU: /* alternative */
75229292 { /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */
75239293 { /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 8LLU]; }/* SP + 1LLU = 11LLU */
75249294 { /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 12LLU *//* predicate */
@@ -7529,36 +9299,36 @@
75299299 { /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
75309300 /* leave place for return addr *//* SP + 1LLU = 15LLU */
75319301 }
7532-{ /* PUSH */ stack[stackbase + 15LLU] = /* LOCAL VAR */ stack[stackbase + 11LLU]; }/* SP + 1LLU = 16LLU */
75339302 {
75349303 /* CALLBEGIN */
7535- /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
7536-{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
7537- /* leave place for return addr *//* SP + 1LLU = 19LLU *//* SPMAX = 19LLU */
9304+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
9305+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
9306+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
75389307 }
7539-{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 20LLU *//* SPMAX = 20LLU */
9308+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 11LLU]; }/* SP + 1LLU = 19LLU *//* SPMAX = 19LLU */
75409309 {
75419310 /*CALLEND*/
7542- stackbase += 19LLU;
7543- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE05LLU;
7544- fnaddr = /*typestore_*/0xBF4AE0BAFAAD8000LLU;/* SP = 0LLU */
7545-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typestore_*/\n"); exit(-1); }
9311+ stackbase += 18LLU;
9312+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD83LLU;
9313+ fnaddr = /*encodeVAL_*/0x8297AA7E05813000LLU;/* SP = 0LLU */
9314+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeVAL_*/\n"); exit(-1); }
75469315 break;
75479316 }
7548-case 0xFFFFFFFFFFFFFE05LLU:
7549-/* SP = 17LLU */
9317+case 0xFFFFFFFFFFFFFD83LLU:
9318+/* SP = 16LLU */
9319+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 17LLU */
75509320 {
75519321 /*CALLEND*/
75529322 stackbase += 15LLU;
7553- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE04LLU;
9323+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD82LLU;
75549324 fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
75559325 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
75569326 break;
75579327 }
7558-case 0xFFFFFFFFFFFFFE04LLU:
9328+case 0xFFFFFFFFFFFFFD82LLU:
75599329 /* SP = 13LLU */
75609330 if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU])
7561-{ /* JUMP */ fnaddr = 18446744073709551111LLU; break; } /* skip consequent */
9331+{ /* JUMP */ fnaddr = 18446744073709550981LLU; break; } /* skip consequent */
75629332 /* consequent */
75639333 {
75649334 /* CALLBEGIN */
@@ -7569,12 +9339,12 @@
75699339 {
75709340 /*CALLEND*/
75719341 stackbase += 14LLU;
7572- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE03LLU;
9342+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD81LLU;
75739343 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
75749344 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
75759345 break;
75769346 }
7577-case 0xFFFFFFFFFFFFFE03LLU:
9347+case 0xFFFFFFFFFFFFFD81LLU:
75789348 /* SP = 12LLU */fputs("expected ", stderr);
75799349 {
75809350 /* CALLBEGIN */
@@ -7582,33 +9352,17 @@
75829352 { /* PUSH */ stack[stackbase + 12LLU] = stackbase; }/* SP + 1LLU = 13LLU */
75839353 /* leave place for return addr *//* SP + 1LLU = 14LLU */
75849354 }
9355+{ /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 15LLU */
75859356 {
7586- /* CALLBEGIN */
7587- /* reserve space for 1LLU returned values *//* SP + 1LLU = 15LLU */
7588-{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
7589- /* leave place for return addr *//* SP + 1LLU = 17LLU */
7590- }
7591-{ /* PUSH */ stack[stackbase + 17LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 18LLU */
7592- {
75939357 /*CALLEND*/
7594- stackbase += 17LLU;
7595- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE02LLU;
7596- fnaddr = /*typestore_*/0xBF4AE0BAFAAD8000LLU;/* SP = 0LLU */
7597-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typestore_*/\n"); exit(-1); }
7598- break;
7599- }
7600-case 0xFFFFFFFFFFFFFE02LLU:
7601-/* SP = 15LLU */
7602- {
7603- /*CALLEND*/
76049358 stackbase += 14LLU;
7605- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE01LLU;
7606- fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
7607-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
9359+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD80LLU;
9360+ fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
9361+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); }
76089362 break;
76099363 }
7610-case 0xFFFFFFFFFFFFFE01LLU:
7611-/* SP = 12LLU */fputs(" 64-bit chunks but function ", stderr);
9364+case 0xFFFFFFFFFFFFFD80LLU:
9365+/* SP = 12LLU */fputs(" but function ", stderr);
76129366 {
76139367 /* CALLBEGIN */
76149368 /* reserve space for 0LLU returned values *//* SP + 0LLU = 12LLU */
@@ -7619,12 +9373,12 @@
76199373 {
76209374 /*CALLEND*/
76219375 stackbase += 14LLU;
7622- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE00LLU;
9376+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7FLLU;
76239377 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
76249378 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
76259379 break;
76269380 }
7627-case 0xFFFFFFFFFFFFFE00LLU:
9381+case 0xFFFFFFFFFFFFFD7FLLU:
76289382 /* SP = 12LLU */fputs(" returns ", stderr);
76299383 {
76309384 /* CALLBEGIN */
@@ -7636,15 +9390,15 @@
76369390 {
76379391 /*CALLEND*/
76389392 stackbase += 14LLU;
7639- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFFLLU;
7640- fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
7641-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
9393+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7ELLU;
9394+ fnaddr = /*debugstype*/0x7E07708AEBF4AE00LLU;/* SP = 0LLU */
9395+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugstype*/\n"); exit(-1); }
76429396 break;
76439397 }
7644-case 0xFFFFFFFFFFFFFDFFLLU:
9398+case 0xFFFFFFFFFFFFFD7ELLU:
76459399 /* SP = 12LLU */fputs("\n", stderr); exit(-1);/* SP = 12LLU *//* SP = 12LLU */
7646-{ /* JUMP */ fnaddr = 18446744073709551110LLU; break; } /* skip alternative */
7647-case 18446744073709551111LLU: /* alternative */
9400+{ /* JUMP */ fnaddr = 18446744073709550980LLU; break; } /* skip alternative */
9401+case 18446744073709550981LLU: /* alternative */
76489402 {
76499403 /* CALLBEGIN */
76509404 /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */
@@ -7651,176 +9405,215 @@
76519405 { /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */
76529406 /* leave place for return addr *//* SP + 1LLU = 15LLU */
76539407 }
7654-{ /* PUSH */ stack[stackbase + 15LLU] = /* LOCAL VAR */ stack[stackbase + 11LLU]; }/* SP + 1LLU = 16LLU */
9408+{ /* PUSH */ stack[stackbase + 15LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 16LLU */
9409+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 11LLU]; }/* SP + 1LLU = 17LLU */
76559410 {
76569411 /*CALLEND*/
76579412 stackbase += 15LLU;
7658- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFELLU;
9413+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7DLLU;
9414+ fnaddr = /*subsize___*/0xBB076E9358000000LLU;/* SP = 0LLU */
9415+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subsize___*/\n"); exit(-1); }
9416+ break;
9417+ }
9418+case 0xFFFFFFFFFFFFFD7DLLU:
9419+/* SP = 13LLU *//* predicate */
9420+
9421+ {
9422+ /* CALLBEGIN */
9423+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
9424+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
9425+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
9426+ }
9427+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 17LLU */
9428+ {
9429+ /*CALLEND*/
9430+ stackbase += 16LLU;
9431+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7ALLU;
9432+ fnaddr = /*isclear___*/0x92E7A781CB400000LLU;/* SP = 0LLU */
9433+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isclear___*/\n"); exit(-1); }
9434+ break;
9435+ }
9436+case 0xFFFFFFFFFFFFFD7ALLU:
9437+/* SP = 14LLU */
9438+if(!/* SP - 1LLU = 13LLU */stack[stackbase + 13LLU])
9439+{ /* JUMP */ fnaddr = 18446744073709550972LLU; break; } /* skip consequent */
9440+/* consequent */
9441+ {
9442+ /* CALLBEGIN */
9443+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
9444+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
9445+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
9446+ }
9447+{ /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 12LLU]; }/* SP + 1LLU = 17LLU */
9448+ {
9449+ /*CALLEND*/
9450+ stackbase += 16LLU;
9451+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD79LLU;
76599452 fnaddr = /*CALLBEGIN_*/0xC130C0851C93800LLU;/* SP = 0LLU */
76609453 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*CALLBEGIN_*/\n"); exit(-1); }
76619454 break;
76629455 }
7663-case 0xFFFFFFFFFFFFFDFELLU:
7664-/* SP = 13LLU */
7665-{ /* PUSH */ stack[stackbase + 13LLU] = /* LOCAL VAR */ stack[stackbase + 10LLU]; }/* SP + 1LLU = 14LLU */
7666-{ /* PUSH */ stack[stackbase + 14LLU] = 0LLU; }/* SP + 1LLU = 15LLU */
7667-case 0xFFFFFFFFFFFFFDFDLLU: /* loop to here *//* predicate */
9456+case 0xFFFFFFFFFFFFFD79LLU:
9457+/* SP = 14LLU *//* SP = 13LLU */
9458+{ /* JUMP */ fnaddr = 18446744073709550971LLU; break; } /* skip alternative */
9459+case 18446744073709550972LLU: /* alternative */
9460+{ /* PUSH */ stack[stackbase + 13LLU] = 0LLU; }/* SP + 1LLU = 14LLU */
9461+case 18446744073709550971LLU: /* skip to here */
76689462
9463+{ /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 10LLU]; }/* SP + 1LLU = 15LLU */
9464+{ /* PUSH */ stack[stackbase + 15LLU] = 0LLU; }/* SP + 1LLU = 16LLU */
9465+case 0xFFFFFFFFFFFFFD78LLU: /* loop to here *//* predicate */
9466+
76699467 {
76709468 /* CALLBEGIN */
7671- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
7672-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
7673- /* leave place for return addr *//* SP + 1LLU = 18LLU */
9469+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
9470+{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
9471+ /* leave place for return addr *//* SP + 1LLU = 19LLU */
76749472 }
76759473 {
76769474 /* CALLBEGIN */
7677- /* reserve space for 1LLU returned values *//* SP + 1LLU = 19LLU */
7678-{ /* PUSH */ stack[stackbase + 19LLU] = stackbase; }/* SP + 1LLU = 20LLU */
7679- /* leave place for return addr *//* SP + 1LLU = 21LLU *//* SPMAX = 21LLU */
9475+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 20LLU *//* SPMAX = 20LLU */
9476+{ /* PUSH */ stack[stackbase + 20LLU] = stackbase; }/* SP + 1LLU = 21LLU *//* SPMAX = 21LLU */
9477+ /* leave place for return addr *//* SP + 1LLU = 22LLU *//* SPMAX = 22LLU */
76809478 }
7681-{ /* PUSH */ stack[stackbase + 21LLU] = 41LLU; }/* SP + 1LLU = 22LLU *//* SPMAX = 22LLU */
9479+{ /* PUSH */ stack[stackbase + 22LLU] = 41LLU; }/* SP + 1LLU = 23LLU *//* SPMAX = 23LLU */
76829480 {
76839481 /*CALLEND*/
7684- stackbase += 21LLU;
7685- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFBLLU;
9482+ stackbase += 22LLU;
9483+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD76LLU;
76869484 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
76879485 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
76889486 break;
76899487 }
7690-case 0xFFFFFFFFFFFFFDFBLLU:
7691-/* SP = 19LLU */
9488+case 0xFFFFFFFFFFFFFD76LLU:
9489+/* SP = 20LLU */
76929490 {
76939491 /*CALLEND*/
7694- stackbase += 18LLU;
7695- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFALLU;
9492+ stackbase += 19LLU;
9493+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD75LLU;
76969494 fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
76979495 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
76989496 break;
76999497 }
7700-case 0xFFFFFFFFFFFFFDFALLU:
7701-/* SP = 16LLU */
7702-if(!/* SP - 1LLU = 15LLU */stack[stackbase + 15LLU])
7703-{ /* JUMP */ fnaddr = 18446744073709551100LLU; break; } /* skip loop */
9498+case 0xFFFFFFFFFFFFFD75LLU:
9499+/* SP = 17LLU */
9500+if(!/* SP - 1LLU = 16LLU */stack[stackbase + 16LLU])
9501+{ /* JUMP */ fnaddr = 18446744073709550967LLU; break; } /* skip loop */
77049502 /* loop */
77059503 {
77069504 /* CALLBEGIN */
7707- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
7708-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
7709- /* leave place for return addr *//* SP + 1LLU = 18LLU */
9505+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
9506+{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
9507+ /* leave place for return addr *//* SP + 1LLU = 19LLU */
77109508 }
7711-{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 13LLU]; }/* SP + 1LLU = 19LLU */
7712-{ /* PUSH */ stack[stackbase + 19LLU] = 1LLU; }/* SP + 1LLU = 20LLU */
9509+{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 14LLU]; }/* SP + 1LLU = 20LLU */
9510+{ /* PUSH */ stack[stackbase + 20LLU] = 1LLU; }/* SP + 1LLU = 21LLU */
77139511 {
77149512 /*CALLEND*/
7715- stackbase += 18LLU;
7716- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF9LLU;
9513+ stackbase += 19LLU;
9514+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD74LLU;
77179515 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
77189516 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
77199517 break;
77209518 }
7721-case 0xFFFFFFFFFFFFFDF9LLU:
7722-/* SP = 16LLU *//* LOCAL VAR */ stack[stackbase + 13LLU] = /* SP - 1LLU = 15LLU */stack[stackbase + 15LLU]; /* POP */
9519+case 0xFFFFFFFFFFFFFD74LLU:
9520+/* SP = 17LLU *//* LOCAL VAR */ stack[stackbase + 14LLU] = /* SP - 1LLU = 16LLU */stack[stackbase + 16LLU]; /* POP */
77239521
77249522 {
77259523 /* CALLBEGIN */
7726- /* reserve space for 0LLU returned values *//* SP + 0LLU = 15LLU */
7727-{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
7728- /* leave place for return addr *//* SP + 1LLU = 17LLU */
9524+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
9525+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
9526+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
77299527 }
77309528 {
77319529 /*CALLEND*/
7732- stackbase += 17LLU;
7733- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF8LLU;
9530+ stackbase += 18LLU;
9531+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD73LLU;
77349532 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
77359533 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
77369534 break;
77379535 }
7738-case 0xFFFFFFFFFFFFFDF8LLU:
7739-/* SP = 15LLU */
9536+case 0xFFFFFFFFFFFFFD73LLU:
9537+/* SP = 16LLU */
77409538 {
77419539 /* CALLBEGIN */
7742- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
7743-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
7744- /* leave place for return addr *//* SP + 1LLU = 18LLU */
9540+ /* reserve space for 2LLU returned values *//* SP + 2LLU = 18LLU */
9541+{ /* PUSH */ stack[stackbase + 18LLU] = stackbase; }/* SP + 1LLU = 19LLU */
9542+ /* leave place for return addr *//* SP + 1LLU = 20LLU */
77459543 }
7746-{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 19LLU */
7747-{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 20LLU */
7748-{ /* PUSH */ stack[stackbase + 20LLU] = /* LOCAL VAR */ stack[stackbase + 13LLU]; }/* SP + 1LLU = 21LLU */
9544+{ /* PUSH */ stack[stackbase + 20LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 21LLU */
9545+{ /* PUSH */ stack[stackbase + 21LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 22LLU */
9546+{ /* PUSH */ stack[stackbase + 22LLU] = /* LOCAL VAR */ stack[stackbase + 14LLU]; }/* SP + 1LLU = 23LLU */
77499547 {
77509548 /*CALLEND*/
7751- stackbase += 18LLU;
7752- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF7LLU;
9549+ stackbase += 20LLU;
9550+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD72LLU;
77539551 fnaddr = /*getdefpart*/0x8A0BDF821ADCB6F0LLU;/* SP = 0LLU */
77549552 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*getdefpart*/\n"); exit(-1); }
77559553 break;
77569554 }
7757-case 0xFFFFFFFFFFFFFDF7LLU:
7758-/* SP = 16LLU */
9555+case 0xFFFFFFFFFFFFFD72LLU:
9556+/* SP = 18LLU */
9557+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 16LLU]; }/* SP + 1LLU = 19LLU */
9558+{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 17LLU]; }/* SP + 1LLU = 20LLU */
77599559 {
77609560 /* CALLBEGIN */
7761- /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
7762-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
7763- /* leave place for return addr *//* SP + 1LLU = 18LLU */
9561+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 20LLU */
9562+{ /* PUSH */ stack[stackbase + 20LLU] = stackbase; }/* SP + 1LLU = 21LLU */
9563+ /* leave place for return addr *//* SP + 1LLU = 22LLU */
77649564 }
7765-{ /* PUSH */ stack[stackbase + 18LLU] = 0LLU; }/* SP + 1LLU = 19LLU */
7766-{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 20LLU */
7767-{ /* PUSH */ stack[stackbase + 20LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 21LLU */
9565+{ /* PUSH */ stack[stackbase + 22LLU] = 0LLU; }/* SP + 1LLU = 23LLU */
9566+{ /* PUSH */ stack[stackbase + 23LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 24LLU *//* SPMAX = 24LLU */
9567+{ /* PUSH */ stack[stackbase + 24LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 25LLU *//* SPMAX = 25LLU */
77689568 {
77699569 /* CALLBEGIN */
7770- /* reserve space for 1LLU returned values *//* SP + 1LLU = 22LLU */
7771-{ /* PUSH */ stack[stackbase + 22LLU] = stackbase; }/* SP + 1LLU = 23LLU *//* SPMAX = 23LLU */
7772- /* leave place for return addr *//* SP + 1LLU = 24LLU *//* SPMAX = 24LLU */
9570+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 26LLU *//* SPMAX = 26LLU */
9571+{ /* PUSH */ stack[stackbase + 26LLU] = stackbase; }/* SP + 1LLU = 27LLU *//* SPMAX = 27LLU */
9572+ /* leave place for return addr *//* SP + 1LLU = 28LLU *//* SPMAX = 28LLU */
77739573 }
77749574 {
77759575 /*CALLEND*/
7776- stackbase += 24LLU;
7777- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF6LLU;
9576+ stackbase += 28LLU;
9577+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD71LLU;
77789578 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
77799579 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
77809580 break;
77819581 }
7782-case 0xFFFFFFFFFFFFFDF6LLU:
7783-/* SP = 22LLU */
7784-{ /* PUSH */ stack[stackbase + 22LLU] = /* LOCAL VAR */ stack[stackbase + 15LLU]; }/* SP + 1LLU = 23LLU */
7785-{ /* PUSH */ stack[stackbase + 23LLU] = 0LLU; }/* SP + 1LLU = 24LLU */
9582+case 0xFFFFFFFFFFFFFD71LLU:
9583+/* SP = 26LLU */
9584+{ /* PUSH */ stack[stackbase + 26LLU] = /* LOCAL VAR */ stack[stackbase + 19LLU]; }/* SP + 1LLU = 27LLU */
9585+{ /* PUSH */ stack[stackbase + 27LLU] = 0LLU; }/* SP + 1LLU = 28LLU */
77869586 {
77879587 /*CALLEND*/
7788- stackbase += 18LLU;
7789- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF5LLU;
9588+ stackbase += 22LLU;
9589+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD70LLU;
77909590 fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
77919591 if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); }
77929592 break;
77939593 }
7794-case 0xFFFFFFFFFFFFFDF5LLU:
7795-/* SP = 16LLU */
9594+case 0xFFFFFFFFFFFFFD70LLU:
9595+/* SP = 20LLU */
77969596 {
77979597 /* CALLBEGIN */
7798- /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
7799-{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
7800- /* leave place for return addr *//* SP + 1LLU = 19LLU */
9598+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 21LLU */
9599+{ /* PUSH */ stack[stackbase + 21LLU] = stackbase; }/* SP + 1LLU = 22LLU */
9600+ /* leave place for return addr *//* SP + 1LLU = 23LLU */
78019601 }
7802-{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 9LLU]; }/* SP + 1LLU = 20LLU */
7803-{ /* PUSH */ stack[stackbase + 20LLU] = 1LLU; }/* SP + 1LLU = 21LLU */
9602+{ /* PUSH */ stack[stackbase + 23LLU] = /* LOCAL VAR */ stack[stackbase + 9LLU]; }/* SP + 1LLU = 24LLU */
9603+{ /* PUSH */ stack[stackbase + 24LLU] = 1LLU; }/* SP + 1LLU = 25LLU */
78049604 {
78059605 /*CALLEND*/
7806- stackbase += 19LLU;
7807- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF4LLU;
9606+ stackbase += 23LLU;
9607+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6FLLU;
78089608 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
78099609 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
78109610 break;
78119611 }
7812-case 0xFFFFFFFFFFFFFDF4LLU:
7813-/* SP = 17LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 16LLU */stack[stackbase + 16LLU]; /* POP */
9612+case 0xFFFFFFFFFFFFFD6FLLU:
9613+/* SP = 21LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 20LLU */stack[stackbase + 20LLU]; /* POP */
78149614
78159615 {
78169616 /* CALLBEGIN */
7817- /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
7818-{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
7819- /* leave place for return addr *//* SP + 1LLU = 19LLU */
7820- }
7821-{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 14LLU]; }/* SP + 1LLU = 20LLU */
7822- {
7823- /* CALLBEGIN */
78249617 /* reserve space for 1LLU returned values *//* SP + 1LLU = 21LLU */
78259618 { /* PUSH */ stack[stackbase + 21LLU] = stackbase; }/* SP + 1LLU = 22LLU */
78269619 /* leave place for return addr *//* SP + 1LLU = 23LLU */
@@ -7827,198 +9620,228 @@
78279620 }
78289621 { /* PUSH */ stack[stackbase + 23LLU] = /* LOCAL VAR */ stack[stackbase + 15LLU]; }/* SP + 1LLU = 24LLU */
78299622 {
9623+ /* CALLBEGIN */
9624+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 25LLU */
9625+{ /* PUSH */ stack[stackbase + 25LLU] = stackbase; }/* SP + 1LLU = 26LLU */
9626+ /* leave place for return addr *//* SP + 1LLU = 27LLU */
9627+ }
9628+{ /* PUSH */ stack[stackbase + 27LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 28LLU */
9629+{ /* PUSH */ stack[stackbase + 28LLU] = /* LOCAL VAR */ stack[stackbase + 19LLU]; }/* SP + 1LLU = 29LLU *//* SPMAX = 29LLU */
9630+ {
78309631 /*CALLEND*/
7831- stackbase += 23LLU;
7832- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF3LLU;
7833- fnaddr = /*typestore_*/0xBF4AE0BAFAAD8000LLU;/* SP = 0LLU */
7834-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typestore_*/\n"); exit(-1); }
9632+ stackbase += 27LLU;
9633+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6ELLU;
9634+ fnaddr = /*typesize__*/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
9635+if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typesize__*/\n"); exit(-1); }
78359636 break;
78369637 }
7837-case 0xFFFFFFFFFFFFFDF3LLU:
7838-/* SP = 21LLU */
9638+case 0xFFFFFFFFFFFFFD6ELLU:
9639+/* SP = 25LLU */
78399640 {
78409641 /*CALLEND*/
7841- stackbase += 19LLU;
7842- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF2LLU;
9642+ stackbase += 23LLU;
9643+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6DLLU;
78439644 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
78449645 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
78459646 break;
78469647 }
7847-case 0xFFFFFFFFFFFFFDF2LLU:
7848-/* SP = 17LLU *//* LOCAL VAR */ stack[stackbase + 14LLU] = /* SP - 1LLU = 16LLU */stack[stackbase + 16LLU]; /* POP */
9648+case 0xFFFFFFFFFFFFFD6DLLU:
9649+/* SP = 21LLU *//* LOCAL VAR */ stack[stackbase + 15LLU] = /* SP - 1LLU = 20LLU */stack[stackbase + 20LLU]; /* POP */
78499650
78509651 {
78519652 /* CALLBEGIN */
7852- /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
7853-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
7854- /* leave place for return addr *//* SP + 1LLU = 18LLU */
9653+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 20LLU */
9654+{ /* PUSH */ stack[stackbase + 20LLU] = stackbase; }/* SP + 1LLU = 21LLU */
9655+ /* leave place for return addr *//* SP + 1LLU = 22LLU */
78559656 }
78569657 {
78579658 /*CALLEND*/
7858- stackbase += 18LLU;
7859- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF1LLU;
9659+ stackbase += 22LLU;
9660+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6CLLU;
78609661 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
78619662 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
78629663 break;
78639664 }
7864-case 0xFFFFFFFFFFFFFDF1LLU:
7865-/* SP = 16LLU *//* predicate */
9665+case 0xFFFFFFFFFFFFFD6CLLU:
9666+/* SP = 20LLU *//* predicate */
78669667
78679668 {
78689669 /* CALLBEGIN */
7869- /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
7870-{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
7871- /* leave place for return addr *//* SP + 1LLU = 19LLU */
9670+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 21LLU */
9671+{ /* PUSH */ stack[stackbase + 21LLU] = stackbase; }/* SP + 1LLU = 22LLU */
9672+ /* leave place for return addr *//* SP + 1LLU = 23LLU */
78729673 }
7873-{ /* PUSH */ stack[stackbase + 19LLU] = 44LLU; }/* SP + 1LLU = 20LLU */
9674+{ /* PUSH */ stack[stackbase + 23LLU] = 44LLU; }/* SP + 1LLU = 24LLU */
78749675 {
78759676 /*CALLEND*/
7876- stackbase += 19LLU;
7877- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEFLLU;
9677+ stackbase += 23LLU;
9678+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6ALLU;
78789679 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
78799680 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
78809681 break;
78819682 }
7882-case 0xFFFFFFFFFFFFFDEFLLU:
7883-/* SP = 17LLU */
7884-if(!/* SP - 1LLU = 16LLU */stack[stackbase + 16LLU])
7885-{ /* JUMP */ fnaddr = 18446744073709551088LLU; break; } /* skip consequent */
9683+case 0xFFFFFFFFFFFFFD6ALLU:
9684+/* SP = 21LLU */
9685+if(!/* SP - 1LLU = 20LLU */stack[stackbase + 20LLU])
9686+{ /* JUMP */ fnaddr = 18446744073709550955LLU; break; } /* skip consequent */
78869687 /* consequent */
78879688 {
78889689 /* CALLBEGIN */
7889- /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
7890-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
7891- /* leave place for return addr *//* SP + 1LLU = 18LLU */
9690+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 20LLU */
9691+{ /* PUSH */ stack[stackbase + 20LLU] = stackbase; }/* SP + 1LLU = 21LLU */
9692+ /* leave place for return addr *//* SP + 1LLU = 22LLU */
78929693 }
78939694 {
78949695 /*CALLEND*/
7895- stackbase += 18LLU;
7896- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEELLU;
9696+ stackbase += 22LLU;
9697+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD69LLU;
78979698 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
78989699 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
78999700 break;
79009701 }
7901-case 0xFFFFFFFFFFFFFDEELLU:
7902-/* SP = 16LLU *//* SP = 16LLU */
7903-case 18446744073709551088LLU: /* alternative *//* SP = 15LLU */
7904-{ /* JUMP */ fnaddr = 18446744073709551101LLU; break; } /* loop */
7905-case 18446744073709551100LLU: /* skip to here *//* predicate */
9702+case 0xFFFFFFFFFFFFFD69LLU:
9703+/* SP = 20LLU *//* SP = 20LLU */
9704+case 18446744073709550955LLU: /* alternative *//* SP = 16LLU */
9705+{ /* JUMP */ fnaddr = 18446744073709550968LLU; break; } /* loop */
9706+case 18446744073709550967LLU: /* skip to here *//* predicate */
79069707
79079708 {
79089709 /* CALLBEGIN */
7909- /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
7910-{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
7911- /* leave place for return addr *//* SP + 1LLU = 18LLU */
9710+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
9711+{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
9712+ /* leave place for return addr *//* SP + 1LLU = 19LLU */
79129713 }
7913-{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 9LLU]; }/* SP + 1LLU = 19LLU */
7914-{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 10LLU]; }/* SP + 1LLU = 20LLU */
9714+{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 9LLU]; }/* SP + 1LLU = 20LLU */
9715+{ /* PUSH */ stack[stackbase + 20LLU] = /* LOCAL VAR */ stack[stackbase + 10LLU]; }/* SP + 1LLU = 21LLU */
79159716 {
79169717 /*CALLEND*/
7917- stackbase += 18LLU;
7918- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDECLLU;
9718+ stackbase += 19LLU;
9719+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD67LLU;
79199720 fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */
79209721 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); }
79219722 break;
79229723 }
7923-case 0xFFFFFFFFFFFFFDECLLU:
7924-/* SP = 16LLU */
7925-if(!/* SP - 1LLU = 15LLU */stack[stackbase + 15LLU])
7926-{ /* JUMP */ fnaddr = 18446744073709551085LLU; break; } /* skip consequent */
9724+case 0xFFFFFFFFFFFFFD67LLU:
9725+/* SP = 17LLU */
9726+if(!/* SP - 1LLU = 16LLU */stack[stackbase + 16LLU])
9727+{ /* JUMP */ fnaddr = 18446744073709550952LLU; break; } /* skip consequent */
79279728 /* consequent */
79289729 {
79299730 /* CALLBEGIN */
7930- /* reserve space for 0LLU returned values *//* SP + 0LLU = 15LLU */
7931-{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
7932- /* leave place for return addr *//* SP + 1LLU = 17LLU */
9731+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
9732+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
9733+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
79339734 }
79349735 {
79359736 /*CALLEND*/
7936- stackbase += 17LLU;
7937- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEBLLU;
9737+ stackbase += 18LLU;
9738+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD66LLU;
79389739 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
79399740 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
79409741 break;
79419742 }
7942-case 0xFFFFFFFFFFFFFDEBLLU:
7943-/* SP = 15LLU */fputs("call to ", stderr);
9743+case 0xFFFFFFFFFFFFFD66LLU:
9744+/* SP = 16LLU */fputs("call to ", stderr);
79449745 {
79459746 /* CALLBEGIN */
7946- /* reserve space for 0LLU returned values *//* SP + 0LLU = 15LLU */
7947-{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
7948- /* leave place for return addr *//* SP + 1LLU = 17LLU */
9747+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
9748+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
9749+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
79499750 }
7950-{ /* PUSH */ stack[stackbase + 17LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 18LLU */
9751+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 19LLU */
79519752 {
79529753 /*CALLEND*/
7953- stackbase += 17LLU;
7954- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEALLU;
9754+ stackbase += 18LLU;
9755+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD65LLU;
79559756 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
79569757 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
79579758 break;
79589759 }
7959-case 0xFFFFFFFFFFFFFDEALLU:
7960-/* SP = 15LLU */fputs(" argument-count ", stderr);
9760+case 0xFFFFFFFFFFFFFD65LLU:
9761+/* SP = 16LLU */fputs(" argument-count ", stderr);
79619762 {
79629763 /* CALLBEGIN */
7963- /* reserve space for 0LLU returned values *//* SP + 0LLU = 15LLU */
7964-{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
7965- /* leave place for return addr *//* SP + 1LLU = 17LLU */
9764+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
9765+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
9766+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
79669767 }
7967-{ /* PUSH */ stack[stackbase + 17LLU] = /* LOCAL VAR */ stack[stackbase + 9LLU]; }/* SP + 1LLU = 18LLU */
9768+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 9LLU]; }/* SP + 1LLU = 19LLU */
79689769 {
79699770 /*CALLEND*/
7970- stackbase += 17LLU;
7971- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE9LLU;
9771+ stackbase += 18LLU;
9772+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD64LLU;
79729773 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
79739774 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
79749775 break;
79759776 }
7976-case 0xFFFFFFFFFFFFFDE9LLU:
7977-/* SP = 15LLU */fputs(" does not match parameter-count ", stderr);
9777+case 0xFFFFFFFFFFFFFD64LLU:
9778+/* SP = 16LLU */fputs(" does not match parameter-count ", stderr);
79789779 {
79799780 /* CALLBEGIN */
7980- /* reserve space for 0LLU returned values *//* SP + 0LLU = 15LLU */
7981-{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
7982- /* leave place for return addr *//* SP + 1LLU = 17LLU */
9781+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
9782+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
9783+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
79839784 }
7984-{ /* PUSH */ stack[stackbase + 17LLU] = /* LOCAL VAR */ stack[stackbase + 10LLU]; }/* SP + 1LLU = 18LLU */
9785+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 10LLU]; }/* SP + 1LLU = 19LLU */
79859786 {
79869787 /*CALLEND*/
7987- stackbase += 17LLU;
7988- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE8LLU;
9788+ stackbase += 18LLU;
9789+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD63LLU;
79899790 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
79909791 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
79919792 break;
79929793 }
7993-case 0xFFFFFFFFFFFFFDE8LLU:
7994-/* SP = 15LLU */fputs("\n", stderr); exit(-1);/* SP = 15LLU */
7995-case 18446744073709551085LLU: /* alternative */
9794+case 0xFFFFFFFFFFFFFD63LLU:
9795+/* SP = 16LLU */fputs("\n", stderr); exit(-1);/* SP = 16LLU */
9796+case 18446744073709550952LLU: /* alternative *//* predicate */
9797+
79969798 {
79979799 /* CALLBEGIN */
7998- /* reserve space for 0LLU returned values *//* SP + 0LLU = 15LLU */
7999-{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
8000- /* leave place for return addr *//* SP + 1LLU = 17LLU */
9800+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
9801+{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
9802+ /* leave place for return addr *//* SP + 1LLU = 19LLU */
80019803 }
8002-{ /* PUSH */ stack[stackbase + 17LLU] = /* LOCAL VAR */ stack[stackbase + 14LLU]; }/* SP + 1LLU = 18LLU */
8003-{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 19LLU */
8004-{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 12LLU]; }/* SP + 1LLU = 20LLU */
8005-{ /* PUSH */ stack[stackbase + 20LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 21LLU */
9804+{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 20LLU */
80069805 {
80079806 /*CALLEND*/
8008- stackbase += 17LLU;
8009- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE7LLU;
9807+ stackbase += 19LLU;
9808+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD61LLU;
9809+ fnaddr = /*isclear___*/0x92E7A781CB400000LLU;/* SP = 0LLU */
9810+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isclear___*/\n"); exit(-1); }
9811+ break;
9812+ }
9813+case 0xFFFFFFFFFFFFFD61LLU:
9814+/* SP = 17LLU */
9815+if(!/* SP - 1LLU = 16LLU */stack[stackbase + 16LLU])
9816+{ /* JUMP */ fnaddr = 18446744073709550946LLU; break; } /* skip consequent */
9817+/* consequent */
9818+ {
9819+ /* CALLBEGIN */
9820+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 16LLU */
9821+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
9822+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
9823+ }
9824+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 15LLU]; }/* SP + 1LLU = 19LLU */
9825+{ /* PUSH */ stack[stackbase + 19LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 20LLU */
9826+{ /* PUSH */ stack[stackbase + 20LLU] = /* LOCAL VAR */ stack[stackbase + 13LLU]; }/* SP + 1LLU = 21LLU */
9827+{ /* PUSH */ stack[stackbase + 21LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 22LLU */
9828+ {
9829+ /*CALLEND*/
9830+ stackbase += 18LLU;
9831+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD60LLU;
80109832 fnaddr = /*CALLEND___*/0xC130C14E1000000LLU;/* SP = 0LLU */
80119833 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*CALLEND___*/\n"); exit(-1); }
80129834 break;
80139835 }
8014-case 0xFFFFFFFFFFFFFDE7LLU:
8015-/* SP = 15LLU *//* SP = 12LLU */
8016-case 18446744073709551110LLU: /* skip to here */
9836+case 0xFFFFFFFFFFFFFD60LLU:
9837+/* SP = 16LLU *//* SP = 16LLU */
9838+case 18446744073709550946LLU: /* alternative *//* SP = 12LLU */
9839+case 18446744073709550980LLU: /* skip to here */
80179840 /* SP = 9LLU */
8018-case 18446744073709551117LLU: /* skip to here */
9841+case 18446744073709550987LLU: /* skip to here */
80199842 /* SP = 6LLU *//* SP = 6LLU */
8020-{ /* JUMP */ fnaddr = 18446744073709551121LLU; break; } /* skip alternative */
8021-case 18446744073709551122LLU: /* alternative *//* predicate */
9843+{ /* JUMP */ fnaddr = 18446744073709550991LLU; break; } /* skip alternative */
9844+case 18446744073709550992LLU: /* alternative *//* predicate */
80229845
80239846 {
80249847 /* CALLBEGIN */
@@ -8031,15 +9854,15 @@
80319854 {
80329855 /*CALLEND*/
80339856 stackbase += 9LLU;
8034- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE4LLU;
9857+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5DLLU;
80359858 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
80369859 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
80379860 break;
80389861 }
8039-case 0xFFFFFFFFFFFFFDE4LLU:
9862+case 0xFFFFFFFFFFFFFD5DLLU:
80409863 /* SP = 7LLU */
80419864 if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
8042-{ /* JUMP */ fnaddr = 18446744073709551078LLU; break; } /* skip consequent */
9865+{ /* JUMP */ fnaddr = 18446744073709550943LLU; break; } /* skip consequent */
80439866 /* consequent */
80449867 {
80459868 /* CALLBEGIN */
@@ -8050,12 +9873,12 @@
80509873 {
80519874 /*CALLEND*/
80529875 stackbase += 9LLU;
8053- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE3LLU;
9876+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5CLLU;
80549877 fnaddr = /*ADDRNEXT__*/0x441123856140000LLU;/* SP = 0LLU */
80559878 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRNEXT__*/\n"); exit(-1); }
80569879 break;
80579880 }
8058-case 0xFFFFFFFFFFFFFDE3LLU:
9881+case 0xFFFFFFFFFFFFFD5CLLU:
80599882 /* SP = 7LLU */(void)/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */
80609883
80619884 {
@@ -8067,12 +9890,12 @@
80679890 {
80689891 /*CALLEND*/
80699892 stackbase += 9LLU;
8070- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE2LLU;
9893+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5BLLU;
80719894 fnaddr = /*ADDRNEXT__*/0x441123856140000LLU;/* SP = 0LLU */
80729895 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRNEXT__*/\n"); exit(-1); }
80739896 break;
80749897 }
8075-case 0xFFFFFFFFFFFFFDE2LLU:
9898+case 0xFFFFFFFFFFFFFD5BLLU:
80769899 /* SP = 7LLU */
80779900 {
80789901 /* CALLBEGIN */
@@ -8083,12 +9906,12 @@
80839906 {
80849907 /*CALLEND*/
80859908 stackbase += 9LLU;
8086- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE1LLU;
9909+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5ALLU;
80879910 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
80889911 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
80899912 break;
80909913 }
8091-case 0xFFFFFFFFFFFFFDE1LLU:
9914+case 0xFFFFFFFFFFFFFD5ALLU:
80929915 /* SP = 7LLU */fputs("/* predicate */\n", stdout);
80939916 {
80949917 /* CALLBEGIN */
@@ -8099,12 +9922,12 @@
80999922 {
81009923 /*CALLEND*/
81019924 stackbase += 9LLU;
8102- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE0LLU;
9925+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD59LLU;
81039926 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
81049927 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
81059928 break;
81069929 }
8107-case 0xFFFFFFFFFFFFFDE0LLU:
9930+case 0xFFFFFFFFFFFFFD59LLU:
81089931 /* SP = 7LLU */
81099932 {
81109933 /* CALLBEGIN */
@@ -8124,12 +9947,12 @@
81249947 {
81259948 /*CALLEND*/
81269949 stackbase += 15LLU;
8127- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDFLLU;
9950+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD58LLU;
81289951 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
81299952 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
81309953 break;
81319954 }
8132-case 0xFFFFFFFFFFFFFDDFLLU:
9955+case 0xFFFFFFFFFFFFFD58LLU:
81339956 /* SP = 13LLU */
81349957 {
81359958 /* CALLBEGIN */
@@ -8141,23 +9964,23 @@
81419964 {
81429965 /*CALLEND*/
81439966 stackbase += 16LLU;
8144- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDELLU;
9967+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD57LLU;
81459968 fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
81469969 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); }
81479970 break;
81489971 }
8149-case 0xFFFFFFFFFFFFFDDELLU:
9972+case 0xFFFFFFFFFFFFFD57LLU:
81509973 /* SP = 14LLU */
81519974 { /* PUSH */ stack[stackbase + 14LLU] = 0LLU; }/* SP + 1LLU = 15LLU */
81529975 {
81539976 /*CALLEND*/
81549977 stackbase += 9LLU;
8155- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDDLLU;
9978+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD56LLU;
81569979 fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
81579980 if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); }
81589981 break;
81599982 }
8160-case 0xFFFFFFFFFFFFFDDDLLU:
9983+case 0xFFFFFFFFFFFFFD56LLU:
81619984 /* SP = 7LLU */fputs("\nif(!", stdout);
81629985 {
81639986 /* CALLBEGIN */
@@ -8168,12 +9991,12 @@
81689991 {
81699992 /*CALLEND*/
81709993 stackbase += 9LLU;
8171- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDCLLU;
9994+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD55LLU;
81729995 fnaddr = /*POP_START_*/0x40F4004D40525000LLU;/* SP = 0LLU */
81739996 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_START_*/\n"); exit(-1); }
81749997 break;
81759998 }
8176-case 0xFFFFFFFFFFFFFDDCLLU:
9999+case 0xFFFFFFFFFFFFFD55LLU:
817710000 /* SP = 7LLU */fputs(")", stdout);
817810001 {
817910002 /* CALLBEGIN */
@@ -8184,12 +10007,12 @@
818410007 {
818510008 /*CALLEND*/
818610009 stackbase += 9LLU;
8187- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDBLLU;
10010+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD54LLU;
818810011 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
818910012 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
819010013 break;
819110014 }
8192-case 0xFFFFFFFFFFFFFDDBLLU:
10015+case 0xFFFFFFFFFFFFFD54LLU:
819310016 /* SP = 7LLU *//* predicate */
819410017
819510018 {
@@ -8208,25 +10031,25 @@
820810031 {
820910032 /*CALLEND*/
821010033 stackbase += 14LLU;
8211- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD8LLU;
10034+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD51LLU;
821210035 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
821310036 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
821410037 break;
821510038 }
8216-case 0xFFFFFFFFFFFFFDD8LLU:
10039+case 0xFFFFFFFFFFFFFD51LLU:
821710040 /* SP = 12LLU */
821810041 {
821910042 /*CALLEND*/
822010043 stackbase += 10LLU;
8221- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD7LLU;
10044+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD50LLU;
822210045 fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */
822310046 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); }
822410047 break;
822510048 }
8226-case 0xFFFFFFFFFFFFFDD7LLU:
10049+case 0xFFFFFFFFFFFFFD50LLU:
822710050 /* SP = 8LLU */
822810051 if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
8229-{ /* JUMP */ fnaddr = 18446744073709551066LLU; break; } /* skip consequent */
10052+{ /* JUMP */ fnaddr = 18446744073709550931LLU; break; } /* skip consequent */
823010053 /* consequent */
823110054 {
823210055 /* CALLBEGIN */
@@ -8245,22 +10068,22 @@
824510068 {
824610069 /*CALLEND*/
824710070 stackbase += 12LLU;
8248- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD6LLU;
10071+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4FLLU;
824910072 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
825010073 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
825110074 break;
825210075 }
8253-case 0xFFFFFFFFFFFFFDD6LLU:
10076+case 0xFFFFFFFFFFFFFD4FLLU:
825410077 /* SP = 10LLU */
825510078 {
825610079 /*CALLEND*/
825710080 stackbase += 9LLU;
8258- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD5LLU;
10081+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4ELLU;
825910082 fnaddr = /*JUMP______*/0x2953500000000000LLU;/* SP = 0LLU */
826010083 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*JUMP______*/\n"); exit(-1); }
826110084 break;
826210085 }
8263-case 0xFFFFFFFFFFFFFDD5LLU:
10086+case 0xFFFFFFFFFFFFFD4ELLU:
826410087 /* SP = 7LLU */fputs(" /* skip consequent */", stdout); fputs("\n/* consequent */", stdout);
826510088 {
826610089 /* CALLBEGIN */
@@ -8271,12 +10094,12 @@
827110094 {
827210095 /*CALLEND*/
827310096 stackbase += 10LLU;
8274- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD4LLU;
10097+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4DLLU;
827510098 fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */
827610099 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); }
827710100 break;
827810101 }
8279-case 0xFFFFFFFFFFFFFDD4LLU:
10102+case 0xFFFFFFFFFFFFFD4DLLU:
828010103 /* SP = 8LLU */
828110104 {
828210105 /* CALLBEGIN */
@@ -8287,12 +10110,12 @@
828710110 {
828810111 /*CALLEND*/
828910112 stackbase += 10LLU;
8290- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD3LLU;
10113+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4CLLU;
829110114 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
829210115 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
829310116 break;
829410117 }
8295-case 0xFFFFFFFFFFFFFDD3LLU:
10118+case 0xFFFFFFFFFFFFFD4CLLU:
829610119 /* SP = 8LLU */
829710120 {
829810121 /* CALLBEGIN */
@@ -8312,12 +10135,12 @@
831210135 {
831310136 /*CALLEND*/
831410137 stackbase += 16LLU;
8315- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD2LLU;
10138+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4BLLU;
831610139 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
831710140 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
831810141 break;
831910142 }
8320-case 0xFFFFFFFFFFFFFDD2LLU:
10143+case 0xFFFFFFFFFFFFFD4BLLU:
832110144 /* SP = 14LLU */
832210145 { /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 15LLU */
832310146 { /* PUSH */ stack[stackbase + 15LLU] = 0LLU; }/* SP + 1LLU = 16LLU */
@@ -8324,12 +10147,12 @@
832410147 {
832510148 /*CALLEND*/
832610149 stackbase += 10LLU;
8327- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD1LLU;
10150+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4ALLU;
832810151 fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
832910152 if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); }
833010153 break;
833110154 }
8332-case 0xFFFFFFFFFFFFFDD1LLU:
10155+case 0xFFFFFFFFFFFFFD4ALLU:
833310156 /* SP = 8LLU */
833410157 {
833510158 /* CALLBEGIN */
@@ -8341,12 +10164,12 @@
834110164 {
834210165 /*CALLEND*/
834310166 stackbase += 10LLU;
8344- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD0LLU;
10167+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD49LLU;
834510168 fnaddr = /*SP_SET____*/0x4D00131540000000LLU;/* SP = 0LLU */
834610169 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SET____*/\n"); exit(-1); }
834710170 break;
834810171 }
8349-case 0xFFFFFFFFFFFFFDD0LLU:
10172+case 0xFFFFFFFFFFFFFD49LLU:
835010173 /* SP = 8LLU */
835110174 {
835210175 /* CALLBEGIN */
@@ -8358,12 +10181,12 @@
835810181 {
835910182 /*CALLEND*/
836010183 stackbase += 10LLU;
8361- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCFLLU;
10184+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD48LLU;
836210185 fnaddr = /*JUMP______*/0x2953500000000000LLU;/* SP = 0LLU */
836310186 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*JUMP______*/\n"); exit(-1); }
836410187 break;
836510188 }
8366-case 0xFFFFFFFFFFFFFDCFLLU:
10189+case 0xFFFFFFFFFFFFFD48LLU:
836710190 /* SP = 8LLU */fputs(" /* skip alternative */", stdout); fputs("\ncase ", stdout);
836810191 {
836910192 /* CALLBEGIN */
@@ -8382,22 +10205,22 @@
838210205 {
838310206 /*CALLEND*/
838410207 stackbase += 13LLU;
8385- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCELLU;
10208+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD47LLU;
838610209 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
838710210 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
838810211 break;
838910212 }
8390-case 0xFFFFFFFFFFFFFDCELLU:
10213+case 0xFFFFFFFFFFFFFD47LLU:
839110214 /* SP = 11LLU */
839210215 {
839310216 /*CALLEND*/
839410217 stackbase += 10LLU;
8395- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCDLLU;
10218+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD46LLU;
839610219 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
839710220 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
839810221 break;
839910222 }
8400-case 0xFFFFFFFFFFFFFDCDLLU:
10223+case 0xFFFFFFFFFFFFFD46LLU:
840110224 /* SP = 8LLU */fputs(": /* alternative */", stdout);
840210225 {
840310226 /* CALLBEGIN */
@@ -8408,12 +10231,12 @@
840810231 {
840910232 /*CALLEND*/
841010233 stackbase += 10LLU;
8411- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCCLLU;
10234+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD45LLU;
841210235 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
841310236 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
841410237 break;
841510238 }
8416-case 0xFFFFFFFFFFFFFDCCLLU:
10239+case 0xFFFFFFFFFFFFFD45LLU:
841710240 /* SP = 8LLU *//* predicate */
841810241
841910242 {
@@ -8426,15 +10249,15 @@
842610249 {
842710250 /*CALLEND*/
842810251 stackbase += 11LLU;
8429- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC9LLU;
10252+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD42LLU;
843010253 fnaddr = /*matchoptid*/0xA1CBDE8EAAEF91F0LLU;/* SP = 0LLU */
843110254 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchoptid*/\n"); exit(-1); }
843210255 break;
843310256 }
8434-case 0xFFFFFFFFFFFFFDC9LLU:
10257+case 0xFFFFFFFFFFFFFD42LLU:
843510258 /* SP = 9LLU */
843610259 if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
8437-{ /* JUMP */ fnaddr = 18446744073709551051LLU; break; } /* skip consequent */
10260+{ /* JUMP */ fnaddr = 18446744073709550916LLU; break; } /* skip consequent */
843810261 /* consequent */
843910262 {
844010263 /* CALLBEGIN */
@@ -8445,12 +10268,12 @@
844510268 {
844610269 /*CALLEND*/
844710270 stackbase += 10LLU;
8448- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC8LLU;
10271+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD41LLU;
844910272 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
845010273 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
845110274 break;
845210275 }
8453-case 0xFFFFFFFFFFFFFDC8LLU:
10276+case 0xFFFFFFFFFFFFFD41LLU:
845410277 /* SP = 8LLU */
845510278 {
845610279 /* CALLBEGIN */
@@ -8470,12 +10293,12 @@
847010293 {
847110294 /*CALLEND*/
847210295 stackbase += 16LLU;
8473- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC7LLU;
10296+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD40LLU;
847410297 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
847510298 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
847610299 break;
847710300 }
8478-case 0xFFFFFFFFFFFFFDC7LLU:
10301+case 0xFFFFFFFFFFFFFD40LLU:
847910302 /* SP = 14LLU */
848010303 { /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 15LLU */
848110304 { /* PUSH */ stack[stackbase + 15LLU] = 0LLU; }/* SP + 1LLU = 16LLU */
@@ -8482,12 +10305,12 @@
848210305 {
848310306 /*CALLEND*/
848410307 stackbase += 10LLU;
8485- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC6LLU;
10308+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3FLLU;
848610309 fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
848710310 if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); }
848810311 break;
848910312 }
8490-case 0xFFFFFFFFFFFFFDC6LLU:
10313+case 0xFFFFFFFFFFFFFD3FLLU:
849110314 /* SP = 8LLU */fputs("\ncase ", stdout);
849210315 {
849310316 /* CALLBEGIN */
@@ -8499,15 +10322,15 @@
849910322 {
850010323 /*CALLEND*/
850110324 stackbase += 10LLU;
8502- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC5LLU;
10325+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3ELLU;
850310326 fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */
850410327 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); }
850510328 break;
850610329 }
8507-case 0xFFFFFFFFFFFFFDC5LLU:
10330+case 0xFFFFFFFFFFFFFD3ELLU:
850810331 /* SP = 8LLU */fputs(": /* skip to here */\n", stdout); /* SP = 8LLU *//* SP = 8LLU */
8509-{ /* JUMP */ fnaddr = 18446744073709551050LLU; break; } /* skip alternative */
8510-case 18446744073709551051LLU: /* alternative */
10332+{ /* JUMP */ fnaddr = 18446744073709550915LLU; break; } /* skip alternative */
10333+case 18446744073709550916LLU: /* alternative */
851110334 {
851210335 /* CALLBEGIN */
851310336 /* reserve space for 0LLU returned values *//* SP + 0LLU = 8LLU */
@@ -8517,17 +10340,17 @@
851710340 {
851810341 /*CALLEND*/
851910342 stackbase += 10LLU;
8520- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC4LLU;
10343+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3DLLU;
852110344 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
852210345 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
852310346 break;
852410347 }
8525-case 0xFFFFFFFFFFFFFDC4LLU:
10348+case 0xFFFFFFFFFFFFFD3DLLU:
852610349 /* SP = 8LLU */fputs("missing keyword \"else\"\n", stderr); exit(-1);/* SP = 8LLU */
8527-case 18446744073709551050LLU: /* skip to here */
10350+case 18446744073709550915LLU: /* skip to here */
852810351 /* SP = 7LLU *//* SP = 7LLU */
8529-{ /* JUMP */ fnaddr = 18446744073709551065LLU; break; } /* skip alternative */
8530-case 18446744073709551066LLU: /* alternative */
10352+{ /* JUMP */ fnaddr = 18446744073709550930LLU; break; } /* skip alternative */
10353+case 18446744073709550931LLU: /* alternative */
853110354 {
853210355 /* CALLBEGIN */
853310356 /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */
@@ -8537,17 +10360,17 @@
853710360 {
853810361 /*CALLEND*/
853910362 stackbase += 9LLU;
8540- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC3LLU;
10363+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3CLLU;
854110364 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
854210365 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
854310366 break;
854410367 }
8545-case 0xFFFFFFFFFFFFFDC3LLU:
10368+case 0xFFFFFFFFFFFFFD3CLLU:
854610369 /* SP = 7LLU */fputs("missing keyword \"then\"\n", stderr); exit(-1);/* SP = 7LLU */
8547-case 18446744073709551065LLU: /* skip to here */
10370+case 18446744073709550930LLU: /* skip to here */
854810371 /* SP = 6LLU *//* SP = 6LLU */
8549-{ /* JUMP */ fnaddr = 18446744073709551077LLU; break; } /* skip alternative */
8550-case 18446744073709551078LLU: /* alternative */
10372+{ /* JUMP */ fnaddr = 18446744073709550942LLU; break; } /* skip alternative */
10373+case 18446744073709550943LLU: /* alternative */
855110374 {
855210375 /* CALLBEGIN */
855310376 /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */
@@ -8559,12 +10382,12 @@
855910382 {
856010383 /*CALLEND*/
856110384 stackbase += 9LLU;
8562- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC2LLU;
10385+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3BLLU;
856310386 fnaddr = /*findvaro__*/0x864A5FC5CB6A0000LLU;/* SP = 0LLU */
856410387 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvaro__*/\n"); exit(-1); }
856510388 break;
856610389 }
8567-case 0xFFFFFFFFFFFFFDC2LLU:
10390+case 0xFFFFFFFFFFFFFD3BLLU:
856810391 /* SP = 7LLU */
856910392 {
857010393 /* CALLBEGIN */
@@ -8577,12 +10400,12 @@
857710400 {
857810401 /*CALLEND*/
857910402 stackbase += 10LLU;
8580- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC1LLU;
10403+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3ALLU;
858110404 fnaddr = /*findvart__*/0x864A5FC5CB6F0000LLU;/* SP = 0LLU */
858210405 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvart__*/\n"); exit(-1); }
858310406 break;
858410407 }
8585-case 0xFFFFFFFFFFFFFDC1LLU:
10408+case 0xFFFFFFFFFFFFFD3ALLU:
858610409 /* SP = 8LLU */
858710410 {
858810411 /* CALLBEGIN */
@@ -8595,12 +10418,12 @@
859510418 {
859610419 /*CALLEND*/
859710420 stackbase += 11LLU;
8598- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC0LLU;
10421+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD39LLU;
859910422 fnaddr = /*findvarv__*/0x864A5FC5CB710000LLU;/* SP = 0LLU */
860010423 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvarv__*/\n"); exit(-1); }
860110424 break;
860210425 }
8603-case 0xFFFFFFFFFFFFFDC0LLU:
10426+case 0xFFFFFFFFFFFFFD39LLU:
860410427 /* SP = 9LLU *//* predicate */
860510428
860610429 {
@@ -8613,15 +10436,15 @@
861310436 {
861410437 /*CALLEND*/
861510438 stackbase += 12LLU;
8616- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBDLLU;
10439+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD36LLU;
861710440 fnaddr = /*typeisval_*/0xBF4AE092EC5C9C00LLU;/* SP = 0LLU */
861810441 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeisval_*/\n"); exit(-1); }
861910442 break;
862010443 }
8621-case 0xFFFFFFFFFFFFFDBDLLU:
10444+case 0xFFFFFFFFFFFFFD36LLU:
862210445 /* SP = 10LLU */
862310446 if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
8624-{ /* JUMP */ fnaddr = 18446744073709551039LLU; break; } /* skip consequent */
10447+{ /* JUMP */ fnaddr = 18446744073709550904LLU; break; } /* skip consequent */
862510448 /* consequent */
862610449 {
862710450 /* CALLBEGIN */
@@ -8629,16 +10452,17 @@
862910452 { /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
863010453 /* leave place for return addr *//* SP + 1LLU = 12LLU */
863110454 }
8632-{ /* PUSH */ stack[stackbase + 12LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 13LLU */
10455+{ /* PUSH */ stack[stackbase + 12LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 13LLU */
10456+{ /* PUSH */ stack[stackbase + 13LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 14LLU */
863310457 {
863410458 /*CALLEND*/
863510459 stackbase += 12LLU;
8636- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBCLLU;
8637- fnaddr = /*typestore_*/0xBF4AE0BAFAAD8000LLU;/* SP = 0LLU */
8638-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typestore_*/\n"); exit(-1); }
10460+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD35LLU;
10461+ fnaddr = /*typesize__*/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
10462+if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typesize__*/\n"); exit(-1); }
863910463 break;
864010464 }
8641-case 0xFFFFFFFFFFFFFDBCLLU:
10465+case 0xFFFFFFFFFFFFFD35LLU:
864210466 /* SP = 10LLU */
864310467 {
864410468 /* CALLBEGIN */
@@ -8649,12 +10473,12 @@
864910473 {
865010474 /*CALLEND*/
865110475 stackbase += 12LLU;
8652- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBBLLU;
10476+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD34LLU;
865310477 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
865410478 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
865510479 break;
865610480 }
8657-case 0xFFFFFFFFFFFFFDBBLLU:
10481+case 0xFFFFFFFFFFFFFD34LLU:
865810482 /* SP = 10LLU *//* predicate */
865910483
866010484 {
@@ -8667,31 +10491,193 @@
866710491 {
866810492 /*CALLEND*/
866910493 stackbase += 13LLU;
8670- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB9LLU;
10494+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD32LLU;
867110495 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
867210496 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
867310497 break;
867410498 }
8675-case 0xFFFFFFFFFFFFFDB9LLU:
10499+case 0xFFFFFFFFFFFFFD32LLU:
867610500 /* SP = 11LLU */
867710501 if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
8678-{ /* JUMP */ fnaddr = 18446744073709551034LLU; break; } /* skip consequent */
10502+{ /* JUMP */ fnaddr = 18446744073709550899LLU; break; } /* skip consequent */
867910503 /* consequent */
868010504 {
868110505 /* CALLBEGIN */
10506+ /* reserve space for 0LLU returned values *//* SP + 0LLU = 10LLU */
10507+{ /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */
10508+ /* leave place for return addr *//* SP + 1LLU = 12LLU */
10509+ }
10510+ {
10511+ /*CALLEND*/
10512+ stackbase += 12LLU;
10513+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD31LLU;
10514+ fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10515+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
10516+ break;
10517+ }
10518+case 0xFFFFFFFFFFFFFD31LLU:
10519+/* SP = 10LLU *//* predicate */
10520+
10521+ {
10522+ /* CALLBEGIN */
868210523 /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
868310524 { /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
868410525 /* leave place for return addr *//* SP + 1LLU = 13LLU */
868510526 }
868610527 {
10528+ /* CALLBEGIN */
10529+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 14LLU */
10530+{ /* PUSH */ stack[stackbase + 14LLU] = stackbase; }/* SP + 1LLU = 15LLU */
10531+ /* leave place for return addr *//* SP + 1LLU = 16LLU */
10532+ }
10533+ {
868710534 /*CALLEND*/
10535+ stackbase += 16LLU;
10536+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2ELLU;
10537+ fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */
10538+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); }
10539+ break;
10540+ }
10541+case 0xFFFFFFFFFFFFFD2ELLU:
10542+/* SP = 14LLU */
10543+ {
10544+ /*CALLEND*/
868810545 stackbase += 13LLU;
8689- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB8LLU;
10546+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2DLLU;
10547+ fnaddr = /*isalpha___*/0x92E727AE37000000LLU;/* SP = 0LLU */
10548+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isalpha___*/\n"); exit(-1); }
10549+ break;
10550+ }
10551+case 0xFFFFFFFFFFFFFD2DLLU:
10552+/* SP = 11LLU */
10553+if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
10554+{ /* JUMP */ fnaddr = 18446744073709550896LLU; break; } /* skip consequent */
10555+/* consequent */
10556+ {
10557+ /* CALLBEGIN */
10558+ /* reserve space for 2LLU returned values *//* SP + 2LLU = 12LLU */
10559+{ /* PUSH */ stack[stackbase + 12LLU] = stackbase; }/* SP + 1LLU = 13LLU */
10560+ /* leave place for return addr *//* SP + 1LLU = 14LLU */
10561+ }
10562+{ /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 15LLU */
10563+ {
10564+ /* CALLBEGIN */
10565+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 16LLU */
10566+{ /* PUSH */ stack[stackbase + 16LLU] = stackbase; }/* SP + 1LLU = 17LLU */
10567+ /* leave place for return addr *//* SP + 1LLU = 18LLU */
10568+ }
10569+ {
10570+ /* CALLBEGIN */
10571+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 19LLU */
10572+{ /* PUSH */ stack[stackbase + 19LLU] = stackbase; }/* SP + 1LLU = 20LLU */
10573+ /* leave place for return addr *//* SP + 1LLU = 21LLU */
10574+ }
10575+{ /* PUSH */ stack[stackbase + 21LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 22LLU */
10576+ {
10577+ /*CALLEND*/
10578+ stackbase += 21LLU;
10579+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2CLLU;
10580+ fnaddr = /*typetosub_*/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
10581+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosub_*/\n"); exit(-1); }
10582+ break;
10583+ }
10584+case 0xFFFFFFFFFFFFFD2CLLU:
10585+/* SP = 19LLU */
10586+ {
10587+ /*CALLEND*/
10588+ stackbase += 18LLU;
10589+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2BLLU;
10590+ fnaddr = /*subtoid___*/0xBB076FAA47C00000LLU;/* SP = 0LLU */
10591+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*subtoid___*/\n"); exit(-1); }
10592+ break;
10593+ }
10594+case 0xFFFFFFFFFFFFFD2BLLU:
10595+/* SP = 16LLU */
10596+ {
10597+ /* CALLBEGIN */
10598+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 17LLU */
10599+{ /* PUSH */ stack[stackbase + 17LLU] = stackbase; }/* SP + 1LLU = 18LLU */
10600+ /* leave place for return addr *//* SP + 1LLU = 19LLU */
10601+ }
10602+ {
10603+ /*CALLEND*/
10604+ stackbase += 19LLU;
10605+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2ALLU;
10606+ fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
10607+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
10608+ break;
10609+ }
10610+case 0xFFFFFFFFFFFFFD2ALLU:
10611+/* SP = 17LLU */
10612+ {
10613+ /*CALLEND*/
10614+ stackbase += 14LLU;
10615+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD29LLU;
10616+ fnaddr = /*getdefelem*/0x8A0BDF8218278280LLU;/* SP = 0LLU */
10617+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*getdefelem*/\n"); exit(-1); }
10618+ break;
10619+ }
10620+case 0xFFFFFFFFFFFFFD29LLU:
10621+/* SP = 12LLU */
10622+{ /* PUSH */ stack[stackbase + 12LLU] = /* LOCAL VAR */ stack[stackbase + 10LLU]; }/* SP + 1LLU = 13LLU */
10623+{ /* PUSH */ stack[stackbase + 13LLU] = /* LOCAL VAR */ stack[stackbase + 11LLU]; }/* SP + 1LLU = 14LLU */
10624+ {
10625+ /* CALLBEGIN */
10626+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 15LLU */
10627+{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
10628+ /* leave place for return addr *//* SP + 1LLU = 17LLU */
10629+ }
10630+{ /* PUSH */ stack[stackbase + 17LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 18LLU */
10631+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 12LLU]; }/* SP + 1LLU = 19LLU */
10632+ {
10633+ /*CALLEND*/
10634+ stackbase += 17LLU;
10635+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD28LLU;
10636+ fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
10637+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
10638+ break;
10639+ }
10640+case 0xFFFFFFFFFFFFFD28LLU:
10641+/* SP = 15LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 14LLU */stack[stackbase + 14LLU]; /* POP */
10642+
10643+{ /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 13LLU]; }/* SP + 1LLU = 15LLU *//* LOCAL VAR */ stack[stackbase + 7LLU] = /* SP - 1LLU = 14LLU */stack[stackbase + 14LLU]; /* POP */
10644+
10645+ {
10646+ /* CALLBEGIN */
10647+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 15LLU */
10648+{ /* PUSH */ stack[stackbase + 15LLU] = stackbase; }/* SP + 1LLU = 16LLU */
10649+ /* leave place for return addr *//* SP + 1LLU = 17LLU */
10650+ }
10651+{ /* PUSH */ stack[stackbase + 17LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 18LLU */
10652+{ /* PUSH */ stack[stackbase + 18LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 19LLU */
10653+ {
10654+ /*CALLEND*/
10655+ stackbase += 17LLU;
10656+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD27LLU;
10657+ fnaddr = /*typesize__*/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
10658+if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typesize__*/\n"); exit(-1); }
10659+ break;
10660+ }
10661+case 0xFFFFFFFFFFFFFD27LLU:
10662+/* SP = 15LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 14LLU */stack[stackbase + 14LLU]; /* POP */
10663+/* SP = 10LLU *//* SP = 10LLU */
10664+{ /* JUMP */ fnaddr = 18446744073709550895LLU; break; } /* skip alternative */
10665+case 18446744073709550896LLU: /* alternative */
10666+ {
10667+ /* CALLBEGIN */
10668+ /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */
10669+{ /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */
10670+ /* leave place for return addr *//* SP + 1LLU = 13LLU */
10671+ }
10672+ {
10673+ /*CALLEND*/
10674+ stackbase += 13LLU;
10675+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD26LLU;
869010676 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
869110677 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
869210678 break;
869310679 }
8694-case 0xFFFFFFFFFFFFFDB8LLU:
10680+case 0xFFFFFFFFFFFFFD26LLU:
869510681 /* SP = 11LLU *//* predicate */
869610682
869710683 {
@@ -8705,15 +10691,15 @@
870510691 {
870610692 /*CALLEND*/
870710693 stackbase += 14LLU;
8708- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB5LLU;
10694+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD23LLU;
870910695 fnaddr = /*lss_______*/0x9EEB800000000000LLU;/* SP = 0LLU */
871010696 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*lss_______*/\n"); exit(-1); }
871110697 break;
871210698 }
8713-case 0xFFFFFFFFFFFFFDB5LLU:
10699+case 0xFFFFFFFFFFFFFD23LLU:
871410700 /* SP = 12LLU */
871510701 if(!/* SP - 1LLU = 11LLU */stack[stackbase + 11LLU])
8716-{ /* JUMP */ fnaddr = 18446744073709551031LLU; break; } /* skip consequent */
10702+{ /* JUMP */ fnaddr = 18446744073709550885LLU; break; } /* skip consequent */
871710703 /* consequent */
871810704 {
871910705 /* CALLBEGIN */
@@ -8726,12 +10712,12 @@
872610712 {
872710713 /*CALLEND*/
872810714 stackbase += 14LLU;
8729- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB4LLU;
10715+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD22LLU;
873010716 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
873110717 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
873210718 break;
873310719 }
8734-case 0xFFFFFFFFFFFFFDB4LLU:
10720+case 0xFFFFFFFFFFFFFD22LLU:
873510721 /* SP = 12LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 11LLU */stack[stackbase + 11LLU]; /* POP */
873610722
873710723 { /* PUSH */ stack[stackbase + 11LLU] = 1LLU; }/* SP + 1LLU = 12LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 11LLU */stack[stackbase + 11LLU]; /* POP */
@@ -8746,16 +10732,16 @@
874610732 {
874710733 /*CALLEND*/
874810734 stackbase += 14LLU;
8749- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB3LLU;
10735+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD21LLU;
875010736 fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
875110737 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); }
875210738 break;
875310739 }
8754-case 0xFFFFFFFFFFFFFDB3LLU:
10740+case 0xFFFFFFFFFFFFFD21LLU:
875510741 /* SP = 12LLU *//* LOCAL VAR */ stack[stackbase + 7LLU] = /* SP - 1LLU = 11LLU */stack[stackbase + 11LLU]; /* POP */
875610742 /* SP = 11LLU *//* SP = 11LLU */
8757-{ /* JUMP */ fnaddr = 18446744073709551030LLU; break; } /* skip alternative */
8758-case 18446744073709551031LLU: /* alternative */
10743+{ /* JUMP */ fnaddr = 18446744073709550884LLU; break; } /* skip alternative */
10744+case 18446744073709550885LLU: /* alternative */
875910745 {
876010746 /* CALLBEGIN */
876110747 /* reserve space for 0LLU returned values *//* SP + 0LLU = 11LLU */
@@ -8765,12 +10751,12 @@
876510751 {
876610752 /*CALLEND*/
876710753 stackbase += 13LLU;
8768- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB2LLU;
10754+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD20LLU;
876910755 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
877010756 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
877110757 break;
877210758 }
8773-case 0xFFFFFFFFFFFFFDB2LLU:
10759+case 0xFFFFFFFFFFFFFD20LLU:
877410760 /* SP = 11LLU */fputs("variable ", stderr);
877510761 {
877610762 /* CALLBEGIN */
@@ -8782,12 +10768,12 @@
878210768 {
878310769 /*CALLEND*/
878410770 stackbase += 13LLU;
8785- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB1LLU;
10771+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1FLLU;
878610772 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
878710773 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
878810774 break;
878910775 }
8790-case 0xFFFFFFFFFFFFFDB1LLU:
10776+case 0xFFFFFFFFFFFFFD1FLLU:
879110777 /* SP = 11LLU */fputs(" of size ", stderr);
879210778 {
879310779 /* CALLBEGIN */
@@ -8799,12 +10785,12 @@
879910785 {
880010786 /*CALLEND*/
880110787 stackbase += 13LLU;
8802- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB0LLU;
10788+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1ELLU;
880310789 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
880410790 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
880510791 break;
880610792 }
8807-case 0xFFFFFFFFFFFFFDB0LLU:
10793+case 0xFFFFFFFFFFFFFD1ELLU:
880810794 /* SP = 11LLU */fputs(" has no element ", stderr);
880910795 {
881010796 /* CALLBEGIN */
@@ -8816,16 +10802,18 @@
881610802 {
881710803 /*CALLEND*/
881810804 stackbase += 13LLU;
8819- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAFLLU;
10805+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1DLLU;
882010806 fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */
882110807 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); }
882210808 break;
882310809 }
8824-case 0xFFFFFFFFFFFFFDAFLLU:
10810+case 0xFFFFFFFFFFFFFD1DLLU:
882510811 /* SP = 11LLU */exit(-1);/* SP = 11LLU */
8826-case 18446744073709551030LLU: /* skip to here */
10812+case 18446744073709550884LLU: /* skip to here */
882710813 /* SP = 10LLU */
8828-case 18446744073709551034LLU: /* alternative */
10814+case 18446744073709550895LLU: /* skip to here */
10815+/* SP = 10LLU */
10816+case 18446744073709550899LLU: /* alternative */
882910817 {
883010818 /* CALLBEGIN */
883110819 /* reserve space for 0LLU returned values *//* SP + 0LLU = 10LLU */
@@ -8835,12 +10823,12 @@
883510823 {
883610824 /*CALLEND*/
883710825 stackbase += 12LLU;
8838- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAELLU;
10826+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1CLLU;
883910827 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
884010828 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
884110829 break;
884210830 }
8843-case 0xFFFFFFFFFFFFFDAELLU:
10831+case 0xFFFFFFFFFFFFFD1CLLU:
884410832 /* SP = 10LLU *//* predicate */
884510833
884610834 {
@@ -8853,15 +10841,15 @@
885310841 {
885410842 /*CALLEND*/
885510843 stackbase += 13LLU;
8856- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDABLLU;
10844+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD19LLU;
885710845 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
885810846 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
885910847 break;
886010848 }
8861-case 0xFFFFFFFFFFFFFDABLLU:
10849+case 0xFFFFFFFFFFFFFD19LLU:
886210850 /* SP = 11LLU */
886310851 if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
8864-{ /* JUMP */ fnaddr = 18446744073709551021LLU; break; } /* skip consequent */
10852+{ /* JUMP */ fnaddr = 18446744073709550875LLU; break; } /* skip consequent */
886510853 /* consequent */
886610854 {
886710855 /* CALLBEGIN */
@@ -8879,23 +10867,23 @@
887910867 {
888010868 /*CALLEND*/
888110869 stackbase += 15LLU;
8882- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAALLU;
10870+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD18LLU;
888310871 fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
888410872 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); }
888510873 break;
888610874 }
8887-case 0xFFFFFFFFFFFFFDAALLU:
10875+case 0xFFFFFFFFFFFFFD18LLU:
888810876 /* SP = 13LLU */
888910877 { /* PUSH */ stack[stackbase + 13LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 14LLU */
889010878 {
889110879 /*CALLEND*/
889210880 stackbase += 12LLU;
8893- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA9LLU;
10881+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD17LLU;
889410882 fnaddr = /*typecheck_*/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
889510883 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typecheck_*/\n"); exit(-1); }
889610884 break;
889710885 }
8898-case 0xFFFFFFFFFFFFFDA9LLU:
10886+case 0xFFFFFFFFFFFFFD17LLU:
889910887 /* SP = 10LLU */
890010888 {
890110889 /* CALLBEGIN */
@@ -8906,12 +10894,12 @@
890610894 {
890710895 /*CALLEND*/
890810896 stackbase += 12LLU;
8909- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA8LLU;
10897+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD16LLU;
891010898 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
891110899 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
891210900 break;
891310901 }
8914-case 0xFFFFFFFFFFFFFDA8LLU:
10902+case 0xFFFFFFFFFFFFFD16LLU:
891510903 /* SP = 10LLU */
891610904 {
891710905 /* CALLBEGIN */
@@ -8931,12 +10919,12 @@
893110919 {
893210920 /*CALLEND*/
893310921 stackbase += 18LLU;
8934- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA7LLU;
10922+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD15LLU;
893510923 fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */
893610924 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); }
893710925 break;
893810926 }
8939-case 0xFFFFFFFFFFFFFDA7LLU:
10927+case 0xFFFFFFFFFFFFFD15LLU:
894010928 /* SP = 16LLU */
894110929 { /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 17LLU */
894210930 { /* PUSH */ stack[stackbase + 17LLU] = 0LLU; }/* SP + 1LLU = 18LLU */
@@ -8943,14 +10931,14 @@
894310931 {
894410932 /*CALLEND*/
894510933 stackbase += 12LLU;
8946- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA6LLU;
10934+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD14LLU;
894710935 fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
894810936 if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); }
894910937 break;
895010938 }
8951-case 0xFFFFFFFFFFFFFDA6LLU:
10939+case 0xFFFFFFFFFFFFFD14LLU:
895210940 /* SP = 10LLU */
8953-case 0xFFFFFFFFFFFFFDA5LLU: /* loop to here *//* predicate */
10941+case 0xFFFFFFFFFFFFFD13LLU: /* loop to here *//* predicate */
895410942
895510943 {
895610944 /* CALLBEGIN */
@@ -8963,15 +10951,15 @@
896310951 {
896410952 /*CALLEND*/
896510953 stackbase += 13LLU;
8966- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA3LLU;
10954+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD11LLU;
896710955 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
896810956 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
896910957 break;
897010958 }
8971-case 0xFFFFFFFFFFFFFDA3LLU:
10959+case 0xFFFFFFFFFFFFFD11LLU:
897210960 /* SP = 11LLU */
897310961 if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
8974-{ /* JUMP */ fnaddr = 18446744073709551012LLU; break; } /* skip loop */
10962+{ /* JUMP */ fnaddr = 18446744073709550866LLU; break; } /* skip loop */
897510963 /* loop */
897610964 {
897710965 /* CALLBEGIN */
@@ -8984,12 +10972,12 @@
898410972 {
898510973 /*CALLEND*/
898610974 stackbase += 13LLU;
8987- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA2LLU;
10975+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD10LLU;
898810976 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
898910977 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
899010978 break;
899110979 }
8992-case 0xFFFFFFFFFFFFFDA2LLU:
10980+case 0xFFFFFFFFFFFFFD10LLU:
899310981 /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */
899410982
899510983 {
@@ -9009,22 +10997,22 @@
900910997 {
901010998 /*CALLEND*/
901110999 stackbase += 15LLU;
9012- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA1LLU;
11000+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0FLLU;
901311001 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
901411002 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
901511003 break;
901611004 }
9017-case 0xFFFFFFFFFFFFFDA1LLU:
11005+case 0xFFFFFFFFFFFFFD0FLLU:
901811006 /* SP = 13LLU */
901911007 {
902011008 /*CALLEND*/
902111009 stackbase += 12LLU;
9022- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA0LLU;
11010+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0ELLU;
902311011 fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */
902411012 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); }
902511013 break;
902611014 }
9027-case 0xFFFFFFFFFFFFFDA0LLU:
11015+case 0xFFFFFFFFFFFFFD0ELLU:
902811016 /* SP = 10LLU */fputs(" = ", stdout);
902911017 {
903011018 /* CALLBEGIN */
@@ -9035,17 +11023,17 @@
903511023 {
903611024 /*CALLEND*/
903711025 stackbase += 12LLU;
9038- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9FLLU;
11026+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0DLLU;
903911027 fnaddr = /*POP_______*/0x40F4000000000000LLU;/* SP = 0LLU */
904011028 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_______*/\n"); exit(-1); }
904111029 break;
904211030 }
9043-case 0xFFFFFFFFFFFFFD9FLLU:
11031+case 0xFFFFFFFFFFFFFD0DLLU:
904411032 /* SP = 10LLU *//* SP = 10LLU */
9045-{ /* JUMP */ fnaddr = 18446744073709551013LLU; break; } /* loop */
9046-case 18446744073709551012LLU: /* skip to here *//* SP = 10LLU *//* SP = 10LLU */
9047-{ /* JUMP */ fnaddr = 18446744073709551020LLU; break; } /* skip alternative */
9048-case 18446744073709551021LLU: /* alternative */
11033+{ /* JUMP */ fnaddr = 18446744073709550867LLU; break; } /* loop */
11034+case 18446744073709550866LLU: /* skip to here *//* SP = 10LLU *//* SP = 10LLU */
11035+{ /* JUMP */ fnaddr = 18446744073709550874LLU; break; } /* skip alternative */
11036+case 18446744073709550875LLU: /* alternative */
904911037 {
905011038 /* CALLBEGIN */
905111039 /* reserve space for 0LLU returned values *//* SP + 0LLU = 10LLU */
@@ -9058,14 +11046,14 @@
905811046 {
905911047 /*CALLEND*/
906011048 stackbase += 12LLU;
9061- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9ELLU;
11049+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0CLLU;
906211050 fnaddr = /*typecheckV*/0xBF4AE07A381E9960LLU;/* SP = 0LLU */
906311051 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typecheckV*/\n"); exit(-1); }
906411052 break;
906511053 }
9066-case 0xFFFFFFFFFFFFFD9ELLU:
11054+case 0xFFFFFFFFFFFFFD0CLLU:
906711055 /* SP = 10LLU */
9068-case 0xFFFFFFFFFFFFFD9DLLU: /* loop to here *//* predicate */
11056+case 0xFFFFFFFFFFFFFD0BLLU: /* loop to here *//* predicate */
906911057
907011058 {
907111059 /* CALLBEGIN */
@@ -9078,15 +11066,15 @@
907811066 {
907911067 /*CALLEND*/
908011068 stackbase += 13LLU;
9081- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9BLLU;
11069+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD09LLU;
908211070 fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */
908311071 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); }
908411072 break;
908511073 }
9086-case 0xFFFFFFFFFFFFFD9BLLU:
11074+case 0xFFFFFFFFFFFFFD09LLU:
908711075 /* SP = 11LLU */
908811076 if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
9089-{ /* JUMP */ fnaddr = 18446744073709551004LLU; break; } /* skip loop */
11077+{ /* JUMP */ fnaddr = 18446744073709550858LLU; break; } /* skip loop */
909011078 /* loop */
909111079 {
909211080 /* CALLBEGIN */
@@ -9099,12 +11087,12 @@
909911087 {
910011088 /*CALLEND*/
910111089 stackbase += 13LLU;
9102- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9ALLU;
11090+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD08LLU;
910311091 fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */
910411092 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); }
910511093 break;
910611094 }
9107-case 0xFFFFFFFFFFFFFD9ALLU:
11095+case 0xFFFFFFFFFFFFFD08LLU:
910811096 /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */
910911097
911011098 {
@@ -9116,12 +11104,12 @@
911611104 {
911711105 /*CALLEND*/
911811106 stackbase += 12LLU;
9119- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD99LLU;
11107+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD07LLU;
912011108 fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */
912111109 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); }
912211110 break;
912311111 }
9124-case 0xFFFFFFFFFFFFFD99LLU:
11112+case 0xFFFFFFFFFFFFFD07LLU:
912511113 /* SP = 10LLU */
912611114 {
912711115 /* CALLBEGIN */
@@ -9133,12 +11121,12 @@
913311121 {
913411122 /*CALLEND*/
913511123 stackbase += 12LLU;
9136- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD98LLU;
11124+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD06LLU;
913711125 fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */
913811126 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); }
913911127 break;
914011128 }
9141-case 0xFFFFFFFFFFFFFD98LLU:
11129+case 0xFFFFFFFFFFFFFD06LLU:
914211130 /* SP = 10LLU */
914311131 {
914411132 /* CALLBEGIN */
@@ -9149,12 +11137,12 @@
914911137 {
915011138 /*CALLEND*/
915111139 stackbase += 12LLU;
9152- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD97LLU;
11140+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD05LLU;
915311141 fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */
915411142 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); }
915511143 break;
915611144 }
9157-case 0xFFFFFFFFFFFFFD97LLU:
11145+case 0xFFFFFFFFFFFFFD05LLU:
915811146 /* SP = 10LLU */
915911147 {
916011148 /* CALLBEGIN */
@@ -9167,20 +11155,20 @@
916711155 {
916811156 /*CALLEND*/
916911157 stackbase += 13LLU;
9170- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD96LLU;
11158+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD04LLU;
917111159 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
917211160 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
917311161 break;
917411162 }
9175-case 0xFFFFFFFFFFFFFD96LLU:
11163+case 0xFFFFFFFFFFFFFD04LLU:
917611164 /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */
917711165 /* SP = 10LLU */
9178-{ /* JUMP */ fnaddr = 18446744073709551005LLU; break; } /* loop */
9179-case 18446744073709551004LLU: /* skip to here *//* SP = 10LLU */
9180-case 18446744073709551020LLU: /* skip to here */
11166+{ /* JUMP */ fnaddr = 18446744073709550859LLU; break; } /* loop */
11167+case 18446744073709550858LLU: /* skip to here *//* SP = 10LLU */
11168+case 18446744073709550874LLU: /* skip to here */
918111169 /* SP = 9LLU *//* SP = 9LLU */
9182-{ /* JUMP */ fnaddr = 18446744073709551038LLU; break; } /* skip alternative */
9183-case 18446744073709551039LLU: /* alternative */
11170+{ /* JUMP */ fnaddr = 18446744073709550903LLU; break; } /* skip alternative */
11171+case 18446744073709550904LLU: /* alternative */
918411172 {
918511173 /* CALLBEGIN */
918611174 /* reserve space for 0LLU returned values *//* SP + 0LLU = 9LLU */
@@ -9190,12 +11178,12 @@
919011178 {
919111179 /*CALLEND*/
919211180 stackbase += 11LLU;
9193- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD95LLU;
11181+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD03LLU;
919411182 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
919511183 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
919611184 break;
919711185 }
9198-case 0xFFFFFFFFFFFFFD95LLU:
11186+case 0xFFFFFFFFFFFFFD03LLU:
919911187 /* SP = 9LLU *//* predicate */
920011188
920111189 {
@@ -9208,15 +11196,15 @@
920811196 {
920911197 /*CALLEND*/
921011198 stackbase += 12LLU;
9211- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD92LLU;
11199+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD00LLU;
921211200 fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
921311201 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); }
921411202 break;
921511203 }
9216-case 0xFFFFFFFFFFFFFD92LLU:
11204+case 0xFFFFFFFFFFFFFD00LLU:
921711205 /* SP = 10LLU */
921811206 if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
9219-{ /* JUMP */ fnaddr = 18446744073709550996LLU; break; } /* skip consequent */
11207+{ /* JUMP */ fnaddr = 18446744073709550850LLU; break; } /* skip consequent */
922011208 /* consequent *//* predicate */
922111209
922211210 {
@@ -9229,15 +11217,15 @@
922911217 {
923011218 /*CALLEND*/
923111219 stackbase += 12LLU;
9232- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD90LLU;
11220+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFELLU;
923311221 fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */
923411222 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); }
923511223 break;
923611224 }
9237-case 0xFFFFFFFFFFFFFD90LLU:
11225+case 0xFFFFFFFFFFFFFCFELLU:
923811226 /* SP = 10LLU */
923911227 if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
9240-{ /* JUMP */ fnaddr = 18446744073709550993LLU; break; } /* skip consequent */
11228+{ /* JUMP */ fnaddr = 18446744073709550847LLU; break; } /* skip consequent */
924111229 /* consequent */
924211230 {
924311231 /* CALLBEGIN */
@@ -9248,12 +11236,12 @@
924811236 {
924911237 /*CALLEND*/
925011238 stackbase += 11LLU;
9251- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8FLLU;
11239+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFDLLU;
925211240 fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */
925311241 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); }
925411242 break;
925511243 }
9256-case 0xFFFFFFFFFFFFFD8FLLU:
11244+case 0xFFFFFFFFFFFFFCFDLLU:
925711245 /* SP = 9LLU */fputs("accessing unverified list ", stderr);
925811246 {
925911247 /* CALLBEGIN */
@@ -9265,14 +11253,14 @@
926511253 {
926611254 /*CALLEND*/
926711255 stackbase += 11LLU;
9268- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ELLU;
11256+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFCLLU;
926911257 fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */
927011258 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); }
927111259 break;
927211260 }
9273-case 0xFFFFFFFFFFFFFD8ELLU:
11261+case 0xFFFFFFFFFFFFFCFCLLU:
927411262 /* SP = 9LLU */fputs("\n", stderr); exit(-1);/* SP = 9LLU */
9275-case 18446744073709550993LLU: /* alternative */
11263+case 18446744073709550847LLU: /* alternative */
927611264 {
927711265 /* CALLBEGIN */
927811266 /* reserve space for 0LLU returned values *//* SP + 0LLU = 9LLU */
@@ -9282,12 +11270,12 @@
928211270 {
928311271 /*CALLEND*/
928411272 stackbase += 11LLU;
9285- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8DLLU;
11273+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFBLLU;
928611274 fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
928711275 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); }
928811276 break;
928911277 }
9290-case 0xFFFFFFFFFFFFFD8DLLU:
11278+case 0xFFFFFFFFFFFFFCFBLLU:
929111279 /* SP = 9LLU */
929211280 { /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */
929311281 {
@@ -9305,23 +11293,23 @@
930511293 {
930611294 /*CALLEND*/
930711295 stackbase += 16LLU;
9308- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8CLLU;
11296+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFALLU;
930911297 fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */
931011298 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); }
931111299 break;
931211300 }
9313-case 0xFFFFFFFFFFFFFD8CLLU:
11301+case 0xFFFFFFFFFFFFFCFALLU:
931411302 /* SP = 14LLU */
931511303 { /* PUSH */ stack[stackbase + 14LLU] = 1LLU; }/* SP + 1LLU = 15LLU */
931611304 {
931711305 /*CALLEND*/
931811306 stackbase += 13LLU;
9319- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8BLLU;
11307+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF9LLU;
932011308 fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */
932111309 if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); }
932211310 break;
932311311 }
9324-case 0xFFFFFFFFFFFFFD8BLLU:
11312+case 0xFFFFFFFFFFFFFCF9LLU:
932511313 /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */
932611314 /* predicate */
932711315
@@ -9342,25 +11330,25 @@
934211330 {
934311331 /*CALLEND*/
934411332 stackbase += 17LLU;
9345- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD88LLU;
11333+ stack[stackbase - 1] = 0xFFFFFFFFFF

差分はサイズ制限により省略されました。全ての差分を見るためにはローカルクライアントを利用してください。

旧リポジトリブラウザで表示