リビジョン | 238 (tree) |
---|---|
日時 | 2018-10-12 05:29:23 |
作者 | jakobthomsen |
implement struct types
@@ -930,7 +930,7 @@ | ||
930 | 930 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
931 | 931 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
932 | 932 | /* function requires 10LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
933 | -case /*comment___'*/0x7AAA28829BC00001LLU:/* SP = 0LLU */ | |
933 | +case /*comments__*/0x7AAA28829BEE0000LLU:/* SP = 0LLU */ | |
934 | 934 | case 0xFFFFFFFFFFFFFFD0LLU: /* loop to here *//* predicate */ |
935 | 935 | |
936 | 936 | { |
@@ -1146,8 +1146,8 @@ | ||
1146 | 1146 | /*CALLEND*/ |
1147 | 1147 | stackbase += 2LLU; |
1148 | 1148 | 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); } | |
1151 | 1151 | break; |
1152 | 1152 | } |
1153 | 1153 | case 0xFFFFFFFFFFFFFFBDLLU: |
@@ -1256,7 +1256,382 @@ | ||
1256 | 1256 | case /*printhexnr*/0xAED929BE3833A6D0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */fprintf(stdout, "0x%0llXLLU", (long long unsigned int)ACCESS_VAR(0));/* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
1257 | 1257 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
1258 | 1258 | /* 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 | + | |
1260 | 1635 | for(register uint64_t i = 10; i > 0; i--) |
1261 | 1636 | { |
1262 | 1637 | if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 1) |
@@ -1270,11 +1645,11 @@ | ||
1270 | 1645 | else // if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 64) |
1271 | 1646 | fputc('0' + ((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) - 54, stdout); |
1272 | 1647 | } |
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); | |
1275 | 1650 | fputs("*/", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
1276 | 1651 | { /* 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) */ | |
1278 | 1653 | case /*printid___*/0xAED929BE47C00000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
1279 | 1654 | { |
1280 | 1655 | /* CALLBEGIN */ |
@@ -1286,12 +1661,12 @@ | ||
1286 | 1661 | { |
1287 | 1662 | /*CALLEND*/ |
1288 | 1663 | stackbase += 3LLU; |
1289 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB6LLU; | |
1664 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9ELLU; | |
1290 | 1665 | fnaddr = /*commentid_*/0x7AAA28829BE47C00LLU;/* SP = 0LLU */ |
1291 | 1666 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*commentid_*/\n"); exit(-1); } |
1292 | 1667 | break; |
1293 | 1668 | } |
1294 | -case 0xFFFFFFFFFFFFFFB6LLU: | |
1669 | +case 0xFFFFFFFFFFFFFF9ELLU: | |
1295 | 1670 | /* SP = 1LLU */ |
1296 | 1671 | { |
1297 | 1672 | /* CALLBEGIN */ |
@@ -1303,17 +1678,92 @@ | ||
1303 | 1678 | { |
1304 | 1679 | /*CALLEND*/ |
1305 | 1680 | stackbase += 3LLU; |
1306 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB5LLU; | |
1681 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9DLLU; | |
1307 | 1682 | fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */ |
1308 | 1683 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); } |
1309 | 1684 | break; |
1310 | 1685 | } |
1311 | -case 0xFFFFFFFFFFFFFFB5LLU: | |
1686 | +case 0xFFFFFFFFFFFFFF9DLLU: | |
1312 | 1687 | /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
1313 | 1688 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
1314 | 1689 | /* 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 | + | |
1316 | 1692 | { |
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 | + { | |
1317 | 1767 | if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 1) |
1318 | 1768 | fputc('_' + ((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) - 0, stderr); |
1319 | 1769 | else if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 27) |
@@ -1325,10 +1775,10 @@ | ||
1325 | 1775 | else // if(((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) < 64) |
1326 | 1776 | fputc('0' + ((ACCESS_VAR(0) >> (i * 6 - 2)) & 0x3F) - 54, stderr); |
1327 | 1777 | } |
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 */ | |
1330 | 1780 | { /* 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) */ | |
1332 | 1782 | case /*encodeval_*/0x8297AA7E0C5C9C00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
1333 | 1783 | { |
1334 | 1784 | /* CALLBEGIN */ |
@@ -1336,17 +1786,17 @@ | ||
1336 | 1786 | { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */ |
1337 | 1787 | /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */ |
1338 | 1788 | } |
1339 | -{ /* PUSH */ stack[stackbase + 4LLU] = 2LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */ | |
1789 | +{ /* PUSH */ stack[stackbase + 4LLU] = 16LLU; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */ | |
1340 | 1790 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */ |
1341 | 1791 | { |
1342 | 1792 | /*CALLEND*/ |
1343 | 1793 | stackbase += 4LLU; |
1344 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB4LLU; | |
1794 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF93LLU; | |
1345 | 1795 | fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */ |
1346 | 1796 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); } |
1347 | 1797 | break; |
1348 | 1798 | } |
1349 | -case 0xFFFFFFFFFFFFFFB4LLU: | |
1799 | +case 0xFFFFFFFFFFFFFF93LLU: | |
1350 | 1800 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1351 | 1801 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1352 | 1802 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
@@ -1365,33 +1815,159 @@ | ||
1365 | 1815 | { /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */ |
1366 | 1816 | /* leave place for return addr *//* SP + 1LLU = 7LLU *//* SPMAX = 7LLU */ |
1367 | 1817 | } |
1368 | -{ /* PUSH */ stack[stackbase + 7LLU] = 2LLU; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */ | |
1818 | +{ /* PUSH */ stack[stackbase + 7LLU] = 16LLU; }/* SP + 1LLU = 8LLU *//* SPMAX = 8LLU */ | |
1369 | 1819 | { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU *//* SPMAX = 9LLU */ |
1370 | 1820 | { |
1371 | 1821 | /*CALLEND*/ |
1372 | 1822 | stackbase += 7LLU; |
1373 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB3LLU; | |
1823 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF92LLU; | |
1374 | 1824 | fnaddr = /*mul_______*/0xA309C00000000000LLU;/* SP = 0LLU */ |
1375 | 1825 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*mul_______*/\n"); exit(-1); } |
1376 | 1826 | break; |
1377 | 1827 | } |
1378 | -case 0xFFFFFFFFFFFFFFB3LLU: | |
1828 | +case 0xFFFFFFFFFFFFFF92LLU: | |
1379 | 1829 | /* SP = 5LLU */ |
1380 | -{ /* PUSH */ stack[stackbase + 5LLU] = 1LLU; }/* SP + 1LLU = 6LLU */ | |
1830 | +{ /* PUSH */ stack[stackbase + 5LLU] = 4LLU; }/* SP + 1LLU = 6LLU */ | |
1381 | 1831 | { |
1382 | 1832 | /*CALLEND*/ |
1383 | 1833 | stackbase += 4LLU; |
1384 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB2LLU; | |
1834 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF91LLU; | |
1385 | 1835 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
1386 | 1836 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
1387 | 1837 | break; |
1388 | 1838 | } |
1389 | -case 0xFFFFFFFFFFFFFFB2LLU: | |
1839 | +case 0xFFFFFFFFFFFFFF91LLU: | |
1390 | 1840 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1391 | 1841 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1392 | 1842 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
1393 | 1843 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
1394 | 1844 | /* 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) */ | |
1395 | 1971 | case /*typeislist*/0xBF4AE092E9E4BAF0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
1396 | 1972 | { |
1397 | 1973 | /* CALLBEGIN */ |
@@ -1399,22 +1975,39 @@ | ||
1399 | 1975 | { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */ |
1400 | 1976 | /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */ |
1401 | 1977 | } |
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 */ | |
1404 | 1978 | { |
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 | + { | |
1405 | 1987 | /*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*/ | |
1406 | 1999 | stackbase += 4LLU; |
1407 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB1LLU; | |
2000 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF89LLU; | |
1408 | 2001 | fnaddr = /*bitand____*/0x764BDCA5F0000000LLU;/* SP = 0LLU */ |
1409 | 2002 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*bitand____*/\n"); exit(-1); } |
1410 | 2003 | break; |
1411 | 2004 | } |
1412 | -case 0xFFFFFFFFFFFFFFB1LLU: | |
2005 | +case 0xFFFFFFFFFFFFFF89LLU: | |
1413 | 2006 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1414 | 2007 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1415 | 2008 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
1416 | 2009 | { /* 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) */ | |
1418 | 2011 | case /*typeisval_*/0xBF4AE092EC5C9C00LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
1419 | 2012 | { |
1420 | 2013 | /* CALLBEGIN */ |
@@ -1432,28 +2025,28 @@ | ||
1432 | 2025 | { |
1433 | 2026 | /*CALLEND*/ |
1434 | 2027 | stackbase += 7LLU; |
1435 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFB0LLU; | |
2028 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF88LLU; | |
1436 | 2029 | fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */ |
1437 | 2030 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); } |
1438 | 2031 | break; |
1439 | 2032 | } |
1440 | -case 0xFFFFFFFFFFFFFFB0LLU: | |
2033 | +case 0xFFFFFFFFFFFFFF88LLU: | |
1441 | 2034 | /* SP = 5LLU */ |
1442 | 2035 | { |
1443 | 2036 | /*CALLEND*/ |
1444 | 2037 | stackbase += 4LLU; |
1445 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAFLLU; | |
2038 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF87LLU; | |
1446 | 2039 | fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */ |
1447 | 2040 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); } |
1448 | 2041 | break; |
1449 | 2042 | } |
1450 | -case 0xFFFFFFFFFFFFFFAFLLU: | |
2043 | +case 0xFFFFFFFFFFFFFF87LLU: | |
1451 | 2044 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1452 | 2045 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1453 | 2046 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
1454 | 2047 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
1455 | 2048 | /* 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 */ | |
1457 | 2050 | { |
1458 | 2051 | /* CALLBEGIN */ |
1459 | 2052 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */ |
@@ -1461,21 +2054,270 @@ | ||
1461 | 2054 | /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */ |
1462 | 2055 | } |
1463 | 2056 | { /* 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 */ | |
1464 | 2214 | { /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */ |
1465 | 2215 | { |
1466 | 2216 | /*CALLEND*/ |
1467 | 2217 | stackbase += 4LLU; |
1468 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAELLU; | |
2218 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7ELLU; | |
1469 | 2219 | fnaddr = /*div_______*/0x7E4C400000000000LLU;/* SP = 0LLU */ |
1470 | 2220 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*div_______*/\n"); exit(-1); } |
1471 | 2221 | break; |
1472 | 2222 | } |
1473 | -case 0xFFFFFFFFFFFFFFAELLU: | |
2223 | +case 0xFFFFFFFFFFFFFF7ELLU: | |
1474 | 2224 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1475 | 2225 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1476 | 2226 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
1477 | 2227 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
1478 | 2228 | /* 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) */ | |
1479 | 2321 | case /*typelistel*/0xBF4AE09E4BAF8270LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
1480 | 2322 | { |
1481 | 2323 | /* CALLBEGIN */ |
@@ -1493,22 +2335,22 @@ | ||
1493 | 2335 | { |
1494 | 2336 | /*CALLEND*/ |
1495 | 2337 | stackbase += 7LLU; |
1496 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFADLLU; | |
2338 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF79LLU; | |
1497 | 2339 | fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */ |
1498 | 2340 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); } |
1499 | 2341 | break; |
1500 | 2342 | } |
1501 | -case 0xFFFFFFFFFFFFFFADLLU: | |
2343 | +case 0xFFFFFFFFFFFFFF79LLU: | |
1502 | 2344 | /* SP = 5LLU */ |
1503 | 2345 | { |
1504 | 2346 | /*CALLEND*/ |
1505 | 2347 | stackbase += 4LLU; |
1506 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFACLLU; | |
2348 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF78LLU; | |
1507 | 2349 | fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */ |
1508 | 2350 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); } |
1509 | 2351 | break; |
1510 | 2352 | } |
1511 | -case 0xFFFFFFFFFFFFFFACLLU: | |
2353 | +case 0xFFFFFFFFFFFFFF78LLU: | |
1512 | 2354 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1513 | 2355 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1514 | 2356 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
@@ -1531,85 +2373,1522 @@ | ||
1531 | 2373 | { |
1532 | 2374 | /*CALLEND*/ |
1533 | 2375 | stackbase += 7LLU; |
1534 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFABLLU; | |
2376 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF77LLU; | |
1535 | 2377 | fnaddr = /*typetosize*/0xBF4AE0BEABA4D600LLU;/* SP = 0LLU */ |
1536 | 2378 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typetosize*/\n"); exit(-1); } |
1537 | 2379 | break; |
1538 | 2380 | } |
1539 | -case 0xFFFFFFFFFFFFFFABLLU: | |
2381 | +case 0xFFFFFFFFFFFFFF77LLU: | |
1540 | 2382 | /* SP = 5LLU */ |
1541 | 2383 | { |
1542 | 2384 | /*CALLEND*/ |
1543 | 2385 | stackbase += 4LLU; |
1544 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFAALLU; | |
2386 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF76LLU; | |
1545 | 2387 | fnaddr = /*encodelist*/0x8297AA7E09E4BAF0LLU;/* SP = 0LLU */ |
1546 | 2388 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodelist*/\n"); exit(-1); } |
1547 | 2389 | break; |
1548 | 2390 | } |
1549 | -case 0xFFFFFFFFFFFFFFAALLU: | |
2391 | +case 0xFFFFFFFFFFFFFF76LLU: | |
1550 | 2392 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1551 | 2393 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
1552 | 2394 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
1553 | 2395 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
1554 | 2396 | /* 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 */ | |
1556 | 2455 | |
1557 | 2456 | { |
1558 | 2457 | /* 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 */ | |
1559 | 2573 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */ |
1560 | 2574 | { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */ |
1561 | 2575 | /* leave place for return addr *//* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */ |
1562 | 2576 | } |
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 | + } | |
1563 | 3464 | { /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */ |
1564 | 3465 | { |
1565 | 3466 | /*CALLEND*/ |
1566 | 3467 | 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; | |
1568 | 3573 | fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */ |
1569 | 3574 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); } |
1570 | 3575 | break; |
1571 | 3576 | } |
1572 | -case 0xFFFFFFFFFFFFFFA7LLU: | |
3577 | +case 0xFFFFFFFFFFFFFF21LLU: | |
1573 | 3578 | /* SP = 2LLU */ |
1574 | 3579 | 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); | |
1581 | 3582 | { |
1582 | 3583 | /* 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 */ | |
1583 | 3679 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */ |
1584 | 3680 | { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */ |
1585 | 3681 | /* leave place for return addr *//* SP + 1LLU = 4LLU */ |
1586 | 3682 | } |
1587 | -{ /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU */ | |
1588 | 3683 | { |
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 | + { | |
1589 | 3691 | /*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*/ | |
1590 | 3703 | 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); } | |
1594 | 3707 | break; |
1595 | 3708 | } |
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 */ | |
1603 | 3788 | { /* 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) */ | |
1605 | 3884 | case /*debugdefs_*/0x7E077089F821B800LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
1606 | 3885 | { /* PUSH */ stack[stackbase + 1LLU] = 0LLU; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */ |
1607 | 3886 | { /* 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? */ | |
1609 | 3888 | |
1610 | 3889 | { /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */ |
1611 | 3890 | if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]) |
1612 | -{ /* JUMP */ fnaddr = 18446744073709551524LLU; break; } /* skip loop */ | |
3891 | +{ /* JUMP */ fnaddr = 18446744073709551369LLU; break; } /* skip loop */ | |
1613 | 3892 | /* loop *//* predicate */ |
1614 | 3893 | |
1615 | 3894 | { |
@@ -1623,15 +3902,15 @@ | ||
1623 | 3902 | { |
1624 | 3903 | /*CALLEND*/ |
1625 | 3904 | stackbase += 6LLU; |
1626 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA1LLU; | |
3905 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF06LLU; | |
1627 | 3906 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
1628 | 3907 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
1629 | 3908 | break; |
1630 | 3909 | } |
1631 | -case 0xFFFFFFFFFFFFFFA1LLU: | |
3910 | +case 0xFFFFFFFFFFFFFF06LLU: | |
1632 | 3911 | /* SP = 4LLU */ |
1633 | 3912 | if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]) |
1634 | -{ /* JUMP */ fnaddr = 18446744073709551523LLU; break; } /* skip consequent */ | |
3913 | +{ /* JUMP */ fnaddr = 18446744073709551368LLU; break; } /* skip consequent */ | |
1635 | 3914 | /* consequent */ |
1636 | 3915 | { |
1637 | 3916 | /* CALLBEGIN */ |
@@ -1644,12 +3923,12 @@ | ||
1644 | 3923 | { |
1645 | 3924 | /*CALLEND*/ |
1646 | 3925 | stackbase += 6LLU; |
1647 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFFA0LLU; | |
3926 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF05LLU; | |
1648 | 3927 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
1649 | 3928 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
1650 | 3929 | break; |
1651 | 3930 | } |
1652 | -case 0xFFFFFFFFFFFFFFA0LLU: | |
3931 | +case 0xFFFFFFFFFFFFFF05LLU: | |
1653 | 3932 | /* SP = 4LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */ |
1654 | 3933 | fputs(" ", stderr); |
1655 | 3934 | { |
@@ -1662,15 +3941,15 @@ | ||
1662 | 3941 | { |
1663 | 3942 | /*CALLEND*/ |
1664 | 3943 | stackbase += 5LLU; |
1665 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9FLLU; | |
3944 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF04LLU; | |
1666 | 3945 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
1667 | 3946 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
1668 | 3947 | break; |
1669 | 3948 | } |
1670 | -case 0xFFFFFFFFFFFFFF9FLLU: | |
3949 | +case 0xFFFFFFFFFFFFFF04LLU: | |
1671 | 3950 | /* 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 */ | |
1674 | 3953 | { /* 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 */ |
1675 | 3954 | fputs("\n", stderr); |
1676 | 3955 | { |
@@ -1683,12 +3962,12 @@ | ||
1683 | 3962 | { |
1684 | 3963 | /*CALLEND*/ |
1685 | 3964 | stackbase += 5LLU; |
1686 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9ELLU; | |
3965 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF03LLU; | |
1687 | 3966 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
1688 | 3967 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
1689 | 3968 | break; |
1690 | 3969 | } |
1691 | -case 0xFFFFFFFFFFFFFF9ELLU: | |
3970 | +case 0xFFFFFFFFFFFFFF03LLU: | |
1692 | 3971 | /* SP = 3LLU */fputs(" ", stderr); |
1693 | 3972 | { |
1694 | 3973 | /* CALLBEGIN */ |
@@ -1700,12 +3979,12 @@ | ||
1700 | 3979 | { |
1701 | 3980 | /*CALLEND*/ |
1702 | 3981 | stackbase += 5LLU; |
1703 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9DLLU; | |
3982 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF02LLU; | |
1704 | 3983 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
1705 | 3984 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
1706 | 3985 | break; |
1707 | 3986 | } |
1708 | -case 0xFFFFFFFFFFFFFF9DLLU: | |
3987 | +case 0xFFFFFFFFFFFFFF02LLU: | |
1709 | 3988 | /* SP = 3LLU */ |
1710 | 3989 | { |
1711 | 3990 | /* CALLBEGIN */ |
@@ -1718,29 +3997,29 @@ | ||
1718 | 3997 | { |
1719 | 3998 | /*CALLEND*/ |
1720 | 3999 | stackbase += 6LLU; |
1721 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF9CLLU; | |
4000 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFF01LLU; | |
1722 | 4001 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
1723 | 4002 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
1724 | 4003 | break; |
1725 | 4004 | } |
1726 | -case 0xFFFFFFFFFFFFFF9CLLU: | |
4005 | +case 0xFFFFFFFFFFFFFF01LLU: | |
1727 | 4006 | /* SP = 4LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */ |
1728 | 4007 | /* SP = 3LLU */ |
1729 | -case 18446744073709551522LLU: /* skip to here */ | |
4008 | +case 18446744073709551367LLU: /* skip to here */ | |
1730 | 4009 | /* SP = 3LLU */ |
1731 | 4010 | { /* 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 */ | |
1734 | 4013 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
1735 | 4014 | /* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
1736 | 4015 | case /*existsdef_*/0x83392EBEE7E08400LLU:/* SP = 2LLU *//* SPMAX = 2LLU */ |
1737 | 4016 | { /* PUSH */ stack[stackbase + 2LLU] = 0LLU; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */ |
1738 | 4017 | { /* 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? */ | |
1740 | 4019 | |
1741 | 4020 | { /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 5LLU *//* SPMAX = 5LLU */ |
1742 | 4021 | if(!/* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]) |
1743 | -{ /* JUMP */ fnaddr = 18446744073709551514LLU; break; } /* skip loop */ | |
4022 | +{ /* JUMP */ fnaddr = 18446744073709551359LLU; break; } /* skip loop */ | |
1744 | 4023 | /* loop *//* predicate */ |
1745 | 4024 | |
1746 | 4025 | { |
@@ -1754,15 +4033,15 @@ | ||
1754 | 4033 | { |
1755 | 4034 | /*CALLEND*/ |
1756 | 4035 | stackbase += 7LLU; |
1757 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF97LLU; | |
4036 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFCLLU; | |
1758 | 4037 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
1759 | 4038 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
1760 | 4039 | break; |
1761 | 4040 | } |
1762 | -case 0xFFFFFFFFFFFFFF97LLU: | |
4041 | +case 0xFFFFFFFFFFFFFEFCLLU: | |
1763 | 4042 | /* SP = 5LLU */ |
1764 | 4043 | if(!/* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]) |
1765 | -{ /* JUMP */ fnaddr = 18446744073709551513LLU; break; } /* skip consequent */ | |
4044 | +{ /* JUMP */ fnaddr = 18446744073709551358LLU; break; } /* skip consequent */ | |
1766 | 4045 | /* consequent */ |
1767 | 4046 | { |
1768 | 4047 | /* CALLBEGIN */ |
@@ -1775,16 +4054,16 @@ | ||
1775 | 4054 | { |
1776 | 4055 | /*CALLEND*/ |
1777 | 4056 | stackbase += 7LLU; |
1778 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF96LLU; | |
4057 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFBLLU; | |
1779 | 4058 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
1780 | 4059 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
1781 | 4060 | break; |
1782 | 4061 | } |
1783 | -case 0xFFFFFFFFFFFFFF96LLU: | |
4062 | +case 0xFFFFFFFFFFFFFEFBLLU: | |
1784 | 4063 | /* SP = 5LLU *//* LOCAL VAR */ stack[stackbase + 3LLU] = /* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]; /* POP */ |
1785 | 4064 | /* 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 */ | |
1788 | 4067 | |
1789 | 4068 | { |
1790 | 4069 | /* CALLBEGIN */ |
@@ -1797,30 +4076,30 @@ | ||
1797 | 4076 | { |
1798 | 4077 | /*CALLEND*/ |
1799 | 4078 | stackbase += 7LLU; |
1800 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF93LLU; | |
4079 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF8LLU; | |
1801 | 4080 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
1802 | 4081 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
1803 | 4082 | break; |
1804 | 4083 | } |
1805 | -case 0xFFFFFFFFFFFFFF93LLU: | |
4084 | +case 0xFFFFFFFFFFFFFEF8LLU: | |
1806 | 4085 | /* SP = 5LLU */ |
1807 | 4086 | if(!/* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]) |
1808 | -{ /* JUMP */ fnaddr = 18446744073709551509LLU; break; } /* skip consequent */ | |
4087 | +{ /* JUMP */ fnaddr = 18446744073709551354LLU; break; } /* skip consequent */ | |
1809 | 4088 | /* consequent */ |
1810 | 4089 | { /* PUSH */ stack[stackbase + 4LLU] = 1LLU; }/* SP + 1LLU = 5LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 4LLU */stack[stackbase + 4LLU]; /* POP */ |
1811 | 4090 | |
1812 | 4091 | {/* 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 */ | |
1815 | 4094 | { /* 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 */ |
1816 | 4095 | /* SP = 4LLU */ |
1817 | -case 18446744073709551508LLU: /* skip to here */ | |
4096 | +case 18446744073709551353LLU: /* skip to here */ | |
1818 | 4097 | |
1819 | -case 18446744073709551512LLU: /* skip to here */ | |
4098 | +case 18446744073709551357LLU: /* skip to here */ | |
1820 | 4099 | /* SP = 4LLU */ |
1821 | 4100 | { /* 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 */ | |
1824 | 4103 | { /* PUSH */ stack[stackbase + 4LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 5LLU *//* SP - 1LLU = 4LLU */ |
1825 | 4104 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */ |
1826 | 4105 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; } |
@@ -1848,28 +4127,86 @@ | ||
1848 | 4127 | { |
1849 | 4128 | /*CALLEND*/ |
1850 | 4129 | stackbase += 11LLU; |
1851 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF90LLU; | |
4130 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF5LLU; | |
1852 | 4131 | fnaddr = /*existsdef_*/0x83392EBEE7E08400LLU;/* SP = 0LLU */ |
1853 | 4132 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*existsdef_*/\n"); exit(-1); } |
1854 | 4133 | break; |
1855 | 4134 | } |
1856 | -case 0xFFFFFFFFFFFFFF90LLU: | |
4135 | +case 0xFFFFFFFFFFFFFEF5LLU: | |
1857 | 4136 | /* SP = 9LLU */ |
1858 | 4137 | { |
1859 | 4138 | /*CALLEND*/ |
1860 | 4139 | stackbase += 8LLU; |
1861 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8FLLU; | |
4140 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF4LLU; | |
1862 | 4141 | fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */ |
1863 | 4142 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); } |
1864 | 4143 | break; |
1865 | 4144 | } |
1866 | -case 0xFFFFFFFFFFFFFF8FLLU: | |
4145 | +case 0xFFFFFFFFFFFFFEF4LLU: | |
1867 | 4146 | /* SP = 6LLU */ |
1868 | 4147 | 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 */ | |
1870 | 4187 | /* consequent */ |
1871 | 4188 | { |
1872 | 4189 | /* 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 */ | |
1873 | 4210 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 5LLU */ |
1874 | 4211 | { /* PUSH */ stack[stackbase + 5LLU] = stackbase; }/* SP + 1LLU = 6LLU */ |
1875 | 4212 | /* leave place for return addr *//* SP + 1LLU = 7LLU */ |
@@ -1877,12 +4214,12 @@ | ||
1877 | 4214 | { |
1878 | 4215 | /*CALLEND*/ |
1879 | 4216 | stackbase += 7LLU; |
1880 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8ELLU; | |
4217 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEELLU; | |
1881 | 4218 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
1882 | 4219 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
1883 | 4220 | break; |
1884 | 4221 | } |
1885 | -case 0xFFFFFFFFFFFFFF8ELLU: | |
4222 | +case 0xFFFFFFFFFFFFFEEELLU: | |
1886 | 4223 | /* SP = 5LLU */fputs("undefined function ", stderr); |
1887 | 4224 | { |
1888 | 4225 | /* CALLBEGIN */ |
@@ -1894,12 +4231,12 @@ | ||
1894 | 4231 | { |
1895 | 4232 | /*CALLEND*/ |
1896 | 4233 | stackbase += 7LLU; |
1897 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8DLLU; | |
4234 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEDLLU; | |
1898 | 4235 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
1899 | 4236 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
1900 | 4237 | break; |
1901 | 4238 | } |
1902 | -case 0xFFFFFFFFFFFFFF8DLLU: | |
4239 | +case 0xFFFFFFFFFFFFFEEDLLU: | |
1903 | 4240 | /* SP = 5LLU */fputs("\n", stderr); fputs("defined functions\n", stderr); |
1904 | 4241 | { |
1905 | 4242 | /* CALLBEGIN */ |
@@ -1911,21 +4248,23 @@ | ||
1911 | 4248 | { |
1912 | 4249 | /*CALLEND*/ |
1913 | 4250 | stackbase += 7LLU; |
1914 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF8CLLU; | |
4251 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEECLLU; | |
1915 | 4252 | fnaddr = /*debugdefs_*/0x7E077089F821B800LLU;/* SP = 0LLU */ |
1916 | 4253 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugdefs_*/\n"); exit(-1); } |
1917 | 4254 | break; |
1918 | 4255 | } |
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 */ | |
1923 | 4262 | { /* 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? */ | |
1925 | 4264 | |
1926 | 4265 | { /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 7LLU */ |
1927 | 4266 | if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]) |
1928 | -{ /* JUMP */ fnaddr = 18446744073709551498LLU; break; } /* skip loop */ | |
4267 | +{ /* JUMP */ fnaddr = 18446744073709551338LLU; break; } /* skip loop */ | |
1929 | 4268 | /* loop *//* predicate */ |
1930 | 4269 | |
1931 | 4270 | { |
@@ -1939,15 +4278,15 @@ | ||
1939 | 4278 | { |
1940 | 4279 | /*CALLEND*/ |
1941 | 4280 | stackbase += 9LLU; |
1942 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF87LLU; | |
4281 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE7LLU; | |
1943 | 4282 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
1944 | 4283 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
1945 | 4284 | break; |
1946 | 4285 | } |
1947 | -case 0xFFFFFFFFFFFFFF87LLU: | |
4286 | +case 0xFFFFFFFFFFFFFEE7LLU: | |
1948 | 4287 | /* SP = 7LLU */ |
1949 | 4288 | if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]) |
1950 | -{ /* JUMP */ fnaddr = 18446744073709551497LLU; break; } /* skip consequent */ | |
4289 | +{ /* JUMP */ fnaddr = 18446744073709551337LLU; break; } /* skip consequent */ | |
1951 | 4290 | /* consequent */ |
1952 | 4291 | { |
1953 | 4292 | /* CALLBEGIN */ |
@@ -1960,16 +4299,16 @@ | ||
1960 | 4299 | { |
1961 | 4300 | /*CALLEND*/ |
1962 | 4301 | stackbase += 9LLU; |
1963 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF86LLU; | |
4302 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE6LLU; | |
1964 | 4303 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
1965 | 4304 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
1966 | 4305 | break; |
1967 | 4306 | } |
1968 | -case 0xFFFFFFFFFFFFFF86LLU: | |
4307 | +case 0xFFFFFFFFFFFFFEE6LLU: | |
1969 | 4308 | /* SP = 7LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */ |
1970 | 4309 | /* 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 */ | |
1973 | 4312 | |
1974 | 4313 | { |
1975 | 4314 | /* CALLBEGIN */ |
@@ -1982,15 +4321,15 @@ | ||
1982 | 4321 | { |
1983 | 4322 | /*CALLEND*/ |
1984 | 4323 | stackbase += 9LLU; |
1985 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF83LLU; | |
4324 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE3LLU; | |
1986 | 4325 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
1987 | 4326 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
1988 | 4327 | break; |
1989 | 4328 | } |
1990 | -case 0xFFFFFFFFFFFFFF83LLU: | |
4329 | +case 0xFFFFFFFFFFFFFEE3LLU: | |
1991 | 4330 | /* SP = 7LLU */ |
1992 | 4331 | if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]) |
1993 | -{ /* JUMP */ fnaddr = 18446744073709551493LLU; break; } /* skip consequent */ | |
4332 | +{ /* JUMP */ fnaddr = 18446744073709551333LLU; break; } /* skip consequent */ | |
1994 | 4333 | /* consequent */ |
1995 | 4334 | { /* 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 */ |
1996 | 4335 |
@@ -1999,18 +4338,18 @@ | ||
1999 | 4338 | { /* 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 */ |
2000 | 4339 | |
2001 | 4340 | {/* 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 */ | |
2004 | 4343 | { /* 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 */ |
2005 | 4344 | /* SP = 6LLU */ |
2006 | -case 18446744073709551492LLU: /* skip to here */ | |
4345 | +case 18446744073709551332LLU: /* skip to here */ | |
2007 | 4346 | |
2008 | -case 18446744073709551496LLU: /* skip to here */ | |
4347 | +case 18446744073709551336LLU: /* skip to here */ | |
2009 | 4348 | /* SP = 6LLU */ |
2010 | 4349 | { /* 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 */ | |
2014 | 4353 | |
2015 | 4354 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU */ |
2016 | 4355 | { /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 7LLU */ |
@@ -2044,25 +4383,25 @@ | ||
2044 | 4383 | { |
2045 | 4384 | /*CALLEND*/ |
2046 | 4385 | stackbase += 11LLU; |
2047 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF80LLU; | |
4386 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE0LLU; | |
2048 | 4387 | fnaddr = /*existsdef_*/0x83392EBEE7E08400LLU;/* SP = 0LLU */ |
2049 | 4388 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*existsdef_*/\n"); exit(-1); } |
2050 | 4389 | break; |
2051 | 4390 | } |
2052 | -case 0xFFFFFFFFFFFFFF80LLU: | |
4391 | +case 0xFFFFFFFFFFFFFEE0LLU: | |
2053 | 4392 | /* SP = 9LLU */ |
2054 | 4393 | { |
2055 | 4394 | /*CALLEND*/ |
2056 | 4395 | stackbase += 8LLU; |
2057 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7FLLU; | |
4396 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDFLLU; | |
2058 | 4397 | fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */ |
2059 | 4398 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); } |
2060 | 4399 | break; |
2061 | 4400 | } |
2062 | -case 0xFFFFFFFFFFFFFF7FLLU: | |
4401 | +case 0xFFFFFFFFFFFFFEDFLLU: | |
2063 | 4402 | /* SP = 6LLU */ |
2064 | 4403 | if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]) |
2065 | -{ /* JUMP */ fnaddr = 18446744073709551490LLU; break; } /* skip consequent */ | |
4404 | +{ /* JUMP */ fnaddr = 18446744073709551330LLU; break; } /* skip consequent */ | |
2066 | 4405 | /* consequent */ |
2067 | 4406 | { |
2068 | 4407 | /* CALLBEGIN */ |
@@ -2073,12 +4412,12 @@ | ||
2073 | 4412 | { |
2074 | 4413 | /*CALLEND*/ |
2075 | 4414 | stackbase += 7LLU; |
2076 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7ELLU; | |
4415 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDELLU; | |
2077 | 4416 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
2078 | 4417 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
2079 | 4418 | break; |
2080 | 4419 | } |
2081 | -case 0xFFFFFFFFFFFFFF7ELLU: | |
4420 | +case 0xFFFFFFFFFFFFFEDELLU: | |
2082 | 4421 | /* SP = 5LLU */fputs("undefined function ", stderr); |
2083 | 4422 | { |
2084 | 4423 | /* CALLBEGIN */ |
@@ -2090,12 +4429,12 @@ | ||
2090 | 4429 | { |
2091 | 4430 | /*CALLEND*/ |
2092 | 4431 | stackbase += 7LLU; |
2093 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7DLLU; | |
4432 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDDLLU; | |
2094 | 4433 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
2095 | 4434 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
2096 | 4435 | break; |
2097 | 4436 | } |
2098 | -case 0xFFFFFFFFFFFFFF7DLLU: | |
4437 | +case 0xFFFFFFFFFFFFFEDDLLU: | |
2099 | 4438 | /* SP = 5LLU */fputs("\n", stderr); fputs("defined functions\n", stderr); |
2100 | 4439 | { |
2101 | 4440 | /* CALLBEGIN */ |
@@ -2107,34 +4446,34 @@ | ||
2107 | 4446 | { |
2108 | 4447 | /*CALLEND*/ |
2109 | 4448 | stackbase += 7LLU; |
2110 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF7CLLU; | |
4449 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDCLLU; | |
2111 | 4450 | fnaddr = /*debugdefs_*/0x7E077089F821B800LLU;/* SP = 0LLU */ |
2112 | 4451 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugdefs_*/\n"); exit(-1); } |
2113 | 4452 | break; |
2114 | 4453 | } |
2115 | -case 0xFFFFFFFFFFFFFF7CLLU: | |
4454 | +case 0xFFFFFFFFFFFFFEDCLLU: | |
2116 | 4455 | /* 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 */ | |
2119 | 4458 | { /* PUSH */ stack[stackbase + 5LLU] = 0LLU; }/* SP + 1LLU = 6LLU */ |
2120 | 4459 | { /* PUSH */ stack[stackbase + 6LLU] = 0LLU; }/* SP + 1LLU = 7LLU */ |
2121 | 4460 | { /* 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? */ | |
2123 | 4462 | |
2124 | 4463 | { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU */ |
2125 | 4464 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
2126 | -{ /* JUMP */ fnaddr = 18446744073709551482LLU; break; } /* skip loop */ | |
4465 | +{ /* JUMP */ fnaddr = 18446744073709551322LLU; break; } /* skip loop */ | |
2127 | 4466 | /* loop *//* predicate */ |
2128 | 4467 | |
2129 | 4468 | { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 6LLU]; }/* SP + 1LLU = 9LLU */ |
2130 | 4469 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
2131 | -{ /* JUMP */ fnaddr = 18446744073709551481LLU; break; } /* skip consequent */ | |
4470 | +{ /* JUMP */ fnaddr = 18446744073709551321LLU; break; } /* skip consequent */ | |
2132 | 4471 | /* consequent */ |
2133 | -case 0xFFFFFFFFFFFFFF77LLU: /* loop to here *//* predicate: list non-empty? */ | |
4472 | +case 0xFFFFFFFFFFFFFED7LLU: /* loop to here *//* predicate: list non-empty? */ | |
2134 | 4473 | |
2135 | 4474 | { /* PUSH */ stack[stackbase + 8LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 9LLU */ |
2136 | 4475 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
2137 | -{ /* JUMP */ fnaddr = 18446744073709551478LLU; break; } /* skip loop */ | |
4476 | +{ /* JUMP */ fnaddr = 18446744073709551318LLU; break; } /* skip loop */ | |
2138 | 4477 | /* loop *//* predicate */ |
2139 | 4478 | |
2140 | 4479 | { |
@@ -2148,15 +4487,15 @@ | ||
2148 | 4487 | { |
2149 | 4488 | /*CALLEND*/ |
2150 | 4489 | stackbase += 11LLU; |
2151 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF73LLU; | |
4490 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFED3LLU; | |
2152 | 4491 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
2153 | 4492 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
2154 | 4493 | break; |
2155 | 4494 | } |
2156 | -case 0xFFFFFFFFFFFFFF73LLU: | |
4495 | +case 0xFFFFFFFFFFFFFED3LLU: | |
2157 | 4496 | /* SP = 9LLU */ |
2158 | 4497 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
2159 | -{ /* JUMP */ fnaddr = 18446744073709551477LLU; break; } /* skip consequent */ | |
4498 | +{ /* JUMP */ fnaddr = 18446744073709551317LLU; break; } /* skip consequent */ | |
2160 | 4499 | /* consequent */ |
2161 | 4500 | { /* 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 */ |
2162 | 4501 |
@@ -2165,8 +4504,8 @@ | ||
2165 | 4504 | {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;} |
2166 | 4505 | { /* PUSH */ stack[stackbase + 8LLU] = 2LLU; }/* SP + 1LLU = 9LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */ |
2167 | 4506 | /* 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 */ | |
2170 | 4509 | { |
2171 | 4510 | /* CALLBEGIN */ |
2172 | 4511 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 9LLU */ |
@@ -2178,19 +4517,19 @@ | ||
2178 | 4517 | { |
2179 | 4518 | /*CALLEND*/ |
2180 | 4519 | stackbase += 11LLU; |
2181 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF72LLU; | |
4520 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFED2LLU; | |
2182 | 4521 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
2183 | 4522 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
2184 | 4523 | break; |
2185 | 4524 | } |
2186 | -case 0xFFFFFFFFFFFFFF72LLU: | |
4525 | +case 0xFFFFFFFFFFFFFED2LLU: | |
2187 | 4526 | /* SP = 9LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */ |
2188 | 4527 | /* SP = 8LLU */ |
2189 | -case 18446744073709551476LLU: /* skip to here */ | |
4528 | +case 18446744073709551316LLU: /* skip to here */ | |
2190 | 4529 | /* SP = 8LLU */ |
2191 | 4530 | { /* 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 */ | |
2194 | 4533 | |
2195 | 4534 | { |
2196 | 4535 | /* CALLBEGIN */ |
@@ -2203,15 +4542,15 @@ | ||
2203 | 4542 | { |
2204 | 4543 | /*CALLEND*/ |
2205 | 4544 | stackbase += 11LLU; |
2206 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF70LLU; | |
4545 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFED0LLU; | |
2207 | 4546 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
2208 | 4547 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
2209 | 4548 | break; |
2210 | 4549 | } |
2211 | -case 0xFFFFFFFFFFFFFF70LLU: | |
4550 | +case 0xFFFFFFFFFFFFFED0LLU: | |
2212 | 4551 | /* SP = 9LLU */ |
2213 | 4552 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
2214 | -{ /* JUMP */ fnaddr = 18446744073709551473LLU; break; } /* skip consequent */ | |
4553 | +{ /* JUMP */ fnaddr = 18446744073709551313LLU; break; } /* skip consequent */ | |
2215 | 4554 | /* consequent */ |
2216 | 4555 | { |
2217 | 4556 | /* CALLBEGIN */ |
@@ -2222,12 +4561,12 @@ | ||
2222 | 4561 | { |
2223 | 4562 | /*CALLEND*/ |
2224 | 4563 | stackbase += 10LLU; |
2225 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6FLLU; | |
4564 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFECFLLU; | |
2226 | 4565 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
2227 | 4566 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
2228 | 4567 | break; |
2229 | 4568 | } |
2230 | -case 0xFFFFFFFFFFFFFF6FLLU: | |
4569 | +case 0xFFFFFFFFFFFFFECFLLU: | |
2231 | 4570 | /* SP = 8LLU */fputs("call to ", stderr); |
2232 | 4571 | { |
2233 | 4572 | /* CALLBEGIN */ |
@@ -2239,12 +4578,12 @@ | ||
2239 | 4578 | { |
2240 | 4579 | /*CALLEND*/ |
2241 | 4580 | stackbase += 10LLU; |
2242 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6ELLU; | |
4581 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFECELLU; | |
2243 | 4582 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
2244 | 4583 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
2245 | 4584 | break; |
2246 | 4585 | } |
2247 | -case 0xFFFFFFFFFFFFFF6ELLU: | |
4586 | +case 0xFFFFFFFFFFFFFECELLU: | |
2248 | 4587 | /* SP = 8LLU */fputs(" argument-count ", stderr); fputs("exceeds parameter-count ", stderr); |
2249 | 4588 | { |
2250 | 4589 | /* CALLBEGIN */ |
@@ -2256,16 +4595,16 @@ | ||
2256 | 4595 | { |
2257 | 4596 | /*CALLEND*/ |
2258 | 4597 | stackbase += 10LLU; |
2259 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6DLLU; | |
4598 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFECDLLU; | |
2260 | 4599 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
2261 | 4600 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
2262 | 4601 | break; |
2263 | 4602 | } |
2264 | -case 0xFFFFFFFFFFFFFF6DLLU: | |
4603 | +case 0xFFFFFFFFFFFFFECDLLU: | |
2265 | 4604 | /* 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 */ | |
2269 | 4608 | |
2270 | 4609 | { |
2271 | 4610 | /* CALLBEGIN */ |
@@ -2278,15 +4617,15 @@ | ||
2278 | 4617 | { |
2279 | 4618 | /*CALLEND*/ |
2280 | 4619 | stackbase += 11LLU; |
2281 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF6ALLU; | |
4620 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFECALLU; | |
2282 | 4621 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
2283 | 4622 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
2284 | 4623 | break; |
2285 | 4624 | } |
2286 | -case 0xFFFFFFFFFFFFFF6ALLU: | |
4625 | +case 0xFFFFFFFFFFFFFECALLU: | |
2287 | 4626 | /* SP = 9LLU */ |
2288 | 4627 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
2289 | -{ /* JUMP */ fnaddr = 18446744073709551468LLU; break; } /* skip consequent */ | |
4628 | +{ /* JUMP */ fnaddr = 18446744073709551308LLU; break; } /* skip consequent */ | |
2290 | 4629 | /* consequent */ |
2291 | 4630 | { |
2292 | 4631 | /* CALLBEGIN */ |
@@ -2299,16 +4638,16 @@ | ||
2299 | 4638 | { |
2300 | 4639 | /*CALLEND*/ |
2301 | 4640 | stackbase += 11LLU; |
2302 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF69LLU; | |
4641 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC9LLU; | |
2303 | 4642 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
2304 | 4643 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
2305 | 4644 | break; |
2306 | 4645 | } |
2307 | -case 0xFFFFFFFFFFFFFF69LLU: | |
4646 | +case 0xFFFFFFFFFFFFFEC9LLU: | |
2308 | 4647 | /* SP = 9LLU *//* LOCAL VAR */ stack[stackbase + 7LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */ |
2309 | 4648 | /* 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 */ | |
2312 | 4651 | |
2313 | 4652 | { |
2314 | 4653 | /* CALLBEGIN */ |
@@ -2321,47 +4660,929 @@ | ||
2321 | 4660 | { |
2322 | 4661 | /*CALLEND*/ |
2323 | 4662 | stackbase += 11LLU; |
2324 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF66LLU; | |
4663 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC6LLU; | |
2325 | 4664 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
2326 | 4665 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
2327 | 4666 | break; |
2328 | 4667 | } |
2329 | -case 0xFFFFFFFFFFFFFF66LLU: | |
4668 | +case 0xFFFFFFFFFFFFFEC6LLU: | |
2330 | 4669 | /* SP = 9LLU */ |
2331 | 4670 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
2332 | -{ /* JUMP */ fnaddr = 18446744073709551464LLU; break; } /* skip consequent */ | |
4671 | +{ /* JUMP */ fnaddr = 18446744073709551304LLU; break; } /* skip consequent */ | |
2333 | 4672 | /* consequent */ |
2334 | 4673 | { /* 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 */ |
2335 | 4674 | |
2336 | 4675 | { /* PUSH */ stack[stackbase + 8LLU] = 1LLU; }/* SP + 1LLU = 9LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]; /* POP */ |
2337 | 4676 | /* 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 */ | |
2340 | 4679 | { /* 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 */ |
2341 | 4680 | /* SP = 8LLU */ |
2342 | -case 18446744073709551463LLU: /* skip to here */ | |
4681 | +case 18446744073709551303LLU: /* skip to here */ | |
2343 | 4682 | |
2344 | -case 18446744073709551467LLU: /* skip to here */ | |
4683 | +case 18446744073709551307LLU: /* skip to here */ | |
2345 | 4684 | /* SP = 8LLU */ |
2346 | -case 18446744073709551480LLU: /* skip to here */ | |
4685 | +case 18446744073709551320LLU: /* skip to here */ | |
2347 | 4686 | /* SP = 8LLU */ |
2348 | 4687 | { /* 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 */ | |
2352 | 4691 | |
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]; } | |
2356 | 4698 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
2357 | 4699 | /* 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) */ | |
2358 | 5579 | case /*debugvars_*/0x7E07708B172DB800LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
2359 | 5580 | { /* 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? */ | |
2361 | 5582 | |
2362 | 5583 | { /* PUSH */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 3LLU *//* SPMAX = 3LLU */ |
2363 | 5584 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
2364 | -{ /* JUMP */ fnaddr = 18446744073709551460LLU; break; } /* skip loop */ | |
5585 | +{ /* JUMP */ fnaddr = 18446744073709551227LLU; break; } /* skip loop */ | |
2365 | 5586 | /* loop */ |
2366 | 5587 | { |
2367 | 5588 | /* CALLBEGIN */ |
@@ -2373,12 +5594,12 @@ | ||
2373 | 5594 | { |
2374 | 5595 | /*CALLEND*/ |
2375 | 5596 | stackbase += 4LLU; |
2376 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF63LLU; | |
5597 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ALLU; | |
2377 | 5598 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
2378 | 5599 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
2379 | 5600 | break; |
2380 | 5601 | } |
2381 | -case 0xFFFFFFFFFFFFFF63LLU: | |
5602 | +case 0xFFFFFFFFFFFFFE7ALLU: | |
2382 | 5603 | /* SP = 2LLU */fputs(" ", stderr); |
2383 | 5604 | { |
2384 | 5605 | /* CALLBEGIN */ |
@@ -2391,12 +5612,12 @@ | ||
2391 | 5612 | { |
2392 | 5613 | /*CALLEND*/ |
2393 | 5614 | stackbase += 5LLU; |
2394 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF62LLU; | |
5615 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE79LLU; | |
2395 | 5616 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
2396 | 5617 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
2397 | 5618 | break; |
2398 | 5619 | } |
2399 | -case 0xFFFFFFFFFFFFFF62LLU: | |
5620 | +case 0xFFFFFFFFFFFFFE79LLU: | |
2400 | 5621 | /* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */ |
2401 | 5622 | |
2402 | 5623 | { |
@@ -2409,25 +5630,25 @@ | ||
2409 | 5630 | { |
2410 | 5631 | /*CALLEND*/ |
2411 | 5632 | stackbase += 4LLU; |
2412 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF61LLU; | |
5633 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE78LLU; | |
2413 | 5634 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
2414 | 5635 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
2415 | 5636 | break; |
2416 | 5637 | } |
2417 | -case 0xFFFFFFFFFFFFFF61LLU: | |
5638 | +case 0xFFFFFFFFFFFFFE78LLU: | |
2418 | 5639 | /* SP = 2LLU */fputs(";", stderr); /* SP = 2LLU */ |
2419 | 5640 | { /* 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 */ | |
2422 | 5643 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
2423 | 5644 | /* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
2424 | 5645 | case /*existsvar_*/0x83392EBEEC5CB400LLU:/* SP = 2LLU *//* SPMAX = 2LLU */ |
2425 | 5646 | { /* 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? */ | |
2427 | 5648 | |
2428 | 5649 | { /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 4LLU *//* SPMAX = 4LLU */ |
2429 | 5650 | if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]) |
2430 | -{ /* JUMP */ fnaddr = 18446744073709551455LLU; break; } /* skip loop */ | |
5651 | +{ /* JUMP */ fnaddr = 18446744073709551222LLU; break; } /* skip loop */ | |
2431 | 5652 | /* loop *//* predicate */ |
2432 | 5653 | |
2433 | 5654 | { |
@@ -2441,23 +5662,23 @@ | ||
2441 | 5662 | { |
2442 | 5663 | /*CALLEND*/ |
2443 | 5664 | stackbase += 6LLU; |
2444 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5DLLU; | |
5665 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE74LLU; | |
2445 | 5666 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
2446 | 5667 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
2447 | 5668 | break; |
2448 | 5669 | } |
2449 | -case 0xFFFFFFFFFFFFFF5DLLU: | |
5670 | +case 0xFFFFFFFFFFFFFE74LLU: | |
2450 | 5671 | /* SP = 4LLU */ |
2451 | 5672 | if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]) |
2452 | -{ /* JUMP */ fnaddr = 18446744073709551454LLU; break; } /* skip consequent */ | |
5673 | +{ /* JUMP */ fnaddr = 18446744073709551221LLU; break; } /* skip consequent */ | |
2453 | 5674 | /* consequent */ |
2454 | 5675 | { /* PUSH */ stack[stackbase + 3LLU] = 1LLU; }/* SP + 1LLU = 4LLU *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]; /* POP */ |
2455 | 5676 | |
2456 | 5677 | {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 3LLU */ |
2457 | -case 18446744073709551454LLU: /* alternative *//* SP = 3LLU */ | |
5678 | +case 18446744073709551221LLU: /* alternative *//* SP = 3LLU */ | |
2458 | 5679 | { /* 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 */ | |
2461 | 5682 | { /* PUSH */ stack[stackbase + 3LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 4LLU *//* SP - 1LLU = 3LLU */ |
2462 | 5683 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */ |
2463 | 5684 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; } |
@@ -2485,25 +5706,25 @@ | ||
2485 | 5706 | { |
2486 | 5707 | /*CALLEND*/ |
2487 | 5708 | stackbase += 11LLU; |
2488 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF5ALLU; | |
5709 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE71LLU; | |
2489 | 5710 | fnaddr = /*existsvar_*/0x83392EBEEC5CB400LLU;/* SP = 0LLU */ |
2490 | 5711 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*existsvar_*/\n"); exit(-1); } |
2491 | 5712 | break; |
2492 | 5713 | } |
2493 | -case 0xFFFFFFFFFFFFFF5ALLU: | |
5714 | +case 0xFFFFFFFFFFFFFE71LLU: | |
2494 | 5715 | /* SP = 9LLU */ |
2495 | 5716 | { |
2496 | 5717 | /*CALLEND*/ |
2497 | 5718 | stackbase += 8LLU; |
2498 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF59LLU; | |
5719 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE70LLU; | |
2499 | 5720 | fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */ |
2500 | 5721 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); } |
2501 | 5722 | break; |
2502 | 5723 | } |
2503 | -case 0xFFFFFFFFFFFFFF59LLU: | |
5724 | +case 0xFFFFFFFFFFFFFE70LLU: | |
2504 | 5725 | /* SP = 6LLU */ |
2505 | 5726 | if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]) |
2506 | -{ /* JUMP */ fnaddr = 18446744073709551452LLU; break; } /* skip consequent */ | |
5727 | +{ /* JUMP */ fnaddr = 18446744073709551219LLU; break; } /* skip consequent */ | |
2507 | 5728 | /* consequent */ |
2508 | 5729 | { |
2509 | 5730 | /* CALLBEGIN */ |
@@ -2514,12 +5735,12 @@ | ||
2514 | 5735 | { |
2515 | 5736 | /*CALLEND*/ |
2516 | 5737 | stackbase += 7LLU; |
2517 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF58LLU; | |
5738 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6FLLU; | |
2518 | 5739 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
2519 | 5740 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
2520 | 5741 | break; |
2521 | 5742 | } |
2522 | -case 0xFFFFFFFFFFFFFF58LLU: | |
5743 | +case 0xFFFFFFFFFFFFFE6FLLU: | |
2523 | 5744 | /* SP = 5LLU */fputs("undefined variable ", stderr); |
2524 | 5745 | { |
2525 | 5746 | /* CALLBEGIN */ |
@@ -2531,12 +5752,12 @@ | ||
2531 | 5752 | { |
2532 | 5753 | /*CALLEND*/ |
2533 | 5754 | stackbase += 7LLU; |
2534 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF57LLU; | |
5755 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6ELLU; | |
2535 | 5756 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
2536 | 5757 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
2537 | 5758 | break; |
2538 | 5759 | } |
2539 | -case 0xFFFFFFFFFFFFFF57LLU: | |
5760 | +case 0xFFFFFFFFFFFFFE6ELLU: | |
2540 | 5761 | /* SP = 5LLU */fputs("\n", stderr); fputs("defined variables\n", stderr); |
2541 | 5762 | { |
2542 | 5763 | /* CALLBEGIN */ |
@@ -2548,20 +5769,20 @@ | ||
2548 | 5769 | { |
2549 | 5770 | /*CALLEND*/ |
2550 | 5771 | stackbase += 7LLU; |
2551 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF56LLU; | |
5772 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6DLLU; | |
2552 | 5773 | fnaddr = /*debugvars_*/0x7E07708B172DB800LLU;/* SP = 0LLU */ |
2553 | 5774 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugvars_*/\n"); exit(-1); } |
2554 | 5775 | break; |
2555 | 5776 | } |
2556 | -case 0xFFFFFFFFFFFFFF56LLU: | |
5777 | +case 0xFFFFFFFFFFFFFE6DLLU: | |
2557 | 5778 | /* 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? */ | |
2561 | 5782 | |
2562 | 5783 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */ |
2563 | 5784 | if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]) |
2564 | -{ /* JUMP */ fnaddr = 18446744073709551444LLU; break; } /* skip loop */ | |
5785 | +{ /* JUMP */ fnaddr = 18446744073709551211LLU; break; } /* skip loop */ | |
2565 | 5786 | /* loop *//* predicate */ |
2566 | 5787 | |
2567 | 5788 | { |
@@ -2575,15 +5796,15 @@ | ||
2575 | 5796 | { |
2576 | 5797 | /*CALLEND*/ |
2577 | 5798 | stackbase += 8LLU; |
2578 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF52LLU; | |
5799 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE69LLU; | |
2579 | 5800 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
2580 | 5801 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
2581 | 5802 | break; |
2582 | 5803 | } |
2583 | -case 0xFFFFFFFFFFFFFF52LLU: | |
5804 | +case 0xFFFFFFFFFFFFFE69LLU: | |
2584 | 5805 | /* SP = 6LLU */ |
2585 | 5806 | if(!/* SP - 1LLU = 5LLU */stack[stackbase + 5LLU]) |
2586 | -{ /* JUMP */ fnaddr = 18446744073709551443LLU; break; } /* skip consequent */ | |
5807 | +{ /* JUMP */ fnaddr = 18446744073709551210LLU; break; } /* skip consequent */ | |
2587 | 5808 | /* consequent */ |
2588 | 5809 | { /* 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 */ |
2589 | 5810 |
@@ -2592,11 +5813,11 @@ | ||
2592 | 5813 | { /* 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 */ |
2593 | 5814 | |
2594 | 5815 | {/* LOCAL VAR */ stack[stackbase + 0LLU] = 0;}/* SP = 5LLU */ |
2595 | -case 18446744073709551443LLU: /* alternative *//* SP = 5LLU */ | |
5816 | +case 18446744073709551210LLU: /* alternative *//* SP = 5LLU */ | |
2596 | 5817 | { /* 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 */ | |
2600 | 5821 | |
2601 | 5822 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU */ |
2602 | 5823 | { /* PUSH */ stack[stackbase + 6LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 7LLU */ |
@@ -2621,12 +5842,12 @@ | ||
2621 | 5842 | { |
2622 | 5843 | /*CALLEND*/ |
2623 | 5844 | stackbase += 7LLU; |
2624 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF51LLU; | |
5845 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE68LLU; | |
2625 | 5846 | fnaddr = /*findvar___*/0x864A5FC5CB400000LLU;/* SP = 0LLU */ |
2626 | 5847 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvar___*/\n"); exit(-1); } |
2627 | 5848 | break; |
2628 | 5849 | } |
2629 | -case 0xFFFFFFFFFFFFFF51LLU: | |
5850 | +case 0xFFFFFFFFFFFFFE68LLU: | |
2630 | 5851 | /* SP = 5LLU */ |
2631 | 5852 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */ |
2632 | 5853 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */ |
@@ -2645,12 +5866,12 @@ | ||
2645 | 5866 | { |
2646 | 5867 | /*CALLEND*/ |
2647 | 5868 | stackbase += 7LLU; |
2648 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF50LLU; | |
5869 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE67LLU; | |
2649 | 5870 | fnaddr = /*findvar___*/0x864A5FC5CB400000LLU;/* SP = 0LLU */ |
2650 | 5871 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvar___*/\n"); exit(-1); } |
2651 | 5872 | break; |
2652 | 5873 | } |
2653 | -case 0xFFFFFFFFFFFFFF50LLU: | |
5874 | +case 0xFFFFFFFFFFFFFE67LLU: | |
2654 | 5875 | /* SP = 5LLU */ |
2655 | 5876 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */ |
2656 | 5877 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */ |
@@ -2669,12 +5890,12 @@ | ||
2669 | 5890 | { |
2670 | 5891 | /*CALLEND*/ |
2671 | 5892 | stackbase += 7LLU; |
2672 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4FLLU; | |
5893 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE66LLU; | |
2673 | 5894 | fnaddr = /*findvar___*/0x864A5FC5CB400000LLU;/* SP = 0LLU */ |
2674 | 5895 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvar___*/\n"); exit(-1); } |
2675 | 5896 | break; |
2676 | 5897 | } |
2677 | -case 0xFFFFFFFFFFFFFF4FLLU: | |
5898 | +case 0xFFFFFFFFFFFFFE66LLU: | |
2678 | 5899 | /* SP = 5LLU */ |
2679 | 5900 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 6LLU *//* SP - 1LLU = 5LLU */ |
2680 | 5901 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 5LLU]; }/* SP = 3LLU *//* SP - 1LLU = 2LLU */ |
@@ -2748,12 +5969,12 @@ | ||
2748 | 5969 | { |
2749 | 5970 | /*CALLEND*/ |
2750 | 5971 | stackbase += 6LLU; |
2751 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4DLLU; | |
5972 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE64LLU; | |
2752 | 5973 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
2753 | 5974 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
2754 | 5975 | break; |
2755 | 5976 | } |
2756 | -case 0xFFFFFFFFFFFFFF4DLLU: | |
5977 | +case 0xFFFFFFFFFFFFFE64LLU: | |
2757 | 5978 | /* SP = 4LLU */ |
2758 | 5979 | { |
2759 | 5980 | /* CALLBEGIN */ |
@@ -2764,27 +5985,27 @@ | ||
2764 | 5985 | { |
2765 | 5986 | /*CALLEND*/ |
2766 | 5987 | stackbase += 7LLU; |
2767 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4CLLU; | |
5988 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE63LLU; | |
2768 | 5989 | fnaddr = /*SPMAX_GET_*/0x4D03416001C55000LLU;/* SP = 0LLU */ |
2769 | 5990 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SPMAX_GET_*/\n"); exit(-1); } |
2770 | 5991 | break; |
2771 | 5992 | } |
2772 | -case 0xFFFFFFFFFFFFFF4CLLU: | |
5993 | +case 0xFFFFFFFFFFFFFE63LLU: | |
2773 | 5994 | /* SP = 5LLU */ |
2774 | 5995 | { |
2775 | 5996 | /*CALLEND*/ |
2776 | 5997 | stackbase += 3LLU; |
2777 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4BLLU; | |
5998 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE62LLU; | |
2778 | 5999 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
2779 | 6000 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
2780 | 6001 | break; |
2781 | 6002 | } |
2782 | -case 0xFFFFFFFFFFFFFF4BLLU: | |
6003 | +case 0xFFFFFFFFFFFFFE62LLU: | |
2783 | 6004 | /* SP = 1LLU */ |
2784 | 6005 | if(!/* SP - 1LLU = 0LLU */stack[stackbase + 0LLU]) |
2785 | -{ /* JUMP */ fnaddr = 18446744073709551438LLU; break; } /* skip consequent */ | |
6006 | +{ /* JUMP */ fnaddr = 18446744073709551205LLU; break; } /* skip consequent */ | |
2786 | 6007 | /* 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 */ | |
2788 | 6009 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
2789 | 6010 | /* function requires 7LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
2790 | 6011 | case /*SP_SET____*/0x4D00131540000000LLU:/* SP = 1LLU *//* SPMAX = 1LLU */stack[2] = ACCESS_VAR(0);fputs("/* SP = ", stdout); |
@@ -2798,12 +6019,12 @@ | ||
2798 | 6019 | { |
2799 | 6020 | /*CALLEND*/ |
2800 | 6021 | stackbase += 3LLU; |
2801 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF4ALLU; | |
6022 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE61LLU; | |
2802 | 6023 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
2803 | 6024 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
2804 | 6025 | break; |
2805 | 6026 | } |
2806 | -case 0xFFFFFFFFFFFFFF4ALLU: | |
6027 | +case 0xFFFFFFFFFFFFFE61LLU: | |
2807 | 6028 | /* SP = 1LLU */fputs(" */", stdout); |
2808 | 6029 | { |
2809 | 6030 | /* CALLBEGIN */ |
@@ -2814,12 +6035,12 @@ | ||
2814 | 6035 | { |
2815 | 6036 | /*CALLEND*/ |
2816 | 6037 | stackbase += 3LLU; |
2817 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF49LLU; | |
6038 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE60LLU; | |
2818 | 6039 | fnaddr = /*SPMAXCHECK*/0x4D03416032050CB0LLU;/* SP = 0LLU */ |
2819 | 6040 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SPMAXCHECK*/\n"); exit(-1); } |
2820 | 6041 | break; |
2821 | 6042 | } |
2822 | -case 0xFFFFFFFFFFFFFF49LLU: | |
6043 | +case 0xFFFFFFFFFFFFFE60LLU: | |
2823 | 6044 | /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
2824 | 6045 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
2825 | 6046 | /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -2834,12 +6055,12 @@ | ||
2834 | 6055 | { |
2835 | 6056 | /*CALLEND*/ |
2836 | 6057 | stackbase += 3LLU; |
2837 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF48LLU; | |
6058 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5FLLU; | |
2838 | 6059 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
2839 | 6060 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
2840 | 6061 | break; |
2841 | 6062 | } |
2842 | -case 0xFFFFFFFFFFFFFF48LLU: | |
6063 | +case 0xFFFFFFFFFFFFFE5FLLU: | |
2843 | 6064 | /* SP = 1LLU */fputs(" = ", stdout); |
2844 | 6065 | { |
2845 | 6066 | /* CALLBEGIN */ |
@@ -2856,22 +6077,22 @@ | ||
2856 | 6077 | { |
2857 | 6078 | /*CALLEND*/ |
2858 | 6079 | stackbase += 6LLU; |
2859 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF47LLU; | |
6080 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ELLU; | |
2860 | 6081 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
2861 | 6082 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
2862 | 6083 | break; |
2863 | 6084 | } |
2864 | -case 0xFFFFFFFFFFFFFF47LLU: | |
6085 | +case 0xFFFFFFFFFFFFFE5ELLU: | |
2865 | 6086 | /* SP = 4LLU */ |
2866 | 6087 | { |
2867 | 6088 | /*CALLEND*/ |
2868 | 6089 | stackbase += 3LLU; |
2869 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF46LLU; | |
6090 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5DLLU; | |
2870 | 6091 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
2871 | 6092 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
2872 | 6093 | break; |
2873 | 6094 | } |
2874 | -case 0xFFFFFFFFFFFFFF46LLU: | |
6095 | +case 0xFFFFFFFFFFFFFE5DLLU: | |
2875 | 6096 | /* SP = 1LLU */fputs(" */", stdout); |
2876 | 6097 | { |
2877 | 6098 | /* CALLBEGIN */ |
@@ -2882,12 +6103,12 @@ | ||
2882 | 6103 | { |
2883 | 6104 | /*CALLEND*/ |
2884 | 6105 | stackbase += 3LLU; |
2885 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF45LLU; | |
6106 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5CLLU; | |
2886 | 6107 | fnaddr = /*SPMAXCHECK*/0x4D03416032050CB0LLU;/* SP = 0LLU */ |
2887 | 6108 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SPMAXCHECK*/\n"); exit(-1); } |
2888 | 6109 | break; |
2889 | 6110 | } |
2890 | -case 0xFFFFFFFFFFFFFF45LLU: | |
6111 | +case 0xFFFFFFFFFFFFFE5CLLU: | |
2891 | 6112 | /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
2892 | 6113 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
2893 | 6114 | /* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -2902,12 +6123,12 @@ | ||
2902 | 6123 | { |
2903 | 6124 | /*CALLEND*/ |
2904 | 6125 | stackbase += 3LLU; |
2905 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF44LLU; | |
6126 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5BLLU; | |
2906 | 6127 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
2907 | 6128 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
2908 | 6129 | break; |
2909 | 6130 | } |
2910 | -case 0xFFFFFFFFFFFFFF44LLU: | |
6131 | +case 0xFFFFFFFFFFFFFE5BLLU: | |
2911 | 6132 | /* SP = 1LLU */fputs(" = ", stdout); |
2912 | 6133 | { |
2913 | 6134 | /* CALLBEGIN */ |
@@ -2924,22 +6145,22 @@ | ||
2924 | 6145 | { |
2925 | 6146 | /*CALLEND*/ |
2926 | 6147 | stackbase += 6LLU; |
2927 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF43LLU; | |
6148 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ALLU; | |
2928 | 6149 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
2929 | 6150 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
2930 | 6151 | break; |
2931 | 6152 | } |
2932 | -case 0xFFFFFFFFFFFFFF43LLU: | |
6153 | +case 0xFFFFFFFFFFFFFE5ALLU: | |
2933 | 6154 | /* SP = 4LLU */ |
2934 | 6155 | { |
2935 | 6156 | /*CALLEND*/ |
2936 | 6157 | stackbase += 3LLU; |
2937 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF42LLU; | |
6158 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE59LLU; | |
2938 | 6159 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
2939 | 6160 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
2940 | 6161 | break; |
2941 | 6162 | } |
2942 | -case 0xFFFFFFFFFFFFFF42LLU: | |
6163 | +case 0xFFFFFFFFFFFFFE59LLU: | |
2943 | 6164 | /* SP = 1LLU */fputs(" */", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
2944 | 6165 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
2945 | 6166 | /* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -2967,12 +6188,12 @@ | ||
2967 | 6188 | { |
2968 | 6189 | /*CALLEND*/ |
2969 | 6190 | stackbase += 3LLU; |
2970 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF41LLU; | |
6191 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE58LLU; | |
2971 | 6192 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
2972 | 6193 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
2973 | 6194 | break; |
2974 | 6195 | } |
2975 | -case 0xFFFFFFFFFFFFFF41LLU: | |
6196 | +case 0xFFFFFFFFFFFFFE58LLU: | |
2976 | 6197 | /* SP = 1LLU */fputs("]", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
2977 | 6198 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
2978 | 6199 | /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -2993,12 +6214,12 @@ | ||
2993 | 6214 | { |
2994 | 6215 | /*CALLEND*/ |
2995 | 6216 | stackbase += 3LLU; |
2996 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF40LLU; | |
6217 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE57LLU; | |
2997 | 6218 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
2998 | 6219 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
2999 | 6220 | break; |
3000 | 6221 | } |
3001 | -case 0xFFFFFFFFFFFFFF40LLU: | |
6222 | +case 0xFFFFFFFFFFFFFE57LLU: | |
3002 | 6223 | /* SP = 1LLU */fputs("]", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
3003 | 6224 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3004 | 6225 | /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -3013,12 +6234,12 @@ | ||
3013 | 6234 | { |
3014 | 6235 | /*CALLEND*/ |
3015 | 6236 | stackbase += 3LLU; |
3016 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3FLLU; | |
6237 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE56LLU; | |
3017 | 6238 | fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */ |
3018 | 6239 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); } |
3019 | 6240 | break; |
3020 | 6241 | } |
3021 | -case 0xFFFFFFFFFFFFFF3FLLU: | |
6242 | +case 0xFFFFFFFFFFFFFE56LLU: | |
3022 | 6243 | /* SP = 1LLU */fputs(") ", stdout); |
3023 | 6244 | { |
3024 | 6245 | /* CALLBEGIN */ |
@@ -3030,12 +6251,12 @@ | ||
3030 | 6251 | { |
3031 | 6252 | /*CALLEND*/ |
3032 | 6253 | stackbase += 3LLU; |
3033 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3ELLU; | |
6254 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE55LLU; | |
3034 | 6255 | fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */ |
3035 | 6256 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); } |
3036 | 6257 | break; |
3037 | 6258 | } |
3038 | -case 0xFFFFFFFFFFFFFF3ELLU: | |
6259 | +case 0xFFFFFFFFFFFFFE55LLU: | |
3039 | 6260 | /* SP = 1LLU */fputs(" = ", stdout); |
3040 | 6261 | { |
3041 | 6262 | /* CALLBEGIN */ |
@@ -3046,12 +6267,12 @@ | ||
3046 | 6267 | { |
3047 | 6268 | /*CALLEND*/ |
3048 | 6269 | stackbase += 3LLU; |
3049 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3DLLU; | |
6270 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE54LLU; | |
3050 | 6271 | fnaddr = /*DEREFSTART*/0x1054851935014940LLU;/* SP = 0LLU */ |
3051 | 6272 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEREFSTART*/\n"); exit(-1); } |
3052 | 6273 | break; |
3053 | 6274 | } |
3054 | -case 0xFFFFFFFFFFFFFF3DLLU: | |
6275 | +case 0xFFFFFFFFFFFFFE54LLU: | |
3055 | 6276 | /* SP = 1LLU */ |
3056 | 6277 | { |
3057 | 6278 | /* CALLBEGIN */ |
@@ -3063,12 +6284,12 @@ | ||
3063 | 6284 | { |
3064 | 6285 | /*CALLEND*/ |
3065 | 6286 | stackbase += 3LLU; |
3066 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3CLLU; | |
6287 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE53LLU; | |
3067 | 6288 | fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */ |
3068 | 6289 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); } |
3069 | 6290 | break; |
3070 | 6291 | } |
3071 | -case 0xFFFFFFFFFFFFFF3CLLU: | |
6292 | +case 0xFFFFFFFFFFFFFE53LLU: | |
3072 | 6293 | /* SP = 1LLU */ |
3073 | 6294 | { |
3074 | 6295 | /* CALLBEGIN */ |
@@ -3079,12 +6300,12 @@ | ||
3079 | 6300 | { |
3080 | 6301 | /*CALLEND*/ |
3081 | 6302 | stackbase += 3LLU; |
3082 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3BLLU; | |
6303 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE52LLU; | |
3083 | 6304 | fnaddr = /*DEREFEND__*/0x1054851853840000LLU;/* SP = 0LLU */ |
3084 | 6305 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEREFEND__*/\n"); exit(-1); } |
3085 | 6306 | break; |
3086 | 6307 | } |
3087 | -case 0xFFFFFFFFFFFFFF3BLLU: | |
6308 | +case 0xFFFFFFFFFFFFFE52LLU: | |
3088 | 6309 | /* SP = 1LLU */fputs("; }", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
3089 | 6310 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3090 | 6311 | /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -3104,22 +6325,22 @@ | ||
3104 | 6325 | { |
3105 | 6326 | /*CALLEND*/ |
3106 | 6327 | stackbase += 5LLU; |
3107 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF3ALLU; | |
6328 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE51LLU; | |
3108 | 6329 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
3109 | 6330 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
3110 | 6331 | break; |
3111 | 6332 | } |
3112 | -case 0xFFFFFFFFFFFFFF3ALLU: | |
6333 | +case 0xFFFFFFFFFFFFFE51LLU: | |
3113 | 6334 | /* SP = 3LLU */ |
3114 | 6335 | { |
3115 | 6336 | /*CALLEND*/ |
3116 | 6337 | stackbase += 2LLU; |
3117 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF39LLU; | |
6338 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE50LLU; | |
3118 | 6339 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3119 | 6340 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3120 | 6341 | break; |
3121 | 6342 | } |
3122 | -case 0xFFFFFFFFFFFFFF39LLU: | |
6343 | +case 0xFFFFFFFFFFFFFE50LLU: | |
3123 | 6344 | /* SP = 0LLU */fputs("] = ", stdout); /* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
3124 | 6345 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3125 | 6346 | /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -3134,12 +6355,12 @@ | ||
3134 | 6355 | { |
3135 | 6356 | /*CALLEND*/ |
3136 | 6357 | stackbase += 2LLU; |
3137 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF38LLU; | |
6358 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4FLLU; | |
3138 | 6359 | fnaddr = /*SP_ADD____*/0x4D00011040000000LLU;/* SP = 0LLU */ |
3139 | 6360 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_ADD____*/\n"); exit(-1); } |
3140 | 6361 | break; |
3141 | 6362 | } |
3142 | -case 0xFFFFFFFFFFFFFF38LLU: | |
6363 | +case 0xFFFFFFFFFFFFFE4FLLU: | |
3143 | 6364 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
3144 | 6365 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3145 | 6366 | /* function requires 3LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -3153,12 +6374,12 @@ | ||
3153 | 6374 | { |
3154 | 6375 | /*CALLEND*/ |
3155 | 6376 | stackbase += 3LLU; |
3156 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF37LLU; | |
6377 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ELLU; | |
3157 | 6378 | fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */ |
3158 | 6379 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); } |
3159 | 6380 | break; |
3160 | 6381 | } |
3161 | -case 0xFFFFFFFFFFFFFF37LLU: | |
6382 | +case 0xFFFFFFFFFFFFFE4ELLU: | |
3162 | 6383 | /* SP = 1LLU */ |
3163 | 6384 | { |
3164 | 6385 | /* CALLBEGIN */ |
@@ -3170,12 +6391,12 @@ | ||
3170 | 6391 | { |
3171 | 6392 | /*CALLEND*/ |
3172 | 6393 | stackbase += 3LLU; |
3173 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF36LLU; | |
6394 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4DLLU; | |
3174 | 6395 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3175 | 6396 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3176 | 6397 | break; |
3177 | 6398 | } |
3178 | -case 0xFFFFFFFFFFFFFF36LLU: | |
6399 | +case 0xFFFFFFFFFFFFFE4DLLU: | |
3179 | 6400 | /* SP = 1LLU */ |
3180 | 6401 | { |
3181 | 6402 | /* CALLBEGIN */ |
@@ -3186,12 +6407,12 @@ | ||
3186 | 6407 | { |
3187 | 6408 | /*CALLEND*/ |
3188 | 6409 | stackbase += 3LLU; |
3189 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF35LLU; | |
6410 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4CLLU; | |
3190 | 6411 | fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */ |
3191 | 6412 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); } |
3192 | 6413 | break; |
3193 | 6414 | } |
3194 | -case 0xFFFFFFFFFFFFFF35LLU: | |
6415 | +case 0xFFFFFFFFFFFFFE4CLLU: | |
3195 | 6416 | /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
3196 | 6417 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3197 | 6418 | /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -3206,12 +6427,12 @@ | ||
3206 | 6427 | { |
3207 | 6428 | /*CALLEND*/ |
3208 | 6429 | stackbase += 2LLU; |
3209 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF34LLU; | |
6430 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4BLLU; | |
3210 | 6431 | fnaddr = /*SP_SUB____*/0x4D00135420000000LLU;/* SP = 0LLU */ |
3211 | 6432 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SUB____*/\n"); exit(-1); } |
3212 | 6433 | break; |
3213 | 6434 | } |
3214 | -case 0xFFFFFFFFFFFFFF34LLU: | |
6435 | +case 0xFFFFFFFFFFFFFE4BLLU: | |
3215 | 6436 | /* SP = 0LLU */fputs("stack[stackbase + ", stdout); |
3216 | 6437 | { |
3217 | 6438 | /* CALLBEGIN */ |
@@ -3228,22 +6449,22 @@ | ||
3228 | 6449 | { |
3229 | 6450 | /*CALLEND*/ |
3230 | 6451 | stackbase += 5LLU; |
3231 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF33LLU; | |
6452 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ALLU; | |
3232 | 6453 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
3233 | 6454 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
3234 | 6455 | break; |
3235 | 6456 | } |
3236 | -case 0xFFFFFFFFFFFFFF33LLU: | |
6457 | +case 0xFFFFFFFFFFFFFE4ALLU: | |
3237 | 6458 | /* SP = 3LLU */ |
3238 | 6459 | { |
3239 | 6460 | /*CALLEND*/ |
3240 | 6461 | stackbase += 2LLU; |
3241 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF32LLU; | |
6462 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE49LLU; | |
3242 | 6463 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3243 | 6464 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3244 | 6465 | break; |
3245 | 6466 | } |
3246 | -case 0xFFFFFFFFFFFFFF32LLU: | |
6467 | +case 0xFFFFFFFFFFFFFE49LLU: | |
3247 | 6468 | /* SP = 0LLU */fputs("]", stdout); /* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
3248 | 6469 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3249 | 6470 | /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -3260,12 +6481,12 @@ | ||
3260 | 6481 | { |
3261 | 6482 | /*CALLEND*/ |
3262 | 6483 | stackbase += 2LLU; |
3263 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF31LLU; | |
6484 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE48LLU; | |
3264 | 6485 | fnaddr = /*POP_START_*/0x40F4004D40525000LLU;/* SP = 0LLU */ |
3265 | 6486 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_START_*/\n"); exit(-1); } |
3266 | 6487 | break; |
3267 | 6488 | } |
3268 | -case 0xFFFFFFFFFFFFFF31LLU: | |
6489 | +case 0xFFFFFFFFFFFFFE48LLU: | |
3269 | 6490 | /* SP = 0LLU */ |
3270 | 6491 | { |
3271 | 6492 | /* CALLBEGIN */ |
@@ -3276,12 +6497,12 @@ | ||
3276 | 6497 | { |
3277 | 6498 | /*CALLEND*/ |
3278 | 6499 | stackbase += 2LLU; |
3279 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF30LLU; | |
6500 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE47LLU; | |
3280 | 6501 | fnaddr = /*POP_END___*/0x40F40014E1000000LLU;/* SP = 0LLU */ |
3281 | 6502 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_END___*/\n"); exit(-1); } |
3282 | 6503 | break; |
3283 | 6504 | } |
3284 | -case 0xFFFFFFFFFFFFFF30LLU: | |
6505 | +case 0xFFFFFFFFFFFFFE47LLU: | |
3285 | 6506 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
3286 | 6507 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3287 | 6508 | /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -3301,22 +6522,22 @@ | ||
3301 | 6522 | { |
3302 | 6523 | /*CALLEND*/ |
3303 | 6524 | stackbase += 5LLU; |
3304 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2FLLU; | |
6525 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE46LLU; | |
3305 | 6526 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
3306 | 6527 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
3307 | 6528 | break; |
3308 | 6529 | } |
3309 | -case 0xFFFFFFFFFFFFFF2FLLU: | |
6530 | +case 0xFFFFFFFFFFFFFE46LLU: | |
3310 | 6531 | /* SP = 3LLU */ |
3311 | 6532 | { |
3312 | 6533 | /*CALLEND*/ |
3313 | 6534 | stackbase += 2LLU; |
3314 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2ELLU; | |
6535 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE45LLU; | |
3315 | 6536 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3316 | 6537 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3317 | 6538 | break; |
3318 | 6539 | } |
3319 | -case 0xFFFFFFFFFFFFFF2ELLU: | |
6540 | +case 0xFFFFFFFFFFFFFE45LLU: | |
3320 | 6541 | /* SP = 0LLU */fputs(" - 1]", stdout); /* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
3321 | 6542 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3322 | 6543 | /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -3333,12 +6554,12 @@ | ||
3333 | 6554 | { |
3334 | 6555 | /*CALLEND*/ |
3335 | 6556 | stackbase += 2LLU; |
3336 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2DLLU; | |
6557 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE44LLU; | |
3337 | 6558 | fnaddr = /*TOP_START_*/0x50F4004D40525000LLU;/* SP = 0LLU */ |
3338 | 6559 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*TOP_START_*/\n"); exit(-1); } |
3339 | 6560 | break; |
3340 | 6561 | } |
3341 | -case 0xFFFFFFFFFFFFFF2DLLU: | |
6562 | +case 0xFFFFFFFFFFFFFE44LLU: | |
3342 | 6563 | /* SP = 0LLU */ |
3343 | 6564 | { |
3344 | 6565 | /* CALLBEGIN */ |
@@ -3349,12 +6570,12 @@ | ||
3349 | 6570 | { |
3350 | 6571 | /*CALLEND*/ |
3351 | 6572 | stackbase += 2LLU; |
3352 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2CLLU; | |
6573 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE43LLU; | |
3353 | 6574 | fnaddr = /*TOP_END___*/0x50F40014E1000000LLU;/* SP = 0LLU */ |
3354 | 6575 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*TOP_END___*/\n"); exit(-1); } |
3355 | 6576 | break; |
3356 | 6577 | } |
3357 | -case 0xFFFFFFFFFFFFFF2CLLU: | |
6578 | +case 0xFFFFFFFFFFFFFE43LLU: | |
3358 | 6579 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
3359 | 6580 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3360 | 6581 | /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -3369,12 +6590,12 @@ | ||
3369 | 6590 | { |
3370 | 6591 | /*CALLEND*/ |
3371 | 6592 | stackbase += 4LLU; |
3372 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2BLLU; | |
6593 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE42LLU; | |
3373 | 6594 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3374 | 6595 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3375 | 6596 | break; |
3376 | 6597 | } |
3377 | -case 0xFFFFFFFFFFFFFF2BLLU: | |
6598 | +case 0xFFFFFFFFFFFFFE42LLU: | |
3378 | 6599 | /* SP = 2LLU */fputs(" >= ", stdout); |
3379 | 6600 | { |
3380 | 6601 | /* CALLBEGIN */ |
@@ -3391,22 +6612,22 @@ | ||
3391 | 6612 | { |
3392 | 6613 | /*CALLEND*/ |
3393 | 6614 | stackbase += 7LLU; |
3394 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2ALLU; | |
6615 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE41LLU; | |
3395 | 6616 | fnaddr = /*MEMSIZEGET*/0x34535325A1471540LLU;/* SP = 0LLU */ |
3396 | 6617 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*MEMSIZEGET*/\n"); exit(-1); } |
3397 | 6618 | break; |
3398 | 6619 | } |
3399 | -case 0xFFFFFFFFFFFFFF2ALLU: | |
6620 | +case 0xFFFFFFFFFFFFFE41LLU: | |
3400 | 6621 | /* SP = 5LLU */ |
3401 | 6622 | { |
3402 | 6623 | /*CALLEND*/ |
3403 | 6624 | stackbase += 4LLU; |
3404 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF29LLU; | |
6625 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE40LLU; | |
3405 | 6626 | fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */ |
3406 | 6627 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); } |
3407 | 6628 | break; |
3408 | 6629 | } |
3409 | -case 0xFFFFFFFFFFFFFF29LLU: | |
6630 | +case 0xFFFFFFFFFFFFFE40LLU: | |
3410 | 6631 | /* SP = 2LLU */fputs(") { fprintf(stderr, \"STACKOVERFLOW calling ", stdout); |
3411 | 6632 | { |
3412 | 6633 | /* CALLBEGIN */ |
@@ -3418,12 +6639,12 @@ | ||
3418 | 6639 | { |
3419 | 6640 | /*CALLEND*/ |
3420 | 6641 | stackbase += 4LLU; |
3421 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF28LLU; | |
6642 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3FLLU; | |
3422 | 6643 | fnaddr = /*commentid_*/0x7AAA28829BE47C00LLU;/* SP = 0LLU */ |
3423 | 6644 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*commentid_*/\n"); exit(-1); } |
3424 | 6645 | break; |
3425 | 6646 | } |
3426 | -case 0xFFFFFFFFFFFFFF28LLU: | |
6647 | +case 0xFFFFFFFFFFFFFE3FLLU: | |
3427 | 6648 | /* SP = 2LLU */fputs("\\n\"); exit(-1); } ", stdout); /* SP = 2LLU *//* SP - 0LLU = 2LLU */ |
3428 | 6649 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3429 | 6650 | /* function requires 7LLU 64-bit chunks of memory (including 2LLU for parameters) */ |
@@ -3443,23 +6664,23 @@ | ||
3443 | 6664 | { |
3444 | 6665 | /*CALLEND*/ |
3445 | 6666 | stackbase += 7LLU; |
3446 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF27LLU; | |
6667 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ELLU; | |
3447 | 6668 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
3448 | 6669 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
3449 | 6670 | break; |
3450 | 6671 | } |
3451 | -case 0xFFFFFFFFFFFFFF27LLU: | |
6672 | +case 0xFFFFFFFFFFFFFE3ELLU: | |
3452 | 6673 | /* SP = 5LLU */ |
3453 | 6674 | { /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */ |
3454 | 6675 | { |
3455 | 6676 | /*CALLEND*/ |
3456 | 6677 | stackbase += 4LLU; |
3457 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF26LLU; | |
6678 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3DLLU; | |
3458 | 6679 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
3459 | 6680 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
3460 | 6681 | break; |
3461 | 6682 | } |
3462 | -case 0xFFFFFFFFFFFFFF26LLU: | |
6683 | +case 0xFFFFFFFFFFFFFE3DLLU: | |
3463 | 6684 | /* SP = 2LLU */fputs("\n {", stdout); fputs("\n /* CALLBEGIN */", stdout); fputs("\n /* reserve space for ", stdout); |
3464 | 6685 | { |
3465 | 6686 | /* CALLBEGIN */ |
@@ -3471,12 +6692,12 @@ | ||
3471 | 6692 | { |
3472 | 6693 | /*CALLEND*/ |
3473 | 6694 | stackbase += 4LLU; |
3474 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF25LLU; | |
6695 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3CLLU; | |
3475 | 6696 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3476 | 6697 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3477 | 6698 | break; |
3478 | 6699 | } |
3479 | -case 0xFFFFFFFFFFFFFF25LLU: | |
6700 | +case 0xFFFFFFFFFFFFFE3CLLU: | |
3480 | 6701 | /* SP = 2LLU */fputs(" returned values */", stdout); |
3481 | 6702 | { |
3482 | 6703 | /* CALLBEGIN */ |
@@ -3488,12 +6709,12 @@ | ||
3488 | 6709 | { |
3489 | 6710 | /*CALLEND*/ |
3490 | 6711 | stackbase += 4LLU; |
3491 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF24LLU; | |
6712 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3BLLU; | |
3492 | 6713 | fnaddr = /*SP_ADD____*/0x4D00011040000000LLU;/* SP = 0LLU */ |
3493 | 6714 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_ADD____*/\n"); exit(-1); } |
3494 | 6715 | break; |
3495 | 6716 | } |
3496 | -case 0xFFFFFFFFFFFFFF24LLU: | |
6717 | +case 0xFFFFFFFFFFFFFE3BLLU: | |
3497 | 6718 | /* SP = 2LLU */ |
3498 | 6719 | { |
3499 | 6720 | /* CALLBEGIN */ |
@@ -3504,12 +6725,12 @@ | ||
3504 | 6725 | { |
3505 | 6726 | /*CALLEND*/ |
3506 | 6727 | stackbase += 4LLU; |
3507 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF23LLU; | |
6728 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ALLU; | |
3508 | 6729 | fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */ |
3509 | 6730 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); } |
3510 | 6731 | break; |
3511 | 6732 | } |
3512 | -case 0xFFFFFFFFFFFFFF23LLU: | |
6733 | +case 0xFFFFFFFFFFFFFE3ALLU: | |
3513 | 6734 | /* SP = 2LLU */fputs("stackbase", stdout); |
3514 | 6735 | { |
3515 | 6736 | /* CALLBEGIN */ |
@@ -3520,12 +6741,12 @@ | ||
3520 | 6741 | { |
3521 | 6742 | /*CALLEND*/ |
3522 | 6743 | stackbase += 4LLU; |
3523 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF22LLU; | |
6744 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE39LLU; | |
3524 | 6745 | fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */ |
3525 | 6746 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); } |
3526 | 6747 | break; |
3527 | 6748 | } |
3528 | -case 0xFFFFFFFFFFFFFF22LLU: | |
6749 | +case 0xFFFFFFFFFFFFFE39LLU: | |
3529 | 6750 | /* SP = 2LLU */fputs("\n /* leave place for return addr */", stdout); |
3530 | 6751 | { |
3531 | 6752 | /* CALLBEGIN */ |
@@ -3537,12 +6758,12 @@ | ||
3537 | 6758 | { |
3538 | 6759 | /*CALLEND*/ |
3539 | 6760 | stackbase += 4LLU; |
3540 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF21LLU; | |
6761 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE38LLU; | |
3541 | 6762 | fnaddr = /*SP_ADD____*/0x4D00011040000000LLU;/* SP = 0LLU */ |
3542 | 6763 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_ADD____*/\n"); exit(-1); } |
3543 | 6764 | break; |
3544 | 6765 | } |
3545 | -case 0xFFFFFFFFFFFFFF21LLU: | |
6766 | +case 0xFFFFFFFFFFFFFE38LLU: | |
3546 | 6767 | /* SP = 2LLU */fputs("\n }", stdout); |
3547 | 6768 | { /* PUSH */ stack[stackbase + 2LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 3LLU *//* SP - 1LLU = 2LLU */ |
3548 | 6769 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 2LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
@@ -3571,33 +6792,33 @@ | ||
3571 | 6792 | { |
3572 | 6793 | /*CALLEND*/ |
3573 | 6794 | stackbase += 12LLU; |
3574 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF20LLU; | |
6795 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE37LLU; | |
3575 | 6796 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
3576 | 6797 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
3577 | 6798 | break; |
3578 | 6799 | } |
3579 | -case 0xFFFFFFFFFFFFFF20LLU: | |
6800 | +case 0xFFFFFFFFFFFFFE37LLU: | |
3580 | 6801 | /* SP = 10LLU */ |
3581 | 6802 | { /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 11LLU */ |
3582 | 6803 | { |
3583 | 6804 | /*CALLEND*/ |
3584 | 6805 | stackbase += 9LLU; |
3585 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1FLLU; | |
6806 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE36LLU; | |
3586 | 6807 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
3587 | 6808 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
3588 | 6809 | break; |
3589 | 6810 | } |
3590 | -case 0xFFFFFFFFFFFFFF1FLLU: | |
6811 | +case 0xFFFFFFFFFFFFFE36LLU: | |
3591 | 6812 | /* SP = 7LLU */ |
3592 | 6813 | { |
3593 | 6814 | /*CALLEND*/ |
3594 | 6815 | stackbase += 6LLU; |
3595 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ELLU; | |
6816 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE35LLU; | |
3596 | 6817 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3597 | 6818 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3598 | 6819 | break; |
3599 | 6820 | } |
3600 | -case 0xFFFFFFFFFFFFFF1ELLU: | |
6821 | +case 0xFFFFFFFFFFFFFE35LLU: | |
3601 | 6822 | /* SP = 4LLU */fputs(";", stdout); fputs("\n stack[stackbase - 1] = ", stdout); |
3602 | 6823 | { |
3603 | 6824 | /* CALLBEGIN */ |
@@ -3620,33 +6841,33 @@ | ||
3620 | 6841 | { |
3621 | 6842 | /*CALLEND*/ |
3622 | 6843 | stackbase += 12LLU; |
3623 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1DLLU; | |
6844 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE34LLU; | |
3624 | 6845 | fnaddr = /*ADDRGET___*/0x441121C55000000LLU;/* SP = 0LLU */ |
3625 | 6846 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRGET___*/\n"); exit(-1); } |
3626 | 6847 | break; |
3627 | 6848 | } |
3628 | -case 0xFFFFFFFFFFFFFF1DLLU: | |
6849 | +case 0xFFFFFFFFFFFFFE34LLU: | |
3629 | 6850 | /* SP = 10LLU */ |
3630 | 6851 | { /* PUSH */ stack[stackbase + 10LLU] = 1LLU; }/* SP + 1LLU = 11LLU */ |
3631 | 6852 | { |
3632 | 6853 | /*CALLEND*/ |
3633 | 6854 | stackbase += 9LLU; |
3634 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1CLLU; | |
6855 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE33LLU; | |
3635 | 6856 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
3636 | 6857 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
3637 | 6858 | break; |
3638 | 6859 | } |
3639 | -case 0xFFFFFFFFFFFFFF1CLLU: | |
6860 | +case 0xFFFFFFFFFFFFFE33LLU: | |
3640 | 6861 | /* SP = 7LLU */ |
3641 | 6862 | { |
3642 | 6863 | /*CALLEND*/ |
3643 | 6864 | stackbase += 6LLU; |
3644 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1BLLU; | |
6865 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE32LLU; | |
3645 | 6866 | fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */ |
3646 | 6867 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); } |
3647 | 6868 | break; |
3648 | 6869 | } |
3649 | -case 0xFFFFFFFFFFFFFF1BLLU: | |
6870 | +case 0xFFFFFFFFFFFFFE32LLU: | |
3650 | 6871 | /* SP = 4LLU */fputs(";", stdout); fputs("\n fnaddr = ", stdout); |
3651 | 6872 | { |
3652 | 6873 | /* CALLBEGIN */ |
@@ -3658,12 +6879,12 @@ | ||
3658 | 6879 | { |
3659 | 6880 | /*CALLEND*/ |
3660 | 6881 | stackbase += 6LLU; |
3661 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ALLU; | |
6882 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE31LLU; | |
3662 | 6883 | fnaddr = /*printid___*/0xAED929BE47C00000LLU;/* SP = 0LLU */ |
3663 | 6884 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printid___*/\n"); exit(-1); } |
3664 | 6885 | break; |
3665 | 6886 | } |
3666 | -case 0xFFFFFFFFFFFFFF1ALLU: | |
6887 | +case 0xFFFFFFFFFFFFFE31LLU: | |
3667 | 6888 | /* SP = 4LLU */fputs(";", stdout); |
3668 | 6889 | { |
3669 | 6890 | /* CALLBEGIN */ |
@@ -3675,12 +6896,12 @@ | ||
3675 | 6896 | { |
3676 | 6897 | /*CALLEND*/ |
3677 | 6898 | stackbase += 6LLU; |
3678 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF19LLU; | |
6899 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE30LLU; | |
3679 | 6900 | fnaddr = /*SP_SET____*/0x4D00131540000000LLU;/* SP = 0LLU */ |
3680 | 6901 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SET____*/\n"); exit(-1); } |
3681 | 6902 | break; |
3682 | 6903 | } |
3683 | -case 0xFFFFFFFFFFFFFF19LLU: | |
6904 | +case 0xFFFFFFFFFFFFFE30LLU: | |
3684 | 6905 | /* SP = 4LLU */ |
3685 | 6906 | { |
3686 | 6907 | /* CALLBEGIN */ |
@@ -3693,12 +6914,12 @@ | ||
3693 | 6914 | { |
3694 | 6915 | /*CALLEND*/ |
3695 | 6916 | stackbase += 6LLU; |
3696 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF18LLU; | |
6917 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2FLLU; | |
3697 | 6918 | fnaddr = /*STACKCHECK*/0x4D40432C32050CB0LLU;/* SP = 0LLU */ |
3698 | 6919 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*STACKCHECK*/\n"); exit(-1); } |
3699 | 6920 | break; |
3700 | 6921 | } |
3701 | -case 0xFFFFFFFFFFFFFF18LLU: | |
6922 | +case 0xFFFFFFFFFFFFFE2FLLU: | |
3702 | 6923 | /* SP = 4LLU */fputs("\n break;", stdout); fputs("\n }", stdout); fputs("\ncase ", stdout); |
3703 | 6924 | { |
3704 | 6925 | /* CALLBEGIN */ |
@@ -3715,22 +6936,22 @@ | ||
3715 | 6936 | { |
3716 | 6937 | /*CALLEND*/ |
3717 | 6938 | stackbase += 9LLU; |
3718 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF17LLU; | |
6939 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ELLU; | |
3719 | 6940 | fnaddr = /*ADDRNEXT__*/0x441123856140000LLU;/* SP = 0LLU */ |
3720 | 6941 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRNEXT__*/\n"); exit(-1); } |
3721 | 6942 | break; |
3722 | 6943 | } |
3723 | -case 0xFFFFFFFFFFFFFF17LLU: | |
6944 | +case 0xFFFFFFFFFFFFFE2ELLU: | |
3724 | 6945 | /* SP = 7LLU */ |
3725 | 6946 | { |
3726 | 6947 | /*CALLEND*/ |
3727 | 6948 | stackbase += 6LLU; |
3728 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF16LLU; | |
6949 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2DLLU; | |
3729 | 6950 | fnaddr = /*printhexnr*/0xAED929BE3833A6D0LLU;/* SP = 0LLU */ |
3730 | 6951 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printhexnr*/\n"); exit(-1); } |
3731 | 6952 | break; |
3732 | 6953 | } |
3733 | -case 0xFFFFFFFFFFFFFF16LLU: | |
6954 | +case 0xFFFFFFFFFFFFFE2DLLU: | |
3734 | 6955 | /* SP = 4LLU */fputs(":\n", stdout); |
3735 | 6956 | { |
3736 | 6957 | /* CALLBEGIN */ |
@@ -3742,12 +6963,12 @@ | ||
3742 | 6963 | { |
3743 | 6964 | /*CALLEND*/ |
3744 | 6965 | stackbase += 6LLU; |
3745 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF15LLU; | |
6966 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2CLLU; | |
3746 | 6967 | fnaddr = /*SP_SET____*/0x4D00131540000000LLU;/* SP = 0LLU */ |
3747 | 6968 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SET____*/\n"); exit(-1); } |
3748 | 6969 | break; |
3749 | 6970 | } |
3750 | -case 0xFFFFFFFFFFFFFF15LLU: | |
6971 | +case 0xFFFFFFFFFFFFFE2CLLU: | |
3751 | 6972 | /* SP = 4LLU *//* SP = 4LLU *//* SP - 0LLU = 4LLU */ |
3752 | 6973 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3753 | 6974 | /* function requires 12LLU 64-bit chunks of memory (including 4LLU for parameters) */ |
@@ -3765,1624 +6986,15 @@ | ||
3765 | 6986 | { |
3766 | 6987 | /*CALLEND*/ |
3767 | 6988 | stackbase += 3LLU; |
3768 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFF14LLU; | |
6989 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2BLLU; | |
3769 | 6990 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
3770 | 6991 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
3771 | 6992 | break; |
3772 | 6993 | } |
3773 | -case 0xFFFFFFFFFFFFFF14LLU: | |
6994 | +case 0xFFFFFFFFFFFFFE2BLLU: | |
3774 | 6995 | /* SP = 1LLU */fputs("; break; }", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
3775 | 6996 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
3776 | 6997 | /* 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) */ | |
5386 | 6998 | case /*parseglob_*/0xADCB6E8229EA7400LLU:/* SP = 0LLU */ |
5387 | 6999 | { |
5388 | 7000 | /* CALLBEGIN */ |
@@ -5399,22 +7011,22 @@ | ||
5399 | 7011 | { |
5400 | 7012 | /*CALLEND*/ |
5401 | 7013 | stackbase += 5LLU; |
5402 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA2LLU; | |
7014 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ALLU; | |
5403 | 7015 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
5404 | 7016 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
5405 | 7017 | break; |
5406 | 7018 | } |
5407 | -case 0xFFFFFFFFFFFFFEA2LLU: | |
7019 | +case 0xFFFFFFFFFFFFFE2ALLU: | |
5408 | 7020 | /* SP = 3LLU */ |
5409 | 7021 | { |
5410 | 7022 | /*CALLEND*/ |
5411 | 7023 | stackbase += 2LLU; |
5412 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA1LLU; | |
7024 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE29LLU; | |
5413 | 7025 | fnaddr = /*ACCESSGLOB*/0x430C54D31CC3C20LLU;/* SP = 0LLU */ |
5414 | 7026 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSGLOB*/\n"); exit(-1); } |
5415 | 7027 | break; |
5416 | 7028 | } |
5417 | -case 0xFFFFFFFFFFFFFEA1LLU: | |
7029 | +case 0xFFFFFFFFFFFFFE29LLU: | |
5418 | 7030 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
5419 | 7031 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5420 | 7032 | /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -5434,22 +7046,22 @@ | ||
5434 | 7046 | { |
5435 | 7047 | /*CALLEND*/ |
5436 | 7048 | stackbase += 5LLU; |
5437 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA0LLU; | |
7049 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE28LLU; | |
5438 | 7050 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
5439 | 7051 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
5440 | 7052 | break; |
5441 | 7053 | } |
5442 | -case 0xFFFFFFFFFFFFFEA0LLU: | |
7054 | +case 0xFFFFFFFFFFFFFE28LLU: | |
5443 | 7055 | /* SP = 3LLU */ |
5444 | 7056 | { |
5445 | 7057 | /*CALLEND*/ |
5446 | 7058 | stackbase += 2LLU; |
5447 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9FLLU; | |
7059 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE27LLU; | |
5448 | 7060 | fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */ |
5449 | 7061 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); } |
5450 | 7062 | break; |
5451 | 7063 | } |
5452 | -case 0xFFFFFFFFFFFFFE9FLLU: | |
7064 | +case 0xFFFFFFFFFFFFFE27LLU: | |
5453 | 7065 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
5454 | 7066 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5455 | 7067 | /* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -5463,12 +7075,12 @@ | ||
5463 | 7075 | { |
5464 | 7076 | /*CALLEND*/ |
5465 | 7077 | stackbase += 3LLU; |
5466 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ELLU; | |
7078 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE26LLU; | |
5467 | 7079 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
5468 | 7080 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
5469 | 7081 | break; |
5470 | 7082 | } |
5471 | -case 0xFFFFFFFFFFFFFE9ELLU: | |
7083 | +case 0xFFFFFFFFFFFFFE26LLU: | |
5472 | 7084 | /* SP = 1LLU *//* predicate */ |
5473 | 7085 | |
5474 | 7086 | { |
@@ -5486,25 +7098,25 @@ | ||
5486 | 7098 | { |
5487 | 7099 | /*CALLEND*/ |
5488 | 7100 | stackbase += 7LLU; |
5489 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9BLLU; | |
7101 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE23LLU; | |
5490 | 7102 | fnaddr = /*peek______*/0xAE08260000000000LLU;/* SP = 0LLU */ |
5491 | 7103 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*peek______*/\n"); exit(-1); } |
5492 | 7104 | break; |
5493 | 7105 | } |
5494 | -case 0xFFFFFFFFFFFFFE9BLLU: | |
7106 | +case 0xFFFFFFFFFFFFFE23LLU: | |
5495 | 7107 | /* SP = 5LLU */ |
5496 | 7108 | { |
5497 | 7109 | /*CALLEND*/ |
5498 | 7110 | stackbase += 4LLU; |
5499 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ALLU; | |
7111 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE22LLU; | |
5500 | 7112 | fnaddr = /*isalpha___*/0x92E727AE37000000LLU;/* SP = 0LLU */ |
5501 | 7113 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*isalpha___*/\n"); exit(-1); } |
5502 | 7114 | break; |
5503 | 7115 | } |
5504 | -case 0xFFFFFFFFFFFFFE9ALLU: | |
7116 | +case 0xFFFFFFFFFFFFFE22LLU: | |
5505 | 7117 | /* SP = 2LLU */ |
5506 | 7118 | if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]) |
5507 | -{ /* JUMP */ fnaddr = 18446744073709551261LLU; break; } /* skip consequent */ | |
7119 | +{ /* JUMP */ fnaddr = 18446744073709551141LLU; break; } /* skip consequent */ | |
5508 | 7120 | /* consequent */ |
5509 | 7121 | { |
5510 | 7122 | /* CALLBEGIN */ |
@@ -5522,25 +7134,25 @@ | ||
5522 | 7134 | { |
5523 | 7135 | /*CALLEND*/ |
5524 | 7136 | stackbase += 8LLU; |
5525 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE99LLU; | |
7137 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE21LLU; | |
5526 | 7138 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
5527 | 7139 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
5528 | 7140 | break; |
5529 | 7141 | } |
5530 | -case 0xFFFFFFFFFFFFFE99LLU: | |
7142 | +case 0xFFFFFFFFFFFFFE21LLU: | |
5531 | 7143 | /* SP = 6LLU */ |
5532 | 7144 | { |
5533 | 7145 | /*CALLEND*/ |
5534 | 7146 | stackbase += 4LLU; |
5535 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE98LLU; | |
7147 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE20LLU; | |
5536 | 7148 | fnaddr = /*findvaro__*/0x864A5FC5CB6A0000LLU;/* SP = 0LLU */ |
5537 | 7149 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvaro__*/\n"); exit(-1); } |
5538 | 7150 | break; |
5539 | 7151 | } |
5540 | -case 0xFFFFFFFFFFFFFE98LLU: | |
7152 | +case 0xFFFFFFFFFFFFFE20LLU: | |
5541 | 7153 | /* 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 */ | |
5544 | 7156 | { |
5545 | 7157 | /* CALLBEGIN */ |
5546 | 7158 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 1LLU */ |
@@ -5551,12 +7163,12 @@ | ||
5551 | 7163 | { |
5552 | 7164 | /*CALLEND*/ |
5553 | 7165 | stackbase += 3LLU; |
5554 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE97LLU; | |
7166 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1FLLU; | |
5555 | 7167 | fnaddr = /*match_____*/0xA1CBDE8C00000000LLU;/* SP = 0LLU */ |
5556 | 7168 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*match_____*/\n"); exit(-1); } |
5557 | 7169 | break; |
5558 | 7170 | } |
5559 | -case 0xFFFFFFFFFFFFFE97LLU: | |
7171 | +case 0xFFFFFFFFFFFFFE1FLLU: | |
5560 | 7172 | /* SP = 1LLU */ |
5561 | 7173 | { |
5562 | 7174 | /* CALLBEGIN */ |
@@ -5567,15 +7179,15 @@ | ||
5567 | 7179 | { |
5568 | 7180 | /*CALLEND*/ |
5569 | 7181 | stackbase += 4LLU; |
5570 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE96LLU; | |
7182 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1ELLU; | |
5571 | 7183 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
5572 | 7184 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
5573 | 7185 | break; |
5574 | 7186 | } |
5575 | -case 0xFFFFFFFFFFFFFE96LLU: | |
7187 | +case 0xFFFFFFFFFFFFFE1ELLU: | |
5576 | 7188 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
5577 | 7189 | { /* 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 */ | |
5579 | 7191 | fputs("(/* REF TO LOCAL VAR */ stackbase + ", stdout); |
5580 | 7192 | { |
5581 | 7193 | /* CALLBEGIN */ |
@@ -5587,12 +7199,12 @@ | ||
5587 | 7199 | { |
5588 | 7200 | /*CALLEND*/ |
5589 | 7201 | stackbase += 4LLU; |
5590 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE95LLU; | |
7202 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1DLLU; | |
5591 | 7203 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
5592 | 7204 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
5593 | 7205 | break; |
5594 | 7206 | } |
5595 | -case 0xFFFFFFFFFFFFFE95LLU: | |
7207 | +case 0xFFFFFFFFFFFFFE1DLLU: | |
5596 | 7208 | /* SP = 2LLU */fputs(")", stdout); /* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
5597 | 7209 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5598 | 7210 | /* function requires 8LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -5600,7 +7212,7 @@ | ||
5600 | 7212 | |
5601 | 7213 | { /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */ |
5602 | 7214 | if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]) |
5603 | -{ /* JUMP */ fnaddr = 18446744073709551252LLU; break; } /* skip consequent */ | |
7215 | +{ /* JUMP */ fnaddr = 18446744073709551132LLU; break; } /* skip consequent */ | |
5604 | 7216 | /* consequent */ |
5605 | 7217 | { |
5606 | 7218 | /* CALLBEGIN */ |
@@ -5611,12 +7223,12 @@ | ||
5611 | 7223 | { |
5612 | 7224 | /*CALLEND*/ |
5613 | 7225 | stackbase += 4LLU; |
5614 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE93LLU; | |
7226 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1BLLU; | |
5615 | 7227 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
5616 | 7228 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
5617 | 7229 | break; |
5618 | 7230 | } |
5619 | -case 0xFFFFFFFFFFFFFE93LLU: | |
7231 | +case 0xFFFFFFFFFFFFFE1BLLU: | |
5620 | 7232 | /* SP = 2LLU *//* predicate */ |
5621 | 7233 | |
5622 | 7234 | { |
@@ -5630,15 +7242,15 @@ | ||
5630 | 7242 | { |
5631 | 7243 | /*CALLEND*/ |
5632 | 7244 | stackbase += 5LLU; |
5633 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE90LLU; | |
7245 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE18LLU; | |
5634 | 7246 | fnaddr = /*geq_______*/0x8A0B000000000000LLU;/* SP = 0LLU */ |
5635 | 7247 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*geq_______*/\n"); exit(-1); } |
5636 | 7248 | break; |
5637 | 7249 | } |
5638 | -case 0xFFFFFFFFFFFFFE90LLU: | |
7250 | +case 0xFFFFFFFFFFFFFE18LLU: | |
5639 | 7251 | /* SP = 3LLU */ |
5640 | 7252 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
5641 | -{ /* JUMP */ fnaddr = 18446744073709551250LLU; break; } /* skip consequent */ | |
7253 | +{ /* JUMP */ fnaddr = 18446744073709551130LLU; break; } /* skip consequent */ | |
5642 | 7254 | /* consequent */ |
5643 | 7255 | { |
5644 | 7256 | /* CALLBEGIN */ |
@@ -5649,12 +7261,12 @@ | ||
5649 | 7261 | { |
5650 | 7262 | /*CALLEND*/ |
5651 | 7263 | stackbase += 4LLU; |
5652 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8FLLU; | |
7264 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE17LLU; | |
5653 | 7265 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
5654 | 7266 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
5655 | 7267 | break; |
5656 | 7268 | } |
5657 | -case 0xFFFFFFFFFFFFFE8FLLU: | |
7269 | +case 0xFFFFFFFFFFFFFE17LLU: | |
5658 | 7270 | /* SP = 2LLU */fputs("no such parameter ", stderr); |
5659 | 7271 | { |
5660 | 7272 | /* CALLBEGIN */ |
@@ -5666,15 +7278,15 @@ | ||
5666 | 7278 | { |
5667 | 7279 | /*CALLEND*/ |
5668 | 7280 | stackbase += 4LLU; |
5669 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ELLU; | |
7281 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE16LLU; | |
5670 | 7282 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
5671 | 7283 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
5672 | 7284 | break; |
5673 | 7285 | } |
5674 | -case 0xFFFFFFFFFFFFFE8ELLU: | |
7286 | +case 0xFFFFFFFFFFFFFE16LLU: | |
5675 | 7287 | /* 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 */ | |
5678 | 7290 | { |
5679 | 7291 | /* CALLBEGIN */ |
5680 | 7292 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 2LLU */ |
@@ -5685,16 +7297,16 @@ | ||
5685 | 7297 | { |
5686 | 7298 | /*CALLEND*/ |
5687 | 7299 | stackbase += 4LLU; |
5688 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8DLLU; | |
7300 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE15LLU; | |
5689 | 7301 | fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */ |
5690 | 7302 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); } |
5691 | 7303 | break; |
5692 | 7304 | } |
5693 | -case 0xFFFFFFFFFFFFFE8DLLU: | |
7305 | +case 0xFFFFFFFFFFFFFE15LLU: | |
5694 | 7306 | /* SP = 2LLU *//* SP = 2LLU */ |
5695 | -case 18446744073709551249LLU: /* skip to here */ | |
7307 | +case 18446744073709551129LLU: /* skip to here */ | |
5696 | 7308 | /* SP = 1LLU */ |
5697 | -case 18446744073709551252LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ | |
7309 | +case 18446744073709551132LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ | |
5698 | 7310 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5699 | 7311 | /* function requires 7LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
5700 | 7312 | case /*pushglob__*/0xAF0BA38A7A9D0000LLU:/* SP = 0LLU */ |
@@ -5707,12 +7319,12 @@ | ||
5707 | 7319 | { |
5708 | 7320 | /*CALLEND*/ |
5709 | 7321 | stackbase += 2LLU; |
5710 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8CLLU; | |
7322 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE14LLU; | |
5711 | 7323 | fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */ |
5712 | 7324 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); } |
5713 | 7325 | break; |
5714 | 7326 | } |
5715 | -case 0xFFFFFFFFFFFFFE8CLLU: | |
7327 | +case 0xFFFFFFFFFFFFFE14LLU: | |
5716 | 7328 | /* SP = 0LLU */ |
5717 | 7329 | { |
5718 | 7330 | /* CALLBEGIN */ |
@@ -5723,12 +7335,12 @@ | ||
5723 | 7335 | { |
5724 | 7336 | /*CALLEND*/ |
5725 | 7337 | stackbase += 2LLU; |
5726 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8BLLU; | |
7338 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE13LLU; | |
5727 | 7339 | fnaddr = /*parseglob_*/0xADCB6E8229EA7400LLU;/* SP = 0LLU */ |
5728 | 7340 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseglob_*/\n"); exit(-1); } |
5729 | 7341 | break; |
5730 | 7342 | } |
5731 | -case 0xFFFFFFFFFFFFFE8BLLU: | |
7343 | +case 0xFFFFFFFFFFFFFE13LLU: | |
5732 | 7344 | /* SP = 0LLU */ |
5733 | 7345 | { |
5734 | 7346 | /* CALLBEGIN */ |
@@ -5739,12 +7351,12 @@ | ||
5739 | 7351 | { |
5740 | 7352 | /*CALLEND*/ |
5741 | 7353 | stackbase += 2LLU; |
5742 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ALLU; | |
7354 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE12LLU; | |
5743 | 7355 | fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */ |
5744 | 7356 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); } |
5745 | 7357 | break; |
5746 | 7358 | } |
5747 | -case 0xFFFFFFFFFFFFFE8ALLU: | |
7359 | +case 0xFFFFFFFFFFFFFE12LLU: | |
5748 | 7360 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
5749 | 7361 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5750 | 7362 | /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -5758,12 +7370,12 @@ | ||
5758 | 7370 | { |
5759 | 7371 | /*CALLEND*/ |
5760 | 7372 | stackbase += 2LLU; |
5761 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE89LLU; | |
7373 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE11LLU; | |
5762 | 7374 | fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */ |
5763 | 7375 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); } |
5764 | 7376 | break; |
5765 | 7377 | } |
5766 | -case 0xFFFFFFFFFFFFFE89LLU: | |
7378 | +case 0xFFFFFFFFFFFFFE11LLU: | |
5767 | 7379 | /* SP = 0LLU */ |
5768 | 7380 | { |
5769 | 7381 | /* CALLBEGIN */ |
@@ -5774,12 +7386,12 @@ | ||
5774 | 7386 | { |
5775 | 7387 | /*CALLEND*/ |
5776 | 7388 | stackbase += 2LLU; |
5777 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE88LLU; | |
7389 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE10LLU; | |
5778 | 7390 | fnaddr = /*parsevar__*/0xADCB6E83172D0000LLU;/* SP = 0LLU */ |
5779 | 7391 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsevar__*/\n"); exit(-1); } |
5780 | 7392 | break; |
5781 | 7393 | } |
5782 | -case 0xFFFFFFFFFFFFFE88LLU: | |
7394 | +case 0xFFFFFFFFFFFFFE10LLU: | |
5783 | 7395 | /* SP = 0LLU */ |
5784 | 7396 | { |
5785 | 7397 | /* CALLBEGIN */ |
@@ -5790,12 +7402,12 @@ | ||
5790 | 7402 | { |
5791 | 7403 | /*CALLEND*/ |
5792 | 7404 | stackbase += 2LLU; |
5793 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE87LLU; | |
7405 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0FLLU; | |
5794 | 7406 | fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */ |
5795 | 7407 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); } |
5796 | 7408 | break; |
5797 | 7409 | } |
5798 | -case 0xFFFFFFFFFFFFFE87LLU: | |
7410 | +case 0xFFFFFFFFFFFFFE0FLLU: | |
5799 | 7411 | /* SP = 0LLU *//* SP = 0LLU *//* SP - 0LLU = 0LLU */ |
5800 | 7412 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5801 | 7413 | /* function requires 2LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
@@ -5809,12 +7421,12 @@ | ||
5809 | 7421 | { |
5810 | 7422 | /*CALLEND*/ |
5811 | 7423 | stackbase += 3LLU; |
5812 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE86LLU; | |
7424 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ELLU; | |
5813 | 7425 | fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */ |
5814 | 7426 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); } |
5815 | 7427 | break; |
5816 | 7428 | } |
5817 | -case 0xFFFFFFFFFFFFFE86LLU: | |
7429 | +case 0xFFFFFFFFFFFFFE0ELLU: | |
5818 | 7430 | /* SP = 1LLU */ |
5819 | 7431 | { |
5820 | 7432 | /* CALLBEGIN */ |
@@ -5826,12 +7438,12 @@ | ||
5826 | 7438 | { |
5827 | 7439 | /*CALLEND*/ |
5828 | 7440 | stackbase += 3LLU; |
5829 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE85LLU; | |
7441 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0DLLU; | |
5830 | 7442 | fnaddr = /*parseref__*/0xADCB6E82D8210000LLU;/* SP = 0LLU */ |
5831 | 7443 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseref__*/\n"); exit(-1); } |
5832 | 7444 | break; |
5833 | 7445 | } |
5834 | -case 0xFFFFFFFFFFFFFE85LLU: | |
7446 | +case 0xFFFFFFFFFFFFFE0DLLU: | |
5835 | 7447 | /* SP = 1LLU */ |
5836 | 7448 | { |
5837 | 7449 | /* CALLBEGIN */ |
@@ -5842,12 +7454,12 @@ | ||
5842 | 7454 | { |
5843 | 7455 | /*CALLEND*/ |
5844 | 7456 | stackbase += 3LLU; |
5845 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE84LLU; | |
7457 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0CLLU; | |
5846 | 7458 | fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */ |
5847 | 7459 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); } |
5848 | 7460 | break; |
5849 | 7461 | } |
5850 | -case 0xFFFFFFFFFFFFFE84LLU: | |
7462 | +case 0xFFFFFFFFFFFFFE0CLLU: | |
5851 | 7463 | /* SP = 1LLU *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ |
5852 | 7464 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5853 | 7465 | /* function requires 4LLU 64-bit chunks of memory (including 1LLU for parameters) */ |
@@ -5855,7 +7467,7 @@ | ||
5855 | 7467 | |
5856 | 7468 | { /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SPMAX = 2LLU */ |
5857 | 7469 | if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]) |
5858 | -{ /* JUMP */ fnaddr = 18446744073709551235LLU; break; } /* skip consequent */ | |
7470 | +{ /* JUMP */ fnaddr = 18446744073709551115LLU; break; } /* skip consequent */ | |
5859 | 7471 | /* consequent */ |
5860 | 7472 | { |
5861 | 7473 | /* CALLBEGIN */ |
@@ -5866,12 +7478,12 @@ | ||
5866 | 7478 | { |
5867 | 7479 | /*CALLEND*/ |
5868 | 7480 | stackbase += 3LLU; |
5869 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE82LLU; | |
7481 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ALLU; | |
5870 | 7482 | fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */ |
5871 | 7483 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); } |
5872 | 7484 | break; |
5873 | 7485 | } |
5874 | -case 0xFFFFFFFFFFFFFE82LLU: | |
7486 | +case 0xFFFFFFFFFFFFFE0ALLU: | |
5875 | 7487 | /* SP = 1LLU */ |
5876 | 7488 | { |
5877 | 7489 | /* CALLBEGIN */ |
@@ -5883,12 +7495,12 @@ | ||
5883 | 7495 | { |
5884 | 7496 | /*CALLEND*/ |
5885 | 7497 | stackbase += 3LLU; |
5886 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE81LLU; | |
7498 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE09LLU; | |
5887 | 7499 | fnaddr = /*parsearg__*/0xADCB6E81CB620000LLU;/* SP = 0LLU */ |
5888 | 7500 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsearg__*/\n"); exit(-1); } |
5889 | 7501 | break; |
5890 | 7502 | } |
5891 | -case 0xFFFFFFFFFFFFFE81LLU: | |
7503 | +case 0xFFFFFFFFFFFFFE09LLU: | |
5892 | 7504 | /* SP = 1LLU */ |
5893 | 7505 | { |
5894 | 7506 | /* CALLBEGIN */ |
@@ -5899,204 +7511,205 @@ | ||
5899 | 7511 | { |
5900 | 7512 | /*CALLEND*/ |
5901 | 7513 | stackbase += 3LLU; |
5902 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE80LLU; | |
7514 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE08LLU; | |
5903 | 7515 | fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */ |
5904 | 7516 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); } |
5905 | 7517 | break; |
5906 | 7518 | } |
5907 | -case 0xFFFFFFFFFFFFFE80LLU: | |
7519 | +case 0xFFFFFFFFFFFFFE08LLU: | |
5908 | 7520 | /* SP = 1LLU *//* SP = 1LLU */ |
5909 | -case 18446744073709551235LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ | |
7521 | +case 18446744073709551115LLU: /* skipped consequent *//* SP = 1LLU *//* SP - 0LLU = 1LLU */ | |
5910 | 7522 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
5911 | 7523 | /* 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 */ | |
5913 | 7525 | { |
5914 | 7526 | /* 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 */ | |
5918 | 7530 | } |
5919 | 7531 | { |
5920 | 7532 | /*CALLEND*/ |
5921 | - stackbase += 4LLU; | |
5922 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7FLLU; | |
7533 | + stackbase += 5LLU; | |
7534 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE07LLU; | |
5923 | 7535 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
5924 | 7536 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
5925 | 7537 | break; |
5926 | 7538 | } |
5927 | -case 0xFFFFFFFFFFFFFE7FLLU: | |
5928 | -/* SP = 2LLU *//* predicate */ | |
7539 | +case 0xFFFFFFFFFFFFFE07LLU: | |
7540 | +/* SP = 3LLU *//* predicate */ | |
5929 | 7541 | |
5930 | 7542 | { |
5931 | 7543 | /* 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 */ | |
5935 | 7547 | } |
5936 | 7548 | { |
5937 | 7549 | /* 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 */ | |
5941 | 7553 | } |
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 */ | |
5943 | 7555 | { |
5944 | 7556 | /*CALLEND*/ |
5945 | - stackbase += 8LLU; | |
5946 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7DLLU; | |
7557 | + stackbase += 9LLU; | |
7558 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE05LLU; | |
5947 | 7559 | fnaddr = /*typeislist*/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */ |
5948 | 7560 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeislist*/\n"); exit(-1); } |
5949 | 7561 | break; |
5950 | 7562 | } |
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 */ | |
5954 | 7566 | { |
5955 | 7567 | /*CALLEND*/ |
5956 | - stackbase += 5LLU; | |
5957 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7CLLU; | |
7568 | + stackbase += 6LLU; | |
7569 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE04LLU; | |
5958 | 7570 | fnaddr = /*and_______*/0x7297C00000000000LLU;/* SP = 0LLU */ |
5959 | 7571 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*and_______*/\n"); exit(-1); } |
5960 | 7572 | break; |
5961 | 7573 | } |
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 */ | |
5966 | 7578 | /* consequent */ |
5967 | 7579 | { |
5968 | 7580 | /* 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 */ | |
5972 | 7584 | } |
5973 | 7585 | { |
5974 | 7586 | /*CALLEND*/ |
5975 | - stackbase += 4LLU; | |
5976 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7BLLU; | |
7587 | + stackbase += 5LLU; | |
7588 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE03LLU; | |
5977 | 7589 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
5978 | 7590 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
5979 | 7591 | break; |
5980 | 7592 | } |
5981 | -case 0xFFFFFFFFFFFFFE7BLLU: | |
5982 | -/* SP = 2LLU */fputs("expected type ", stderr); | |
7593 | +case 0xFFFFFFFFFFFFFE03LLU: | |
7594 | +/* SP = 3LLU */fputs("expected type ", stderr); | |
5983 | 7595 | { |
5984 | 7596 | /* 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 */ | |
5988 | 7600 | } |
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 */ | |
5990 | 7602 | { |
5991 | 7603 | /*CALLEND*/ |
5992 | - stackbase += 4LLU; | |
5993 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ALLU; | |
7604 | + stackbase += 5LLU; | |
7605 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE02LLU; | |
5994 | 7606 | fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */ |
5995 | 7607 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); } |
5996 | 7608 | break; |
5997 | 7609 | } |
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); | |
6000 | 7612 | { |
6001 | 7613 | /* 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 */ | |
6005 | 7617 | } |
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 */ | |
6007 | 7619 | { |
6008 | 7620 | /*CALLEND*/ |
6009 | - stackbase += 4LLU; | |
6010 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE79LLU; | |
7621 | + stackbase += 5LLU; | |
7622 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFE01LLU; | |
6011 | 7623 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
6012 | 7624 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
6013 | 7625 | break; |
6014 | 7626 | } |
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 */ | |
6018 | 7630 | { |
6019 | 7631 | /* 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 */ | |
6023 | 7635 | } |
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 */ | |
6025 | 7638 | { |
6026 | 7639 | /*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); } | |
6031 | 7644 | break; |
6032 | 7645 | } |
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 */ | |
6036 | 7649 | |
6037 | 7650 | { |
6038 | 7651 | /* 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 */ | |
6042 | 7655 | } |
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 */ | |
6045 | 7658 | { |
6046 | 7659 | /*CALLEND*/ |
6047 | - stackbase += 6LLU; | |
6048 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE75LLU; | |
7660 | + stackbase += 7LLU; | |
7661 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFDLLU; | |
6049 | 7662 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
6050 | 7663 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
6051 | 7664 | break; |
6052 | 7665 | } |
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 */ | |
6057 | 7670 | /* loop */ |
6058 | 7671 | { |
6059 | 7672 | /* 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 */ | |
6063 | 7676 | } |
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 */ | |
6066 | 7679 | { |
6067 | 7680 | /*CALLEND*/ |
6068 | - stackbase += 6LLU; | |
6069 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE74LLU; | |
7681 | + stackbase += 7LLU; | |
7682 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFCLLU; | |
6070 | 7683 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
6071 | 7684 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
6072 | 7685 | break; |
6073 | 7686 | } |
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 */ | |
6076 | 7689 | |
6077 | 7690 | { |
6078 | 7691 | /* 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 */ | |
6082 | 7695 | } |
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 */ | |
6084 | 7697 | { |
6085 | 7698 | /*CALLEND*/ |
6086 | - stackbase += 5LLU; | |
6087 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE73LLU; | |
7699 | + stackbase += 6LLU; | |
7700 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFBLLU; | |
6088 | 7701 | fnaddr = /*PUSH______*/0x4154C80000000000LLU;/* SP = 0LLU */ |
6089 | 7702 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH______*/\n"); exit(-1); } |
6090 | 7703 | break; |
6091 | 7704 | } |
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 */ | |
6096 | 7709 | { /* 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) */ | |
6098 | 7711 | case /*verbatim__*/0xC60B5D72F9280000LLU:/* SP = 0LLU */ |
6099 | -case 0xFFFFFFFFFFFFFE72LLU: /* loop to here *//* predicate */ | |
7712 | +case 0xFFFFFFFFFFFFFDFALLU: /* loop to here *//* predicate */ | |
6100 | 7713 | |
6101 | 7714 | { |
6102 | 7715 | /* CALLBEGIN */ |
@@ -6114,25 +7727,25 @@ | ||
6114 | 7727 | { |
6115 | 7728 | /*CALLEND*/ |
6116 | 7729 | stackbase += 6LLU; |
6117 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE70LLU; | |
7730 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF8LLU; | |
6118 | 7731 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
6119 | 7732 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
6120 | 7733 | break; |
6121 | 7734 | } |
6122 | -case 0xFFFFFFFFFFFFFE70LLU: | |
7735 | +case 0xFFFFFFFFFFFFFDF8LLU: | |
6123 | 7736 | /* SP = 4LLU */ |
6124 | 7737 | { |
6125 | 7738 | /*CALLEND*/ |
6126 | 7739 | stackbase += 3LLU; |
6127 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6FLLU; | |
7740 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF7LLU; | |
6128 | 7741 | fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */ |
6129 | 7742 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); } |
6130 | 7743 | break; |
6131 | 7744 | } |
6132 | -case 0xFFFFFFFFFFFFFE6FLLU: | |
7745 | +case 0xFFFFFFFFFFFFFDF7LLU: | |
6133 | 7746 | /* SP = 1LLU */ |
6134 | 7747 | if(!/* SP - 1LLU = 0LLU */stack[stackbase + 0LLU]) |
6135 | -{ /* JUMP */ fnaddr = 18446744073709551217LLU; break; } /* skip loop */ | |
7748 | +{ /* JUMP */ fnaddr = 18446744073709551097LLU; break; } /* skip loop */ | |
6136 | 7749 | /* loop *//* predicate */ |
6137 | 7750 | |
6138 | 7751 | { |
@@ -6150,26 +7763,26 @@ | ||
6150 | 7763 | { |
6151 | 7764 | /*CALLEND*/ |
6152 | 7765 | stackbase += 6LLU; |
6153 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6DLLU; | |
7766 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF5LLU; | |
6154 | 7767 | fnaddr = /*echo______*/0x81E8EA0000000000LLU;/* SP = 0LLU */ |
6155 | 7768 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*echo______*/\n"); exit(-1); } |
6156 | 7769 | break; |
6157 | 7770 | } |
6158 | -case 0xFFFFFFFFFFFFFE6DLLU: | |
7771 | +case 0xFFFFFFFFFFFFFDF5LLU: | |
6159 | 7772 | /* SP = 4LLU */ |
6160 | 7773 | { /* PUSH */ stack[stackbase + 4LLU] = 255LLU; }/* SP + 1LLU = 5LLU */ |
6161 | 7774 | { |
6162 | 7775 | /*CALLEND*/ |
6163 | 7776 | stackbase += 3LLU; |
6164 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6CLLU; | |
7777 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF4LLU; | |
6165 | 7778 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
6166 | 7779 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
6167 | 7780 | break; |
6168 | 7781 | } |
6169 | -case 0xFFFFFFFFFFFFFE6CLLU: | |
7782 | +case 0xFFFFFFFFFFFFFDF4LLU: | |
6170 | 7783 | /* SP = 1LLU */ |
6171 | 7784 | if(!/* SP - 1LLU = 0LLU */stack[stackbase + 0LLU]) |
6172 | -{ /* JUMP */ fnaddr = 18446744073709551214LLU; break; } /* skip consequent */ | |
7785 | +{ /* JUMP */ fnaddr = 18446744073709551094LLU; break; } /* skip consequent */ | |
6173 | 7786 | /* consequent */ |
6174 | 7787 | { |
6175 | 7788 | /* CALLBEGIN */ |
@@ -6180,78 +7793,63 @@ | ||
6180 | 7793 | { |
6181 | 7794 | /*CALLEND*/ |
6182 | 7795 | stackbase += 2LLU; |
6183 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6BLLU; | |
7796 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF3LLU; | |
6184 | 7797 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
6185 | 7798 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
6186 | 7799 | break; |
6187 | 7800 | } |
6188 | -case 0xFFFFFFFFFFFFFE6BLLU: | |
7801 | +case 0xFFFFFFFFFFFFFDF3LLU: | |
6189 | 7802 | /* 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 */ | |
6193 | 7806 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
6194 | 7807 | /* 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 | + | |
6197 | 7811 | { |
6198 | 7812 | /* 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 */ | |
6202 | 7816 | } |
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 */ | |
6203 | 7819 | { |
6204 | 7820 | /*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); } | |
6209 | 7825 | break; |
6210 | 7826 | } |
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 */ | |
6213 | 7832 | { |
6214 | 7833 | /* 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 */ | |
6232 | 7834 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 3LLU */ |
6233 | 7835 | { /* 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 */ | |
6235 | 7837 | } |
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 */ | |
6238 | 7840 | { |
6239 | 7841 | /*CALLEND*/ |
6240 | 7842 | 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); } | |
6244 | 7846 | break; |
6245 | 7847 | } |
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 */ | |
6252 | 7850 | /* 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 */ | |
6255 | 7853 | |
6256 | 7854 | { |
6257 | 7855 | /* CALLBEGIN */ |
@@ -6259,20 +7857,20 @@ | ||
6259 | 7857 | { /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */ |
6260 | 7858 | /* leave place for return addr *//* SP + 1LLU = 5LLU */ |
6261 | 7859 | } |
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 */ | |
6263 | 7861 | { /* PUSH */ stack[stackbase + 6LLU] = 14109355420086697984LLU; }/* SP + 1LLU = 7LLU */ |
6264 | 7862 | { |
6265 | 7863 | /*CALLEND*/ |
6266 | 7864 | stackbase += 5LLU; |
6267 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE63LLU; | |
7865 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDECLLU; | |
6268 | 7866 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
6269 | 7867 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
6270 | 7868 | break; |
6271 | 7869 | } |
6272 | -case 0xFFFFFFFFFFFFFE63LLU: | |
7870 | +case 0xFFFFFFFFFFFFFDECLLU: | |
6273 | 7871 | /* SP = 3LLU */ |
6274 | 7872 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
6275 | -{ /* JUMP */ fnaddr = 18446744073709551205LLU; break; } /* skip consequent */ | |
7873 | +{ /* JUMP */ fnaddr = 18446744073709551086LLU; break; } /* skip consequent */ | |
6276 | 7874 | /* consequent */ |
6277 | 7875 | { |
6278 | 7876 | /* CALLBEGIN */ |
@@ -6283,12 +7881,12 @@ | ||
6283 | 7881 | { |
6284 | 7882 | /*CALLEND*/ |
6285 | 7883 | stackbase += 4LLU; |
6286 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE62LLU; | |
7884 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEBLLU; | |
6287 | 7885 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
6288 | 7886 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
6289 | 7887 | break; |
6290 | 7888 | } |
6291 | -case 0xFFFFFFFFFFFFFE62LLU: | |
7889 | +case 0xFFFFFFFFFFFFFDEBLLU: | |
6292 | 7890 | /* SP = 2LLU *//* predicate */ |
6293 | 7891 | |
6294 | 7892 | { |
@@ -6301,15 +7899,15 @@ | ||
6301 | 7899 | { |
6302 | 7900 | /*CALLEND*/ |
6303 | 7901 | stackbase += 5LLU; |
6304 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5FLLU; | |
7902 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE8LLU; | |
6305 | 7903 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
6306 | 7904 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
6307 | 7905 | break; |
6308 | 7906 | } |
6309 | -case 0xFFFFFFFFFFFFFE5FLLU: | |
7907 | +case 0xFFFFFFFFFFFFFDE8LLU: | |
6310 | 7908 | /* SP = 3LLU */ |
6311 | 7909 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
6312 | -{ /* JUMP */ fnaddr = 18446744073709551201LLU; break; } /* skip consequent */ | |
7910 | +{ /* JUMP */ fnaddr = 18446744073709551082LLU; break; } /* skip consequent */ | |
6313 | 7911 | /* consequent */ |
6314 | 7912 | { |
6315 | 7913 | /* CALLBEGIN */ |
@@ -6320,12 +7918,12 @@ | ||
6320 | 7918 | { |
6321 | 7919 | /*CALLEND*/ |
6322 | 7920 | stackbase += 4LLU; |
6323 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ELLU; | |
7921 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE7LLU; | |
6324 | 7922 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
6325 | 7923 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
6326 | 7924 | break; |
6327 | 7925 | } |
6328 | -case 0xFFFFFFFFFFFFFE5ELLU: | |
7926 | +case 0xFFFFFFFFFFFFFDE7LLU: | |
6329 | 7927 | /* SP = 2LLU */ |
6330 | 7928 | { |
6331 | 7929 | /* CALLBEGIN */ |
@@ -6333,82 +7931,86 @@ | ||
6333 | 7931 | { /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */ |
6334 | 7932 | /* leave place for return addr *//* SP + 1LLU = 5LLU */ |
6335 | 7933 | } |
7934 | +{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU */ | |
6336 | 7935 | { |
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 | + { | |
6337 | 7942 | /*CALLEND*/ |
6338 | - stackbase += 5LLU; | |
6339 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5DLLU; | |
7943 | + stackbase += 9LLU; | |
7944 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE6LLU; | |
6340 | 7945 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
6341 | 7946 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
6342 | 7947 | break; |
6343 | 7948 | } |
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 */ | |
6346 | 7961 | /* 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 */ | |
6355 | 7964 | { |
6356 | 7965 | /* 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 */ | |
6360 | 7969 | } |
7970 | +{ /* PUSH */ stack[stackbase + 5LLU] = 2LLU; }/* SP + 1LLU = 6LLU */ | |
7971 | +{ /* PUSH */ stack[stackbase + 6LLU] = 1LLU; }/* SP + 1LLU = 7LLU */ | |
6361 | 7972 | { |
6362 | 7973 | /*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); } | |
6367 | 7978 | break; |
6368 | 7979 | } |
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 */ | |
6371 | 7987 | { |
6372 | 7988 | /* 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 */ | |
6376 | 7992 | } |
7993 | +{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 6LLU */ | |
6377 | 7994 | { |
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 | - { | |
6384 | 7995 | /*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); } | |
6389 | 8000 | break; |
6390 | 8001 | } |
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 */ | |
6404 | 8006 | |
6405 | -case 18446744073709551207LLU: /* skip to here */ | |
8007 | +case 18446744073709551089LLU: /* skip to here */ | |
6406 | 8008 | |
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]; } | |
6410 | 8012 | { /* 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) */ | |
6412 | 8014 | case /*parsetype_*/0xADCB6E82FD2B8000LLU:/* SP = 0LLU */ |
6413 | 8015 | { /* PUSH */ stack[stackbase + 0LLU] = 0LLU; }/* SP + 1LLU = 1LLU *//* SPMAX = 1LLU */ |
6414 | 8016 | { |
@@ -6420,12 +8022,12 @@ | ||
6420 | 8022 | { |
6421 | 8023 | /*CALLEND*/ |
6422 | 8024 | stackbase += 3LLU; |
6423 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE59LLU; | |
8025 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE2LLU; | |
6424 | 8026 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
6425 | 8027 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
6426 | 8028 | break; |
6427 | 8029 | } |
6428 | -case 0xFFFFFFFFFFFFFE59LLU: | |
8030 | +case 0xFFFFFFFFFFFFFDE2LLU: | |
6429 | 8031 | /* SP = 1LLU *//* predicate */ |
6430 | 8032 | |
6431 | 8033 | { |
@@ -6438,31 +8040,63 @@ | ||
6438 | 8040 | { |
6439 | 8041 | /*CALLEND*/ |
6440 | 8042 | stackbase += 4LLU; |
6441 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE56LLU; | |
8043 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDFLLU; | |
6442 | 8044 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
6443 | 8045 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
6444 | 8046 | break; |
6445 | 8047 | } |
6446 | -case 0xFFFFFFFFFFFFFE56LLU: | |
8048 | +case 0xFFFFFFFFFFFFFDDFLLU: | |
6447 | 8049 | /* SP = 2LLU */ |
6448 | 8050 | if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]) |
6449 | -{ /* JUMP */ fnaddr = 18446744073709551192LLU; break; } /* skip consequent */ | |
8051 | +{ /* JUMP */ fnaddr = 18446744073709551073LLU; break; } /* skip consequent */ | |
6450 | 8052 | /* consequent */ |
6451 | 8053 | { |
6452 | 8054 | /* 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 */ | |
6453 | 8071 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */ |
6454 | 8072 | { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */ |
6455 | 8073 | /* leave place for return addr *//* SP + 1LLU = 4LLU */ |
6456 | 8074 | } |
6457 | 8075 | { |
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 | + { | |
6458 | 8082 | /*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*/ | |
6459 | 8093 | 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); } | |
6463 | 8097 | break; |
6464 | 8098 | } |
6465 | -case 0xFFFFFFFFFFFFFE55LLU: | |
8099 | +case 0xFFFFFFFFFFFFFDDCLLU: | |
6466 | 8100 | /* SP = 2LLU */ |
6467 | 8101 | { |
6468 | 8102 | /* CALLBEGIN */ |
@@ -6473,12 +8107,12 @@ | ||
6473 | 8107 | { |
6474 | 8108 | /*CALLEND*/ |
6475 | 8109 | stackbase += 4LLU; |
6476 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE54LLU; | |
8110 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDBLLU; | |
6477 | 8111 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
6478 | 8112 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
6479 | 8113 | break; |
6480 | 8114 | } |
6481 | -case 0xFFFFFFFFFFFFFE54LLU: | |
8115 | +case 0xFFFFFFFFFFFFFDDBLLU: | |
6482 | 8116 | /* SP = 2LLU */ |
6483 | 8117 | { |
6484 | 8118 | /* CALLBEGIN */ |
@@ -6490,12 +8124,12 @@ | ||
6490 | 8124 | { |
6491 | 8125 | /*CALLEND*/ |
6492 | 8126 | stackbase += 4LLU; |
6493 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE53LLU; | |
8127 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDALLU; | |
6494 | 8128 | fnaddr = /*match_____*/0xA1CBDE8C00000000LLU;/* SP = 0LLU */ |
6495 | 8129 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*match_____*/\n"); exit(-1); } |
6496 | 8130 | break; |
6497 | 8131 | } |
6498 | -case 0xFFFFFFFFFFFFFE53LLU: | |
8132 | +case 0xFFFFFFFFFFFFFDDALLU: | |
6499 | 8133 | /* SP = 2LLU */ |
6500 | 8134 | { |
6501 | 8135 | /* CALLBEGIN */ |
@@ -6503,22 +8137,55 @@ | ||
6503 | 8137 | { /* PUSH */ stack[stackbase + 3LLU] = stackbase; }/* SP + 1LLU = 4LLU */ |
6504 | 8138 | /* leave place for return addr *//* SP + 1LLU = 5LLU */ |
6505 | 8139 | } |
6506 | -{ /* PUSH */ stack[stackbase + 5LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP + 1LLU = 6LLU *//* SPMAX = 6LLU */ | |
6507 | 8140 | { |
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 | + { | |
6508 | 8149 | /*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*/ | |
6509 | 8160 | stackbase += 5LLU; |
6510 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE52LLU; | |
8161 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD8LLU; | |
6511 | 8162 | fnaddr = /*encodelist*/0x8297AA7E09E4BAF0LLU;/* SP = 0LLU */ |
6512 | 8163 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodelist*/\n"); exit(-1); } |
6513 | 8164 | break; |
6514 | 8165 | } |
6515 | -case 0xFFFFFFFFFFFFFE52LLU: | |
8166 | +case 0xFFFFFFFFFFFFFDD8LLU: | |
6516 | 8167 | /* SP = 3LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]; /* POP */ |
6517 | 8168 | /* 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 */ | |
6520 | 8171 | { |
6521 | 8172 | /* 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 */ | |
6522 | 8189 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 2LLU */ |
6523 | 8190 | { /* PUSH */ stack[stackbase + 2LLU] = stackbase; }/* SP + 1LLU = 3LLU */ |
6524 | 8191 | /* leave place for return addr *//* SP + 1LLU = 4LLU */ |
@@ -6527,37 +8194,53 @@ | ||
6527 | 8194 | /* CALLBEGIN */ |
6528 | 8195 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 5LLU */ |
6529 | 8196 | { /* 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 */ | |
6531 | 8198 | } |
6532 | 8199 | { |
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 | + { | |
6533 | 8206 | /*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*/ | |
6534 | 8217 | 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); } | |
6538 | 8221 | break; |
6539 | 8222 | } |
6540 | -case 0xFFFFFFFFFFFFFE51LLU: | |
8223 | +case 0xFFFFFFFFFFFFFDD5LLU: | |
6541 | 8224 | /* SP = 5LLU */ |
6542 | 8225 | { |
6543 | 8226 | /*CALLEND*/ |
6544 | 8227 | 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); } | |
6548 | 8231 | break; |
6549 | 8232 | } |
6550 | -case 0xFFFFFFFFFFFFFE50LLU: | |
8233 | +case 0xFFFFFFFFFFFFFDD4LLU: | |
6551 | 8234 | /* SP = 2LLU *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]; /* POP */ |
6552 | 8235 | /* SP = 1LLU */ |
6553 | -case 18446744073709551191LLU: /* skip to here */ | |
8236 | +case 18446744073709551072LLU: /* skip to here */ | |
6554 | 8237 | |
6555 | 8238 | { /* PUSH */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 2LLU *//* SP - 1LLU = 1LLU */ |
6556 | 8239 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 0LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 1LLU *//* SP - 1LLU = 0LLU */ |
6557 | 8240 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; } |
6558 | 8241 | { /* 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 */ | |
6561 | 8244 | |
6562 | 8245 | { |
6563 | 8246 | /* CALLBEGIN */ |
@@ -6577,28 +8260,28 @@ | ||
6577 | 8260 | { |
6578 | 8261 | /*CALLEND*/ |
6579 | 8262 | stackbase += 9LLU; |
6580 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4DLLU; | |
8263 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD1LLU; | |
6581 | 8264 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
6582 | 8265 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
6583 | 8266 | break; |
6584 | 8267 | } |
6585 | -case 0xFFFFFFFFFFFFFE4DLLU: | |
8268 | +case 0xFFFFFFFFFFFFFDD1LLU: | |
6586 | 8269 | /* SP = 7LLU */ |
6587 | 8270 | { |
6588 | 8271 | /*CALLEND*/ |
6589 | 8272 | stackbase += 5LLU; |
6590 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4CLLU; | |
8273 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD0LLU; | |
6591 | 8274 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
6592 | 8275 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
6593 | 8276 | break; |
6594 | 8277 | } |
6595 | -case 0xFFFFFFFFFFFFFE4CLLU: | |
8278 | +case 0xFFFFFFFFFFFFFDD0LLU: | |
6596 | 8279 | /* SP = 3LLU */ |
6597 | 8280 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
6598 | -{ /* JUMP */ fnaddr = 18446744073709551183LLU; break; } /* skip consequent */ | |
8281 | +{ /* JUMP */ fnaddr = 18446744073709551059LLU; break; } /* skip consequent */ | |
6599 | 8282 | /* 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 */ | |
6602 | 8285 | |
6603 | 8286 | { |
6604 | 8287 | /* CALLBEGIN */ |
@@ -6611,15 +8294,15 @@ | ||
6611 | 8294 | { |
6612 | 8295 | /*CALLEND*/ |
6613 | 8296 | stackbase += 5LLU; |
6614 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ALLU; | |
8297 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCELLU; | |
6615 | 8298 | fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */ |
6616 | 8299 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); } |
6617 | 8300 | break; |
6618 | 8301 | } |
6619 | -case 0xFFFFFFFFFFFFFE4ALLU: | |
8302 | +case 0xFFFFFFFFFFFFFDCELLU: | |
6620 | 8303 | /* SP = 3LLU */ |
6621 | 8304 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
6622 | -{ /* JUMP */ fnaddr = 18446744073709551179LLU; break; } /* skip consequent */ | |
8305 | +{ /* JUMP */ fnaddr = 18446744073709551055LLU; break; } /* skip consequent */ | |
6623 | 8306 | /* consequent */ |
6624 | 8307 | { |
6625 | 8308 | /* CALLBEGIN */ |
@@ -6630,12 +8313,12 @@ | ||
6630 | 8313 | { |
6631 | 8314 | /*CALLEND*/ |
6632 | 8315 | stackbase += 4LLU; |
6633 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE49LLU; | |
8316 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCDLLU; | |
6634 | 8317 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
6635 | 8318 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
6636 | 8319 | break; |
6637 | 8320 | } |
6638 | -case 0xFFFFFFFFFFFFFE49LLU: | |
8321 | +case 0xFFFFFFFFFFFFFDCDLLU: | |
6639 | 8322 | /* SP = 2LLU */fputs("want type ", stderr); |
6640 | 8323 | { |
6641 | 8324 | /* CALLBEGIN */ |
@@ -6647,12 +8330,12 @@ | ||
6647 | 8330 | { |
6648 | 8331 | /*CALLEND*/ |
6649 | 8332 | 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); } | |
6653 | 8336 | break; |
6654 | 8337 | } |
6655 | -case 0xFFFFFFFFFFFFFE48LLU: | |
8338 | +case 0xFFFFFFFFFFFFFDCCLLU: | |
6656 | 8339 | /* SP = 2LLU */fputs(" but have type ", stderr); |
6657 | 8340 | { |
6658 | 8341 | /* CALLBEGIN */ |
@@ -6664,15 +8347,15 @@ | ||
6664 | 8347 | { |
6665 | 8348 | /*CALLEND*/ |
6666 | 8349 | 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); } | |
6670 | 8353 | break; |
6671 | 8354 | } |
6672 | -case 0xFFFFFFFFFFFFFE47LLU: | |
8355 | +case 0xFFFFFFFFFFFFFDCBLLU: | |
6673 | 8356 | /* 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 */ | |
6676 | 8359 | /* SP = 2LLU *//* SP - 0LLU = 2LLU */ |
6677 | 8360 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
6678 | 8361 | /* function requires 11LLU 64-bit chunks of memory (including 2LLU for parameters) */ |
@@ -6696,28 +8379,28 @@ | ||
6696 | 8379 | { |
6697 | 8380 | /*CALLEND*/ |
6698 | 8381 | stackbase += 9LLU; |
6699 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE44LLU; | |
8382 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC8LLU; | |
6700 | 8383 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
6701 | 8384 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
6702 | 8385 | break; |
6703 | 8386 | } |
6704 | -case 0xFFFFFFFFFFFFFE44LLU: | |
8387 | +case 0xFFFFFFFFFFFFFDC8LLU: | |
6705 | 8388 | /* SP = 7LLU */ |
6706 | 8389 | { |
6707 | 8390 | /*CALLEND*/ |
6708 | 8391 | stackbase += 5LLU; |
6709 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE43LLU; | |
8392 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC7LLU; | |
6710 | 8393 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
6711 | 8394 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
6712 | 8395 | break; |
6713 | 8396 | } |
6714 | -case 0xFFFFFFFFFFFFFE43LLU: | |
8397 | +case 0xFFFFFFFFFFFFFDC7LLU: | |
6715 | 8398 | /* SP = 3LLU */ |
6716 | 8399 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
6717 | -{ /* JUMP */ fnaddr = 18446744073709551174LLU; break; } /* skip consequent */ | |
8400 | +{ /* JUMP */ fnaddr = 18446744073709551050LLU; break; } /* skip consequent */ | |
6718 | 8401 | /* 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 */ | |
6721 | 8404 | |
6722 | 8405 | { |
6723 | 8406 | /* CALLBEGIN */ |
@@ -6730,15 +8413,15 @@ | ||
6730 | 8413 | { |
6731 | 8414 | /*CALLEND*/ |
6732 | 8415 | stackbase += 5LLU; |
6733 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE41LLU; | |
8416 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC5LLU; | |
6734 | 8417 | fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */ |
6735 | 8418 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); } |
6736 | 8419 | break; |
6737 | 8420 | } |
6738 | -case 0xFFFFFFFFFFFFFE41LLU: | |
8421 | +case 0xFFFFFFFFFFFFFDC5LLU: | |
6739 | 8422 | /* SP = 3LLU */ |
6740 | 8423 | if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU]) |
6741 | -{ /* JUMP */ fnaddr = 18446744073709551170LLU; break; } /* skip consequent */ | |
8424 | +{ /* JUMP */ fnaddr = 18446744073709551046LLU; break; } /* skip consequent */ | |
6742 | 8425 | /* consequent */ |
6743 | 8426 | { |
6744 | 8427 | /* CALLBEGIN */ |
@@ -6749,12 +8432,12 @@ | ||
6749 | 8432 | { |
6750 | 8433 | /*CALLEND*/ |
6751 | 8434 | stackbase += 4LLU; |
6752 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE40LLU; | |
8435 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC4LLU; | |
6753 | 8436 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
6754 | 8437 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
6755 | 8438 | break; |
6756 | 8439 | } |
6757 | -case 0xFFFFFFFFFFFFFE40LLU: | |
8440 | +case 0xFFFFFFFFFFFFFDC4LLU: | |
6758 | 8441 | /* SP = 2LLU */fputs("want type ", stderr); |
6759 | 8442 | { |
6760 | 8443 | /* CALLBEGIN */ |
@@ -6766,12 +8449,12 @@ | ||
6766 | 8449 | { |
6767 | 8450 | /*CALLEND*/ |
6768 | 8451 | stackbase += 4LLU; |
6769 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3FLLU; | |
8452 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC3LLU; | |
6770 | 8453 | fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */ |
6771 | 8454 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); } |
6772 | 8455 | break; |
6773 | 8456 | } |
6774 | -case 0xFFFFFFFFFFFFFE3FLLU: | |
8457 | +case 0xFFFFFFFFFFFFFDC3LLU: | |
6775 | 8458 | /* SP = 2LLU */fputs(" but have type ", stderr); |
6776 | 8459 | { |
6777 | 8460 | /* CALLBEGIN */ |
@@ -6783,15 +8466,15 @@ | ||
6783 | 8466 | { |
6784 | 8467 | /*CALLEND*/ |
6785 | 8468 | stackbase += 4LLU; |
6786 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ELLU; | |
8469 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC2LLU; | |
6787 | 8470 | fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */ |
6788 | 8471 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); } |
6789 | 8472 | break; |
6790 | 8473 | } |
6791 | -case 0xFFFFFFFFFFFFFE3ELLU: | |
8474 | +case 0xFFFFFFFFFFFFFDC2LLU: | |
6792 | 8475 | /* 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 */ | |
6795 | 8478 | /* SP = 2LLU *//* SP - 0LLU = 2LLU */ |
6796 | 8479 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
6797 | 8480 | /* function requires 11LLU 64-bit chunks of memory (including 2LLU for parameters) */ |
@@ -6815,28 +8498,28 @@ | ||
6815 | 8498 | { |
6816 | 8499 | /*CALLEND*/ |
6817 | 8500 | stackbase += 10LLU; |
6818 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3BLLU; | |
8501 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBFLLU; | |
6819 | 8502 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
6820 | 8503 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
6821 | 8504 | break; |
6822 | 8505 | } |
6823 | -case 0xFFFFFFFFFFFFFE3BLLU: | |
8506 | +case 0xFFFFFFFFFFFFFDBFLLU: | |
6824 | 8507 | /* SP = 8LLU */ |
6825 | 8508 | { |
6826 | 8509 | /*CALLEND*/ |
6827 | 8510 | stackbase += 6LLU; |
6828 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ALLU; | |
8511 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBELLU; | |
6829 | 8512 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
6830 | 8513 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
6831 | 8514 | break; |
6832 | 8515 | } |
6833 | -case 0xFFFFFFFFFFFFFE3ALLU: | |
8516 | +case 0xFFFFFFFFFFFFFDBELLU: | |
6834 | 8517 | /* SP = 4LLU */ |
6835 | 8518 | if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]) |
6836 | -{ /* JUMP */ fnaddr = 18446744073709551165LLU; break; } /* skip consequent */ | |
8519 | +{ /* JUMP */ fnaddr = 18446744073709551041LLU; break; } /* skip consequent */ | |
6837 | 8520 | /* 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 */ | |
6840 | 8523 | |
6841 | 8524 | { |
6842 | 8525 | /* CALLBEGIN */ |
@@ -6849,15 +8532,15 @@ | ||
6849 | 8532 | { |
6850 | 8533 | /*CALLEND*/ |
6851 | 8534 | stackbase += 6LLU; |
6852 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE38LLU; | |
8535 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBCLLU; | |
6853 | 8536 | fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */ |
6854 | 8537 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); } |
6855 | 8538 | break; |
6856 | 8539 | } |
6857 | -case 0xFFFFFFFFFFFFFE38LLU: | |
8540 | +case 0xFFFFFFFFFFFFFDBCLLU: | |
6858 | 8541 | /* SP = 4LLU */ |
6859 | 8542 | if(!/* SP - 1LLU = 3LLU */stack[stackbase + 3LLU]) |
6860 | -{ /* JUMP */ fnaddr = 18446744073709551161LLU; break; } /* skip consequent */ | |
8543 | +{ /* JUMP */ fnaddr = 18446744073709551037LLU; break; } /* skip consequent */ | |
6861 | 8544 | /* consequent */ |
6862 | 8545 | { |
6863 | 8546 | /* CALLBEGIN */ |
@@ -6868,12 +8551,12 @@ | ||
6868 | 8551 | { |
6869 | 8552 | /*CALLEND*/ |
6870 | 8553 | stackbase += 5LLU; |
6871 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE37LLU; | |
8554 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBBLLU; | |
6872 | 8555 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
6873 | 8556 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
6874 | 8557 | break; |
6875 | 8558 | } |
6876 | -case 0xFFFFFFFFFFFFFE37LLU: | |
8559 | +case 0xFFFFFFFFFFFFFDBBLLU: | |
6877 | 8560 | /* SP = 3LLU */fputs("expected type ", stderr); |
6878 | 8561 | { |
6879 | 8562 | /* CALLBEGIN */ |
@@ -6885,12 +8568,12 @@ | ||
6885 | 8568 | { |
6886 | 8569 | /*CALLEND*/ |
6887 | 8570 | stackbase += 5LLU; |
6888 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE36LLU; | |
8571 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBALLU; | |
6889 | 8572 | fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */ |
6890 | 8573 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); } |
6891 | 8574 | break; |
6892 | 8575 | } |
6893 | -case 0xFFFFFFFFFFFFFE36LLU: | |
8576 | +case 0xFFFFFFFFFFFFFDBALLU: | |
6894 | 8577 | /* SP = 3LLU */fputs(" but variable ", stderr); |
6895 | 8578 | { |
6896 | 8579 | /* CALLBEGIN */ |
@@ -6902,12 +8585,12 @@ | ||
6902 | 8585 | { |
6903 | 8586 | /*CALLEND*/ |
6904 | 8587 | stackbase += 5LLU; |
6905 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE35LLU; | |
8588 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB9LLU; | |
6906 | 8589 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
6907 | 8590 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
6908 | 8591 | break; |
6909 | 8592 | } |
6910 | -case 0xFFFFFFFFFFFFFE35LLU: | |
8593 | +case 0xFFFFFFFFFFFFFDB9LLU: | |
6911 | 8594 | /* SP = 3LLU */fputs(" has type ", stderr); |
6912 | 8595 | { |
6913 | 8596 | /* CALLBEGIN */ |
@@ -6919,15 +8602,15 @@ | ||
6919 | 8602 | { |
6920 | 8603 | /*CALLEND*/ |
6921 | 8604 | stackbase += 5LLU; |
6922 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE34LLU; | |
8605 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB8LLU; | |
6923 | 8606 | fnaddr = /*debugtype_*/0x7E07708AFD2B8000LLU;/* SP = 0LLU */ |
6924 | 8607 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugtype_*/\n"); exit(-1); } |
6925 | 8608 | break; |
6926 | 8609 | } |
6927 | -case 0xFFFFFFFFFFFFFE34LLU: | |
8610 | +case 0xFFFFFFFFFFFFFDB8LLU: | |
6928 | 8611 | /* 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 */ | |
6931 | 8614 | /* SP = 3LLU *//* SP - 0LLU = 3LLU */ |
6932 | 8615 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
6933 | 8616 | /* function requires 12LLU 64-bit chunks of memory (including 3LLU for parameters) */ |
@@ -6941,12 +8624,12 @@ | ||
6941 | 8624 | { |
6942 | 8625 | /*CALLEND*/ |
6943 | 8626 | stackbase += 3LLU; |
6944 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE33LLU; | |
8627 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB7LLU; | |
6945 | 8628 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
6946 | 8629 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
6947 | 8630 | break; |
6948 | 8631 | } |
6949 | -case 0xFFFFFFFFFFFFFE33LLU: | |
8632 | +case 0xFFFFFFFFFFFFFDB7LLU: | |
6950 | 8633 | /* SP = 1LLU *//* predicate */ |
6951 | 8634 | |
6952 | 8635 | { |
@@ -6965,25 +8648,25 @@ | ||
6965 | 8648 | { |
6966 | 8649 | /*CALLEND*/ |
6967 | 8650 | stackbase += 8LLU; |
6968 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE31LLU; | |
8651 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB5LLU; | |
6969 | 8652 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
6970 | 8653 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
6971 | 8654 | break; |
6972 | 8655 | } |
6973 | -case 0xFFFFFFFFFFFFFE31LLU: | |
8656 | +case 0xFFFFFFFFFFFFFDB5LLU: | |
6974 | 8657 | /* SP = 6LLU */ |
6975 | 8658 | { |
6976 | 8659 | /*CALLEND*/ |
6977 | 8660 | stackbase += 4LLU; |
6978 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE30LLU; | |
8661 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB4LLU; | |
6979 | 8662 | fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */ |
6980 | 8663 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); } |
6981 | 8664 | break; |
6982 | 8665 | } |
6983 | -case 0xFFFFFFFFFFFFFE30LLU: | |
8666 | +case 0xFFFFFFFFFFFFFDB4LLU: | |
6984 | 8667 | /* SP = 2LLU */ |
6985 | 8668 | if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]) |
6986 | -{ /* JUMP */ fnaddr = 18446744073709551154LLU; break; } /* skip consequent */ | |
8669 | +{ /* JUMP */ fnaddr = 18446744073709551030LLU; break; } /* skip consequent */ | |
6987 | 8670 | /* consequent */ |
6988 | 8671 | { |
6989 | 8672 | /* CALLBEGIN */ |
@@ -6994,12 +8677,12 @@ | ||
6994 | 8677 | { |
6995 | 8678 | /*CALLEND*/ |
6996 | 8679 | stackbase += 3LLU; |
6997 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2FLLU; | |
8680 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB3LLU; | |
6998 | 8681 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
6999 | 8682 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
7000 | 8683 | break; |
7001 | 8684 | } |
7002 | -case 0xFFFFFFFFFFFFFE2FLLU: | |
8685 | +case 0xFFFFFFFFFFFFFDB3LLU: | |
7003 | 8686 | /* SP = 1LLU */fputs("LEVEL ", stderr); |
7004 | 8687 | { |
7005 | 8688 | /* CALLBEGIN */ |
@@ -7011,12 +8694,12 @@ | ||
7011 | 8694 | { |
7012 | 8695 | /*CALLEND*/ |
7013 | 8696 | stackbase += 3LLU; |
7014 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ELLU; | |
8697 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB2LLU; | |
7015 | 8698 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
7016 | 8699 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
7017 | 8700 | break; |
7018 | 8701 | } |
7019 | -case 0xFFFFFFFFFFFFFE2ELLU: | |
8702 | +case 0xFFFFFFFFFFFFFDB2LLU: | |
7020 | 8703 | /* SP = 1LLU */fputs(" != ", stderr); |
7021 | 8704 | { |
7022 | 8705 | /* CALLBEGIN */ |
@@ -7033,24 +8716,24 @@ | ||
7033 | 8716 | { |
7034 | 8717 | /*CALLEND*/ |
7035 | 8718 | stackbase += 6LLU; |
7036 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2DLLU; | |
8719 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB1LLU; | |
7037 | 8720 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
7038 | 8721 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
7039 | 8722 | break; |
7040 | 8723 | } |
7041 | -case 0xFFFFFFFFFFFFFE2DLLU: | |
8724 | +case 0xFFFFFFFFFFFFFDB1LLU: | |
7042 | 8725 | /* SP = 4LLU */ |
7043 | 8726 | { |
7044 | 8727 | /*CALLEND*/ |
7045 | 8728 | stackbase += 3LLU; |
7046 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2CLLU; | |
8729 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB0LLU; | |
7047 | 8730 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
7048 | 8731 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
7049 | 8732 | break; |
7050 | 8733 | } |
7051 | -case 0xFFFFFFFFFFFFFE2CLLU: | |
8734 | +case 0xFFFFFFFFFFFFFDB0LLU: | |
7052 | 8735 | /* 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 */ | |
7054 | 8737 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
7055 | 8738 | /* function requires 8LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
7056 | 8739 | case /*initvar___*/0x92992FC5CB400000LLU:/* SP = 0LLU */ |
@@ -7063,12 +8746,12 @@ | ||
7063 | 8746 | { |
7064 | 8747 | /*CALLEND*/ |
7065 | 8748 | stackbase += 3LLU; |
7066 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2BLLU; | |
8749 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAFLLU; | |
7067 | 8750 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
7068 | 8751 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
7069 | 8752 | break; |
7070 | 8753 | } |
7071 | -case 0xFFFFFFFFFFFFFE2BLLU: | |
8754 | +case 0xFFFFFFFFFFFFFDAFLLU: | |
7072 | 8755 | /* SP = 1LLU *//* predicate */ |
7073 | 8756 | |
7074 | 8757 | { |
@@ -7087,25 +8770,25 @@ | ||
7087 | 8770 | { |
7088 | 8771 | /*CALLEND*/ |
7089 | 8772 | stackbase += 8LLU; |
7090 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE29LLU; | |
8773 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDADLLU; | |
7091 | 8774 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
7092 | 8775 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
7093 | 8776 | break; |
7094 | 8777 | } |
7095 | -case 0xFFFFFFFFFFFFFE29LLU: | |
8778 | +case 0xFFFFFFFFFFFFFDADLLU: | |
7096 | 8779 | /* SP = 6LLU */ |
7097 | 8780 | { |
7098 | 8781 | /*CALLEND*/ |
7099 | 8782 | stackbase += 4LLU; |
7100 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE28LLU; | |
8783 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDACLLU; | |
7101 | 8784 | fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */ |
7102 | 8785 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); } |
7103 | 8786 | break; |
7104 | 8787 | } |
7105 | -case 0xFFFFFFFFFFFFFE28LLU: | |
8788 | +case 0xFFFFFFFFFFFFFDACLLU: | |
7106 | 8789 | /* SP = 2LLU */ |
7107 | 8790 | if(!/* SP - 1LLU = 1LLU */stack[stackbase + 1LLU]) |
7108 | -{ /* JUMP */ fnaddr = 18446744073709551146LLU; break; } /* skip consequent */ | |
8791 | +{ /* JUMP */ fnaddr = 18446744073709551022LLU; break; } /* skip consequent */ | |
7109 | 8792 | /* consequent */ |
7110 | 8793 | { |
7111 | 8794 | /* CALLBEGIN */ |
@@ -7116,12 +8799,12 @@ | ||
7116 | 8799 | { |
7117 | 8800 | /*CALLEND*/ |
7118 | 8801 | stackbase += 3LLU; |
7119 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE27LLU; | |
8802 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDABLLU; | |
7120 | 8803 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
7121 | 8804 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
7122 | 8805 | break; |
7123 | 8806 | } |
7124 | -case 0xFFFFFFFFFFFFFE27LLU: | |
8807 | +case 0xFFFFFFFFFFFFFDABLLU: | |
7125 | 8808 | /* SP = 1LLU */fputs("VAR ", stderr); |
7126 | 8809 | { |
7127 | 8810 | /* CALLBEGIN */ |
@@ -7133,12 +8816,12 @@ | ||
7133 | 8816 | { |
7134 | 8817 | /*CALLEND*/ |
7135 | 8818 | stackbase += 3LLU; |
7136 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE26LLU; | |
8819 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAALLU; | |
7137 | 8820 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
7138 | 8821 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
7139 | 8822 | break; |
7140 | 8823 | } |
7141 | -case 0xFFFFFFFFFFFFFE26LLU: | |
8824 | +case 0xFFFFFFFFFFFFFDAALLU: | |
7142 | 8825 | /* SP = 1LLU */fputs(" != ", stderr); |
7143 | 8826 | { |
7144 | 8827 | /* CALLBEGIN */ |
@@ -7155,24 +8838,24 @@ | ||
7155 | 8838 | { |
7156 | 8839 | /*CALLEND*/ |
7157 | 8840 | stackbase += 6LLU; |
7158 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE25LLU; | |
8841 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA9LLU; | |
7159 | 8842 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
7160 | 8843 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
7161 | 8844 | break; |
7162 | 8845 | } |
7163 | -case 0xFFFFFFFFFFFFFE25LLU: | |
8846 | +case 0xFFFFFFFFFFFFFDA9LLU: | |
7164 | 8847 | /* SP = 4LLU */ |
7165 | 8848 | { |
7166 | 8849 | /*CALLEND*/ |
7167 | 8850 | stackbase += 3LLU; |
7168 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE24LLU; | |
8851 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA8LLU; | |
7169 | 8852 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
7170 | 8853 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
7171 | 8854 | break; |
7172 | 8855 | } |
7173 | -case 0xFFFFFFFFFFFFFE24LLU: | |
8856 | +case 0xFFFFFFFFFFFFFDA8LLU: | |
7174 | 8857 | /* 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 */ | |
7176 | 8859 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
7177 | 8860 | /* function requires 8LLU 64-bit chunks of memory (including 0LLU for parameters) */ |
7178 | 8861 | case /*matchoptid*/0xA1CBDE8EAAEF91F0LLU:/* SP = 1LLU *//* SPMAX = 1LLU */ |
@@ -7192,69 +8875,96 @@ | ||
7192 | 8875 | { |
7193 | 8876 | /*CALLEND*/ |
7194 | 8877 | stackbase += 8LLU; |
7195 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE23LLU; | |
8878 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA7LLU; | |
7196 | 8879 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
7197 | 8880 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
7198 | 8881 | break; |
7199 | 8882 | } |
7200 | -case 0xFFFFFFFFFFFFFE23LLU: | |
8883 | +case 0xFFFFFFFFFFFFFDA7LLU: | |
7201 | 8884 | /* SP = 6LLU */ |
7202 | 8885 | { |
7203 | 8886 | /*CALLEND*/ |
7204 | 8887 | stackbase += 4LLU; |
7205 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE22LLU; | |
8888 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA6LLU; | |
7206 | 8889 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
7207 | 8890 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
7208 | 8891 | break; |
7209 | 8892 | } |
7210 | -case 0xFFFFFFFFFFFFFE22LLU: | |
8893 | +case 0xFFFFFFFFFFFFFDA6LLU: | |
7211 | 8894 | /* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
7212 | 8895 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 1LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; }/* SP = 2LLU *//* SP - 1LLU = 1LLU */ |
7213 | 8896 | { /* RESULT *//* LOCAL VAR */ stack[stackbase + 18446744073709551613LLU] = /* LOCAL VAR */ stack[stackbase + 1LLU]; } |
7214 | 8897 | { /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; } |
7215 | 8898 | /* 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? */ | |
7217 | 8900 | |
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 | + | |
7218 | 8906 | { |
7219 | 8907 | /* 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 */ | |
7223 | 8911 | } |
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 */ | |
7224 | 8914 | { |
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; | |
7229 | 8921 | } |
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 | + | |
7230 | 8929 | { |
7231 | 8930 | /* 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 */ | |
7235 | 8934 | } |
7236 | -{ /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 0LLU]; }/* SP + 1LLU = 12LLU *//* SPMAX = 12LLU */ | |
7237 | 8935 | { |
7238 | 8936 | /*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); } | |
7243 | 8941 | break; |
7244 | 8942 | } |
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 | + } | |
7247 | 8952 | { /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */ |
8953 | +{ /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 3LLU]; }/* SP + 1LLU = 11LLU */ | |
7248 | 8954 | { |
7249 | 8955 | /*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); } | |
7254 | 8960 | break; |
7255 | 8961 | } |
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 | + | |
7258 | 8968 | { |
7259 | 8969 | /* CALLBEGIN */ |
7260 | 8970 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */ |
@@ -7261,134 +8971,194 @@ | ||
7261 | 8971 | { /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */ |
7262 | 8972 | /* leave place for return addr *//* SP + 1LLU = 9LLU */ |
7263 | 8973 | } |
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 */ | |
7265 | 8976 | { |
7266 | 8977 | /*CALLEND*/ |
7267 | 8978 | 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); } | |
7271 | 8982 | break; |
7272 | 8983 | } |
7273 | -case 0xFFFFFFFFFFFFFE1ELLU: | |
8984 | +case 0xFFFFFFFFFFFFFD9CLLU: | |
7274 | 8985 | /* SP = 7LLU */ |
8986 | +if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]) | |
8987 | +{ /* JUMP */ fnaddr = 18446744073709551005LLU; break; } /* skip consequent */ | |
8988 | +/* consequent */ | |
7275 | 8989 | { |
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 | + { | |
7276 | 8996 | /*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); } | |
7281 | 9001 | break; |
7282 | 9002 | } |
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 */ | |
7288 | 9005 | { |
7289 | 9006 | /* 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 */ | |
7293 | 9010 | } |
7294 | 9011 | { |
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 | + { | |
7295 | 9018 | /*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); } | |
7300 | 9023 | break; |
7301 | 9024 | } |
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 */ | |
7304 | 9028 | { |
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 | + { | |
7305 | 9040 | /* 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 */ | |
7309 | 9044 | } |
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 */ | |
7311 | 9046 | { |
7312 | 9047 | /*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); } | |
7317 | 9052 | break; |
7318 | 9053 | } |
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 */ | |
7325 | 9056 | |
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 | - | |
7331 | 9057 | { |
7332 | 9058 | /* 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 */ | |
7336 | 9062 | } |
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 */ | |
7339 | 9063 | { |
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 | + { | |
7340 | 9071 | /*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); } | |
7345 | 9076 | break; |
7346 | 9077 | } |
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 */ | |
7351 | 9093 | /* consequent */ |
7352 | -{ /* PUSH */ stack[stackbase + 6LLU] = 9223372036854775808LLU; }/* SP + 1LLU = 7LLU *//* LOCAL VAR */ stack[stackbase + 5LLU] = /* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */ | |
7353 | - | |
7354 | 9094 | { |
7355 | 9095 | /* 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 */ | |
7359 | 9099 | } |
7360 | 9100 | { |
7361 | 9101 | /*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); } | |
7366 | 9106 | break; |
7367 | 9107 | } |
7368 | -case 0xFFFFFFFFFFFFFE16LLU: | |
7369 | -/* SP = 6LLU *//* predicate */ | |
7370 | - | |
9108 | +case 0xFFFFFFFFFFFFFD94LLU: | |
9109 | +/* SP = 7LLU */fputs("want ", stderr); | |
7371 | 9110 | { |
7372 | 9111 | /* CALLBEGIN */ |
7373 | - /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */ | |
9112 | + /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */ | |
7374 | 9113 | { /* PUSH */ stack[stackbase + 7LLU] = stackbase; }/* SP + 1LLU = 8LLU */ |
7375 | 9114 | /* leave place for return addr *//* SP + 1LLU = 9LLU */ |
7376 | 9115 | } |
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 */ | |
7379 | 9117 | { |
7380 | 9118 | /*CALLEND*/ |
7381 | 9119 | 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); } | |
7385 | 9123 | break; |
7386 | 9124 | } |
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 */ | |
7392 | 9162 | |
7393 | 9163 | { |
7394 | 9164 | /* CALLBEGIN */ |
@@ -7400,15 +9170,15 @@ | ||
7400 | 9170 | { |
7401 | 9171 | /*CALLEND*/ |
7402 | 9172 | stackbase += 9LLU; |
7403 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE10LLU; | |
9173 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ELLU; | |
7404 | 9174 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
7405 | 9175 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
7406 | 9176 | break; |
7407 | 9177 | } |
7408 | -case 0xFFFFFFFFFFFFFE10LLU: | |
9178 | +case 0xFFFFFFFFFFFFFD8ELLU: | |
7409 | 9179 | /* SP = 7LLU */ |
7410 | 9180 | if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]) |
7411 | -{ /* JUMP */ fnaddr = 18446744073709551122LLU; break; } /* skip consequent */ | |
9181 | +{ /* JUMP */ fnaddr = 18446744073709550992LLU; break; } /* skip consequent */ | |
7412 | 9182 | /* consequent */ |
7413 | 9183 | { |
7414 | 9184 | /* CALLBEGIN */ |
@@ -7416,17 +9186,17 @@ | ||
7416 | 9186 | { /* PUSH */ stack[stackbase + 9LLU] = stackbase; }/* SP + 1LLU = 10LLU */ |
7417 | 9187 | /* leave place for return addr *//* SP + 1LLU = 11LLU */ |
7418 | 9188 | } |
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 */ | |
7421 | 9191 | { |
7422 | 9192 | /*CALLEND*/ |
7423 | 9193 | stackbase += 11LLU; |
7424 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0FLLU; | |
9194 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8DLLU; | |
7425 | 9195 | fnaddr = /*finddef___*/0x864A5F7E08400000LLU;/* SP = 0LLU */ |
7426 | 9196 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*finddef___*/\n"); exit(-1); } |
7427 | 9197 | break; |
7428 | 9198 | } |
7429 | -case 0xFFFFFFFFFFFFFE0FLLU: | |
9199 | +case 0xFFFFFFFFFFFFFD8DLLU: | |
7430 | 9200 | /* SP = 9LLU *//* predicate */ |
7431 | 9201 | |
7432 | 9202 | { |
@@ -7438,7 +9208,7 @@ | ||
7438 | 9208 | { |
7439 | 9209 | /* CALLBEGIN */ |
7440 | 9210 | /* 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 */ | |
7442 | 9212 | /* leave place for return addr *//* SP + 1LLU = 15LLU *//* SPMAX = 15LLU */ |
7443 | 9213 | } |
7444 | 9214 | { /* PUSH */ stack[stackbase + 15LLU] = 0LLU; }/* SP + 1LLU = 16LLU *//* SPMAX = 16LLU */ |
@@ -7446,12 +9216,12 @@ | ||
7446 | 9216 | { |
7447 | 9217 | /*CALLEND*/ |
7448 | 9218 | stackbase += 15LLU; |
7449 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0CLLU; | |
9219 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ALLU; | |
7450 | 9220 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
7451 | 9221 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
7452 | 9222 | break; |
7453 | 9223 | } |
7454 | -case 0xFFFFFFFFFFFFFE0CLLU: | |
9224 | +case 0xFFFFFFFFFFFFFD8ALLU: | |
7455 | 9225 | /* SP = 13LLU */ |
7456 | 9226 | { |
7457 | 9227 | /* CALLBEGIN */ |
@@ -7464,25 +9234,25 @@ | ||
7464 | 9234 | { |
7465 | 9235 | /*CALLEND*/ |
7466 | 9236 | stackbase += 16LLU; |
7467 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0BLLU; | |
9237 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD89LLU; | |
7468 | 9238 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
7469 | 9239 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
7470 | 9240 | break; |
7471 | 9241 | } |
7472 | -case 0xFFFFFFFFFFFFFE0BLLU: | |
9242 | +case 0xFFFFFFFFFFFFFD89LLU: | |
7473 | 9243 | /* SP = 14LLU */ |
7474 | 9244 | { |
7475 | 9245 | /*CALLEND*/ |
7476 | 9246 | stackbase += 12LLU; |
7477 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ALLU; | |
9247 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD88LLU; | |
7478 | 9248 | fnaddr = /*and_______*/0x7297C00000000000LLU;/* SP = 0LLU */ |
7479 | 9249 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*and_______*/\n"); exit(-1); } |
7480 | 9250 | break; |
7481 | 9251 | } |
7482 | -case 0xFFFFFFFFFFFFFE0ALLU: | |
9252 | +case 0xFFFFFFFFFFFFFD88LLU: | |
7483 | 9253 | /* SP = 10LLU */ |
7484 | 9254 | if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU]) |
7485 | -{ /* JUMP */ fnaddr = 18446744073709551118LLU; break; } /* skip consequent */ | |
9255 | +{ /* JUMP */ fnaddr = 18446744073709550988LLU; break; } /* skip consequent */ | |
7486 | 9256 | /* consequent */ |
7487 | 9257 | { |
7488 | 9258 | /* CALLBEGIN */ |
@@ -7493,12 +9263,12 @@ | ||
7493 | 9263 | { |
7494 | 9264 | /*CALLEND*/ |
7495 | 9265 | stackbase += 11LLU; |
7496 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE09LLU; | |
9266 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD87LLU; | |
7497 | 9267 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
7498 | 9268 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
7499 | 9269 | break; |
7500 | 9270 | } |
7501 | -case 0xFFFFFFFFFFFFFE09LLU: | |
9271 | +case 0xFFFFFFFFFFFFFD87LLU: | |
7502 | 9272 | /* SP = 9LLU */fputs("recursive function ", stderr); |
7503 | 9273 | { |
7504 | 9274 | /* CALLBEGIN */ |
@@ -7510,15 +9280,15 @@ | ||
7510 | 9280 | { |
7511 | 9281 | /*CALLEND*/ |
7512 | 9282 | stackbase += 11LLU; |
7513 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE08LLU; | |
9283 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD86LLU; | |
7514 | 9284 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
7515 | 9285 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
7516 | 9286 | break; |
7517 | 9287 | } |
7518 | -case 0xFFFFFFFFFFFFFE08LLU: | |
9288 | +case 0xFFFFFFFFFFFFFD86LLU: | |
7519 | 9289 | /* 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 */ | |
7522 | 9292 | { /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */ |
7523 | 9293 | { /* PUSH */ stack[stackbase + 10LLU] = /* LOCAL VAR */ stack[stackbase + 8LLU]; }/* SP + 1LLU = 11LLU */ |
7524 | 9294 | { /* PUSH */ stack[stackbase + 11LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 12LLU *//* predicate */ |
@@ -7529,36 +9299,36 @@ | ||
7529 | 9299 | { /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */ |
7530 | 9300 | /* leave place for return addr *//* SP + 1LLU = 15LLU */ |
7531 | 9301 | } |
7532 | -{ /* PUSH */ stack[stackbase + 15LLU] = /* LOCAL VAR */ stack[stackbase + 11LLU]; }/* SP + 1LLU = 16LLU */ | |
7533 | 9302 | { |
7534 | 9303 | /* 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 */ | |
7538 | 9307 | } |
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 */ | |
7540 | 9309 | { |
7541 | 9310 | /*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); } | |
7546 | 9315 | break; |
7547 | 9316 | } |
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 */ | |
7550 | 9320 | { |
7551 | 9321 | /*CALLEND*/ |
7552 | 9322 | stackbase += 15LLU; |
7553 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE04LLU; | |
9323 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD82LLU; | |
7554 | 9324 | fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */ |
7555 | 9325 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); } |
7556 | 9326 | break; |
7557 | 9327 | } |
7558 | -case 0xFFFFFFFFFFFFFE04LLU: | |
9328 | +case 0xFFFFFFFFFFFFFD82LLU: | |
7559 | 9329 | /* SP = 13LLU */ |
7560 | 9330 | if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU]) |
7561 | -{ /* JUMP */ fnaddr = 18446744073709551111LLU; break; } /* skip consequent */ | |
9331 | +{ /* JUMP */ fnaddr = 18446744073709550981LLU; break; } /* skip consequent */ | |
7562 | 9332 | /* consequent */ |
7563 | 9333 | { |
7564 | 9334 | /* CALLBEGIN */ |
@@ -7569,12 +9339,12 @@ | ||
7569 | 9339 | { |
7570 | 9340 | /*CALLEND*/ |
7571 | 9341 | stackbase += 14LLU; |
7572 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE03LLU; | |
9342 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD81LLU; | |
7573 | 9343 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
7574 | 9344 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
7575 | 9345 | break; |
7576 | 9346 | } |
7577 | -case 0xFFFFFFFFFFFFFE03LLU: | |
9347 | +case 0xFFFFFFFFFFFFFD81LLU: | |
7578 | 9348 | /* SP = 12LLU */fputs("expected ", stderr); |
7579 | 9349 | { |
7580 | 9350 | /* CALLBEGIN */ |
@@ -7582,33 +9352,17 @@ | ||
7582 | 9352 | { /* PUSH */ stack[stackbase + 12LLU] = stackbase; }/* SP + 1LLU = 13LLU */ |
7583 | 9353 | /* leave place for return addr *//* SP + 1LLU = 14LLU */ |
7584 | 9354 | } |
9355 | +{ /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 15LLU */ | |
7585 | 9356 | { |
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 | - { | |
7593 | 9357 | /*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*/ | |
7604 | 9358 | 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); } | |
7608 | 9362 | break; |
7609 | 9363 | } |
7610 | -case 0xFFFFFFFFFFFFFE01LLU: | |
7611 | -/* SP = 12LLU */fputs(" 64-bit chunks but function ", stderr); | |
9364 | +case 0xFFFFFFFFFFFFFD80LLU: | |
9365 | +/* SP = 12LLU */fputs(" but function ", stderr); | |
7612 | 9366 | { |
7613 | 9367 | /* CALLBEGIN */ |
7614 | 9368 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 12LLU */ |
@@ -7619,12 +9373,12 @@ | ||
7619 | 9373 | { |
7620 | 9374 | /*CALLEND*/ |
7621 | 9375 | stackbase += 14LLU; |
7622 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFE00LLU; | |
9376 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7FLLU; | |
7623 | 9377 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
7624 | 9378 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
7625 | 9379 | break; |
7626 | 9380 | } |
7627 | -case 0xFFFFFFFFFFFFFE00LLU: | |
9381 | +case 0xFFFFFFFFFFFFFD7FLLU: | |
7628 | 9382 | /* SP = 12LLU */fputs(" returns ", stderr); |
7629 | 9383 | { |
7630 | 9384 | /* CALLBEGIN */ |
@@ -7636,15 +9390,15 @@ | ||
7636 | 9390 | { |
7637 | 9391 | /*CALLEND*/ |
7638 | 9392 | 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); } | |
7642 | 9396 | break; |
7643 | 9397 | } |
7644 | -case 0xFFFFFFFFFFFFFDFFLLU: | |
9398 | +case 0xFFFFFFFFFFFFFD7ELLU: | |
7645 | 9399 | /* 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 */ | |
7648 | 9402 | { |
7649 | 9403 | /* CALLBEGIN */ |
7650 | 9404 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 13LLU */ |
@@ -7651,176 +9405,215 @@ | ||
7651 | 9405 | { /* PUSH */ stack[stackbase + 13LLU] = stackbase; }/* SP + 1LLU = 14LLU */ |
7652 | 9406 | /* leave place for return addr *//* SP + 1LLU = 15LLU */ |
7653 | 9407 | } |
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 */ | |
7655 | 9410 | { |
7656 | 9411 | /*CALLEND*/ |
7657 | 9412 | 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; | |
7659 | 9452 | fnaddr = /*CALLBEGIN_*/0xC130C0851C93800LLU;/* SP = 0LLU */ |
7660 | 9453 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*CALLBEGIN_*/\n"); exit(-1); } |
7661 | 9454 | break; |
7662 | 9455 | } |
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 */ | |
7668 | 9462 | |
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 | + | |
7669 | 9467 | { |
7670 | 9468 | /* 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 */ | |
7674 | 9472 | } |
7675 | 9473 | { |
7676 | 9474 | /* 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 */ | |
7680 | 9478 | } |
7681 | -{ /* PUSH */ stack[stackbase + 21LLU] = 41LLU; }/* SP + 1LLU = 22LLU *//* SPMAX = 22LLU */ | |
9479 | +{ /* PUSH */ stack[stackbase + 22LLU] = 41LLU; }/* SP + 1LLU = 23LLU *//* SPMAX = 23LLU */ | |
7682 | 9480 | { |
7683 | 9481 | /*CALLEND*/ |
7684 | - stackbase += 21LLU; | |
7685 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFBLLU; | |
9482 | + stackbase += 22LLU; | |
9483 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD76LLU; | |
7686 | 9484 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
7687 | 9485 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
7688 | 9486 | break; |
7689 | 9487 | } |
7690 | -case 0xFFFFFFFFFFFFFDFBLLU: | |
7691 | -/* SP = 19LLU */ | |
9488 | +case 0xFFFFFFFFFFFFFD76LLU: | |
9489 | +/* SP = 20LLU */ | |
7692 | 9490 | { |
7693 | 9491 | /*CALLEND*/ |
7694 | - stackbase += 18LLU; | |
7695 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFALLU; | |
9492 | + stackbase += 19LLU; | |
9493 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD75LLU; | |
7696 | 9494 | fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */ |
7697 | 9495 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); } |
7698 | 9496 | break; |
7699 | 9497 | } |
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 */ | |
7704 | 9502 | /* loop */ |
7705 | 9503 | { |
7706 | 9504 | /* 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 */ | |
7710 | 9508 | } |
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 */ | |
7713 | 9511 | { |
7714 | 9512 | /*CALLEND*/ |
7715 | - stackbase += 18LLU; | |
7716 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF9LLU; | |
9513 | + stackbase += 19LLU; | |
9514 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD74LLU; | |
7717 | 9515 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
7718 | 9516 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
7719 | 9517 | break; |
7720 | 9518 | } |
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 */ | |
7723 | 9521 | |
7724 | 9522 | { |
7725 | 9523 | /* 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 */ | |
7729 | 9527 | } |
7730 | 9528 | { |
7731 | 9529 | /*CALLEND*/ |
7732 | - stackbase += 17LLU; | |
7733 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF8LLU; | |
9530 | + stackbase += 18LLU; | |
9531 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD73LLU; | |
7734 | 9532 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
7735 | 9533 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
7736 | 9534 | break; |
7737 | 9535 | } |
7738 | -case 0xFFFFFFFFFFFFFDF8LLU: | |
7739 | -/* SP = 15LLU */ | |
9536 | +case 0xFFFFFFFFFFFFFD73LLU: | |
9537 | +/* SP = 16LLU */ | |
7740 | 9538 | { |
7741 | 9539 | /* 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 */ | |
7745 | 9543 | } |
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 */ | |
7749 | 9547 | { |
7750 | 9548 | /*CALLEND*/ |
7751 | - stackbase += 18LLU; | |
7752 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF7LLU; | |
9549 | + stackbase += 20LLU; | |
9550 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD72LLU; | |
7753 | 9551 | fnaddr = /*getdefpart*/0x8A0BDF821ADCB6F0LLU;/* SP = 0LLU */ |
7754 | 9552 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*getdefpart*/\n"); exit(-1); } |
7755 | 9553 | break; |
7756 | 9554 | } |
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 */ | |
7759 | 9559 | { |
7760 | 9560 | /* 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 */ | |
7764 | 9564 | } |
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 */ | |
7768 | 9568 | { |
7769 | 9569 | /* 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 */ | |
7773 | 9573 | } |
7774 | 9574 | { |
7775 | 9575 | /*CALLEND*/ |
7776 | - stackbase += 24LLU; | |
7777 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF6LLU; | |
9576 | + stackbase += 28LLU; | |
9577 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD71LLU; | |
7778 | 9578 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
7779 | 9579 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
7780 | 9580 | break; |
7781 | 9581 | } |
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 */ | |
7786 | 9586 | { |
7787 | 9587 | /*CALLEND*/ |
7788 | - stackbase += 18LLU; | |
7789 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF5LLU; | |
9588 | + stackbase += 22LLU; | |
9589 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD70LLU; | |
7790 | 9590 | fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */ |
7791 | 9591 | if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); } |
7792 | 9592 | break; |
7793 | 9593 | } |
7794 | -case 0xFFFFFFFFFFFFFDF5LLU: | |
7795 | -/* SP = 16LLU */ | |
9594 | +case 0xFFFFFFFFFFFFFD70LLU: | |
9595 | +/* SP = 20LLU */ | |
7796 | 9596 | { |
7797 | 9597 | /* 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 */ | |
7801 | 9601 | } |
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 */ | |
7804 | 9604 | { |
7805 | 9605 | /*CALLEND*/ |
7806 | - stackbase += 19LLU; | |
7807 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF4LLU; | |
9606 | + stackbase += 23LLU; | |
9607 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6FLLU; | |
7808 | 9608 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
7809 | 9609 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
7810 | 9610 | break; |
7811 | 9611 | } |
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 */ | |
7814 | 9614 | |
7815 | 9615 | { |
7816 | 9616 | /* 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 */ | |
7824 | 9617 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 21LLU */ |
7825 | 9618 | { /* PUSH */ stack[stackbase + 21LLU] = stackbase; }/* SP + 1LLU = 22LLU */ |
7826 | 9619 | /* leave place for return addr *//* SP + 1LLU = 23LLU */ |
@@ -7827,198 +9620,228 @@ | ||
7827 | 9620 | } |
7828 | 9621 | { /* PUSH */ stack[stackbase + 23LLU] = /* LOCAL VAR */ stack[stackbase + 15LLU]; }/* SP + 1LLU = 24LLU */ |
7829 | 9622 | { |
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 | + { | |
7830 | 9631 | /*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); } | |
7835 | 9636 | break; |
7836 | 9637 | } |
7837 | -case 0xFFFFFFFFFFFFFDF3LLU: | |
7838 | -/* SP = 21LLU */ | |
9638 | +case 0xFFFFFFFFFFFFFD6ELLU: | |
9639 | +/* SP = 25LLU */ | |
7839 | 9640 | { |
7840 | 9641 | /*CALLEND*/ |
7841 | - stackbase += 19LLU; | |
7842 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF2LLU; | |
9642 | + stackbase += 23LLU; | |
9643 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6DLLU; | |
7843 | 9644 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
7844 | 9645 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
7845 | 9646 | break; |
7846 | 9647 | } |
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 */ | |
7849 | 9650 | |
7850 | 9651 | { |
7851 | 9652 | /* 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 */ | |
7855 | 9656 | } |
7856 | 9657 | { |
7857 | 9658 | /*CALLEND*/ |
7858 | - stackbase += 18LLU; | |
7859 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF1LLU; | |
9659 | + stackbase += 22LLU; | |
9660 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6CLLU; | |
7860 | 9661 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
7861 | 9662 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
7862 | 9663 | break; |
7863 | 9664 | } |
7864 | -case 0xFFFFFFFFFFFFFDF1LLU: | |
7865 | -/* SP = 16LLU *//* predicate */ | |
9665 | +case 0xFFFFFFFFFFFFFD6CLLU: | |
9666 | +/* SP = 20LLU *//* predicate */ | |
7866 | 9667 | |
7867 | 9668 | { |
7868 | 9669 | /* 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 */ | |
7872 | 9673 | } |
7873 | -{ /* PUSH */ stack[stackbase + 19LLU] = 44LLU; }/* SP + 1LLU = 20LLU */ | |
9674 | +{ /* PUSH */ stack[stackbase + 23LLU] = 44LLU; }/* SP + 1LLU = 24LLU */ | |
7874 | 9675 | { |
7875 | 9676 | /*CALLEND*/ |
7876 | - stackbase += 19LLU; | |
7877 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEFLLU; | |
9677 | + stackbase += 23LLU; | |
9678 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6ALLU; | |
7878 | 9679 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
7879 | 9680 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
7880 | 9681 | break; |
7881 | 9682 | } |
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 */ | |
7886 | 9687 | /* consequent */ |
7887 | 9688 | { |
7888 | 9689 | /* 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 */ | |
7892 | 9693 | } |
7893 | 9694 | { |
7894 | 9695 | /*CALLEND*/ |
7895 | - stackbase += 18LLU; | |
7896 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEELLU; | |
9696 | + stackbase += 22LLU; | |
9697 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD69LLU; | |
7897 | 9698 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
7898 | 9699 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
7899 | 9700 | break; |
7900 | 9701 | } |
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 */ | |
7906 | 9707 | |
7907 | 9708 | { |
7908 | 9709 | /* 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 */ | |
7912 | 9713 | } |
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 */ | |
7915 | 9716 | { |
7916 | 9717 | /*CALLEND*/ |
7917 | - stackbase += 18LLU; | |
7918 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDECLLU; | |
9718 | + stackbase += 19LLU; | |
9719 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD67LLU; | |
7919 | 9720 | fnaddr = /*neq_______*/0xA60B000000000000LLU;/* SP = 0LLU */ |
7920 | 9721 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*neq_______*/\n"); exit(-1); } |
7921 | 9722 | break; |
7922 | 9723 | } |
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 */ | |
7927 | 9728 | /* consequent */ |
7928 | 9729 | { |
7929 | 9730 | /* 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 */ | |
7933 | 9734 | } |
7934 | 9735 | { |
7935 | 9736 | /*CALLEND*/ |
7936 | - stackbase += 17LLU; | |
7937 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEBLLU; | |
9737 | + stackbase += 18LLU; | |
9738 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD66LLU; | |
7938 | 9739 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
7939 | 9740 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
7940 | 9741 | break; |
7941 | 9742 | } |
7942 | -case 0xFFFFFFFFFFFFFDEBLLU: | |
7943 | -/* SP = 15LLU */fputs("call to ", stderr); | |
9743 | +case 0xFFFFFFFFFFFFFD66LLU: | |
9744 | +/* SP = 16LLU */fputs("call to ", stderr); | |
7944 | 9745 | { |
7945 | 9746 | /* 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 */ | |
7949 | 9750 | } |
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 */ | |
7951 | 9752 | { |
7952 | 9753 | /*CALLEND*/ |
7953 | - stackbase += 17LLU; | |
7954 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEALLU; | |
9754 | + stackbase += 18LLU; | |
9755 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD65LLU; | |
7955 | 9756 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
7956 | 9757 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
7957 | 9758 | break; |
7958 | 9759 | } |
7959 | -case 0xFFFFFFFFFFFFFDEALLU: | |
7960 | -/* SP = 15LLU */fputs(" argument-count ", stderr); | |
9760 | +case 0xFFFFFFFFFFFFFD65LLU: | |
9761 | +/* SP = 16LLU */fputs(" argument-count ", stderr); | |
7961 | 9762 | { |
7962 | 9763 | /* 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 */ | |
7966 | 9767 | } |
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 */ | |
7968 | 9769 | { |
7969 | 9770 | /*CALLEND*/ |
7970 | - stackbase += 17LLU; | |
7971 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE9LLU; | |
9771 | + stackbase += 18LLU; | |
9772 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD64LLU; | |
7972 | 9773 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
7973 | 9774 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
7974 | 9775 | break; |
7975 | 9776 | } |
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); | |
7978 | 9779 | { |
7979 | 9780 | /* 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 */ | |
7983 | 9784 | } |
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 */ | |
7985 | 9786 | { |
7986 | 9787 | /*CALLEND*/ |
7987 | - stackbase += 17LLU; | |
7988 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE8LLU; | |
9788 | + stackbase += 18LLU; | |
9789 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD63LLU; | |
7989 | 9790 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
7990 | 9791 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
7991 | 9792 | break; |
7992 | 9793 | } |
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 | + | |
7996 | 9798 | { |
7997 | 9799 | /* 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 */ | |
8001 | 9803 | } |
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 */ | |
8006 | 9805 | { |
8007 | 9806 | /*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; | |
8010 | 9832 | fnaddr = /*CALLEND___*/0xC130C14E1000000LLU;/* SP = 0LLU */ |
8011 | 9833 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*CALLEND___*/\n"); exit(-1); } |
8012 | 9834 | break; |
8013 | 9835 | } |
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 */ | |
8017 | 9840 | /* SP = 9LLU */ |
8018 | -case 18446744073709551117LLU: /* skip to here */ | |
9841 | +case 18446744073709550987LLU: /* skip to here */ | |
8019 | 9842 | /* 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 */ | |
8022 | 9845 | |
8023 | 9846 | { |
8024 | 9847 | /* CALLBEGIN */ |
@@ -8031,15 +9854,15 @@ | ||
8031 | 9854 | { |
8032 | 9855 | /*CALLEND*/ |
8033 | 9856 | stackbase += 9LLU; |
8034 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE4LLU; | |
9857 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5DLLU; | |
8035 | 9858 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
8036 | 9859 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
8037 | 9860 | break; |
8038 | 9861 | } |
8039 | -case 0xFFFFFFFFFFFFFDE4LLU: | |
9862 | +case 0xFFFFFFFFFFFFFD5DLLU: | |
8040 | 9863 | /* SP = 7LLU */ |
8041 | 9864 | if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]) |
8042 | -{ /* JUMP */ fnaddr = 18446744073709551078LLU; break; } /* skip consequent */ | |
9865 | +{ /* JUMP */ fnaddr = 18446744073709550943LLU; break; } /* skip consequent */ | |
8043 | 9866 | /* consequent */ |
8044 | 9867 | { |
8045 | 9868 | /* CALLBEGIN */ |
@@ -8050,12 +9873,12 @@ | ||
8050 | 9873 | { |
8051 | 9874 | /*CALLEND*/ |
8052 | 9875 | stackbase += 9LLU; |
8053 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE3LLU; | |
9876 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5CLLU; | |
8054 | 9877 | fnaddr = /*ADDRNEXT__*/0x441123856140000LLU;/* SP = 0LLU */ |
8055 | 9878 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRNEXT__*/\n"); exit(-1); } |
8056 | 9879 | break; |
8057 | 9880 | } |
8058 | -case 0xFFFFFFFFFFFFFDE3LLU: | |
9881 | +case 0xFFFFFFFFFFFFFD5CLLU: | |
8059 | 9882 | /* SP = 7LLU */(void)/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU]; /* POP */ |
8060 | 9883 | |
8061 | 9884 | { |
@@ -8067,12 +9890,12 @@ | ||
8067 | 9890 | { |
8068 | 9891 | /*CALLEND*/ |
8069 | 9892 | stackbase += 9LLU; |
8070 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE2LLU; | |
9893 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5BLLU; | |
8071 | 9894 | fnaddr = /*ADDRNEXT__*/0x441123856140000LLU;/* SP = 0LLU */ |
8072 | 9895 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ADDRNEXT__*/\n"); exit(-1); } |
8073 | 9896 | break; |
8074 | 9897 | } |
8075 | -case 0xFFFFFFFFFFFFFDE2LLU: | |
9898 | +case 0xFFFFFFFFFFFFFD5BLLU: | |
8076 | 9899 | /* SP = 7LLU */ |
8077 | 9900 | { |
8078 | 9901 | /* CALLBEGIN */ |
@@ -8083,12 +9906,12 @@ | ||
8083 | 9906 | { |
8084 | 9907 | /*CALLEND*/ |
8085 | 9908 | stackbase += 9LLU; |
8086 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE1LLU; | |
9909 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5ALLU; | |
8087 | 9910 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8088 | 9911 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8089 | 9912 | break; |
8090 | 9913 | } |
8091 | -case 0xFFFFFFFFFFFFFDE1LLU: | |
9914 | +case 0xFFFFFFFFFFFFFD5ALLU: | |
8092 | 9915 | /* SP = 7LLU */fputs("/* predicate */\n", stdout); |
8093 | 9916 | { |
8094 | 9917 | /* CALLBEGIN */ |
@@ -8099,12 +9922,12 @@ | ||
8099 | 9922 | { |
8100 | 9923 | /*CALLEND*/ |
8101 | 9924 | stackbase += 9LLU; |
8102 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE0LLU; | |
9925 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD59LLU; | |
8103 | 9926 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8104 | 9927 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8105 | 9928 | break; |
8106 | 9929 | } |
8107 | -case 0xFFFFFFFFFFFFFDE0LLU: | |
9930 | +case 0xFFFFFFFFFFFFFD59LLU: | |
8108 | 9931 | /* SP = 7LLU */ |
8109 | 9932 | { |
8110 | 9933 | /* CALLBEGIN */ |
@@ -8124,12 +9947,12 @@ | ||
8124 | 9947 | { |
8125 | 9948 | /*CALLEND*/ |
8126 | 9949 | stackbase += 15LLU; |
8127 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDFLLU; | |
9950 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD58LLU; | |
8128 | 9951 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
8129 | 9952 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
8130 | 9953 | break; |
8131 | 9954 | } |
8132 | -case 0xFFFFFFFFFFFFFDDFLLU: | |
9955 | +case 0xFFFFFFFFFFFFFD58LLU: | |
8133 | 9956 | /* SP = 13LLU */ |
8134 | 9957 | { |
8135 | 9958 | /* CALLBEGIN */ |
@@ -8141,23 +9964,23 @@ | ||
8141 | 9964 | { |
8142 | 9965 | /*CALLEND*/ |
8143 | 9966 | stackbase += 16LLU; |
8144 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDELLU; | |
9967 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD57LLU; | |
8145 | 9968 | fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */ |
8146 | 9969 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); } |
8147 | 9970 | break; |
8148 | 9971 | } |
8149 | -case 0xFFFFFFFFFFFFFDDELLU: | |
9972 | +case 0xFFFFFFFFFFFFFD57LLU: | |
8150 | 9973 | /* SP = 14LLU */ |
8151 | 9974 | { /* PUSH */ stack[stackbase + 14LLU] = 0LLU; }/* SP + 1LLU = 15LLU */ |
8152 | 9975 | { |
8153 | 9976 | /*CALLEND*/ |
8154 | 9977 | stackbase += 9LLU; |
8155 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDDLLU; | |
9978 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD56LLU; | |
8156 | 9979 | fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */ |
8157 | 9980 | if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); } |
8158 | 9981 | break; |
8159 | 9982 | } |
8160 | -case 0xFFFFFFFFFFFFFDDDLLU: | |
9983 | +case 0xFFFFFFFFFFFFFD56LLU: | |
8161 | 9984 | /* SP = 7LLU */fputs("\nif(!", stdout); |
8162 | 9985 | { |
8163 | 9986 | /* CALLBEGIN */ |
@@ -8168,12 +9991,12 @@ | ||
8168 | 9991 | { |
8169 | 9992 | /*CALLEND*/ |
8170 | 9993 | stackbase += 9LLU; |
8171 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDCLLU; | |
9994 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD55LLU; | |
8172 | 9995 | fnaddr = /*POP_START_*/0x40F4004D40525000LLU;/* SP = 0LLU */ |
8173 | 9996 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_START_*/\n"); exit(-1); } |
8174 | 9997 | break; |
8175 | 9998 | } |
8176 | -case 0xFFFFFFFFFFFFFDDCLLU: | |
9999 | +case 0xFFFFFFFFFFFFFD55LLU: | |
8177 | 10000 | /* SP = 7LLU */fputs(")", stdout); |
8178 | 10001 | { |
8179 | 10002 | /* CALLBEGIN */ |
@@ -8184,12 +10007,12 @@ | ||
8184 | 10007 | { |
8185 | 10008 | /*CALLEND*/ |
8186 | 10009 | stackbase += 9LLU; |
8187 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDBLLU; | |
10010 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD54LLU; | |
8188 | 10011 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8189 | 10012 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8190 | 10013 | break; |
8191 | 10014 | } |
8192 | -case 0xFFFFFFFFFFFFFDDBLLU: | |
10015 | +case 0xFFFFFFFFFFFFFD54LLU: | |
8193 | 10016 | /* SP = 7LLU *//* predicate */ |
8194 | 10017 | |
8195 | 10018 | { |
@@ -8208,25 +10031,25 @@ | ||
8208 | 10031 | { |
8209 | 10032 | /*CALLEND*/ |
8210 | 10033 | stackbase += 14LLU; |
8211 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD8LLU; | |
10034 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD51LLU; | |
8212 | 10035 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
8213 | 10036 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
8214 | 10037 | break; |
8215 | 10038 | } |
8216 | -case 0xFFFFFFFFFFFFFDD8LLU: | |
10039 | +case 0xFFFFFFFFFFFFFD51LLU: | |
8217 | 10040 | /* SP = 12LLU */ |
8218 | 10041 | { |
8219 | 10042 | /*CALLEND*/ |
8220 | 10043 | stackbase += 10LLU; |
8221 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD7LLU; | |
10044 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD50LLU; | |
8222 | 10045 | fnaddr = /*equ_______*/0x82CC000000000000LLU;/* SP = 0LLU */ |
8223 | 10046 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*equ_______*/\n"); exit(-1); } |
8224 | 10047 | break; |
8225 | 10048 | } |
8226 | -case 0xFFFFFFFFFFFFFDD7LLU: | |
10049 | +case 0xFFFFFFFFFFFFFD50LLU: | |
8227 | 10050 | /* SP = 8LLU */ |
8228 | 10051 | if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU]) |
8229 | -{ /* JUMP */ fnaddr = 18446744073709551066LLU; break; } /* skip consequent */ | |
10052 | +{ /* JUMP */ fnaddr = 18446744073709550931LLU; break; } /* skip consequent */ | |
8230 | 10053 | /* consequent */ |
8231 | 10054 | { |
8232 | 10055 | /* CALLBEGIN */ |
@@ -8245,22 +10068,22 @@ | ||
8245 | 10068 | { |
8246 | 10069 | /*CALLEND*/ |
8247 | 10070 | stackbase += 12LLU; |
8248 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD6LLU; | |
10071 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4FLLU; | |
8249 | 10072 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
8250 | 10073 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
8251 | 10074 | break; |
8252 | 10075 | } |
8253 | -case 0xFFFFFFFFFFFFFDD6LLU: | |
10076 | +case 0xFFFFFFFFFFFFFD4FLLU: | |
8254 | 10077 | /* SP = 10LLU */ |
8255 | 10078 | { |
8256 | 10079 | /*CALLEND*/ |
8257 | 10080 | stackbase += 9LLU; |
8258 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD5LLU; | |
10081 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4ELLU; | |
8259 | 10082 | fnaddr = /*JUMP______*/0x2953500000000000LLU;/* SP = 0LLU */ |
8260 | 10083 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*JUMP______*/\n"); exit(-1); } |
8261 | 10084 | break; |
8262 | 10085 | } |
8263 | -case 0xFFFFFFFFFFFFFDD5LLU: | |
10086 | +case 0xFFFFFFFFFFFFFD4ELLU: | |
8264 | 10087 | /* SP = 7LLU */fputs(" /* skip consequent */", stdout); fputs("\n/* consequent */", stdout); |
8265 | 10088 | { |
8266 | 10089 | /* CALLBEGIN */ |
@@ -8271,12 +10094,12 @@ | ||
8271 | 10094 | { |
8272 | 10095 | /*CALLEND*/ |
8273 | 10096 | stackbase += 10LLU; |
8274 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD4LLU; | |
10097 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4DLLU; | |
8275 | 10098 | fnaddr = /*SP_GET____*/0x4D00071540000000LLU;/* SP = 0LLU */ |
8276 | 10099 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_GET____*/\n"); exit(-1); } |
8277 | 10100 | break; |
8278 | 10101 | } |
8279 | -case 0xFFFFFFFFFFFFFDD4LLU: | |
10102 | +case 0xFFFFFFFFFFFFFD4DLLU: | |
8280 | 10103 | /* SP = 8LLU */ |
8281 | 10104 | { |
8282 | 10105 | /* CALLBEGIN */ |
@@ -8287,12 +10110,12 @@ | ||
8287 | 10110 | { |
8288 | 10111 | /*CALLEND*/ |
8289 | 10112 | stackbase += 10LLU; |
8290 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD3LLU; | |
10113 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4CLLU; | |
8291 | 10114 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8292 | 10115 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8293 | 10116 | break; |
8294 | 10117 | } |
8295 | -case 0xFFFFFFFFFFFFFDD3LLU: | |
10118 | +case 0xFFFFFFFFFFFFFD4CLLU: | |
8296 | 10119 | /* SP = 8LLU */ |
8297 | 10120 | { |
8298 | 10121 | /* CALLBEGIN */ |
@@ -8312,12 +10135,12 @@ | ||
8312 | 10135 | { |
8313 | 10136 | /*CALLEND*/ |
8314 | 10137 | stackbase += 16LLU; |
8315 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD2LLU; | |
10138 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4BLLU; | |
8316 | 10139 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
8317 | 10140 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
8318 | 10141 | break; |
8319 | 10142 | } |
8320 | -case 0xFFFFFFFFFFFFFDD2LLU: | |
10143 | +case 0xFFFFFFFFFFFFFD4BLLU: | |
8321 | 10144 | /* SP = 14LLU */ |
8322 | 10145 | { /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 15LLU */ |
8323 | 10146 | { /* PUSH */ stack[stackbase + 15LLU] = 0LLU; }/* SP + 1LLU = 16LLU */ |
@@ -8324,12 +10147,12 @@ | ||
8324 | 10147 | { |
8325 | 10148 | /*CALLEND*/ |
8326 | 10149 | stackbase += 10LLU; |
8327 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD1LLU; | |
10150 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4ALLU; | |
8328 | 10151 | fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */ |
8329 | 10152 | if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); } |
8330 | 10153 | break; |
8331 | 10154 | } |
8332 | -case 0xFFFFFFFFFFFFFDD1LLU: | |
10155 | +case 0xFFFFFFFFFFFFFD4ALLU: | |
8333 | 10156 | /* SP = 8LLU */ |
8334 | 10157 | { |
8335 | 10158 | /* CALLBEGIN */ |
@@ -8341,12 +10164,12 @@ | ||
8341 | 10164 | { |
8342 | 10165 | /*CALLEND*/ |
8343 | 10166 | stackbase += 10LLU; |
8344 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD0LLU; | |
10167 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD49LLU; | |
8345 | 10168 | fnaddr = /*SP_SET____*/0x4D00131540000000LLU;/* SP = 0LLU */ |
8346 | 10169 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*SP_SET____*/\n"); exit(-1); } |
8347 | 10170 | break; |
8348 | 10171 | } |
8349 | -case 0xFFFFFFFFFFFFFDD0LLU: | |
10172 | +case 0xFFFFFFFFFFFFFD49LLU: | |
8350 | 10173 | /* SP = 8LLU */ |
8351 | 10174 | { |
8352 | 10175 | /* CALLBEGIN */ |
@@ -8358,12 +10181,12 @@ | ||
8358 | 10181 | { |
8359 | 10182 | /*CALLEND*/ |
8360 | 10183 | stackbase += 10LLU; |
8361 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCFLLU; | |
10184 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD48LLU; | |
8362 | 10185 | fnaddr = /*JUMP______*/0x2953500000000000LLU;/* SP = 0LLU */ |
8363 | 10186 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*JUMP______*/\n"); exit(-1); } |
8364 | 10187 | break; |
8365 | 10188 | } |
8366 | -case 0xFFFFFFFFFFFFFDCFLLU: | |
10189 | +case 0xFFFFFFFFFFFFFD48LLU: | |
8367 | 10190 | /* SP = 8LLU */fputs(" /* skip alternative */", stdout); fputs("\ncase ", stdout); |
8368 | 10191 | { |
8369 | 10192 | /* CALLBEGIN */ |
@@ -8382,22 +10205,22 @@ | ||
8382 | 10205 | { |
8383 | 10206 | /*CALLEND*/ |
8384 | 10207 | stackbase += 13LLU; |
8385 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCELLU; | |
10208 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD47LLU; | |
8386 | 10209 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
8387 | 10210 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
8388 | 10211 | break; |
8389 | 10212 | } |
8390 | -case 0xFFFFFFFFFFFFFDCELLU: | |
10213 | +case 0xFFFFFFFFFFFFFD47LLU: | |
8391 | 10214 | /* SP = 11LLU */ |
8392 | 10215 | { |
8393 | 10216 | /*CALLEND*/ |
8394 | 10217 | stackbase += 10LLU; |
8395 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCDLLU; | |
10218 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD46LLU; | |
8396 | 10219 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
8397 | 10220 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
8398 | 10221 | break; |
8399 | 10222 | } |
8400 | -case 0xFFFFFFFFFFFFFDCDLLU: | |
10223 | +case 0xFFFFFFFFFFFFFD46LLU: | |
8401 | 10224 | /* SP = 8LLU */fputs(": /* alternative */", stdout); |
8402 | 10225 | { |
8403 | 10226 | /* CALLBEGIN */ |
@@ -8408,12 +10231,12 @@ | ||
8408 | 10231 | { |
8409 | 10232 | /*CALLEND*/ |
8410 | 10233 | stackbase += 10LLU; |
8411 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCCLLU; | |
10234 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD45LLU; | |
8412 | 10235 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8413 | 10236 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8414 | 10237 | break; |
8415 | 10238 | } |
8416 | -case 0xFFFFFFFFFFFFFDCCLLU: | |
10239 | +case 0xFFFFFFFFFFFFFD45LLU: | |
8417 | 10240 | /* SP = 8LLU *//* predicate */ |
8418 | 10241 | |
8419 | 10242 | { |
@@ -8426,15 +10249,15 @@ | ||
8426 | 10249 | { |
8427 | 10250 | /*CALLEND*/ |
8428 | 10251 | stackbase += 11LLU; |
8429 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC9LLU; | |
10252 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD42LLU; | |
8430 | 10253 | fnaddr = /*matchoptid*/0xA1CBDE8EAAEF91F0LLU;/* SP = 0LLU */ |
8431 | 10254 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchoptid*/\n"); exit(-1); } |
8432 | 10255 | break; |
8433 | 10256 | } |
8434 | -case 0xFFFFFFFFFFFFFDC9LLU: | |
10257 | +case 0xFFFFFFFFFFFFFD42LLU: | |
8435 | 10258 | /* SP = 9LLU */ |
8436 | 10259 | if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU]) |
8437 | -{ /* JUMP */ fnaddr = 18446744073709551051LLU; break; } /* skip consequent */ | |
10260 | +{ /* JUMP */ fnaddr = 18446744073709550916LLU; break; } /* skip consequent */ | |
8438 | 10261 | /* consequent */ |
8439 | 10262 | { |
8440 | 10263 | /* CALLBEGIN */ |
@@ -8445,12 +10268,12 @@ | ||
8445 | 10268 | { |
8446 | 10269 | /*CALLEND*/ |
8447 | 10270 | stackbase += 10LLU; |
8448 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC8LLU; | |
10271 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD41LLU; | |
8449 | 10272 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8450 | 10273 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8451 | 10274 | break; |
8452 | 10275 | } |
8453 | -case 0xFFFFFFFFFFFFFDC8LLU: | |
10276 | +case 0xFFFFFFFFFFFFFD41LLU: | |
8454 | 10277 | /* SP = 8LLU */ |
8455 | 10278 | { |
8456 | 10279 | /* CALLBEGIN */ |
@@ -8470,12 +10293,12 @@ | ||
8470 | 10293 | { |
8471 | 10294 | /*CALLEND*/ |
8472 | 10295 | stackbase += 16LLU; |
8473 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC7LLU; | |
10296 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD40LLU; | |
8474 | 10297 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
8475 | 10298 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
8476 | 10299 | break; |
8477 | 10300 | } |
8478 | -case 0xFFFFFFFFFFFFFDC7LLU: | |
10301 | +case 0xFFFFFFFFFFFFFD40LLU: | |
8479 | 10302 | /* SP = 14LLU */ |
8480 | 10303 | { /* PUSH */ stack[stackbase + 14LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 15LLU */ |
8481 | 10304 | { /* PUSH */ stack[stackbase + 15LLU] = 0LLU; }/* SP + 1LLU = 16LLU */ |
@@ -8482,12 +10305,12 @@ | ||
8482 | 10305 | { |
8483 | 10306 | /*CALLEND*/ |
8484 | 10307 | stackbase += 10LLU; |
8485 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC6LLU; | |
10308 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3FLLU; | |
8486 | 10309 | fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */ |
8487 | 10310 | if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); } |
8488 | 10311 | break; |
8489 | 10312 | } |
8490 | -case 0xFFFFFFFFFFFFFDC6LLU: | |
10313 | +case 0xFFFFFFFFFFFFFD3FLLU: | |
8491 | 10314 | /* SP = 8LLU */fputs("\ncase ", stdout); |
8492 | 10315 | { |
8493 | 10316 | /* CALLBEGIN */ |
@@ -8499,15 +10322,15 @@ | ||
8499 | 10322 | { |
8500 | 10323 | /*CALLEND*/ |
8501 | 10324 | stackbase += 10LLU; |
8502 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC5LLU; | |
10325 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3ELLU; | |
8503 | 10326 | fnaddr = /*printnr___*/0xAED929BE9B400000LLU;/* SP = 0LLU */ |
8504 | 10327 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*printnr___*/\n"); exit(-1); } |
8505 | 10328 | break; |
8506 | 10329 | } |
8507 | -case 0xFFFFFFFFFFFFFDC5LLU: | |
10330 | +case 0xFFFFFFFFFFFFFD3ELLU: | |
8508 | 10331 | /* 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 */ | |
8511 | 10334 | { |
8512 | 10335 | /* CALLBEGIN */ |
8513 | 10336 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 8LLU */ |
@@ -8517,17 +10340,17 @@ | ||
8517 | 10340 | { |
8518 | 10341 | /*CALLEND*/ |
8519 | 10342 | stackbase += 10LLU; |
8520 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC4LLU; | |
10343 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3DLLU; | |
8521 | 10344 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
8522 | 10345 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
8523 | 10346 | break; |
8524 | 10347 | } |
8525 | -case 0xFFFFFFFFFFFFFDC4LLU: | |
10348 | +case 0xFFFFFFFFFFFFFD3DLLU: | |
8526 | 10349 | /* SP = 8LLU */fputs("missing keyword \"else\"\n", stderr); exit(-1);/* SP = 8LLU */ |
8527 | -case 18446744073709551050LLU: /* skip to here */ | |
10350 | +case 18446744073709550915LLU: /* skip to here */ | |
8528 | 10351 | /* 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 */ | |
8531 | 10354 | { |
8532 | 10355 | /* CALLBEGIN */ |
8533 | 10356 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 7LLU */ |
@@ -8537,17 +10360,17 @@ | ||
8537 | 10360 | { |
8538 | 10361 | /*CALLEND*/ |
8539 | 10362 | stackbase += 9LLU; |
8540 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC3LLU; | |
10363 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3CLLU; | |
8541 | 10364 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
8542 | 10365 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
8543 | 10366 | break; |
8544 | 10367 | } |
8545 | -case 0xFFFFFFFFFFFFFDC3LLU: | |
10368 | +case 0xFFFFFFFFFFFFFD3CLLU: | |
8546 | 10369 | /* SP = 7LLU */fputs("missing keyword \"then\"\n", stderr); exit(-1);/* SP = 7LLU */ |
8547 | -case 18446744073709551065LLU: /* skip to here */ | |
10370 | +case 18446744073709550930LLU: /* skip to here */ | |
8548 | 10371 | /* 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 */ | |
8551 | 10374 | { |
8552 | 10375 | /* CALLBEGIN */ |
8553 | 10376 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 7LLU */ |
@@ -8559,12 +10382,12 @@ | ||
8559 | 10382 | { |
8560 | 10383 | /*CALLEND*/ |
8561 | 10384 | stackbase += 9LLU; |
8562 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC2LLU; | |
10385 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3BLLU; | |
8563 | 10386 | fnaddr = /*findvaro__*/0x864A5FC5CB6A0000LLU;/* SP = 0LLU */ |
8564 | 10387 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvaro__*/\n"); exit(-1); } |
8565 | 10388 | break; |
8566 | 10389 | } |
8567 | -case 0xFFFFFFFFFFFFFDC2LLU: | |
10390 | +case 0xFFFFFFFFFFFFFD3BLLU: | |
8568 | 10391 | /* SP = 7LLU */ |
8569 | 10392 | { |
8570 | 10393 | /* CALLBEGIN */ |
@@ -8577,12 +10400,12 @@ | ||
8577 | 10400 | { |
8578 | 10401 | /*CALLEND*/ |
8579 | 10402 | stackbase += 10LLU; |
8580 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC1LLU; | |
10403 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3ALLU; | |
8581 | 10404 | fnaddr = /*findvart__*/0x864A5FC5CB6F0000LLU;/* SP = 0LLU */ |
8582 | 10405 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvart__*/\n"); exit(-1); } |
8583 | 10406 | break; |
8584 | 10407 | } |
8585 | -case 0xFFFFFFFFFFFFFDC1LLU: | |
10408 | +case 0xFFFFFFFFFFFFFD3ALLU: | |
8586 | 10409 | /* SP = 8LLU */ |
8587 | 10410 | { |
8588 | 10411 | /* CALLBEGIN */ |
@@ -8595,12 +10418,12 @@ | ||
8595 | 10418 | { |
8596 | 10419 | /*CALLEND*/ |
8597 | 10420 | stackbase += 11LLU; |
8598 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC0LLU; | |
10421 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD39LLU; | |
8599 | 10422 | fnaddr = /*findvarv__*/0x864A5FC5CB710000LLU;/* SP = 0LLU */ |
8600 | 10423 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*findvarv__*/\n"); exit(-1); } |
8601 | 10424 | break; |
8602 | 10425 | } |
8603 | -case 0xFFFFFFFFFFFFFDC0LLU: | |
10426 | +case 0xFFFFFFFFFFFFFD39LLU: | |
8604 | 10427 | /* SP = 9LLU *//* predicate */ |
8605 | 10428 | |
8606 | 10429 | { |
@@ -8613,15 +10436,15 @@ | ||
8613 | 10436 | { |
8614 | 10437 | /*CALLEND*/ |
8615 | 10438 | stackbase += 12LLU; |
8616 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBDLLU; | |
10439 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD36LLU; | |
8617 | 10440 | fnaddr = /*typeisval_*/0xBF4AE092EC5C9C00LLU;/* SP = 0LLU */ |
8618 | 10441 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typeisval_*/\n"); exit(-1); } |
8619 | 10442 | break; |
8620 | 10443 | } |
8621 | -case 0xFFFFFFFFFFFFFDBDLLU: | |
10444 | +case 0xFFFFFFFFFFFFFD36LLU: | |
8622 | 10445 | /* SP = 10LLU */ |
8623 | 10446 | if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU]) |
8624 | -{ /* JUMP */ fnaddr = 18446744073709551039LLU; break; } /* skip consequent */ | |
10447 | +{ /* JUMP */ fnaddr = 18446744073709550904LLU; break; } /* skip consequent */ | |
8625 | 10448 | /* consequent */ |
8626 | 10449 | { |
8627 | 10450 | /* CALLBEGIN */ |
@@ -8629,16 +10452,17 @@ | ||
8629 | 10452 | { /* PUSH */ stack[stackbase + 10LLU] = stackbase; }/* SP + 1LLU = 11LLU */ |
8630 | 10453 | /* leave place for return addr *//* SP + 1LLU = 12LLU */ |
8631 | 10454 | } |
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 */ | |
8633 | 10457 | { |
8634 | 10458 | /*CALLEND*/ |
8635 | 10459 | 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); } | |
8639 | 10463 | break; |
8640 | 10464 | } |
8641 | -case 0xFFFFFFFFFFFFFDBCLLU: | |
10465 | +case 0xFFFFFFFFFFFFFD35LLU: | |
8642 | 10466 | /* SP = 10LLU */ |
8643 | 10467 | { |
8644 | 10468 | /* CALLBEGIN */ |
@@ -8649,12 +10473,12 @@ | ||
8649 | 10473 | { |
8650 | 10474 | /*CALLEND*/ |
8651 | 10475 | stackbase += 12LLU; |
8652 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBBLLU; | |
10476 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD34LLU; | |
8653 | 10477 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8654 | 10478 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8655 | 10479 | break; |
8656 | 10480 | } |
8657 | -case 0xFFFFFFFFFFFFFDBBLLU: | |
10481 | +case 0xFFFFFFFFFFFFFD34LLU: | |
8658 | 10482 | /* SP = 10LLU *//* predicate */ |
8659 | 10483 | |
8660 | 10484 | { |
@@ -8667,31 +10491,193 @@ | ||
8667 | 10491 | { |
8668 | 10492 | /*CALLEND*/ |
8669 | 10493 | stackbase += 13LLU; |
8670 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB9LLU; | |
10494 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD32LLU; | |
8671 | 10495 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
8672 | 10496 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
8673 | 10497 | break; |
8674 | 10498 | } |
8675 | -case 0xFFFFFFFFFFFFFDB9LLU: | |
10499 | +case 0xFFFFFFFFFFFFFD32LLU: | |
8676 | 10500 | /* SP = 11LLU */ |
8677 | 10501 | if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]) |
8678 | -{ /* JUMP */ fnaddr = 18446744073709551034LLU; break; } /* skip consequent */ | |
10502 | +{ /* JUMP */ fnaddr = 18446744073709550899LLU; break; } /* skip consequent */ | |
8679 | 10503 | /* consequent */ |
8680 | 10504 | { |
8681 | 10505 | /* 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 */ | |
8682 | 10523 | /* reserve space for 1LLU returned values *//* SP + 1LLU = 11LLU */ |
8683 | 10524 | { /* PUSH */ stack[stackbase + 11LLU] = stackbase; }/* SP + 1LLU = 12LLU */ |
8684 | 10525 | /* leave place for return addr *//* SP + 1LLU = 13LLU */ |
8685 | 10526 | } |
8686 | 10527 | { |
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 | + { | |
8687 | 10534 | /*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*/ | |
8688 | 10545 | 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; | |
8690 | 10676 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
8691 | 10677 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
8692 | 10678 | break; |
8693 | 10679 | } |
8694 | -case 0xFFFFFFFFFFFFFDB8LLU: | |
10680 | +case 0xFFFFFFFFFFFFFD26LLU: | |
8695 | 10681 | /* SP = 11LLU *//* predicate */ |
8696 | 10682 | |
8697 | 10683 | { |
@@ -8705,15 +10691,15 @@ | ||
8705 | 10691 | { |
8706 | 10692 | /*CALLEND*/ |
8707 | 10693 | stackbase += 14LLU; |
8708 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB5LLU; | |
10694 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD23LLU; | |
8709 | 10695 | fnaddr = /*lss_______*/0x9EEB800000000000LLU;/* SP = 0LLU */ |
8710 | 10696 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*lss_______*/\n"); exit(-1); } |
8711 | 10697 | break; |
8712 | 10698 | } |
8713 | -case 0xFFFFFFFFFFFFFDB5LLU: | |
10699 | +case 0xFFFFFFFFFFFFFD23LLU: | |
8714 | 10700 | /* SP = 12LLU */ |
8715 | 10701 | if(!/* SP - 1LLU = 11LLU */stack[stackbase + 11LLU]) |
8716 | -{ /* JUMP */ fnaddr = 18446744073709551031LLU; break; } /* skip consequent */ | |
10702 | +{ /* JUMP */ fnaddr = 18446744073709550885LLU; break; } /* skip consequent */ | |
8717 | 10703 | /* consequent */ |
8718 | 10704 | { |
8719 | 10705 | /* CALLBEGIN */ |
@@ -8726,12 +10712,12 @@ | ||
8726 | 10712 | { |
8727 | 10713 | /*CALLEND*/ |
8728 | 10714 | stackbase += 14LLU; |
8729 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB4LLU; | |
10715 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD22LLU; | |
8730 | 10716 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
8731 | 10717 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
8732 | 10718 | break; |
8733 | 10719 | } |
8734 | -case 0xFFFFFFFFFFFFFDB4LLU: | |
10720 | +case 0xFFFFFFFFFFFFFD22LLU: | |
8735 | 10721 | /* SP = 12LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 11LLU */stack[stackbase + 11LLU]; /* POP */ |
8736 | 10722 | |
8737 | 10723 | { /* PUSH */ stack[stackbase + 11LLU] = 1LLU; }/* SP + 1LLU = 12LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 11LLU */stack[stackbase + 11LLU]; /* POP */ |
@@ -8746,16 +10732,16 @@ | ||
8746 | 10732 | { |
8747 | 10733 | /*CALLEND*/ |
8748 | 10734 | stackbase += 14LLU; |
8749 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB3LLU; | |
10735 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD21LLU; | |
8750 | 10736 | fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */ |
8751 | 10737 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); } |
8752 | 10738 | break; |
8753 | 10739 | } |
8754 | -case 0xFFFFFFFFFFFFFDB3LLU: | |
10740 | +case 0xFFFFFFFFFFFFFD21LLU: | |
8755 | 10741 | /* SP = 12LLU *//* LOCAL VAR */ stack[stackbase + 7LLU] = /* SP - 1LLU = 11LLU */stack[stackbase + 11LLU]; /* POP */ |
8756 | 10742 | /* 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 */ | |
8759 | 10745 | { |
8760 | 10746 | /* CALLBEGIN */ |
8761 | 10747 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 11LLU */ |
@@ -8765,12 +10751,12 @@ | ||
8765 | 10751 | { |
8766 | 10752 | /*CALLEND*/ |
8767 | 10753 | stackbase += 13LLU; |
8768 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB2LLU; | |
10754 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD20LLU; | |
8769 | 10755 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
8770 | 10756 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
8771 | 10757 | break; |
8772 | 10758 | } |
8773 | -case 0xFFFFFFFFFFFFFDB2LLU: | |
10759 | +case 0xFFFFFFFFFFFFFD20LLU: | |
8774 | 10760 | /* SP = 11LLU */fputs("variable ", stderr); |
8775 | 10761 | { |
8776 | 10762 | /* CALLBEGIN */ |
@@ -8782,12 +10768,12 @@ | ||
8782 | 10768 | { |
8783 | 10769 | /*CALLEND*/ |
8784 | 10770 | stackbase += 13LLU; |
8785 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB1LLU; | |
10771 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1FLLU; | |
8786 | 10772 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
8787 | 10773 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
8788 | 10774 | break; |
8789 | 10775 | } |
8790 | -case 0xFFFFFFFFFFFFFDB1LLU: | |
10776 | +case 0xFFFFFFFFFFFFFD1FLLU: | |
8791 | 10777 | /* SP = 11LLU */fputs(" of size ", stderr); |
8792 | 10778 | { |
8793 | 10779 | /* CALLBEGIN */ |
@@ -8799,12 +10785,12 @@ | ||
8799 | 10785 | { |
8800 | 10786 | /*CALLEND*/ |
8801 | 10787 | stackbase += 13LLU; |
8802 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB0LLU; | |
10788 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1ELLU; | |
8803 | 10789 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
8804 | 10790 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
8805 | 10791 | break; |
8806 | 10792 | } |
8807 | -case 0xFFFFFFFFFFFFFDB0LLU: | |
10793 | +case 0xFFFFFFFFFFFFFD1ELLU: | |
8808 | 10794 | /* SP = 11LLU */fputs(" has no element ", stderr); |
8809 | 10795 | { |
8810 | 10796 | /* CALLBEGIN */ |
@@ -8816,16 +10802,18 @@ | ||
8816 | 10802 | { |
8817 | 10803 | /*CALLEND*/ |
8818 | 10804 | stackbase += 13LLU; |
8819 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAFLLU; | |
10805 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1DLLU; | |
8820 | 10806 | fnaddr = /*debugnr___*/0x7E07708A9B400000LLU;/* SP = 0LLU */ |
8821 | 10807 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugnr___*/\n"); exit(-1); } |
8822 | 10808 | break; |
8823 | 10809 | } |
8824 | -case 0xFFFFFFFFFFFFFDAFLLU: | |
10810 | +case 0xFFFFFFFFFFFFFD1DLLU: | |
8825 | 10811 | /* SP = 11LLU */exit(-1);/* SP = 11LLU */ |
8826 | -case 18446744073709551030LLU: /* skip to here */ | |
10812 | +case 18446744073709550884LLU: /* skip to here */ | |
8827 | 10813 | /* SP = 10LLU */ |
8828 | -case 18446744073709551034LLU: /* alternative */ | |
10814 | +case 18446744073709550895LLU: /* skip to here */ | |
10815 | +/* SP = 10LLU */ | |
10816 | +case 18446744073709550899LLU: /* alternative */ | |
8829 | 10817 | { |
8830 | 10818 | /* CALLBEGIN */ |
8831 | 10819 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 10LLU */ |
@@ -8835,12 +10823,12 @@ | ||
8835 | 10823 | { |
8836 | 10824 | /*CALLEND*/ |
8837 | 10825 | stackbase += 12LLU; |
8838 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAELLU; | |
10826 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1CLLU; | |
8839 | 10827 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8840 | 10828 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8841 | 10829 | break; |
8842 | 10830 | } |
8843 | -case 0xFFFFFFFFFFFFFDAELLU: | |
10831 | +case 0xFFFFFFFFFFFFFD1CLLU: | |
8844 | 10832 | /* SP = 10LLU *//* predicate */ |
8845 | 10833 | |
8846 | 10834 | { |
@@ -8853,15 +10841,15 @@ | ||
8853 | 10841 | { |
8854 | 10842 | /*CALLEND*/ |
8855 | 10843 | stackbase += 13LLU; |
8856 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDABLLU; | |
10844 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD19LLU; | |
8857 | 10845 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
8858 | 10846 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
8859 | 10847 | break; |
8860 | 10848 | } |
8861 | -case 0xFFFFFFFFFFFFFDABLLU: | |
10849 | +case 0xFFFFFFFFFFFFFD19LLU: | |
8862 | 10850 | /* SP = 11LLU */ |
8863 | 10851 | if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]) |
8864 | -{ /* JUMP */ fnaddr = 18446744073709551021LLU; break; } /* skip consequent */ | |
10852 | +{ /* JUMP */ fnaddr = 18446744073709550875LLU; break; } /* skip consequent */ | |
8865 | 10853 | /* consequent */ |
8866 | 10854 | { |
8867 | 10855 | /* CALLBEGIN */ |
@@ -8879,23 +10867,23 @@ | ||
8879 | 10867 | { |
8880 | 10868 | /*CALLEND*/ |
8881 | 10869 | stackbase += 15LLU; |
8882 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAALLU; | |
10870 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD18LLU; | |
8883 | 10871 | fnaddr = /*encodeval_*/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */ |
8884 | 10872 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*encodeval_*/\n"); exit(-1); } |
8885 | 10873 | break; |
8886 | 10874 | } |
8887 | -case 0xFFFFFFFFFFFFFDAALLU: | |
10875 | +case 0xFFFFFFFFFFFFFD18LLU: | |
8888 | 10876 | /* SP = 13LLU */ |
8889 | 10877 | { /* PUSH */ stack[stackbase + 13LLU] = /* LOCAL VAR */ stack[stackbase + 4LLU]; }/* SP + 1LLU = 14LLU */ |
8890 | 10878 | { |
8891 | 10879 | /*CALLEND*/ |
8892 | 10880 | stackbase += 12LLU; |
8893 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA9LLU; | |
10881 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD17LLU; | |
8894 | 10882 | fnaddr = /*typecheck_*/0xBF4AE07A381E9800LLU;/* SP = 0LLU */ |
8895 | 10883 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typecheck_*/\n"); exit(-1); } |
8896 | 10884 | break; |
8897 | 10885 | } |
8898 | -case 0xFFFFFFFFFFFFFDA9LLU: | |
10886 | +case 0xFFFFFFFFFFFFFD17LLU: | |
8899 | 10887 | /* SP = 10LLU */ |
8900 | 10888 | { |
8901 | 10889 | /* CALLBEGIN */ |
@@ -8906,12 +10894,12 @@ | ||
8906 | 10894 | { |
8907 | 10895 | /*CALLEND*/ |
8908 | 10896 | stackbase += 12LLU; |
8909 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA8LLU; | |
10897 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD16LLU; | |
8910 | 10898 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
8911 | 10899 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
8912 | 10900 | break; |
8913 | 10901 | } |
8914 | -case 0xFFFFFFFFFFFFFDA8LLU: | |
10902 | +case 0xFFFFFFFFFFFFFD16LLU: | |
8915 | 10903 | /* SP = 10LLU */ |
8916 | 10904 | { |
8917 | 10905 | /* CALLBEGIN */ |
@@ -8931,12 +10919,12 @@ | ||
8931 | 10919 | { |
8932 | 10920 | /*CALLEND*/ |
8933 | 10921 | stackbase += 18LLU; |
8934 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA7LLU; | |
10922 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD15LLU; | |
8935 | 10923 | fnaddr = /*parseid___*/0xADCB6E8247C00000LLU;/* SP = 0LLU */ |
8936 | 10924 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parseid___*/\n"); exit(-1); } |
8937 | 10925 | break; |
8938 | 10926 | } |
8939 | -case 0xFFFFFFFFFFFFFDA7LLU: | |
10927 | +case 0xFFFFFFFFFFFFFD15LLU: | |
8940 | 10928 | /* SP = 16LLU */ |
8941 | 10929 | { /* PUSH */ stack[stackbase + 16LLU] = /* LOCAL VAR */ stack[stackbase + 7LLU]; }/* SP + 1LLU = 17LLU */ |
8942 | 10930 | { /* PUSH */ stack[stackbase + 17LLU] = 0LLU; }/* SP + 1LLU = 18LLU */ |
@@ -8943,14 +10931,14 @@ | ||
8943 | 10931 | { |
8944 | 10932 | /*CALLEND*/ |
8945 | 10933 | stackbase += 12LLU; |
8946 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA6LLU; | |
10934 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD14LLU; | |
8947 | 10935 | fnaddr = /*parsestep_*/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */ |
8948 | 10936 | if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsestep_*/\n"); exit(-1); } |
8949 | 10937 | break; |
8950 | 10938 | } |
8951 | -case 0xFFFFFFFFFFFFFDA6LLU: | |
10939 | +case 0xFFFFFFFFFFFFFD14LLU: | |
8952 | 10940 | /* SP = 10LLU */ |
8953 | -case 0xFFFFFFFFFFFFFDA5LLU: /* loop to here *//* predicate */ | |
10941 | +case 0xFFFFFFFFFFFFFD13LLU: /* loop to here *//* predicate */ | |
8954 | 10942 | |
8955 | 10943 | { |
8956 | 10944 | /* CALLBEGIN */ |
@@ -8963,15 +10951,15 @@ | ||
8963 | 10951 | { |
8964 | 10952 | /*CALLEND*/ |
8965 | 10953 | stackbase += 13LLU; |
8966 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA3LLU; | |
10954 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD11LLU; | |
8967 | 10955 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
8968 | 10956 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
8969 | 10957 | break; |
8970 | 10958 | } |
8971 | -case 0xFFFFFFFFFFFFFDA3LLU: | |
10959 | +case 0xFFFFFFFFFFFFFD11LLU: | |
8972 | 10960 | /* SP = 11LLU */ |
8973 | 10961 | if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]) |
8974 | -{ /* JUMP */ fnaddr = 18446744073709551012LLU; break; } /* skip loop */ | |
10962 | +{ /* JUMP */ fnaddr = 18446744073709550866LLU; break; } /* skip loop */ | |
8975 | 10963 | /* loop */ |
8976 | 10964 | { |
8977 | 10965 | /* CALLBEGIN */ |
@@ -8984,12 +10972,12 @@ | ||
8984 | 10972 | { |
8985 | 10973 | /*CALLEND*/ |
8986 | 10974 | stackbase += 13LLU; |
8987 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA2LLU; | |
10975 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD10LLU; | |
8988 | 10976 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
8989 | 10977 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
8990 | 10978 | break; |
8991 | 10979 | } |
8992 | -case 0xFFFFFFFFFFFFFDA2LLU: | |
10980 | +case 0xFFFFFFFFFFFFFD10LLU: | |
8993 | 10981 | /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */ |
8994 | 10982 | |
8995 | 10983 | { |
@@ -9009,22 +10997,22 @@ | ||
9009 | 10997 | { |
9010 | 10998 | /*CALLEND*/ |
9011 | 10999 | stackbase += 15LLU; |
9012 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA1LLU; | |
11000 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0FLLU; | |
9013 | 11001 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
9014 | 11002 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
9015 | 11003 | break; |
9016 | 11004 | } |
9017 | -case 0xFFFFFFFFFFFFFDA1LLU: | |
11005 | +case 0xFFFFFFFFFFFFFD0FLLU: | |
9018 | 11006 | /* SP = 13LLU */ |
9019 | 11007 | { |
9020 | 11008 | /*CALLEND*/ |
9021 | 11009 | stackbase += 12LLU; |
9022 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA0LLU; | |
11010 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0ELLU; | |
9023 | 11011 | fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */ |
9024 | 11012 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); } |
9025 | 11013 | break; |
9026 | 11014 | } |
9027 | -case 0xFFFFFFFFFFFFFDA0LLU: | |
11015 | +case 0xFFFFFFFFFFFFFD0ELLU: | |
9028 | 11016 | /* SP = 10LLU */fputs(" = ", stdout); |
9029 | 11017 | { |
9030 | 11018 | /* CALLBEGIN */ |
@@ -9035,17 +11023,17 @@ | ||
9035 | 11023 | { |
9036 | 11024 | /*CALLEND*/ |
9037 | 11025 | stackbase += 12LLU; |
9038 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9FLLU; | |
11026 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0DLLU; | |
9039 | 11027 | fnaddr = /*POP_______*/0x40F4000000000000LLU;/* SP = 0LLU */ |
9040 | 11028 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*POP_______*/\n"); exit(-1); } |
9041 | 11029 | break; |
9042 | 11030 | } |
9043 | -case 0xFFFFFFFFFFFFFD9FLLU: | |
11031 | +case 0xFFFFFFFFFFFFFD0DLLU: | |
9044 | 11032 | /* 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 */ | |
9049 | 11037 | { |
9050 | 11038 | /* CALLBEGIN */ |
9051 | 11039 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 10LLU */ |
@@ -9058,14 +11046,14 @@ | ||
9058 | 11046 | { |
9059 | 11047 | /*CALLEND*/ |
9060 | 11048 | stackbase += 12LLU; |
9061 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9ELLU; | |
11049 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0CLLU; | |
9062 | 11050 | fnaddr = /*typecheckV*/0xBF4AE07A381E9960LLU;/* SP = 0LLU */ |
9063 | 11051 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*typecheckV*/\n"); exit(-1); } |
9064 | 11052 | break; |
9065 | 11053 | } |
9066 | -case 0xFFFFFFFFFFFFFD9ELLU: | |
11054 | +case 0xFFFFFFFFFFFFFD0CLLU: | |
9067 | 11055 | /* SP = 10LLU */ |
9068 | -case 0xFFFFFFFFFFFFFD9DLLU: /* loop to here *//* predicate */ | |
11056 | +case 0xFFFFFFFFFFFFFD0BLLU: /* loop to here *//* predicate */ | |
9069 | 11057 | |
9070 | 11058 | { |
9071 | 11059 | /* CALLBEGIN */ |
@@ -9078,15 +11066,15 @@ | ||
9078 | 11066 | { |
9079 | 11067 | /*CALLEND*/ |
9080 | 11068 | stackbase += 13LLU; |
9081 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9BLLU; | |
11069 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD09LLU; | |
9082 | 11070 | fnaddr = /*gtr_______*/0x8AFB400000000000LLU;/* SP = 0LLU */ |
9083 | 11071 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*gtr_______*/\n"); exit(-1); } |
9084 | 11072 | break; |
9085 | 11073 | } |
9086 | -case 0xFFFFFFFFFFFFFD9BLLU: | |
11074 | +case 0xFFFFFFFFFFFFFD09LLU: | |
9087 | 11075 | /* SP = 11LLU */ |
9088 | 11076 | if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]) |
9089 | -{ /* JUMP */ fnaddr = 18446744073709551004LLU; break; } /* skip loop */ | |
11077 | +{ /* JUMP */ fnaddr = 18446744073709550858LLU; break; } /* skip loop */ | |
9090 | 11078 | /* loop */ |
9091 | 11079 | { |
9092 | 11080 | /* CALLBEGIN */ |
@@ -9099,12 +11087,12 @@ | ||
9099 | 11087 | { |
9100 | 11088 | /*CALLEND*/ |
9101 | 11089 | stackbase += 13LLU; |
9102 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9ALLU; | |
11090 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD08LLU; | |
9103 | 11091 | fnaddr = /*sub_______*/0xBB07400000000000LLU;/* SP = 0LLU */ |
9104 | 11092 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*sub_______*/\n"); exit(-1); } |
9105 | 11093 | break; |
9106 | 11094 | } |
9107 | -case 0xFFFFFFFFFFFFFD9ALLU: | |
11095 | +case 0xFFFFFFFFFFFFFD08LLU: | |
9108 | 11096 | /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */ |
9109 | 11097 | |
9110 | 11098 | { |
@@ -9116,12 +11104,12 @@ | ||
9116 | 11104 | { |
9117 | 11105 | /*CALLEND*/ |
9118 | 11106 | stackbase += 12LLU; |
9119 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD99LLU; | |
11107 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD07LLU; | |
9120 | 11108 | fnaddr = /*PUSH_START*/0x4154C80135014940LLU;/* SP = 0LLU */ |
9121 | 11109 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_START*/\n"); exit(-1); } |
9122 | 11110 | break; |
9123 | 11111 | } |
9124 | -case 0xFFFFFFFFFFFFFD99LLU: | |
11112 | +case 0xFFFFFFFFFFFFFD07LLU: | |
9125 | 11113 | /* SP = 10LLU */ |
9126 | 11114 | { |
9127 | 11115 | /* CALLBEGIN */ |
@@ -9133,12 +11121,12 @@ | ||
9133 | 11121 | { |
9134 | 11122 | /*CALLEND*/ |
9135 | 11123 | stackbase += 12LLU; |
9136 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD98LLU; | |
11124 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD06LLU; | |
9137 | 11125 | fnaddr = /*ACCESSVAR_*/0x430C54D35814800LLU;/* SP = 0LLU */ |
9138 | 11126 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*ACCESSVAR_*/\n"); exit(-1); } |
9139 | 11127 | break; |
9140 | 11128 | } |
9141 | -case 0xFFFFFFFFFFFFFD98LLU: | |
11129 | +case 0xFFFFFFFFFFFFFD06LLU: | |
9142 | 11130 | /* SP = 10LLU */ |
9143 | 11131 | { |
9144 | 11132 | /* CALLBEGIN */ |
@@ -9149,12 +11137,12 @@ | ||
9149 | 11137 | { |
9150 | 11138 | /*CALLEND*/ |
9151 | 11139 | stackbase += 12LLU; |
9152 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD97LLU; | |
11140 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD05LLU; | |
9153 | 11141 | fnaddr = /*PUSH_END__*/0x4154C80053840000LLU;/* SP = 0LLU */ |
9154 | 11142 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*PUSH_END__*/\n"); exit(-1); } |
9155 | 11143 | break; |
9156 | 11144 | } |
9157 | -case 0xFFFFFFFFFFFFFD97LLU: | |
11145 | +case 0xFFFFFFFFFFFFFD05LLU: | |
9158 | 11146 | /* SP = 10LLU */ |
9159 | 11147 | { |
9160 | 11148 | /* CALLBEGIN */ |
@@ -9167,20 +11155,20 @@ | ||
9167 | 11155 | { |
9168 | 11156 | /*CALLEND*/ |
9169 | 11157 | stackbase += 13LLU; |
9170 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD96LLU; | |
11158 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD04LLU; | |
9171 | 11159 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
9172 | 11160 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
9173 | 11161 | break; |
9174 | 11162 | } |
9175 | -case 0xFFFFFFFFFFFFFD96LLU: | |
11163 | +case 0xFFFFFFFFFFFFFD04LLU: | |
9176 | 11164 | /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 6LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */ |
9177 | 11165 | /* 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 */ | |
9181 | 11169 | /* 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 */ | |
9184 | 11172 | { |
9185 | 11173 | /* CALLBEGIN */ |
9186 | 11174 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 9LLU */ |
@@ -9190,12 +11178,12 @@ | ||
9190 | 11178 | { |
9191 | 11179 | /*CALLEND*/ |
9192 | 11180 | stackbase += 11LLU; |
9193 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD95LLU; | |
11181 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD03LLU; | |
9194 | 11182 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
9195 | 11183 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
9196 | 11184 | break; |
9197 | 11185 | } |
9198 | -case 0xFFFFFFFFFFFFFD95LLU: | |
11186 | +case 0xFFFFFFFFFFFFFD03LLU: | |
9199 | 11187 | /* SP = 9LLU *//* predicate */ |
9200 | 11188 | |
9201 | 11189 | { |
@@ -9208,15 +11196,15 @@ | ||
9208 | 11196 | { |
9209 | 11197 | /*CALLEND*/ |
9210 | 11198 | stackbase += 12LLU; |
9211 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD92LLU; | |
11199 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFD00LLU; | |
9212 | 11200 | fnaddr = /*matchopt__*/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */ |
9213 | 11201 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*matchopt__*/\n"); exit(-1); } |
9214 | 11202 | break; |
9215 | 11203 | } |
9216 | -case 0xFFFFFFFFFFFFFD92LLU: | |
11204 | +case 0xFFFFFFFFFFFFFD00LLU: | |
9217 | 11205 | /* SP = 10LLU */ |
9218 | 11206 | if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU]) |
9219 | -{ /* JUMP */ fnaddr = 18446744073709550996LLU; break; } /* skip consequent */ | |
11207 | +{ /* JUMP */ fnaddr = 18446744073709550850LLU; break; } /* skip consequent */ | |
9220 | 11208 | /* consequent *//* predicate */ |
9221 | 11209 | |
9222 | 11210 | { |
@@ -9229,15 +11217,15 @@ | ||
9229 | 11217 | { |
9230 | 11218 | /*CALLEND*/ |
9231 | 11219 | stackbase += 12LLU; |
9232 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD90LLU; | |
11220 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFELLU; | |
9233 | 11221 | fnaddr = /*not_______*/0xA6ABC00000000000LLU;/* SP = 0LLU */ |
9234 | 11222 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*not_______*/\n"); exit(-1); } |
9235 | 11223 | break; |
9236 | 11224 | } |
9237 | -case 0xFFFFFFFFFFFFFD90LLU: | |
11225 | +case 0xFFFFFFFFFFFFFCFELLU: | |
9238 | 11226 | /* SP = 10LLU */ |
9239 | 11227 | if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU]) |
9240 | -{ /* JUMP */ fnaddr = 18446744073709550993LLU; break; } /* skip consequent */ | |
11228 | +{ /* JUMP */ fnaddr = 18446744073709550847LLU; break; } /* skip consequent */ | |
9241 | 11229 | /* consequent */ |
9242 | 11230 | { |
9243 | 11231 | /* CALLBEGIN */ |
@@ -9248,12 +11236,12 @@ | ||
9248 | 11236 | { |
9249 | 11237 | /*CALLEND*/ |
9250 | 11238 | stackbase += 11LLU; |
9251 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8FLLU; | |
11239 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFDLLU; | |
9252 | 11240 | fnaddr = /*DEBUGLINE_*/0x1050951CC24E1400LLU;/* SP = 0LLU */ |
9253 | 11241 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*DEBUGLINE_*/\n"); exit(-1); } |
9254 | 11242 | break; |
9255 | 11243 | } |
9256 | -case 0xFFFFFFFFFFFFFD8FLLU: | |
11244 | +case 0xFFFFFFFFFFFFFCFDLLU: | |
9257 | 11245 | /* SP = 9LLU */fputs("accessing unverified list ", stderr); |
9258 | 11246 | { |
9259 | 11247 | /* CALLBEGIN */ |
@@ -9265,14 +11253,14 @@ | ||
9265 | 11253 | { |
9266 | 11254 | /*CALLEND*/ |
9267 | 11255 | stackbase += 11LLU; |
9268 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ELLU; | |
11256 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFCLLU; | |
9269 | 11257 | fnaddr = /*debugid___*/0x7E07708A47C00000LLU;/* SP = 0LLU */ |
9270 | 11258 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*debugid___*/\n"); exit(-1); } |
9271 | 11259 | break; |
9272 | 11260 | } |
9273 | -case 0xFFFFFFFFFFFFFD8ELLU: | |
11261 | +case 0xFFFFFFFFFFFFFCFCLLU: | |
9274 | 11262 | /* SP = 9LLU */fputs("\n", stderr); exit(-1);/* SP = 9LLU */ |
9275 | -case 18446744073709550993LLU: /* alternative */ | |
11263 | +case 18446744073709550847LLU: /* alternative */ | |
9276 | 11264 | { |
9277 | 11265 | /* CALLBEGIN */ |
9278 | 11266 | /* reserve space for 0LLU returned values *//* SP + 0LLU = 9LLU */ |
@@ -9282,12 +11270,12 @@ | ||
9282 | 11270 | { |
9283 | 11271 | /*CALLEND*/ |
9284 | 11272 | stackbase += 11LLU; |
9285 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8DLLU; | |
11273 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFBLLU; | |
9286 | 11274 | fnaddr = /*skipcmnts_*/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */ |
9287 | 11275 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*skipcmnts_*/\n"); exit(-1); } |
9288 | 11276 | break; |
9289 | 11277 | } |
9290 | -case 0xFFFFFFFFFFFFFD8DLLU: | |
11278 | +case 0xFFFFFFFFFFFFFCFBLLU: | |
9291 | 11279 | /* SP = 9LLU */ |
9292 | 11280 | { /* PUSH */ stack[stackbase + 9LLU] = 0LLU; }/* SP + 1LLU = 10LLU */ |
9293 | 11281 | { |
@@ -9305,23 +11293,23 @@ | ||
9305 | 11293 | { |
9306 | 11294 | /*CALLEND*/ |
9307 | 11295 | stackbase += 16LLU; |
9308 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8CLLU; | |
11296 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFALLU; | |
9309 | 11297 | fnaddr = /*parsenr___*/0xADCB6E829B400000LLU;/* SP = 0LLU */ |
9310 | 11298 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*parsenr___*/\n"); exit(-1); } |
9311 | 11299 | break; |
9312 | 11300 | } |
9313 | -case 0xFFFFFFFFFFFFFD8CLLU: | |
11301 | +case 0xFFFFFFFFFFFFFCFALLU: | |
9314 | 11302 | /* SP = 14LLU */ |
9315 | 11303 | { /* PUSH */ stack[stackbase + 14LLU] = 1LLU; }/* SP + 1LLU = 15LLU */ |
9316 | 11304 | { |
9317 | 11305 | /*CALLEND*/ |
9318 | 11306 | stackbase += 13LLU; |
9319 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8BLLU; | |
11307 | + stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF9LLU; | |
9320 | 11308 | fnaddr = /*add_______*/0x71F7C00000000000LLU;/* SP = 0LLU */ |
9321 | 11309 | if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /*add_______*/\n"); exit(-1); } |
9322 | 11310 | break; |
9323 | 11311 | } |
9324 | -case 0xFFFFFFFFFFFFFD8BLLU: | |
11312 | +case 0xFFFFFFFFFFFFFCF9LLU: | |
9325 | 11313 | /* SP = 11LLU *//* LOCAL VAR */ stack[stackbase + 9LLU] = /* SP - 1LLU = 10LLU */stack[stackbase + 10LLU]; /* POP */ |
9326 | 11314 | /* predicate */ |
9327 | 11315 |
@@ -9342,25 +11330,25 @@ | ||
9342 | 11330 | { |
9343 | 11331 | /*CALLEND*/ |
9344 | 11332 | stackbase += 17LLU; |
9345 | - stack[stackbase - 1] = 0xFFFFFFFFFFFFFD88LLU; | |
11333 | + stack[stackbase - 1] = 0xFFFFFFFFFF |
差分はサイズ制限により省略されました。全ての差分を見るためにはローカルクライアントを利用してください。