修订版 | 991 (tree) |
---|---|
时间 | 2020-04-29 23:11:07 |
作者 | jakobthomsen |
cleanup
@@ -1082,22 +1082,6 @@ | ||
1082 | 1082 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 57; |
1083 | 1083 | |
1084 | 1084 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) <= /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); |
1085 | - { | |
1086 | - uint64_t arg = 0; | |
1087 | - LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
1088 | - } | |
1089 | - *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU); | |
1090 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551590LLU : 18446744073709551589LLU; | |
1091 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 | |
1092 | - break; | |
1093 | - } | |
1094 | - case 18446744073709551590LLU: // 999999999k''''''''''''''' | |
1095 | - { | |
1096 | - state.addr = 18446744073709551589LLU; // 999999999j''''''''''''''' | |
1097 | - break; | |
1098 | - } | |
1099 | - case 18446744073709551589LLU: // 999999999j''''''''''''''' | |
1100 | - { | |
1101 | 1085 | state.addr = 18446744073709551591LLU; // 999999999l''''''''''''''' |
1102 | 1086 | break; |
1103 | 1087 | } |
@@ -1134,7 +1118,7 @@ | ||
1134 | 1118 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
1135 | 1119 | } |
1136 | 1120 | // ACCUMULATE ARGUMENTS - END |
1137 | - uint64_t return_to = 18446744073709551586LLU; | |
1121 | + uint64_t return_to = 18446744073709551588LLU; | |
1138 | 1122 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
1139 | 1123 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
1140 | 1124 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -1143,13 +1127,13 @@ | ||
1143 | 1127 | state.addr = 661671490923528192LLU; // isspace___ |
1144 | 1128 | break; |
1145 | 1129 | } |
1146 | - case 18446744073709551586LLU: // 999999999g''''''''''''''' | |
1130 | + case 18446744073709551588LLU: // 999999999i''''''''''''''' | |
1147 | 1131 | { |
1148 | - state.addr = *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) ? 18446744073709551588LLU : 18446744073709551587LLU; | |
1132 | + state.addr = *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) ? 18446744073709551590LLU : 18446744073709551589LLU; | |
1149 | 1133 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
1150 | 1134 | break; |
1151 | 1135 | } |
1152 | - case 18446744073709551588LLU: // 999999999i''''''''''''''' | |
1136 | + case 18446744073709551590LLU: // 999999999k''''''''''''''' | |
1153 | 1137 | { |
1154 | 1138 | { |
1155 | 1139 | uint64_t arg = 0; |
@@ -1156,15 +1140,15 @@ | ||
1156 | 1140 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
1157 | 1141 | } |
1158 | 1142 | *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = 0; |
1159 | - state.addr = 18446744073709551585LLU; // 999999999f''''''''''''''' | |
1143 | + state.addr = 18446744073709551587LLU; // 999999999h''''''''''''''' | |
1160 | 1144 | break; |
1161 | 1145 | } |
1162 | - case 18446744073709551585LLU: // 999999999f''''''''''''''' | |
1146 | + case 18446744073709551587LLU: // 999999999h''''''''''''''' | |
1163 | 1147 | { |
1164 | 1148 | *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = (uint64_t)getchar(); |
1165 | 1149 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU) || *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) > 255) |
1166 | 1150 | { |
1167 | - state.addr = 18446744073709551584LLU; // 999999999e''''''''''''''' | |
1151 | + state.addr = 18446744073709551586LLU; // 999999999g''''''''''''''' | |
1168 | 1152 | break; |
1169 | 1153 | } |
1170 | 1154 | { |
@@ -1181,7 +1165,7 @@ | ||
1181 | 1165 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
1182 | 1166 | } |
1183 | 1167 | // ACCUMULATE ARGUMENTS - END |
1184 | - uint64_t return_to = 18446744073709551580LLU; | |
1168 | + uint64_t return_to = 18446744073709551582LLU; | |
1185 | 1169 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
1186 | 1170 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
1187 | 1171 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -1190,39 +1174,39 @@ | ||
1190 | 1174 | state.addr = 661671490923528192LLU; // isspace___ |
1191 | 1175 | break; |
1192 | 1176 | } |
1193 | - case 18446744073709551580LLU: // 999999999a''''''''''''''' | |
1177 | + case 18446744073709551582LLU: // 999999999c''''''''''''''' | |
1194 | 1178 | { |
1195 | - state.addr = *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) ? 18446744073709551583LLU : 18446744073709551582LLU; | |
1179 | + state.addr = *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) ? 18446744073709551585LLU : 18446744073709551584LLU; | |
1196 | 1180 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
1197 | 1181 | break; |
1198 | 1182 | } |
1199 | - case 18446744073709551583LLU: // 999999999d''''''''''''''' | |
1183 | + case 18446744073709551585LLU: // 999999999f''''''''''''''' | |
1200 | 1184 | { |
1201 | - state.addr = 18446744073709551581LLU; // 999999999b''''''''''''''' | |
1185 | + state.addr = 18446744073709551583LLU; // 999999999d''''''''''''''' | |
1202 | 1186 | break; |
1203 | 1187 | } |
1204 | - case 18446744073709551582LLU: // 999999999c''''''''''''''' | |
1188 | + case 18446744073709551584LLU: // 999999999e''''''''''''''' | |
1205 | 1189 | { |
1206 | 1190 | |
1207 | 1191 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = /*c_________*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU); |
1208 | 1192 | ungetc(0, stdin); |
1209 | - state.addr = 18446744073709551581LLU; // 999999999b''''''''''''''' | |
1193 | + state.addr = 18446744073709551583LLU; // 999999999d''''''''''''''' | |
1210 | 1194 | break; |
1211 | 1195 | } |
1212 | - case 18446744073709551581LLU: // 999999999b''''''''''''''' | |
1196 | + case 18446744073709551583LLU: // 999999999d''''''''''''''' | |
1213 | 1197 | { |
1214 | - state.addr = 18446744073709551585LLU; // 999999999f''''''''''''''' | |
1198 | + state.addr = 18446744073709551587LLU; // 999999999h''''''''''''''' | |
1215 | 1199 | break; |
1216 | 1200 | } |
1217 | - case 18446744073709551584LLU: // 999999999e''''''''''''''' | |
1201 | + case 18446744073709551586LLU: // 999999999g''''''''''''''' | |
1218 | 1202 | { |
1219 | 1203 | // variable u64 c_________ goes out of scope |
1220 | 1204 | // emitted destructur for type u64 |
1221 | 1205 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 2 |
1222 | - state.addr = 18446744073709551587LLU; // 999999999h''''''''''''''' | |
1206 | + state.addr = 18446744073709551589LLU; // 999999999j''''''''''''''' | |
1223 | 1207 | break; |
1224 | 1208 | } |
1225 | - case 18446744073709551587LLU: // 999999999h''''''''''''''' | |
1209 | + case 18446744073709551589LLU: // 999999999j''''''''''''''' | |
1226 | 1210 | { |
1227 | 1211 | // parameter-reference u64 lookahead_ goes out of scope |
1228 | 1212 | (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 1 |
@@ -1241,25 +1225,25 @@ | ||
1241 | 1225 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
1242 | 1226 | } |
1243 | 1227 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*expected__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)) == /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
1244 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551579LLU : 18446744073709551578LLU; | |
1228 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551581LLU : 18446744073709551580LLU; | |
1245 | 1229 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1246 | 1230 | break; |
1247 | 1231 | } |
1248 | - case 18446744073709551579LLU: // 999999999$''''''''''''''' | |
1232 | + case 18446744073709551581LLU: // 999999999b''''''''''''''' | |
1249 | 1233 | { |
1250 | 1234 | |
1251 | 1235 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)) = (uint64_t)getchar(); |
1252 | 1236 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 1LLU; |
1253 | - state.addr = 18446744073709551577LLU; // 999999999Y''''''''''''''' | |
1237 | + state.addr = 18446744073709551579LLU; // 999999999$''''''''''''''' | |
1254 | 1238 | break; |
1255 | 1239 | } |
1256 | - case 18446744073709551578LLU: // 999999999Z''''''''''''''' | |
1240 | + case 18446744073709551580LLU: // 999999999a''''''''''''''' | |
1257 | 1241 | { |
1258 | 1242 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0LLU; |
1259 | - state.addr = 18446744073709551577LLU; // 999999999Y''''''''''''''' | |
1243 | + state.addr = 18446744073709551579LLU; // 999999999$''''''''''''''' | |
1260 | 1244 | break; |
1261 | 1245 | } |
1262 | - case 18446744073709551577LLU: // 999999999Y''''''''''''''' | |
1246 | + case 18446744073709551579LLU: // 999999999$''''''''''''''' | |
1263 | 1247 | { |
1264 | 1248 | // parameter-reference u64 lookahead_ goes out of scope |
1265 | 1249 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 3 |
@@ -1284,7 +1268,7 @@ | ||
1284 | 1268 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
1285 | 1269 | } |
1286 | 1270 | // ACCUMULATE ARGUMENTS - END |
1287 | - uint64_t return_to = 18446744073709551576LLU; | |
1271 | + uint64_t return_to = 18446744073709551578LLU; | |
1288 | 1272 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
1289 | 1273 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
1290 | 1274 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -1293,7 +1277,7 @@ | ||
1293 | 1277 | state.addr = 787446708198178816LLU; // printnr___ |
1294 | 1278 | break; |
1295 | 1279 | } |
1296 | - case 18446744073709551576LLU: // 999999999X''''''''''''''' | |
1280 | + case 18446744073709551578LLU: // 999999999Z''''''''''''''' | |
1297 | 1281 | { |
1298 | 1282 | fprintf(stdout, "%s", "; count++)"); |
1299 | 1283 | fprintf(stdout, "%s", "\n {"); |
@@ -1306,7 +1290,7 @@ | ||
1306 | 1290 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
1307 | 1291 | } |
1308 | 1292 | // ACCUMULATE ARGUMENTS - END |
1309 | - uint64_t return_to = 18446744073709551575LLU; | |
1293 | + uint64_t return_to = 18446744073709551577LLU; | |
1310 | 1294 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
1311 | 1295 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
1312 | 1296 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -1315,7 +1299,7 @@ | ||
1315 | 1299 | state.addr = 787446708198178816LLU; // printnr___ |
1316 | 1300 | break; |
1317 | 1301 | } |
1318 | - case 18446744073709551575LLU: // 999999999W''''''''''''''' | |
1302 | + case 18446744073709551577LLU: // 999999999Y''''''''''''''' | |
1319 | 1303 | { |
1320 | 1304 | fprintf(stdout, "%s", "; i > 0; i--)"); |
1321 | 1305 | fprintf(stdout, "%s", "\n {"); |
@@ -1332,7 +1316,7 @@ | ||
1332 | 1316 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
1333 | 1317 | } |
1334 | 1318 | // ACCUMULATE ARGUMENTS - END |
1335 | - uint64_t return_to = 18446744073709551574LLU; | |
1319 | + uint64_t return_to = 18446744073709551576LLU; | |
1336 | 1320 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
1337 | 1321 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
1338 | 1322 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -1341,7 +1325,7 @@ | ||
1341 | 1325 | state.addr = 787446708198178816LLU; // printnr___ |
1342 | 1326 | break; |
1343 | 1327 | } |
1344 | - case 18446744073709551574LLU: // 999999999V''''''''''''''' | |
1328 | + case 18446744073709551576LLU: // 999999999X''''''''''''''' | |
1345 | 1329 | { |
1346 | 1330 | fprintf(stdout, "%s", ")"); |
1347 | 1331 | fprintf(stdout, "%s", "\n {"); |
@@ -1352,7 +1336,7 @@ | ||
1352 | 1336 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
1353 | 1337 | } |
1354 | 1338 | // ACCUMULATE ARGUMENTS - END |
1355 | - uint64_t return_to = 18446744073709551573LLU; | |
1339 | + uint64_t return_to = 18446744073709551575LLU; | |
1356 | 1340 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
1357 | 1341 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
1358 | 1342 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -1361,7 +1345,7 @@ | ||
1361 | 1345 | state.addr = 787446708198178816LLU; // printnr___ |
1362 | 1346 | break; |
1363 | 1347 | } |
1364 | - case 18446744073709551573LLU: // 999999999U''''''''''''''' | |
1348 | + case 18446744073709551575LLU: // 999999999W''''''''''''''' | |
1365 | 1349 | { |
1366 | 1350 | fprintf(stdout, "%s", "; i > 0; i--)"); |
1367 | 1351 | fprintf(stdout, "%s", "\n {"); |
@@ -1382,7 +1366,7 @@ | ||
1382 | 1366 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
1383 | 1367 | } |
1384 | 1368 | // ACCUMULATE ARGUMENTS - END |
1385 | - uint64_t return_to = 18446744073709551572LLU; | |
1369 | + uint64_t return_to = 18446744073709551574LLU; | |
1386 | 1370 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
1387 | 1371 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
1388 | 1372 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -1391,7 +1375,7 @@ | ||
1391 | 1375 | state.addr = 787446708198178816LLU; // printnr___ |
1392 | 1376 | break; |
1393 | 1377 | } |
1394 | - case 18446744073709551572LLU: // 999999999T''''''''''''''' | |
1378 | + case 18446744073709551574LLU: // 999999999V''''''''''''''' | |
1395 | 1379 | { |
1396 | 1380 | fprintf(stdout, "%s", "; i > 0; i--)"); |
1397 | 1381 | fprintf(stdout, "%s", "\n {"); |
@@ -1411,7 +1395,7 @@ | ||
1411 | 1395 | } |
1412 | 1396 | break; |
1413 | 1397 | } |
1414 | - case 18446744073709551570LLU: // 999999999R''''''''''''''' | |
1398 | + case 18446744073709551572LLU: // 999999999T''''''''''''''' | |
1415 | 1399 | { |
1416 | 1400 | // destructor for variant typelist__ |
1417 | 1401 | { |
@@ -1431,7 +1415,7 @@ | ||
1431 | 1415 | } |
1432 | 1416 | break; |
1433 | 1417 | } |
1434 | - case 18446744073709551569LLU: // 999999999Q''''''''''''''' | |
1418 | + case 18446744073709551571LLU: // 999999999S''''''''''''''' | |
1435 | 1419 | { |
1436 | 1420 | // destructor for variant typename__ |
1437 | 1421 | { |
@@ -1451,7 +1435,7 @@ | ||
1451 | 1435 | } |
1452 | 1436 | break; |
1453 | 1437 | } |
1454 | - case 18446744073709551568LLU: // 999999999P''''''''''''''' | |
1438 | + case 18446744073709551570LLU: // 999999999R''''''''''''''' | |
1455 | 1439 | { |
1456 | 1440 | // destructor for variant typeu64___ |
1457 | 1441 | // RELEASE destructor-argument |
@@ -1464,11 +1448,11 @@ | ||
1464 | 1448 | } |
1465 | 1449 | break; |
1466 | 1450 | } |
1467 | - case 18446744073709551571LLU: // 999999999S''''''''''''''' | |
1451 | + case 18446744073709551573LLU: // 999999999U''''''''''''''' | |
1468 | 1452 | { |
1469 | 1453 | struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
1470 | 1454 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1; |
1471 | - state.addr = 18446744073709551568LLU + type_data.elem0; | |
1455 | + state.addr = 18446744073709551570LLU + type_data.elem0; | |
1472 | 1456 | break; |
1473 | 1457 | } |
1474 | 1458 | case 861504786250002432LLU: // typelist__ |
@@ -1552,7 +1536,7 @@ | ||
1552 | 1536 | { |
1553 | 1537 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
1554 | 1538 | { |
1555 | - state.addr = 18446744073709551567LLU; // 999999999O''''''''''''''' | |
1539 | + state.addr = 18446744073709551569LLU; // 999999999Q''''''''''''''' | |
1556 | 1540 | break; |
1557 | 1541 | } |
1558 | 1542 | { |
@@ -1562,7 +1546,7 @@ | ||
1562 | 1546 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/) |
1563 | 1547 | { |
1564 | 1548 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1565 | - state.addr = 18446744073709551567LLU; // 999999999O''''''''''''''' | |
1549 | + state.addr = 18446744073709551569LLU; // 999999999Q''''''''''''''' | |
1566 | 1550 | break; |
1567 | 1551 | } |
1568 | 1552 | { |
@@ -1587,11 +1571,11 @@ | ||
1587 | 1571 | } |
1588 | 1572 | break; |
1589 | 1573 | } |
1590 | - case 18446744073709551567LLU: // 999999999O''''''''''''''' | |
1574 | + case 18446744073709551569LLU: // 999999999Q''''''''''''''' | |
1591 | 1575 | { |
1592 | 1576 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/) |
1593 | 1577 | { |
1594 | - state.addr = 18446744073709551566LLU; // 999999999N''''''''''''''' | |
1578 | + state.addr = 18446744073709551568LLU; // 999999999P''''''''''''''' | |
1595 | 1579 | break; |
1596 | 1580 | } |
1597 | 1581 | { |
@@ -1601,7 +1585,7 @@ | ||
1601 | 1585 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/) |
1602 | 1586 | { |
1603 | 1587 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1604 | - state.addr = 18446744073709551566LLU; // 999999999N''''''''''''''' | |
1588 | + state.addr = 18446744073709551568LLU; // 999999999P''''''''''''''' | |
1605 | 1589 | break; |
1606 | 1590 | } |
1607 | 1591 | { |
@@ -1626,11 +1610,11 @@ | ||
1626 | 1610 | } |
1627 | 1611 | break; |
1628 | 1612 | } |
1629 | - case 18446744073709551566LLU: // 999999999N''''''''''''''' | |
1613 | + case 18446744073709551568LLU: // 999999999P''''''''''''''' | |
1630 | 1614 | { |
1631 | 1615 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/) |
1632 | 1616 | { |
1633 | - state.addr = 18446744073709551565LLU; // 999999999M''''''''''''''' | |
1617 | + state.addr = 18446744073709551567LLU; // 999999999O''''''''''''''' | |
1634 | 1618 | break; |
1635 | 1619 | } |
1636 | 1620 | { |
@@ -1640,7 +1624,7 @@ | ||
1640 | 1624 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/) |
1641 | 1625 | { |
1642 | 1626 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1643 | - state.addr = 18446744073709551565LLU; // 999999999M''''''''''''''' | |
1627 | + state.addr = 18446744073709551567LLU; // 999999999O''''''''''''''' | |
1644 | 1628 | break; |
1645 | 1629 | } |
1646 | 1630 | { |
@@ -1665,11 +1649,11 @@ | ||
1665 | 1649 | } |
1666 | 1650 | break; |
1667 | 1651 | } |
1668 | - case 18446744073709551565LLU: // 999999999M''''''''''''''' | |
1652 | + case 18446744073709551567LLU: // 999999999O''''''''''''''' | |
1669 | 1653 | { |
1670 | 1654 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
1671 | 1655 | { |
1672 | - state.addr = 18446744073709551564LLU; // 999999999L''''''''''''''' | |
1656 | + state.addr = 18446744073709551566LLU; // 999999999N''''''''''''''' | |
1673 | 1657 | break; |
1674 | 1658 | } |
1675 | 1659 | { |
@@ -1679,7 +1663,7 @@ | ||
1679 | 1663 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/) |
1680 | 1664 | { |
1681 | 1665 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1682 | - state.addr = 18446744073709551564LLU; // 999999999L''''''''''''''' | |
1666 | + state.addr = 18446744073709551566LLU; // 999999999N''''''''''''''' | |
1683 | 1667 | break; |
1684 | 1668 | } |
1685 | 1669 | { |
@@ -1704,11 +1688,11 @@ | ||
1704 | 1688 | } |
1705 | 1689 | break; |
1706 | 1690 | } |
1707 | - case 18446744073709551564LLU: // 999999999L''''''''''''''' | |
1691 | + case 18446744073709551566LLU: // 999999999N''''''''''''''' | |
1708 | 1692 | { |
1709 | 1693 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/) |
1710 | 1694 | { |
1711 | - state.addr = 18446744073709551563LLU; // 999999999K''''''''''''''' | |
1695 | + state.addr = 18446744073709551565LLU; // 999999999M''''''''''''''' | |
1712 | 1696 | break; |
1713 | 1697 | } |
1714 | 1698 | { |
@@ -1723,7 +1707,7 @@ | ||
1723 | 1707 | { |
1724 | 1708 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
1725 | 1709 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1726 | - state.addr = 18446744073709551563LLU; // 999999999K''''''''''''''' | |
1710 | + state.addr = 18446744073709551565LLU; // 999999999M''''''''''''''' | |
1727 | 1711 | break; |
1728 | 1712 | } |
1729 | 1713 | { |
@@ -1756,11 +1740,11 @@ | ||
1756 | 1740 | } |
1757 | 1741 | break; |
1758 | 1742 | } |
1759 | - case 18446744073709551563LLU: // 999999999K''''''''''''''' | |
1743 | + case 18446744073709551565LLU: // 999999999M''''''''''''''' | |
1760 | 1744 | { |
1761 | 1745 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/) |
1762 | 1746 | { |
1763 | - state.addr = 18446744073709551562LLU; // 999999999J''''''''''''''' | |
1747 | + state.addr = 18446744073709551564LLU; // 999999999L''''''''''''''' | |
1764 | 1748 | break; |
1765 | 1749 | } |
1766 | 1750 | { |
@@ -1770,7 +1754,7 @@ | ||
1770 | 1754 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/) |
1771 | 1755 | { |
1772 | 1756 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1773 | - state.addr = 18446744073709551562LLU; // 999999999J''''''''''''''' | |
1757 | + state.addr = 18446744073709551564LLU; // 999999999L''''''''''''''' | |
1774 | 1758 | break; |
1775 | 1759 | } |
1776 | 1760 | { |
@@ -1795,11 +1779,11 @@ | ||
1795 | 1779 | } |
1796 | 1780 | break; |
1797 | 1781 | } |
1798 | - case 18446744073709551562LLU: // 999999999J''''''''''''''' | |
1782 | + case 18446744073709551564LLU: // 999999999L''''''''''''''' | |
1799 | 1783 | { |
1800 | 1784 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
1801 | 1785 | { |
1802 | - state.addr = 18446744073709551561LLU; // 999999999I''''''''''''''' | |
1786 | + state.addr = 18446744073709551563LLU; // 999999999K''''''''''''''' | |
1803 | 1787 | break; |
1804 | 1788 | } |
1805 | 1789 | { |
@@ -1809,7 +1793,7 @@ | ||
1809 | 1793 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/) |
1810 | 1794 | { |
1811 | 1795 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1812 | - state.addr = 18446744073709551561LLU; // 999999999I''''''''''''''' | |
1796 | + state.addr = 18446744073709551563LLU; // 999999999K''''''''''''''' | |
1813 | 1797 | break; |
1814 | 1798 | } |
1815 | 1799 | { |
@@ -1834,11 +1818,11 @@ | ||
1834 | 1818 | } |
1835 | 1819 | break; |
1836 | 1820 | } |
1837 | - case 18446744073709551561LLU: // 999999999I''''''''''''''' | |
1821 | + case 18446744073709551563LLU: // 999999999K''''''''''''''' | |
1838 | 1822 | { |
1839 | 1823 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/) |
1840 | 1824 | { |
1841 | - state.addr = 18446744073709551560LLU; // 999999999H''''''''''''''' | |
1825 | + state.addr = 18446744073709551562LLU; // 999999999J''''''''''''''' | |
1842 | 1826 | break; |
1843 | 1827 | } |
1844 | 1828 | { |
@@ -1848,7 +1832,7 @@ | ||
1848 | 1832 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/) |
1849 | 1833 | { |
1850 | 1834 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1851 | - state.addr = 18446744073709551560LLU; // 999999999H''''''''''''''' | |
1835 | + state.addr = 18446744073709551562LLU; // 999999999J''''''''''''''' | |
1852 | 1836 | break; |
1853 | 1837 | } |
1854 | 1838 | { |
@@ -1873,11 +1857,11 @@ | ||
1873 | 1857 | } |
1874 | 1858 | break; |
1875 | 1859 | } |
1876 | - case 18446744073709551560LLU: // 999999999H''''''''''''''' | |
1860 | + case 18446744073709551562LLU: // 999999999J''''''''''''''' | |
1877 | 1861 | { |
1878 | 1862 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/) |
1879 | 1863 | { |
1880 | - state.addr = 18446744073709551559LLU; // 999999999G''''''''''''''' | |
1864 | + state.addr = 18446744073709551561LLU; // 999999999I''''''''''''''' | |
1881 | 1865 | break; |
1882 | 1866 | } |
1883 | 1867 | { |
@@ -1892,7 +1876,7 @@ | ||
1892 | 1876 | { |
1893 | 1877 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
1894 | 1878 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
1895 | - state.addr = 18446744073709551559LLU; // 999999999G''''''''''''''' | |
1879 | + state.addr = 18446744073709551561LLU; // 999999999I''''''''''''''' | |
1896 | 1880 | break; |
1897 | 1881 | } |
1898 | 1882 | { |
@@ -1925,203 +1909,17 @@ | ||
1925 | 1909 | } |
1926 | 1910 | break; |
1927 | 1911 | } |
1928 | - case 18446744073709551559LLU: // 999999999G''''''''''''''' | |
1912 | + case 18446744073709551561LLU: // 999999999I''''''''''''''' | |
1929 | 1913 | { |
1930 | 1914 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equtype___\n"); |
1931 | 1915 | exit(-1); |
1932 | 1916 | break; |
1933 | 1917 | } |
1934 | - case 861504787186880512LLU: // typemain__ | |
1935 | - { | |
1936 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) | |
1937 | - { | |
1938 | - state.addr = 18446744073709551558LLU; // 999999999F''''''''''''''' | |
1939 | - break; | |
1940 | - } | |
1941 | - { | |
1942 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
1943 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
1944 | - } | |
1945 | - | |
1946 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 881834713755418624; | |
1947 | - // parameter-reference type______ __________ goes out of scope | |
1948 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
1949 | - // parameter type______ __________ goes out of scope | |
1950 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
1951 | - // parameter-reference u64 maintype__ goes out of scope | |
1952 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 1 | |
1953 | - { | |
1954 | - uint64_t baseinfo = heap.data[0].elem1; | |
1955 | - struct pair pair = unpair(&heap, &baseinfo); | |
1956 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
1957 | - state.addr = pair.elem1; | |
1958 | - } | |
1959 | - break; | |
1960 | - } | |
1961 | - case 18446744073709551558LLU: // 999999999F''''''''''''''' | |
1962 | - { | |
1963 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/) | |
1964 | - { | |
1965 | - state.addr = 18446744073709551557LLU; // 999999999E''''''''''''''' | |
1966 | - break; | |
1967 | - } | |
1968 | - { | |
1969 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
1970 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
1971 | - } | |
1972 | - { | |
1973 | - uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU); | |
1974 | - LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
1975 | - } | |
1976 | - | |
1977 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU)); | |
1978 | - // parameter-reference u64 name______ goes out of scope | |
1979 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4 | |
1980 | - // parameter-reference type______ __________ goes out of scope | |
1981 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
1982 | - // parameter type______ __________ goes out of scope | |
1983 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
1984 | - // parameter-reference u64 maintype__ goes out of scope | |
1985 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 1 | |
1986 | - { | |
1987 | - uint64_t baseinfo = heap.data[0].elem1; | |
1988 | - struct pair pair = unpair(&heap, &baseinfo); | |
1989 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
1990 | - state.addr = pair.elem1; | |
1991 | - } | |
1992 | - break; | |
1993 | - } | |
1994 | - case 18446744073709551557LLU: // 999999999E''''''''''''''' | |
1995 | - { | |
1996 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/) | |
1997 | - { | |
1998 | - state.addr = 18446744073709551556LLU; // 999999999D''''''''''''''' | |
1999 | - break; | |
2000 | - } | |
2001 | - { | |
2002 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
2003 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
2004 | - } | |
2005 | - | |
2006 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 712900180986298368; | |
2007 | - // parameter-reference type______ __________ goes out of scope | |
2008 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
2009 | - // parameter type______ __________ goes out of scope | |
2010 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
2011 | - // parameter-reference u64 maintype__ goes out of scope | |
2012 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 1 | |
2013 | - { | |
2014 | - uint64_t baseinfo = heap.data[0].elem1; | |
2015 | - struct pair pair = unpair(&heap, &baseinfo); | |
2016 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
2017 | - state.addr = pair.elem1; | |
2018 | - } | |
2019 | - break; | |
2020 | - } | |
2021 | - case 18446744073709551556LLU: // 999999999D''''''''''''''' | |
2022 | - { | |
2023 | - fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of typemain__\n"); | |
2024 | - exit(-1); | |
2025 | - break; | |
2026 | - } | |
2027 | - case 861504793962872832LLU: // typesub___ | |
2028 | - { | |
2029 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) | |
2030 | - { | |
2031 | - state.addr = 18446744073709551555LLU; // 999999999C''''''''''''''' | |
2032 | - break; | |
2033 | - } | |
2034 | - { | |
2035 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
2036 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
2037 | - } | |
2038 | - | |
2039 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0; | |
2040 | - // parameter-reference type______ __________ goes out of scope | |
2041 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
2042 | - // parameter type______ __________ goes out of scope | |
2043 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
2044 | - // parameter-reference u64 subtype___ goes out of scope | |
2045 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 1 | |
2046 | - { | |
2047 | - uint64_t baseinfo = heap.data[0].elem1; | |
2048 | - struct pair pair = unpair(&heap, &baseinfo); | |
2049 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
2050 | - state.addr = pair.elem1; | |
2051 | - } | |
2052 | - break; | |
2053 | - } | |
2054 | - case 18446744073709551555LLU: // 999999999C''''''''''''''' | |
2055 | - { | |
2056 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/) | |
2057 | - { | |
2058 | - state.addr = 18446744073709551554LLU; // 999999999B''''''''''''''' | |
2059 | - break; | |
2060 | - } | |
2061 | - { | |
2062 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
2063 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
2064 | - } | |
2065 | - | |
2066 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0; | |
2067 | - // parameter-reference type______ __________ goes out of scope | |
2068 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
2069 | - // parameter type______ __________ goes out of scope | |
2070 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
2071 | - // parameter-reference u64 subtype___ goes out of scope | |
2072 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 1 | |
2073 | - { | |
2074 | - uint64_t baseinfo = heap.data[0].elem1; | |
2075 | - struct pair pair = unpair(&heap, &baseinfo); | |
2076 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
2077 | - state.addr = pair.elem1; | |
2078 | - } | |
2079 | - break; | |
2080 | - } | |
2081 | - case 18446744073709551554LLU: // 999999999B''''''''''''''' | |
2082 | - { | |
2083 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/) | |
2084 | - { | |
2085 | - state.addr = 18446744073709551553LLU; // 999999999A''''''''''''''' | |
2086 | - break; | |
2087 | - } | |
2088 | - { | |
2089 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
2090 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
2091 | - } | |
2092 | - { | |
2093 | - uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU); | |
2094 | - LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
2095 | - } | |
2096 | - | |
2097 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU)); | |
2098 | - // parameter-reference u64 name______ goes out of scope | |
2099 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4 | |
2100 | - // parameter-reference type______ __________ goes out of scope | |
2101 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
2102 | - // parameter type______ __________ goes out of scope | |
2103 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
2104 | - // parameter-reference u64 subtype___ goes out of scope | |
2105 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 1 | |
2106 | - { | |
2107 | - uint64_t baseinfo = heap.data[0].elem1; | |
2108 | - struct pair pair = unpair(&heap, &baseinfo); | |
2109 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
2110 | - state.addr = pair.elem1; | |
2111 | - } | |
2112 | - break; | |
2113 | - } | |
2114 | - case 18446744073709551553LLU: // 999999999A''''''''''''''' | |
2115 | - { | |
2116 | - fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of typesub___\n"); | |
2117 | - exit(-1); | |
2118 | - break; | |
2119 | - } | |
2120 | 1918 | case 861504783110041600LLU: // typeinit__ |
2121 | 1919 | { |
2122 | 1920 | if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 881834713755418624) |
2123 | 1921 | { |
2124 | - state.addr = 18446744073709551552LLU; // 999999999_''''''''''''''' | |
1922 | + state.addr = 18446744073709551560LLU; // 999999999H''''''''''''''' | |
2125 | 1923 | break; |
2126 | 1924 | } |
2127 | 1925 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -2130,7 +1928,7 @@ | ||
2130 | 1928 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2131 | 1929 | } |
2132 | 1930 | // ACCUMULATE ARGUMENTS - END |
2133 | - uint64_t return_to = 18446744073709551551LLU; | |
1931 | + uint64_t return_to = 18446744073709551559LLU; | |
2134 | 1932 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
2135 | 1933 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2136 | 1934 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2139,7 +1937,7 @@ | ||
2139 | 1937 | state.addr = 861504796319285248LLU; // typeu64___ |
2140 | 1938 | break; |
2141 | 1939 | } |
2142 | - case 18446744073709551551LLU: // 9999999989''''''''''''''' | |
1940 | + case 18446744073709551559LLU: // 999999999G''''''''''''''' | |
2143 | 1941 | { |
2144 | 1942 | // parameter-reference u64 subtype___ goes out of scope |
2145 | 1943 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3 |
@@ -2154,11 +1952,11 @@ | ||
2154 | 1952 | } |
2155 | 1953 | break; |
2156 | 1954 | } |
2157 | - case 18446744073709551552LLU: // 999999999_''''''''''''''' | |
1955 | + case 18446744073709551560LLU: // 999999999H''''''''''''''' | |
2158 | 1956 | { |
2159 | 1957 | if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 712900180986298368) |
2160 | 1958 | { |
2161 | - state.addr = 18446744073709551550LLU; // 9999999988''''''''''''''' | |
1959 | + state.addr = 18446744073709551558LLU; // 999999999F''''''''''''''' | |
2162 | 1960 | break; |
2163 | 1961 | } |
2164 | 1962 | { |
@@ -2176,7 +1974,7 @@ | ||
2176 | 1974 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2177 | 1975 | } |
2178 | 1976 | // ACCUMULATE ARGUMENTS - END |
2179 | - uint64_t return_to = 18446744073709551549LLU; | |
1977 | + uint64_t return_to = 18446744073709551557LLU; | |
2180 | 1978 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
2181 | 1979 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2182 | 1980 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2185,7 +1983,7 @@ | ||
2185 | 1983 | state.addr = 861504786250002432LLU; // typelist__ |
2186 | 1984 | break; |
2187 | 1985 | } |
2188 | - case 18446744073709551549LLU: // 9999999987''''''''''''''' | |
1986 | + case 18446744073709551557LLU: // 999999999E''''''''''''''' | |
2189 | 1987 | { |
2190 | 1988 | // variable u64 subtype___ goes out of scope |
2191 | 1989 | // (uninitialized -> no destructor-call) |
@@ -2203,7 +2001,7 @@ | ||
2203 | 2001 | } |
2204 | 2002 | break; |
2205 | 2003 | } |
2206 | - case 18446744073709551550LLU: // 9999999988''''''''''''''' | |
2004 | + case 18446744073709551558LLU: // 999999999F''''''''''''''' | |
2207 | 2005 | { |
2208 | 2006 | { |
2209 | 2007 | uint64_t arg = 0; |
@@ -2210,20 +2008,20 @@ | ||
2210 | 2008 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
2211 | 2009 | } |
2212 | 2010 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
2213 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551547LLU : 18446744073709551546LLU; | |
2011 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551555LLU : 18446744073709551554LLU; | |
2214 | 2012 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
2215 | 2013 | break; |
2216 | 2014 | } |
2217 | - case 18446744073709551547LLU: // 9999999985''''''''''''''' | |
2015 | + case 18446744073709551555LLU: // 999999999C''''''''''''''' | |
2218 | 2016 | { |
2219 | 2017 | fprintf(stderr, "%s", "typeinit: struct/union "); |
2220 | 2018 | printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))); |
2221 | 2019 | fprintf(stderr, "%s", " must not have subtype but found "); |
2222 | 2020 | printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))); |
2223 | - state.addr = 18446744073709551546LLU; // 9999999984''''''''''''''' | |
2021 | + state.addr = 18446744073709551554LLU; // 999999999B''''''''''''''' | |
2224 | 2022 | break; |
2225 | 2023 | } |
2226 | - case 18446744073709551546LLU: // 9999999984''''''''''''''' | |
2024 | + case 18446744073709551554LLU: // 999999999B''''''''''''''' | |
2227 | 2025 | { |
2228 | 2026 | { |
2229 | 2027 | uint64_t arg = 0; |
@@ -2240,7 +2038,7 @@ | ||
2240 | 2038 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2241 | 2039 | } |
2242 | 2040 | // ACCUMULATE ARGUMENTS - END |
2243 | - uint64_t return_to = 18446744073709551545LLU; | |
2041 | + uint64_t return_to = 18446744073709551553LLU; | |
2244 | 2042 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
2245 | 2043 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2246 | 2044 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2249,7 +2047,7 @@ | ||
2249 | 2047 | state.addr = 861504788261634048LLU; // typename__ |
2250 | 2048 | break; |
2251 | 2049 | } |
2252 | - case 18446744073709551545LLU: // 9999999983''''''''''''''' | |
2050 | + case 18446744073709551553LLU: // 999999999A''''''''''''''' | |
2253 | 2051 | { |
2254 | 2052 | // variable u64 maintype__ goes out of scope |
2255 | 2053 | // (uninitialized -> no destructor-call) |
@@ -2271,7 +2069,7 @@ | ||
2271 | 2069 | { |
2272 | 2070 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
2273 | 2071 | { |
2274 | - state.addr = 18446744073709551544LLU; // 9999999982''''''''''''''' | |
2072 | + state.addr = 18446744073709551552LLU; // 999999999_''''''''''''''' | |
2275 | 2073 | break; |
2276 | 2074 | } |
2277 | 2075 | { |
@@ -2284,7 +2082,7 @@ | ||
2284 | 2082 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2285 | 2083 | } |
2286 | 2084 | // ACCUMULATE ARGUMENTS - END |
2287 | - uint64_t return_to = 18446744073709551543LLU; | |
2085 | + uint64_t return_to = 18446744073709551551LLU; | |
2288 | 2086 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
2289 | 2087 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2290 | 2088 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2293,7 +2091,7 @@ | ||
2293 | 2091 | state.addr = 861504796319285248LLU; // typeu64___ |
2294 | 2092 | break; |
2295 | 2093 | } |
2296 | - case 18446744073709551543LLU: // 9999999981''''''''''''''' | |
2094 | + case 18446744073709551551LLU: // 9999999989''''''''''''''' | |
2297 | 2095 | { |
2298 | 2096 | // parameter-reference type______ __________ goes out of scope |
2299 | 2097 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
@@ -2308,11 +2106,11 @@ | ||
2308 | 2106 | } |
2309 | 2107 | break; |
2310 | 2108 | } |
2311 | - case 18446744073709551544LLU: // 9999999982''''''''''''''' | |
2109 | + case 18446744073709551552LLU: // 999999999_''''''''''''''' | |
2312 | 2110 | { |
2313 | 2111 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/) |
2314 | 2112 | { |
2315 | - state.addr = 18446744073709551542LLU; // 9999999980''''''''''''''' | |
2113 | + state.addr = 18446744073709551550LLU; // 9999999988''''''''''''''' | |
2316 | 2114 | break; |
2317 | 2115 | } |
2318 | 2116 | { |
@@ -2338,7 +2136,7 @@ | ||
2338 | 2136 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2339 | 2137 | } |
2340 | 2138 | // ACCUMULATE ARGUMENTS - END |
2341 | - uint64_t return_to = 18446744073709551541LLU; | |
2139 | + uint64_t return_to = 18446744073709551549LLU; | |
2342 | 2140 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
2343 | 2141 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2344 | 2142 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2347,7 +2145,7 @@ | ||
2347 | 2145 | state.addr = 861504788261634048LLU; // typename__ |
2348 | 2146 | break; |
2349 | 2147 | } |
2350 | - case 18446744073709551541LLU: // 999999998z''''''''''''''' | |
2148 | + case 18446744073709551549LLU: // 9999999987''''''''''''''' | |
2351 | 2149 | { |
2352 | 2150 | // variable u64 tmp_______ goes out of scope |
2353 | 2151 | // (uninitialized -> no destructor-call) |
@@ -2367,11 +2165,11 @@ | ||
2367 | 2165 | } |
2368 | 2166 | break; |
2369 | 2167 | } |
2370 | - case 18446744073709551542LLU: // 9999999980''''''''''''''' | |
2168 | + case 18446744073709551550LLU: // 9999999988''''''''''''''' | |
2371 | 2169 | { |
2372 | 2170 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/) |
2373 | 2171 | { |
2374 | - state.addr = 18446744073709551540LLU; // 999999998y''''''''''''''' | |
2172 | + state.addr = 18446744073709551548LLU; // 9999999986''''''''''''''' | |
2375 | 2173 | break; |
2376 | 2174 | } |
2377 | 2175 | { |
@@ -2397,7 +2195,7 @@ | ||
2397 | 2195 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2398 | 2196 | } |
2399 | 2197 | // ACCUMULATE ARGUMENTS - END |
2400 | - uint64_t return_to = 18446744073709551539LLU; | |
2198 | + uint64_t return_to = 18446744073709551547LLU; | |
2401 | 2199 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
2402 | 2200 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2403 | 2201 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2406,7 +2204,7 @@ | ||
2406 | 2204 | state.addr = 861504786250002432LLU; // typelist__ |
2407 | 2205 | break; |
2408 | 2206 | } |
2409 | - case 18446744073709551539LLU: // 999999998x''''''''''''''' | |
2207 | + case 18446744073709551547LLU: // 9999999985''''''''''''''' | |
2410 | 2208 | { |
2411 | 2209 | // variable u64 tmp_______ goes out of scope |
2412 | 2210 | // (uninitialized -> no destructor-call) |
@@ -2426,7 +2224,7 @@ | ||
2426 | 2224 | } |
2427 | 2225 | break; |
2428 | 2226 | } |
2429 | - case 18446744073709551540LLU: // 999999998y''''''''''''''' | |
2227 | + case 18446744073709551548LLU: // 9999999986''''''''''''''' | |
2430 | 2228 | { |
2431 | 2229 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of TYPECOPY__\n"); |
2432 | 2230 | exit(-1); |
@@ -2436,7 +2234,7 @@ | ||
2436 | 2234 | { |
2437 | 2235 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/) |
2438 | 2236 | { |
2439 | - state.addr = 18446744073709551538LLU; // 999999998w''''''''''''''' | |
2237 | + state.addr = 18446744073709551546LLU; // 9999999984''''''''''''''' | |
2440 | 2238 | break; |
2441 | 2239 | } |
2442 | 2240 | { |
@@ -2456,11 +2254,11 @@ | ||
2456 | 2254 | } |
2457 | 2255 | break; |
2458 | 2256 | } |
2459 | - case 18446744073709551538LLU: // 999999998w''''''''''''''' | |
2257 | + case 18446744073709551546LLU: // 9999999984''''''''''''''' | |
2460 | 2258 | { |
2461 | 2259 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/) |
2462 | 2260 | { |
2463 | - state.addr = 18446744073709551537LLU; // 999999998v''''''''''''''' | |
2261 | + state.addr = 18446744073709551545LLU; // 9999999983''''''''''''''' | |
2464 | 2262 | break; |
2465 | 2263 | } |
2466 | 2264 | { |
@@ -2486,11 +2284,11 @@ | ||
2486 | 2284 | } |
2487 | 2285 | break; |
2488 | 2286 | } |
2489 | - case 18446744073709551537LLU: // 999999998v''''''''''''''' | |
2287 | + case 18446744073709551545LLU: // 9999999983''''''''''''''' | |
2490 | 2288 | { |
2491 | 2289 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/) |
2492 | 2290 | { |
2493 | - state.addr = 18446744073709551536LLU; // 999999998u''''''''''''''' | |
2291 | + state.addr = 18446744073709551544LLU; // 9999999982''''''''''''''' | |
2494 | 2292 | break; |
2495 | 2293 | } |
2496 | 2294 | { |
@@ -2506,25 +2304,25 @@ | ||
2506 | 2304 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
2507 | 2305 | } |
2508 | 2306 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
2509 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551535LLU : 18446744073709551534LLU; | |
2307 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551543LLU : 18446744073709551542LLU; | |
2510 | 2308 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
2511 | 2309 | break; |
2512 | 2310 | } |
2513 | - case 18446744073709551535LLU: // 999999998t''''''''''''''' | |
2311 | + case 18446744073709551543LLU: // 9999999981''''''''''''''' | |
2514 | 2312 | { |
2515 | 2313 | fprintf(stderr, "%s", "list<"); |
2516 | 2314 | printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))); |
2517 | 2315 | fprintf(stderr, "%s", ">"); |
2518 | - state.addr = 18446744073709551533LLU; // 999999998r''''''''''''''' | |
2316 | + state.addr = 18446744073709551541LLU; // 999999998z''''''''''''''' | |
2519 | 2317 | break; |
2520 | 2318 | } |
2521 | - case 18446744073709551534LLU: // 999999998s''''''''''''''' | |
2319 | + case 18446744073709551542LLU: // 9999999980''''''''''''''' | |
2522 | 2320 | { |
2523 | 2321 | fprintf(stderr, "%s", "list<?>"); |
2524 | - state.addr = 18446744073709551533LLU; // 999999998r''''''''''''''' | |
2322 | + state.addr = 18446744073709551541LLU; // 999999998z''''''''''''''' | |
2525 | 2323 | break; |
2526 | 2324 | } |
2527 | - case 18446744073709551533LLU: // 999999998r''''''''''''''' | |
2325 | + case 18446744073709551541LLU: // 999999998z''''''''''''''' | |
2528 | 2326 | { |
2529 | 2327 | // parameter-reference u64 subtype___ goes out of scope |
2530 | 2328 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3 |
@@ -2540,7 +2338,7 @@ | ||
2540 | 2338 | } |
2541 | 2339 | break; |
2542 | 2340 | } |
2543 | - case 18446744073709551536LLU: // 999999998u''''''''''''''' | |
2341 | + case 18446744073709551544LLU: // 9999999982''''''''''''''' | |
2544 | 2342 | { |
2545 | 2343 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttype\n"); |
2546 | 2344 | exit(-1); |
@@ -2550,7 +2348,7 @@ | ||
2550 | 2348 | { |
2551 | 2349 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/) |
2552 | 2350 | { |
2553 | - state.addr = 18446744073709551532LLU; // 999999998q''''''''''''''' | |
2351 | + state.addr = 18446744073709551540LLU; // 999999998y''''''''''''''' | |
2554 | 2352 | break; |
2555 | 2353 | } |
2556 | 2354 | { |
@@ -2570,11 +2368,11 @@ | ||
2570 | 2368 | } |
2571 | 2369 | break; |
2572 | 2370 | } |
2573 | - case 18446744073709551532LLU: // 999999998q''''''''''''''' | |
2371 | + case 18446744073709551540LLU: // 999999998y''''''''''''''' | |
2574 | 2372 | { |
2575 | 2373 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/) |
2576 | 2374 | { |
2577 | - state.addr = 18446744073709551531LLU; // 999999998p''''''''''''''' | |
2375 | + state.addr = 18446744073709551539LLU; // 999999998x''''''''''''''' | |
2578 | 2376 | break; |
2579 | 2377 | } |
2580 | 2378 | { |
@@ -2600,11 +2398,11 @@ | ||
2600 | 2398 | } |
2601 | 2399 | break; |
2602 | 2400 | } |
2603 | - case 18446744073709551531LLU: // 999999998p''''''''''''''' | |
2401 | + case 18446744073709551539LLU: // 999999998x''''''''''''''' | |
2604 | 2402 | { |
2605 | 2403 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/) |
2606 | 2404 | { |
2607 | - state.addr = 18446744073709551530LLU; // 999999998o''''''''''''''' | |
2405 | + state.addr = 18446744073709551538LLU; // 999999998w''''''''''''''' | |
2608 | 2406 | break; |
2609 | 2407 | } |
2610 | 2408 | { |
@@ -2620,25 +2418,25 @@ | ||
2620 | 2418 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
2621 | 2419 | } |
2622 | 2420 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
2623 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551529LLU : 18446744073709551528LLU; | |
2421 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551537LLU : 18446744073709551536LLU; | |
2624 | 2422 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
2625 | 2423 | break; |
2626 | 2424 | } |
2627 | - case 18446744073709551529LLU: // 999999998n''''''''''''''' | |
2425 | + case 18446744073709551537LLU: // 999999998v''''''''''''''' | |
2628 | 2426 | { |
2629 | 2427 | fprintf(stdout, "%s", "list<"); |
2630 | 2428 | printid(stdout, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))); |
2631 | 2429 | fprintf(stdout, "%s", ">"); |
2632 | - state.addr = 18446744073709551527LLU; // 999999998l''''''''''''''' | |
2430 | + state.addr = 18446744073709551535LLU; // 999999998t''''''''''''''' | |
2633 | 2431 | break; |
2634 | 2432 | } |
2635 | - case 18446744073709551528LLU: // 999999998m''''''''''''''' | |
2433 | + case 18446744073709551536LLU: // 999999998u''''''''''''''' | |
2636 | 2434 | { |
2637 | 2435 | fprintf(stdout, "%s", "list<?>"); |
2638 | - state.addr = 18446744073709551527LLU; // 999999998l''''''''''''''' | |
2436 | + state.addr = 18446744073709551535LLU; // 999999998t''''''''''''''' | |
2639 | 2437 | break; |
2640 | 2438 | } |
2641 | - case 18446744073709551527LLU: // 999999998l''''''''''''''' | |
2439 | + case 18446744073709551535LLU: // 999999998t''''''''''''''' | |
2642 | 2440 | { |
2643 | 2441 | // parameter-reference u64 subtype___ goes out of scope |
2644 | 2442 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3 |
@@ -2654,13 +2452,13 @@ | ||
2654 | 2452 | } |
2655 | 2453 | break; |
2656 | 2454 | } |
2657 | - case 18446744073709551530LLU: // 999999998o''''''''''''''' | |
2455 | + case 18446744073709551538LLU: // 999999998w''''''''''''''' | |
2658 | 2456 | { |
2659 | 2457 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of printtype_\n"); |
2660 | 2458 | exit(-1); |
2661 | 2459 | break; |
2662 | 2460 | } |
2663 | - case 18446744073709551526LLU: // 999999998k''''''''''''''' | |
2461 | + case 18446744073709551534LLU: // 999999998s''''''''''''''' | |
2664 | 2462 | { |
2665 | 2463 | { |
2666 | 2464 | uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -2687,16 +2485,16 @@ | ||
2687 | 2485 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2688 | 2486 | } |
2689 | 2487 | // ACCUMULATE ARGUMENTS - END |
2690 | - uint64_t return_to = 18446744073709551525LLU; | |
2488 | + uint64_t return_to = 18446744073709551533LLU; | |
2691 | 2489 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
2692 | 2490 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2693 | 2491 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
2694 | 2492 | heap.data[0].elem1 = heap.data[0].elem0; |
2695 | 2493 | heap.data[0].elem0 = restore; |
2696 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
2494 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
2697 | 2495 | break; |
2698 | 2496 | } |
2699 | - case 18446744073709551525LLU: // 999999998j''''''''''''''' | |
2497 | + case 18446744073709551533LLU: // 999999998r''''''''''''''' | |
2700 | 2498 | { |
2701 | 2499 | // RELEASE temporary destructor-variable |
2702 | 2500 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -2765,7 +2563,7 @@ | ||
2765 | 2563 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2766 | 2564 | } |
2767 | 2565 | // ACCUMULATE ARGUMENTS - END |
2768 | - uint64_t return_to = 18446744073709551524LLU; | |
2566 | + uint64_t return_to = 18446744073709551532LLU; | |
2769 | 2567 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
2770 | 2568 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2771 | 2569 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2774,7 +2572,7 @@ | ||
2774 | 2572 | state.addr = 589060043891015680LLU; // equtype___ |
2775 | 2573 | break; |
2776 | 2574 | } |
2777 | - case 18446744073709551524LLU: // 999999998i''''''''''''''' | |
2575 | + case 18446744073709551532LLU: // 999999998q''''''''''''''' | |
2778 | 2576 | { |
2779 | 2577 | { |
2780 | 2578 | uint64_t arg = 0; |
@@ -2781,11 +2579,11 @@ | ||
2781 | 2579 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
2782 | 2580 | } |
2783 | 2581 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
2784 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551523LLU : 18446744073709551522LLU; | |
2582 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551531LLU : 18446744073709551530LLU; | |
2785 | 2583 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
2786 | 2584 | break; |
2787 | 2585 | } |
2788 | - case 18446744073709551523LLU: // 999999998h''''''''''''''' | |
2586 | + case 18446744073709551531LLU: // 999999998p''''''''''''''' | |
2789 | 2587 | { |
2790 | 2588 | |
2791 | 2589 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU)); |
@@ -2794,23 +2592,23 @@ | ||
2794 | 2592 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
2795 | 2593 | } |
2796 | 2594 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
2797 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551521LLU : 18446744073709551520LLU; | |
2595 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551529LLU : 18446744073709551528LLU; | |
2798 | 2596 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
2799 | 2597 | break; |
2800 | 2598 | } |
2801 | - case 18446744073709551521LLU: // 999999998f''''''''''''''' | |
2599 | + case 18446744073709551529LLU: // 999999998n''''''''''''''' | |
2802 | 2600 | { |
2803 | 2601 | |
2804 | 2602 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 2LLU)); |
2805 | - state.addr = 18446744073709551520LLU; // 999999998e''''''''''''''' | |
2603 | + state.addr = 18446744073709551528LLU; // 999999998m''''''''''''''' | |
2806 | 2604 | break; |
2807 | 2605 | } |
2808 | - case 18446744073709551520LLU: // 999999998e''''''''''''''' | |
2606 | + case 18446744073709551528LLU: // 999999998m''''''''''''''' | |
2809 | 2607 | { |
2810 | - state.addr = 18446744073709551522LLU; // 999999998g''''''''''''''' | |
2608 | + state.addr = 18446744073709551530LLU; // 999999998o''''''''''''''' | |
2811 | 2609 | break; |
2812 | 2610 | } |
2813 | - case 18446744073709551522LLU: // 999999998g''''''''''''''' | |
2611 | + case 18446744073709551530LLU: // 999999998o''''''''''''''' | |
2814 | 2612 | { |
2815 | 2613 | // parameter-reference resdest___ y_________ goes out of scope |
2816 | 2614 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3 |
@@ -2863,7 +2661,7 @@ | ||
2863 | 2661 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2864 | 2662 | } |
2865 | 2663 | // ACCUMULATE ARGUMENTS - END |
2866 | - uint64_t return_to = 18446744073709551517LLU; | |
2664 | + uint64_t return_to = 18446744073709551525LLU; | |
2867 | 2665 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
2868 | 2666 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2869 | 2667 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2872,7 +2670,7 @@ | ||
2872 | 2670 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
2873 | 2671 | break; |
2874 | 2672 | } |
2875 | - case 18446744073709551517LLU: // 999999998b''''''''''''''' | |
2673 | + case 18446744073709551525LLU: // 999999998j''''''''''''''' | |
2876 | 2674 | { |
2877 | 2675 | { |
2878 | 2676 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -2901,7 +2699,7 @@ | ||
2901 | 2699 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2902 | 2700 | } |
2903 | 2701 | // ACCUMULATE ARGUMENTS - END |
2904 | - uint64_t return_to = 18446744073709551516LLU; | |
2702 | + uint64_t return_to = 18446744073709551524LLU; | |
2905 | 2703 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
2906 | 2704 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2907 | 2705 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2910,7 +2708,7 @@ | ||
2910 | 2708 | state.addr = 552446646280519680LLU; // copyu64___ |
2911 | 2709 | break; |
2912 | 2710 | } |
2913 | - case 18446744073709551516LLU: // 999999998a''''''''''''''' | |
2711 | + case 18446744073709551524LLU: // 999999998i''''''''''''''' | |
2914 | 2712 | { |
2915 | 2713 | { |
2916 | 2714 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -2939,7 +2737,7 @@ | ||
2939 | 2737 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
2940 | 2738 | } |
2941 | 2739 | // ACCUMULATE ARGUMENTS - END |
2942 | - uint64_t return_to = 18446744073709551515LLU; | |
2740 | + uint64_t return_to = 18446744073709551523LLU; | |
2943 | 2741 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
2944 | 2742 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2945 | 2743 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2948,7 +2746,7 @@ | ||
2948 | 2746 | state.addr = 552446646280519680LLU; // copyu64___ |
2949 | 2747 | break; |
2950 | 2748 | } |
2951 | - case 18446744073709551515LLU: // 999999998$''''''''''''''' | |
2749 | + case 18446744073709551523LLU: // 999999998h''''''''''''''' | |
2952 | 2750 | { |
2953 | 2751 | { |
2954 | 2752 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -2960,7 +2758,7 @@ | ||
2960 | 2758 | } |
2961 | 2759 | } |
2962 | 2760 | // ACCUMULATE ARGUMENTS - END |
2963 | - uint64_t return_to = 18446744073709551518LLU; | |
2761 | + uint64_t return_to = 18446744073709551526LLU; | |
2964 | 2762 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
2965 | 2763 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
2966 | 2764 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -2969,7 +2767,7 @@ | ||
2969 | 2767 | state.addr = 819859607768530944LLU; // resdest___ |
2970 | 2768 | break; |
2971 | 2769 | } |
2972 | - case 18446744073709551518LLU: // 999999998c''''''''''''''' | |
2770 | + case 18446744073709551526LLU: // 999999998k''''''''''''''' | |
2973 | 2771 | { |
2974 | 2772 | // parameter-reference u64 reference_ goes out of scope |
2975 | 2773 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 5 |
@@ -3008,7 +2806,7 @@ | ||
3008 | 2806 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
3009 | 2807 | } |
3010 | 2808 | // ACCUMULATE ARGUMENTS - END |
3011 | - uint64_t return_to = 18446744073709551513LLU; | |
2809 | + uint64_t return_to = 18446744073709551521LLU; | |
3012 | 2810 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
3013 | 2811 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
3014 | 2812 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -3017,7 +2815,7 @@ | ||
3017 | 2815 | state.addr = 819847183518878432LLU; // reporttype |
3018 | 2816 | break; |
3019 | 2817 | } |
3020 | - case 18446744073709551513LLU: // 999999998Y''''''''''''''' | |
2818 | + case 18446744073709551521LLU: // 999999998f''''''''''''''' | |
3021 | 2819 | { |
3022 | 2820 | fprintf(stderr, "%s", " "); |
3023 | 2821 | fprintf(stderr, "%s", "("); |
@@ -3055,10 +2853,10 @@ | ||
3055 | 2853 | uint64_t arg = 0; |
3056 | 2854 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
3057 | 2855 | } |
3058 | - state.addr = 18446744073709551512LLU; // 999999998X''''''''''''''' | |
2856 | + state.addr = 18446744073709551520LLU; // 999999998e''''''''''''''' | |
3059 | 2857 | break; |
3060 | 2858 | } |
3061 | - case 18446744073709551512LLU: // 999999998X''''''''''''''' | |
2859 | + case 18446744073709551520LLU: // 999999998e''''''''''''''' | |
3062 | 2860 | { |
3063 | 2861 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)) |
3064 | 2862 | { |
@@ -3065,7 +2863,7 @@ | ||
3065 | 2863 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3066 | 2864 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
3067 | 2865 | { |
3068 | - state.addr = 18446744073709551511LLU; // 999999998W''''''''''''''' | |
2866 | + state.addr = 18446744073709551519LLU; // 999999998d''''''''''''''' | |
3069 | 2867 | break; |
3070 | 2868 | } |
3071 | 2869 | } |
@@ -3076,24 +2874,24 @@ | ||
3076 | 2874 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
3077 | 2875 | } |
3078 | 2876 | *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*first_____*/*LOCAL_ACCESS(heap.data, 5LLU, 1LLU); |
3079 | - state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551510LLU : 18446744073709551509LLU; | |
2877 | + state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551518LLU : 18446744073709551517LLU; | |
3080 | 2878 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
3081 | 2879 | break; |
3082 | 2880 | } |
3083 | - case 18446744073709551510LLU: // 999999998V''''''''''''''' | |
2881 | + case 18446744073709551518LLU: // 999999998c''''''''''''''' | |
3084 | 2882 | { |
3085 | 2883 | |
3086 | 2884 | *LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = 0; |
3087 | - state.addr = 18446744073709551508LLU; // 999999998T''''''''''''''' | |
2885 | + state.addr = 18446744073709551516LLU; // 999999998a''''''''''''''' | |
3088 | 2886 | break; |
3089 | 2887 | } |
3090 | - case 18446744073709551509LLU: // 999999998U''''''''''''''' | |
2888 | + case 18446744073709551517LLU: // 999999998b''''''''''''''' | |
3091 | 2889 | { |
3092 | 2890 | fprintf(stderr, "%s", ", "); |
3093 | - state.addr = 18446744073709551508LLU; // 999999998T''''''''''''''' | |
2891 | + state.addr = 18446744073709551516LLU; // 999999998a''''''''''''''' | |
3094 | 2892 | break; |
3095 | 2893 | } |
3096 | - case 18446744073709551508LLU: // 999999998T''''''''''''''' | |
2894 | + case 18446744073709551516LLU: // 999999998a''''''''''''''' | |
3097 | 2895 | { |
3098 | 2896 | // ACCUMULATE ARGUMENTS - BEGIN |
3099 | 2897 | { |
@@ -3101,7 +2899,7 @@ | ||
3101 | 2899 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
3102 | 2900 | } |
3103 | 2901 | // ACCUMULATE ARGUMENTS - END |
3104 | - uint64_t return_to = 18446744073709551507LLU; | |
2902 | + uint64_t return_to = 18446744073709551515LLU; | |
3105 | 2903 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
3106 | 2904 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
3107 | 2905 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -3110,14 +2908,14 @@ | ||
3110 | 2908 | state.addr = 325737967258195136LLU; // REPORTRES_ |
3111 | 2909 | break; |
3112 | 2910 | } |
3113 | - case 18446744073709551507LLU: // 999999998S''''''''''''''' | |
2911 | + case 18446744073709551515LLU: // 999999998$''''''''''''''' | |
3114 | 2912 | { |
3115 | 2913 | // parameter-reference resdest___ r_________ goes out of scope |
3116 | 2914 | // parameter-reference list<resdest___> rs________ goes out of scope |
3117 | - state.addr = 18446744073709551512LLU; // 999999998X''''''''''''''' | |
2915 | + state.addr = 18446744073709551520LLU; // 999999998e''''''''''''''' | |
3118 | 2916 | break; |
3119 | 2917 | } |
3120 | - case 18446744073709551511LLU: // 999999998W''''''''''''''' | |
2918 | + case 18446744073709551519LLU: // 999999998d''''''''''''''' | |
3121 | 2919 | { |
3122 | 2920 | fprintf(stderr, "%s", ")"); |
3123 | 2921 | // variable u64 first_____ goes out of scope |
@@ -3133,7 +2931,7 @@ | ||
3133 | 2931 | } |
3134 | 2932 | break; |
3135 | 2933 | } |
3136 | - case 18446744073709551505LLU: // 999999998Q''''''''''''''' | |
2934 | + case 18446744073709551513LLU: // 999999998Y''''''''''''''' | |
3137 | 2935 | { |
3138 | 2936 | // destructor for variant maintain__ |
3139 | 2937 | // RELEASE destructor-argument |
@@ -3146,7 +2944,7 @@ | ||
3146 | 2944 | } |
3147 | 2945 | break; |
3148 | 2946 | } |
3149 | - case 18446744073709551504LLU: // 999999998P''''''''''''''' | |
2947 | + case 18446744073709551512LLU: // 999999998X''''''''''''''' | |
3150 | 2948 | { |
3151 | 2949 | // destructor for variant consume___ |
3152 | 2950 | // RELEASE destructor-argument |
@@ -3159,7 +2957,7 @@ | ||
3159 | 2957 | } |
3160 | 2958 | break; |
3161 | 2959 | } |
3162 | - case 18446744073709551503LLU: // 999999998O''''''''''''''' | |
2960 | + case 18446744073709551511LLU: // 999999998W''''''''''''''' | |
3163 | 2961 | { |
3164 | 2962 | // destructor for variant produce___ |
3165 | 2963 | // RELEASE destructor-argument |
@@ -3172,11 +2970,11 @@ | ||
3172 | 2970 | } |
3173 | 2971 | break; |
3174 | 2972 | } |
3175 | - case 18446744073709551506LLU: // 999999998R''''''''''''''' | |
2973 | + case 18446744073709551514LLU: // 999999998Z''''''''''''''' | |
3176 | 2974 | { |
3177 | 2975 | struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
3178 | 2976 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1; |
3179 | - state.addr = 18446744073709551503LLU + type_data.elem0; | |
2977 | + state.addr = 18446744073709551511LLU + type_data.elem0; | |
3180 | 2978 | break; |
3181 | 2979 | } |
3182 | 2980 | case 728618437845356544LLU: // maintain__ |
@@ -3246,7 +3044,7 @@ | ||
3246 | 3044 | { |
3247 | 3045 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/) |
3248 | 3046 | { |
3249 | - state.addr = 18446744073709551502LLU; // 999999998N''''''''''''''' | |
3047 | + state.addr = 18446744073709551510LLU; // 999999998V''''''''''''''' | |
3250 | 3048 | break; |
3251 | 3049 | } |
3252 | 3050 | { |
@@ -3256,7 +3054,7 @@ | ||
3256 | 3054 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/) |
3257 | 3055 | { |
3258 | 3056 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3259 | - state.addr = 18446744073709551502LLU; // 999999998N''''''''''''''' | |
3057 | + state.addr = 18446744073709551510LLU; // 999999998V''''''''''''''' | |
3260 | 3058 | break; |
3261 | 3059 | } |
3262 | 3060 | { |
@@ -3281,11 +3079,11 @@ | ||
3281 | 3079 | } |
3282 | 3080 | break; |
3283 | 3081 | } |
3284 | - case 18446744073709551502LLU: // 999999998N''''''''''''''' | |
3082 | + case 18446744073709551510LLU: // 999999998V''''''''''''''' | |
3285 | 3083 | { |
3286 | 3084 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/) |
3287 | 3085 | { |
3288 | - state.addr = 18446744073709551501LLU; // 999999998M''''''''''''''' | |
3086 | + state.addr = 18446744073709551509LLU; // 999999998U''''''''''''''' | |
3289 | 3087 | break; |
3290 | 3088 | } |
3291 | 3089 | { |
@@ -3295,7 +3093,7 @@ | ||
3295 | 3093 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/) |
3296 | 3094 | { |
3297 | 3095 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3298 | - state.addr = 18446744073709551501LLU; // 999999998M''''''''''''''' | |
3096 | + state.addr = 18446744073709551509LLU; // 999999998U''''''''''''''' | |
3299 | 3097 | break; |
3300 | 3098 | } |
3301 | 3099 | { |
@@ -3320,11 +3118,11 @@ | ||
3320 | 3118 | } |
3321 | 3119 | break; |
3322 | 3120 | } |
3323 | - case 18446744073709551501LLU: // 999999998M''''''''''''''' | |
3121 | + case 18446744073709551509LLU: // 999999998U''''''''''''''' | |
3324 | 3122 | { |
3325 | 3123 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/) |
3326 | 3124 | { |
3327 | - state.addr = 18446744073709551500LLU; // 999999998L''''''''''''''' | |
3125 | + state.addr = 18446744073709551508LLU; // 999999998T''''''''''''''' | |
3328 | 3126 | break; |
3329 | 3127 | } |
3330 | 3128 | { |
@@ -3334,7 +3132,7 @@ | ||
3334 | 3132 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/) |
3335 | 3133 | { |
3336 | 3134 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3337 | - state.addr = 18446744073709551500LLU; // 999999998L''''''''''''''' | |
3135 | + state.addr = 18446744073709551508LLU; // 999999998T''''''''''''''' | |
3338 | 3136 | break; |
3339 | 3137 | } |
3340 | 3138 | { |
@@ -3359,11 +3157,11 @@ | ||
3359 | 3157 | } |
3360 | 3158 | break; |
3361 | 3159 | } |
3362 | - case 18446744073709551500LLU: // 999999998L''''''''''''''' | |
3160 | + case 18446744073709551508LLU: // 999999998T''''''''''''''' | |
3363 | 3161 | { |
3364 | 3162 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/) |
3365 | 3163 | { |
3366 | - state.addr = 18446744073709551499LLU; // 999999998K''''''''''''''' | |
3164 | + state.addr = 18446744073709551507LLU; // 999999998S''''''''''''''' | |
3367 | 3165 | break; |
3368 | 3166 | } |
3369 | 3167 | { |
@@ -3373,7 +3171,7 @@ | ||
3373 | 3171 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/) |
3374 | 3172 | { |
3375 | 3173 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3376 | - state.addr = 18446744073709551499LLU; // 999999998K''''''''''''''' | |
3174 | + state.addr = 18446744073709551507LLU; // 999999998S''''''''''''''' | |
3377 | 3175 | break; |
3378 | 3176 | } |
3379 | 3177 | { |
@@ -3398,11 +3196,11 @@ | ||
3398 | 3196 | } |
3399 | 3197 | break; |
3400 | 3198 | } |
3401 | - case 18446744073709551499LLU: // 999999998K''''''''''''''' | |
3199 | + case 18446744073709551507LLU: // 999999998S''''''''''''''' | |
3402 | 3200 | { |
3403 | 3201 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/) |
3404 | 3202 | { |
3405 | - state.addr = 18446744073709551498LLU; // 999999998J''''''''''''''' | |
3203 | + state.addr = 18446744073709551506LLU; // 999999998R''''''''''''''' | |
3406 | 3204 | break; |
3407 | 3205 | } |
3408 | 3206 | { |
@@ -3412,7 +3210,7 @@ | ||
3412 | 3210 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/) |
3413 | 3211 | { |
3414 | 3212 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3415 | - state.addr = 18446744073709551498LLU; // 999999998J''''''''''''''' | |
3213 | + state.addr = 18446744073709551506LLU; // 999999998R''''''''''''''' | |
3416 | 3214 | break; |
3417 | 3215 | } |
3418 | 3216 | { |
@@ -3437,11 +3235,11 @@ | ||
3437 | 3235 | } |
3438 | 3236 | break; |
3439 | 3237 | } |
3440 | - case 18446744073709551498LLU: // 999999998J''''''''''''''' | |
3238 | + case 18446744073709551506LLU: // 999999998R''''''''''''''' | |
3441 | 3239 | { |
3442 | 3240 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/) |
3443 | 3241 | { |
3444 | - state.addr = 18446744073709551497LLU; // 999999998I''''''''''''''' | |
3242 | + state.addr = 18446744073709551505LLU; // 999999998Q''''''''''''''' | |
3445 | 3243 | break; |
3446 | 3244 | } |
3447 | 3245 | { |
@@ -3451,7 +3249,7 @@ | ||
3451 | 3249 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/) |
3452 | 3250 | { |
3453 | 3251 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3454 | - state.addr = 18446744073709551497LLU; // 999999998I''''''''''''''' | |
3252 | + state.addr = 18446744073709551505LLU; // 999999998Q''''''''''''''' | |
3455 | 3253 | break; |
3456 | 3254 | } |
3457 | 3255 | { |
@@ -3476,11 +3274,11 @@ | ||
3476 | 3274 | } |
3477 | 3275 | break; |
3478 | 3276 | } |
3479 | - case 18446744073709551497LLU: // 999999998I''''''''''''''' | |
3277 | + case 18446744073709551505LLU: // 999999998Q''''''''''''''' | |
3480 | 3278 | { |
3481 | 3279 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/) |
3482 | 3280 | { |
3483 | - state.addr = 18446744073709551496LLU; // 999999998H''''''''''''''' | |
3281 | + state.addr = 18446744073709551504LLU; // 999999998P''''''''''''''' | |
3484 | 3282 | break; |
3485 | 3283 | } |
3486 | 3284 | { |
@@ -3490,7 +3288,7 @@ | ||
3490 | 3288 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/) |
3491 | 3289 | { |
3492 | 3290 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3493 | - state.addr = 18446744073709551496LLU; // 999999998H''''''''''''''' | |
3291 | + state.addr = 18446744073709551504LLU; // 999999998P''''''''''''''' | |
3494 | 3292 | break; |
3495 | 3293 | } |
3496 | 3294 | { |
@@ -3515,11 +3313,11 @@ | ||
3515 | 3313 | } |
3516 | 3314 | break; |
3517 | 3315 | } |
3518 | - case 18446744073709551496LLU: // 999999998H''''''''''''''' | |
3316 | + case 18446744073709551504LLU: // 999999998P''''''''''''''' | |
3519 | 3317 | { |
3520 | 3318 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/) |
3521 | 3319 | { |
3522 | - state.addr = 18446744073709551495LLU; // 999999998G''''''''''''''' | |
3320 | + state.addr = 18446744073709551503LLU; // 999999998O''''''''''''''' | |
3523 | 3321 | break; |
3524 | 3322 | } |
3525 | 3323 | { |
@@ -3529,7 +3327,7 @@ | ||
3529 | 3327 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/) |
3530 | 3328 | { |
3531 | 3329 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3532 | - state.addr = 18446744073709551495LLU; // 999999998G''''''''''''''' | |
3330 | + state.addr = 18446744073709551503LLU; // 999999998O''''''''''''''' | |
3533 | 3331 | break; |
3534 | 3332 | } |
3535 | 3333 | { |
@@ -3554,11 +3352,11 @@ | ||
3554 | 3352 | } |
3555 | 3353 | break; |
3556 | 3354 | } |
3557 | - case 18446744073709551495LLU: // 999999998G''''''''''''''' | |
3355 | + case 18446744073709551503LLU: // 999999998O''''''''''''''' | |
3558 | 3356 | { |
3559 | 3357 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/) |
3560 | 3358 | { |
3561 | - state.addr = 18446744073709551494LLU; // 999999998F''''''''''''''' | |
3359 | + state.addr = 18446744073709551502LLU; // 999999998N''''''''''''''' | |
3562 | 3360 | break; |
3563 | 3361 | } |
3564 | 3362 | { |
@@ -3568,7 +3366,7 @@ | ||
3568 | 3366 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/) |
3569 | 3367 | { |
3570 | 3368 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
3571 | - state.addr = 18446744073709551494LLU; // 999999998F''''''''''''''' | |
3369 | + state.addr = 18446744073709551502LLU; // 999999998N''''''''''''''' | |
3572 | 3370 | break; |
3573 | 3371 | } |
3574 | 3372 | { |
@@ -3593,206 +3391,17 @@ | ||
3593 | 3391 | } |
3594 | 3392 | break; |
3595 | 3393 | } |
3596 | - case 18446744073709551494LLU: // 999999998F''''''''''''''' | |
3394 | + case 18446744073709551502LLU: // 999999998N''''''''''''''' | |
3597 | 3395 | { |
3598 | 3396 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equbalance\n"); |
3599 | 3397 | exit(-1); |
3600 | 3398 | break; |
3601 | 3399 | } |
3602 | - case 552664889133754368LLU: // cpbalance_ | |
3603 | - { | |
3604 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*produce___*/) | |
3605 | - { | |
3606 | - state.addr = 18446744073709551493LLU; // 999999998E''''''''''''''' | |
3607 | - break; | |
3608 | - } | |
3609 | - { | |
3610 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
3611 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
3612 | - } | |
3613 | - | |
3614 | - // emitted destructur for type continuity | |
3615 | - // ACCUMULATE ARGUMENTS - BEGIN | |
3616 | - { | |
3617 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
3618 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
3619 | - } | |
3620 | - // ACCUMULATE ARGUMENTS - END | |
3621 | - uint64_t return_to = 18446744073709551492LLU; | |
3622 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
3623 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
3624 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
3625 | - heap.data[0].elem1 = heap.data[0].elem0; | |
3626 | - heap.data[0].elem0 = restore; | |
3627 | - state.addr = 18446744073709551506LLU; // 999999998R''''''''''''''' | |
3628 | - break; | |
3629 | - } | |
3630 | - case 18446744073709551492LLU: // 999999998D''''''''''''''' | |
3631 | - { | |
3632 | - // ACCUMULATE ARGUMENTS - BEGIN | |
3633 | - { | |
3634 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
3635 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
3636 | - } | |
3637 | - // ACCUMULATE ARGUMENTS - END | |
3638 | - uint64_t return_to = 18446744073709551491LLU; | |
3639 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
3640 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
3641 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
3642 | - heap.data[0].elem1 = heap.data[0].elem0; | |
3643 | - heap.data[0].elem0 = restore; | |
3644 | - state.addr = 787472410168262656LLU; // produce___ | |
3645 | - break; | |
3646 | - } | |
3647 | - case 18446744073709551491LLU: // 999999998C''''''''''''''' | |
3648 | - { | |
3649 | - // parameter-reference continuity __________ goes out of scope | |
3650 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
3651 | - // parameter continuity __________ goes out of scope | |
3652 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
3653 | - // parameter-reference continuity dst_______ goes out of scope | |
3654 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1 | |
3655 | - { | |
3656 | - uint64_t baseinfo = heap.data[0].elem1; | |
3657 | - struct pair pair = unpair(&heap, &baseinfo); | |
3658 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
3659 | - state.addr = pair.elem1; | |
3660 | - } | |
3661 | - break; | |
3662 | - } | |
3663 | - case 18446744073709551493LLU: // 999999998E''''''''''''''' | |
3664 | - { | |
3665 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*consume___*/) | |
3666 | - { | |
3667 | - state.addr = 18446744073709551490LLU; // 999999998B''''''''''''''' | |
3668 | - break; | |
3669 | - } | |
3670 | - { | |
3671 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
3672 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
3673 | - } | |
3674 | - | |
3675 | - // emitted destructur for type continuity | |
3676 | - // ACCUMULATE ARGUMENTS - BEGIN | |
3677 | - { | |
3678 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
3679 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
3680 | - } | |
3681 | - // ACCUMULATE ARGUMENTS - END | |
3682 | - uint64_t return_to = 18446744073709551489LLU; | |
3683 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
3684 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
3685 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
3686 | - heap.data[0].elem1 = heap.data[0].elem0; | |
3687 | - heap.data[0].elem0 = restore; | |
3688 | - state.addr = 18446744073709551506LLU; // 999999998R''''''''''''''' | |
3689 | - break; | |
3690 | - } | |
3691 | - case 18446744073709551489LLU: // 999999998A''''''''''''''' | |
3692 | - { | |
3693 | - // ACCUMULATE ARGUMENTS - BEGIN | |
3694 | - { | |
3695 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
3696 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
3697 | - } | |
3698 | - // ACCUMULATE ARGUMENTS - END | |
3699 | - uint64_t return_to = 18446744073709551488LLU; | |
3700 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
3701 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
3702 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
3703 | - heap.data[0].elem1 = heap.data[0].elem0; | |
3704 | - heap.data[0].elem0 = restore; | |
3705 | - state.addr = 552437437528276992LLU; // consume___ | |
3706 | - break; | |
3707 | - } | |
3708 | - case 18446744073709551488LLU: // 999999998_''''''''''''''' | |
3709 | - { | |
3710 | - // parameter-reference continuity __________ goes out of scope | |
3711 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
3712 | - // parameter continuity __________ goes out of scope | |
3713 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
3714 | - // parameter-reference continuity dst_______ goes out of scope | |
3715 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1 | |
3716 | - { | |
3717 | - uint64_t baseinfo = heap.data[0].elem1; | |
3718 | - struct pair pair = unpair(&heap, &baseinfo); | |
3719 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
3720 | - state.addr = pair.elem1; | |
3721 | - } | |
3722 | - break; | |
3723 | - } | |
3724 | - case 18446744073709551490LLU: // 999999998B''''''''''''''' | |
3725 | - { | |
3726 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*maintain__*/) | |
3727 | - { | |
3728 | - state.addr = 18446744073709551487LLU; // 9999999979''''''''''''''' | |
3729 | - break; | |
3730 | - } | |
3731 | - { | |
3732 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
3733 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
3734 | - } | |
3735 | - | |
3736 | - // emitted destructur for type continuity | |
3737 | - // ACCUMULATE ARGUMENTS - BEGIN | |
3738 | - { | |
3739 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
3740 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
3741 | - } | |
3742 | - // ACCUMULATE ARGUMENTS - END | |
3743 | - uint64_t return_to = 18446744073709551486LLU; | |
3744 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
3745 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
3746 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
3747 | - heap.data[0].elem1 = heap.data[0].elem0; | |
3748 | - heap.data[0].elem0 = restore; | |
3749 | - state.addr = 18446744073709551506LLU; // 999999998R''''''''''''''' | |
3750 | - break; | |
3751 | - } | |
3752 | - case 18446744073709551486LLU: // 9999999978''''''''''''''' | |
3753 | - { | |
3754 | - // ACCUMULATE ARGUMENTS - BEGIN | |
3755 | - { | |
3756 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
3757 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
3758 | - } | |
3759 | - // ACCUMULATE ARGUMENTS - END | |
3760 | - uint64_t return_to = 18446744073709551485LLU; | |
3761 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
3762 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
3763 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
3764 | - heap.data[0].elem1 = heap.data[0].elem0; | |
3765 | - heap.data[0].elem0 = restore; | |
3766 | - state.addr = 728618437845356544LLU; // maintain__ | |
3767 | - break; | |
3768 | - } | |
3769 | - case 18446744073709551485LLU: // 9999999977''''''''''''''' | |
3770 | - { | |
3771 | - // parameter-reference continuity __________ goes out of scope | |
3772 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
3773 | - // parameter continuity __________ goes out of scope | |
3774 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
3775 | - // parameter-reference continuity dst_______ goes out of scope | |
3776 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1 | |
3777 | - { | |
3778 | - uint64_t baseinfo = heap.data[0].elem1; | |
3779 | - struct pair pair = unpair(&heap, &baseinfo); | |
3780 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
3781 | - state.addr = pair.elem1; | |
3782 | - } | |
3783 | - break; | |
3784 | - } | |
3785 | - case 18446744073709551487LLU: // 9999999979''''''''''''''' | |
3786 | - { | |
3787 | - fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of cpbalance_\n"); | |
3788 | - exit(-1); | |
3789 | - break; | |
3790 | - } | |
3791 | 3400 | case 58555672873677120LLU: // CPBALANCE_ |
3792 | 3401 | { |
3793 | 3402 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*produce___*/) |
3794 | 3403 | { |
3795 | - state.addr = 18446744073709551484LLU; // 9999999976''''''''''''''' | |
3404 | + state.addr = 18446744073709551501LLU; // 999999998M''''''''''''''' | |
3796 | 3405 | break; |
3797 | 3406 | } |
3798 | 3407 | { |
@@ -3805,7 +3414,7 @@ | ||
3805 | 3414 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
3806 | 3415 | } |
3807 | 3416 | // ACCUMULATE ARGUMENTS - END |
3808 | - uint64_t return_to = 18446744073709551483LLU; | |
3417 | + uint64_t return_to = 18446744073709551500LLU; | |
3809 | 3418 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
3810 | 3419 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
3811 | 3420 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -3814,7 +3423,7 @@ | ||
3814 | 3423 | state.addr = 787472410168262656LLU; // produce___ |
3815 | 3424 | break; |
3816 | 3425 | } |
3817 | - case 18446744073709551483LLU: // 9999999975''''''''''''''' | |
3426 | + case 18446744073709551500LLU: // 999999998L''''''''''''''' | |
3818 | 3427 | { |
3819 | 3428 | // parameter-reference continuity __________ goes out of scope |
3820 | 3429 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
@@ -3829,11 +3438,11 @@ | ||
3829 | 3438 | } |
3830 | 3439 | break; |
3831 | 3440 | } |
3832 | - case 18446744073709551484LLU: // 9999999976''''''''''''''' | |
3441 | + case 18446744073709551501LLU: // 999999998M''''''''''''''' | |
3833 | 3442 | { |
3834 | 3443 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*consume___*/) |
3835 | 3444 | { |
3836 | - state.addr = 18446744073709551482LLU; // 9999999974''''''''''''''' | |
3445 | + state.addr = 18446744073709551499LLU; // 999999998K''''''''''''''' | |
3837 | 3446 | break; |
3838 | 3447 | } |
3839 | 3448 | { |
@@ -3846,7 +3455,7 @@ | ||
3846 | 3455 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
3847 | 3456 | } |
3848 | 3457 | // ACCUMULATE ARGUMENTS - END |
3849 | - uint64_t return_to = 18446744073709551481LLU; | |
3458 | + uint64_t return_to = 18446744073709551498LLU; | |
3850 | 3459 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
3851 | 3460 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
3852 | 3461 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -3855,7 +3464,7 @@ | ||
3855 | 3464 | state.addr = 552437437528276992LLU; // consume___ |
3856 | 3465 | break; |
3857 | 3466 | } |
3858 | - case 18446744073709551481LLU: // 9999999973''''''''''''''' | |
3467 | + case 18446744073709551498LLU: // 999999998J''''''''''''''' | |
3859 | 3468 | { |
3860 | 3469 | // parameter-reference continuity __________ goes out of scope |
3861 | 3470 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
@@ -3870,11 +3479,11 @@ | ||
3870 | 3479 | } |
3871 | 3480 | break; |
3872 | 3481 | } |
3873 | - case 18446744073709551482LLU: // 9999999974''''''''''''''' | |
3482 | + case 18446744073709551499LLU: // 999999998K''''''''''''''' | |
3874 | 3483 | { |
3875 | 3484 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*maintain__*/) |
3876 | 3485 | { |
3877 | - state.addr = 18446744073709551480LLU; // 9999999972''''''''''''''' | |
3486 | + state.addr = 18446744073709551497LLU; // 999999998I''''''''''''''' | |
3878 | 3487 | break; |
3879 | 3488 | } |
3880 | 3489 | { |
@@ -3887,7 +3496,7 @@ | ||
3887 | 3496 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
3888 | 3497 | } |
3889 | 3498 | // ACCUMULATE ARGUMENTS - END |
3890 | - uint64_t return_to = 18446744073709551479LLU; | |
3499 | + uint64_t return_to = 18446744073709551496LLU; | |
3891 | 3500 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
3892 | 3501 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
3893 | 3502 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -3896,7 +3505,7 @@ | ||
3896 | 3505 | state.addr = 728618437845356544LLU; // maintain__ |
3897 | 3506 | break; |
3898 | 3507 | } |
3899 | - case 18446744073709551479LLU: // 9999999971''''''''''''''' | |
3508 | + case 18446744073709551496LLU: // 999999998H''''''''''''''' | |
3900 | 3509 | { |
3901 | 3510 | // parameter-reference continuity __________ goes out of scope |
3902 | 3511 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
@@ -3911,13 +3520,13 @@ | ||
3911 | 3520 | } |
3912 | 3521 | break; |
3913 | 3522 | } |
3914 | - case 18446744073709551480LLU: // 9999999972''''''''''''''' | |
3523 | + case 18446744073709551497LLU: // 999999998I''''''''''''''' | |
3915 | 3524 | { |
3916 | 3525 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CPBALANCE_\n"); |
3917 | 3526 | exit(-1); |
3918 | 3527 | break; |
3919 | 3528 | } |
3920 | - case 18446744073709551477LLU: // 999999997z''''''''''''''' | |
3529 | + case 18446744073709551494LLU: // 999999998F''''''''''''''' | |
3921 | 3530 | { |
3922 | 3531 | // destructor for variant blkloop___ |
3923 | 3532 | // RELEASE destructor-argument |
@@ -3930,7 +3539,7 @@ | ||
3930 | 3539 | } |
3931 | 3540 | break; |
3932 | 3541 | } |
3933 | - case 18446744073709551476LLU: // 999999997y''''''''''''''' | |
3542 | + case 18446744073709551493LLU: // 999999998E''''''''''''''' | |
3934 | 3543 | { |
3935 | 3544 | // destructor for variant blkelse___ |
3936 | 3545 | // RELEASE destructor-argument |
@@ -3943,7 +3552,7 @@ | ||
3943 | 3552 | } |
3944 | 3553 | break; |
3945 | 3554 | } |
3946 | - case 18446744073709551475LLU: // 999999997x''''''''''''''' | |
3555 | + case 18446744073709551492LLU: // 999999998D''''''''''''''' | |
3947 | 3556 | { |
3948 | 3557 | // destructor for variant blkif_____ |
3949 | 3558 | // RELEASE destructor-argument |
@@ -3956,7 +3565,7 @@ | ||
3956 | 3565 | } |
3957 | 3566 | break; |
3958 | 3567 | } |
3959 | - case 18446744073709551474LLU: // 999999997w''''''''''''''' | |
3568 | + case 18446744073709551491LLU: // 999999998C''''''''''''''' | |
3960 | 3569 | { |
3961 | 3570 | // destructor for variant blkwhen___ |
3962 | 3571 | // RELEASE destructor-argument |
@@ -3969,7 +3578,7 @@ | ||
3969 | 3578 | } |
3970 | 3579 | break; |
3971 | 3580 | } |
3972 | - case 18446744073709551473LLU: // 999999997v''''''''''''''' | |
3581 | + case 18446744073709551490LLU: // 999999998B''''''''''''''' | |
3973 | 3582 | { |
3974 | 3583 | // destructor for variant blknone___ |
3975 | 3584 | // RELEASE destructor-argument |
@@ -3982,11 +3591,11 @@ | ||
3982 | 3591 | } |
3983 | 3592 | break; |
3984 | 3593 | } |
3985 | - case 18446744073709551478LLU: // 9999999970''''''''''''''' | |
3594 | + case 18446744073709551495LLU: // 999999998G''''''''''''''' | |
3986 | 3595 | { |
3987 | 3596 | struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
3988 | 3597 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1; |
3989 | - state.addr = 18446744073709551473LLU + type_data.elem0; | |
3598 | + state.addr = 18446744073709551490LLU + type_data.elem0; | |
3990 | 3599 | break; |
3991 | 3600 | } |
3992 | 3601 | case 533564932506779648LLU: // blkloop___ |
@@ -4098,7 +3707,7 @@ | ||
4098 | 3707 | { |
4099 | 3708 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*blknone___*/) |
4100 | 3709 | { |
4101 | - state.addr = 18446744073709551472LLU; // 999999997u''''''''''''''' | |
3710 | + state.addr = 18446744073709551489LLU; // 999999998A''''''''''''''' | |
4102 | 3711 | break; |
4103 | 3712 | } |
4104 | 3713 | { |
@@ -4118,11 +3727,11 @@ | ||
4118 | 3727 | } |
4119 | 3728 | break; |
4120 | 3729 | } |
4121 | - case 18446744073709551472LLU: // 999999997u''''''''''''''' | |
3730 | + case 18446744073709551489LLU: // 999999998A''''''''''''''' | |
4122 | 3731 | { |
4123 | 3732 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*blkwhen___*/) |
4124 | 3733 | { |
4125 | - state.addr = 18446744073709551471LLU; // 999999997t''''''''''''''' | |
3734 | + state.addr = 18446744073709551488LLU; // 999999998_''''''''''''''' | |
4126 | 3735 | break; |
4127 | 3736 | } |
4128 | 3737 | { |
@@ -4142,11 +3751,11 @@ | ||
4142 | 3751 | } |
4143 | 3752 | break; |
4144 | 3753 | } |
4145 | - case 18446744073709551471LLU: // 999999997t''''''''''''''' | |
3754 | + case 18446744073709551488LLU: // 999999998_''''''''''''''' | |
4146 | 3755 | { |
4147 | 3756 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*blkif_____*/) |
4148 | 3757 | { |
4149 | - state.addr = 18446744073709551470LLU; // 999999997s''''''''''''''' | |
3758 | + state.addr = 18446744073709551487LLU; // 9999999979''''''''''''''' | |
4150 | 3759 | break; |
4151 | 3760 | } |
4152 | 3761 | { |
@@ -4166,11 +3775,11 @@ | ||
4166 | 3775 | } |
4167 | 3776 | break; |
4168 | 3777 | } |
4169 | - case 18446744073709551470LLU: // 999999997s''''''''''''''' | |
3778 | + case 18446744073709551487LLU: // 9999999979''''''''''''''' | |
4170 | 3779 | { |
4171 | 3780 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*blkelse___*/) |
4172 | 3781 | { |
4173 | - state.addr = 18446744073709551469LLU; // 999999997r''''''''''''''' | |
3782 | + state.addr = 18446744073709551486LLU; // 9999999978''''''''''''''' | |
4174 | 3783 | break; |
4175 | 3784 | } |
4176 | 3785 | { |
@@ -4190,11 +3799,11 @@ | ||
4190 | 3799 | } |
4191 | 3800 | break; |
4192 | 3801 | } |
4193 | - case 18446744073709551469LLU: // 999999997r''''''''''''''' | |
3802 | + case 18446744073709551486LLU: // 9999999978''''''''''''''' | |
4194 | 3803 | { |
4195 | 3804 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*blkloop___*/) |
4196 | 3805 | { |
4197 | - state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
3806 | + state.addr = 18446744073709551485LLU; // 9999999977''''''''''''''' | |
4198 | 3807 | break; |
4199 | 3808 | } |
4200 | 3809 | { |
@@ -4214,13 +3823,13 @@ | ||
4214 | 3823 | } |
4215 | 3824 | break; |
4216 | 3825 | } |
4217 | - case 18446744073709551468LLU: // 999999997q''''''''''''''' | |
3826 | + case 18446744073709551485LLU: // 9999999977''''''''''''''' | |
4218 | 3827 | { |
4219 | 3828 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportblk_\n"); |
4220 | 3829 | exit(-1); |
4221 | 3830 | break; |
4222 | 3831 | } |
4223 | - case 18446744073709551466LLU: // 999999997o''''''''''''''' | |
3832 | + case 18446744073709551483LLU: // 9999999975''''''''''''''' | |
4224 | 3833 | { |
4225 | 3834 | // destructor for variant varhide___ |
4226 | 3835 | // RELEASE destructor-argument |
@@ -4233,7 +3842,7 @@ | ||
4233 | 3842 | } |
4234 | 3843 | break; |
4235 | 3844 | } |
4236 | - case 18446744073709551465LLU: // 999999997n''''''''''''''' | |
3845 | + case 18446744073709551482LLU: // 9999999974''''''''''''''' | |
4237 | 3846 | { |
4238 | 3847 | // destructor for variant elblock___ |
4239 | 3848 | { |
@@ -4253,7 +3862,7 @@ | ||
4253 | 3862 | } |
4254 | 3863 | break; |
4255 | 3864 | } |
4256 | - case 18446744073709551464LLU: // 999999997m''''''''''''''' | |
3865 | + case 18446744073709551481LLU: // 9999999973''''''''''''''' | |
4257 | 3866 | { |
4258 | 3867 | // destructor for variant varblock__ |
4259 | 3868 | // RELEASE destructor-argument |
@@ -4266,7 +3875,7 @@ | ||
4266 | 3875 | } |
4267 | 3876 | break; |
4268 | 3877 | } |
4269 | - case 18446744073709551463LLU: // 999999997l''''''''''''''' | |
3878 | + case 18446744073709551480LLU: // 9999999972''''''''''''''' | |
4270 | 3879 | { |
4271 | 3880 | // destructor for variant varvirt___ |
4272 | 3881 | { |
@@ -4294,16 +3903,16 @@ | ||
4294 | 3903 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
4295 | 3904 | } |
4296 | 3905 | // ACCUMULATE ARGUMENTS - END |
4297 | - uint64_t return_to = 18446744073709551460LLU; | |
3906 | + uint64_t return_to = 18446744073709551477LLU; | |
4298 | 3907 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
4299 | 3908 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
4300 | 3909 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
4301 | 3910 | heap.data[0].elem1 = heap.data[0].elem0; |
4302 | 3911 | heap.data[0].elem0 = restore; |
4303 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
3912 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
4304 | 3913 | break; |
4305 | 3914 | } |
4306 | - case 18446744073709551460LLU: // 999999997i''''''''''''''' | |
3915 | + case 18446744073709551477LLU: // 999999997z''''''''''''''' | |
4307 | 3916 | { |
4308 | 3917 | // RELEASE temporary destructor-variable |
4309 | 3918 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -4331,7 +3940,7 @@ | ||
4331 | 3940 | } |
4332 | 3941 | break; |
4333 | 3942 | } |
4334 | - case 18446744073709551462LLU: // 999999997k''''''''''''''' | |
3943 | + case 18446744073709551479LLU: // 9999999971''''''''''''''' | |
4335 | 3944 | { |
4336 | 3945 | // destructor for variant varref____ |
4337 | 3946 | { |
@@ -4366,16 +3975,16 @@ | ||
4366 | 3975 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
4367 | 3976 | } |
4368 | 3977 | // ACCUMULATE ARGUMENTS - END |
4369 | - uint64_t return_to = 18446744073709551459LLU; | |
3978 | + uint64_t return_to = 18446744073709551476LLU; | |
4370 | 3979 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
4371 | 3980 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
4372 | 3981 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
4373 | 3982 | heap.data[0].elem1 = heap.data[0].elem0; |
4374 | 3983 | heap.data[0].elem0 = restore; |
4375 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
3984 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
4376 | 3985 | break; |
4377 | 3986 | } |
4378 | - case 18446744073709551459LLU: // 999999997h''''''''''''''' | |
3987 | + case 18446744073709551476LLU: // 999999997y''''''''''''''' | |
4379 | 3988 | { |
4380 | 3989 | // RELEASE temporary destructor-variable |
4381 | 3990 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -4403,7 +4012,7 @@ | ||
4403 | 4012 | } |
4404 | 4013 | break; |
4405 | 4014 | } |
4406 | - case 18446744073709551461LLU: // 999999997j''''''''''''''' | |
4015 | + case 18446744073709551478LLU: // 9999999970''''''''''''''' | |
4407 | 4016 | { |
4408 | 4017 | // destructor for variant varvar____ |
4409 | 4018 | { |
@@ -4431,16 +4040,16 @@ | ||
4431 | 4040 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
4432 | 4041 | } |
4433 | 4042 | // ACCUMULATE ARGUMENTS - END |
4434 | - uint64_t return_to = 18446744073709551458LLU; | |
4043 | + uint64_t return_to = 18446744073709551475LLU; | |
4435 | 4044 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
4436 | 4045 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
4437 | 4046 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
4438 | 4047 | heap.data[0].elem1 = heap.data[0].elem0; |
4439 | 4048 | heap.data[0].elem0 = restore; |
4440 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
4049 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
4441 | 4050 | break; |
4442 | 4051 | } |
4443 | - case 18446744073709551458LLU: // 999999997g''''''''''''''' | |
4052 | + case 18446744073709551475LLU: // 999999997x''''''''''''''' | |
4444 | 4053 | { |
4445 | 4054 | // RELEASE temporary destructor-variable |
4446 | 4055 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -4468,11 +4077,11 @@ | ||
4468 | 4077 | } |
4469 | 4078 | break; |
4470 | 4079 | } |
4471 | - case 18446744073709551467LLU: // 999999997p''''''''''''''' | |
4080 | + case 18446744073709551484LLU: // 9999999976''''''''''''''' | |
4472 | 4081 | { |
4473 | 4082 | struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
4474 | 4083 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1; |
4475 | - state.addr = 18446744073709551461LLU + type_data.elem0; | |
4084 | + state.addr = 18446744073709551478LLU + type_data.elem0; | |
4476 | 4085 | break; |
4477 | 4086 | } |
4478 | 4087 | case 890787182770388992LLU: // varhide___ |
@@ -4724,7 +4333,7 @@ | ||
4724 | 4333 | { |
4725 | 4334 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*varvar____*/) |
4726 | 4335 | { |
4727 | - state.addr = 18446744073709551457LLU; // 999999997f''''''''''''''' | |
4336 | + state.addr = 18446744073709551474LLU; // 999999997w''''''''''''''' | |
4728 | 4337 | break; |
4729 | 4338 | } |
4730 | 4339 | { |
@@ -4744,11 +4353,11 @@ | ||
4744 | 4353 | } |
4745 | 4354 | break; |
4746 | 4355 | } |
4747 | - case 18446744073709551457LLU: // 999999997f''''''''''''''' | |
4356 | + case 18446744073709551474LLU: // 999999997w''''''''''''''' | |
4748 | 4357 | { |
4749 | 4358 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*varref____*/) |
4750 | 4359 | { |
4751 | - state.addr = 18446744073709551456LLU; // 999999997e''''''''''''''' | |
4360 | + state.addr = 18446744073709551473LLU; // 999999997v''''''''''''''' | |
4752 | 4361 | break; |
4753 | 4362 | } |
4754 | 4363 | { |
@@ -4768,11 +4377,11 @@ | ||
4768 | 4377 | } |
4769 | 4378 | break; |
4770 | 4379 | } |
4771 | - case 18446744073709551456LLU: // 999999997e''''''''''''''' | |
4380 | + case 18446744073709551473LLU: // 999999997v''''''''''''''' | |
4772 | 4381 | { |
4773 | 4382 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*varvirt___*/) |
4774 | 4383 | { |
4775 | - state.addr = 18446744073709551455LLU; // 999999997d''''''''''''''' | |
4384 | + state.addr = 18446744073709551472LLU; // 999999997u''''''''''''''' | |
4776 | 4385 | break; |
4777 | 4386 | } |
4778 | 4387 | { |
@@ -4792,11 +4401,11 @@ | ||
4792 | 4401 | } |
4793 | 4402 | break; |
4794 | 4403 | } |
4795 | - case 18446744073709551455LLU: // 999999997d''''''''''''''' | |
4404 | + case 18446744073709551472LLU: // 999999997u''''''''''''''' | |
4796 | 4405 | { |
4797 | 4406 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*varblock__*/) |
4798 | 4407 | { |
4799 | - state.addr = 18446744073709551454LLU; // 999999997c''''''''''''''' | |
4408 | + state.addr = 18446744073709551471LLU; // 999999997t''''''''''''''' | |
4800 | 4409 | break; |
4801 | 4410 | } |
4802 | 4411 | { |
@@ -4816,11 +4425,11 @@ | ||
4816 | 4425 | } |
4817 | 4426 | break; |
4818 | 4427 | } |
4819 | - case 18446744073709551454LLU: // 999999997c''''''''''''''' | |
4428 | + case 18446744073709551471LLU: // 999999997t''''''''''''''' | |
4820 | 4429 | { |
4821 | 4430 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*elblock___*/) |
4822 | 4431 | { |
4823 | - state.addr = 18446744073709551453LLU; // 999999997b''''''''''''''' | |
4432 | + state.addr = 18446744073709551470LLU; // 999999997s''''''''''''''' | |
4824 | 4433 | break; |
4825 | 4434 | } |
4826 | 4435 | { |
@@ -4840,11 +4449,11 @@ | ||
4840 | 4449 | } |
4841 | 4450 | break; |
4842 | 4451 | } |
4843 | - case 18446744073709551453LLU: // 999999997b''''''''''''''' | |
4452 | + case 18446744073709551470LLU: // 999999997s''''''''''''''' | |
4844 | 4453 | { |
4845 | 4454 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 5/*varhide___*/) |
4846 | 4455 | { |
4847 | - state.addr = 18446744073709551452LLU; // 999999997a''''''''''''''' | |
4456 | + state.addr = 18446744073709551469LLU; // 999999997r''''''''''''''' | |
4848 | 4457 | break; |
4849 | 4458 | } |
4850 | 4459 | { |
@@ -4864,13 +4473,13 @@ | ||
4864 | 4473 | } |
4865 | 4474 | break; |
4866 | 4475 | } |
4867 | - case 18446744073709551452LLU: // 999999997a''''''''''''''' | |
4476 | + case 18446744073709551469LLU: // 999999997r''''''''''''''' | |
4868 | 4477 | { |
4869 | 4478 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportvar_\n"); |
4870 | 4479 | exit(-1); |
4871 | 4480 | break; |
4872 | 4481 | } |
4873 | - case 18446744073709551451LLU: // 999999997$''''''''''''''' | |
4482 | + case 18446744073709551468LLU: // 999999997q''''''''''''''' | |
4874 | 4483 | { |
4875 | 4484 | { |
4876 | 4485 | uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -4890,16 +4499,16 @@ | ||
4890 | 4499 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
4891 | 4500 | } |
4892 | 4501 | // ACCUMULATE ARGUMENTS - END |
4893 | - uint64_t return_to = 18446744073709551450LLU; | |
4502 | + uint64_t return_to = 18446744073709551467LLU; | |
4894 | 4503 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
4895 | 4504 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
4896 | 4505 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
4897 | 4506 | heap.data[0].elem1 = heap.data[0].elem0; |
4898 | 4507 | heap.data[0].elem0 = restore; |
4899 | - state.addr = 18446744073709551506LLU; // 999999998R''''''''''''''' | |
4508 | + state.addr = 18446744073709551514LLU; // 999999998Z''''''''''''''' | |
4900 | 4509 | break; |
4901 | 4510 | } |
4902 | - case 18446744073709551450LLU: // 999999997Z''''''''''''''' | |
4511 | + case 18446744073709551467LLU: // 999999997p''''''''''''''' | |
4903 | 4512 | { |
4904 | 4513 | // RELEASE temporary destructor-variable |
4905 | 4514 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -4921,16 +4530,16 @@ | ||
4921 | 4530 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
4922 | 4531 | } |
4923 | 4532 | // ACCUMULATE ARGUMENTS - END |
4924 | - uint64_t return_to = 18446744073709551449LLU; | |
4533 | + uint64_t return_to = 18446744073709551466LLU; | |
4925 | 4534 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
4926 | 4535 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
4927 | 4536 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
4928 | 4537 | heap.data[0].elem1 = heap.data[0].elem0; |
4929 | 4538 | heap.data[0].elem0 = restore; |
4930 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
4539 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
4931 | 4540 | break; |
4932 | 4541 | } |
4933 | - case 18446744073709551449LLU: // 999999997Y''''''''''''''' | |
4542 | + case 18446744073709551466LLU: // 999999997o''''''''''''''' | |
4934 | 4543 | { |
4935 | 4544 | // RELEASE temporary destructor-variable |
4936 | 4545 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -4989,7 +4598,7 @@ | ||
4989 | 4598 | } |
4990 | 4599 | break; |
4991 | 4600 | } |
4992 | - case 18446744073709551448LLU: // 999999997X''''''''''''''' | |
4601 | + case 18446744073709551465LLU: // 999999997n''''''''''''''' | |
4993 | 4602 | { |
4994 | 4603 | { |
4995 | 4604 | uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -5002,16 +4611,16 @@ | ||
5002 | 4611 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5003 | 4612 | } |
5004 | 4613 | // ACCUMULATE ARGUMENTS - END |
5005 | - uint64_t return_to = 18446744073709551447LLU; | |
4614 | + uint64_t return_to = 18446744073709551464LLU; | |
5006 | 4615 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5007 | 4616 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5008 | 4617 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
5009 | 4618 | heap.data[0].elem1 = heap.data[0].elem0; |
5010 | 4619 | heap.data[0].elem0 = restore; |
5011 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
4620 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
5012 | 4621 | break; |
5013 | 4622 | } |
5014 | - case 18446744073709551447LLU: // 999999997W''''''''''''''' | |
4623 | + case 18446744073709551464LLU: // 999999997m''''''''''''''' | |
5015 | 4624 | { |
5016 | 4625 | // RELEASE temporary destructor-variable |
5017 | 4626 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -5063,7 +4672,7 @@ | ||
5063 | 4672 | } |
5064 | 4673 | break; |
5065 | 4674 | } |
5066 | - case 18446744073709551446LLU: // 999999997V''''''''''''''' | |
4675 | + case 18446744073709551463LLU: // 999999997l''''''''''''''' | |
5067 | 4676 | { |
5068 | 4677 | { |
5069 | 4678 | uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -5083,16 +4692,16 @@ | ||
5083 | 4692 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5084 | 4693 | } |
5085 | 4694 | // ACCUMULATE ARGUMENTS - END |
5086 | - uint64_t return_to = 18446744073709551445LLU; | |
4695 | + uint64_t return_to = 18446744073709551462LLU; | |
5087 | 4696 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5088 | 4697 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5089 | 4698 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
5090 | 4699 | heap.data[0].elem1 = heap.data[0].elem0; |
5091 | 4700 | heap.data[0].elem0 = restore; |
5092 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
4701 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
5093 | 4702 | break; |
5094 | 4703 | } |
5095 | - case 18446744073709551445LLU: // 999999997U''''''''''''''' | |
4704 | + case 18446744073709551462LLU: // 999999997k''''''''''''''' | |
5096 | 4705 | { |
5097 | 4706 | // RELEASE temporary destructor-variable |
5098 | 4707 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -5114,16 +4723,16 @@ | ||
5114 | 4723 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5115 | 4724 | } |
5116 | 4725 | // ACCUMULATE ARGUMENTS - END |
5117 | - uint64_t return_to = 18446744073709551444LLU; | |
4726 | + uint64_t return_to = 18446744073709551461LLU; | |
5118 | 4727 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5119 | 4728 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5120 | 4729 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
5121 | 4730 | heap.data[0].elem1 = heap.data[0].elem0; |
5122 | 4731 | heap.data[0].elem0 = restore; |
5123 | - state.addr = 18446744073709551506LLU; // 999999998R''''''''''''''' | |
4732 | + state.addr = 18446744073709551514LLU; // 999999998Z''''''''''''''' | |
5124 | 4733 | break; |
5125 | 4734 | } |
5126 | - case 18446744073709551444LLU: // 999999997T''''''''''''''' | |
4735 | + case 18446744073709551461LLU: // 999999997j''''''''''''''' | |
5127 | 4736 | { |
5128 | 4737 | // RELEASE temporary destructor-variable |
5129 | 4738 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -5240,26 +4849,45 @@ | ||
5240 | 4849 | } |
5241 | 4850 | |
5242 | 4851 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 2LLU)) = /*indirect1_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 7LLU)); |
4852 | + | |
4853 | + // emitted destructur for type continuity | |
5243 | 4854 | // ACCUMULATE ARGUMENTS - BEGIN |
5244 | 4855 | { |
5245 | - uint64_t arg = /*cont0_____*/*LOCAL_ACCESS(heap.data, 12LLU, 3LLU); | |
4856 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 3LLU); | |
5246 | 4857 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5247 | 4858 | } |
4859 | + // ACCUMULATE ARGUMENTS - END | |
4860 | + uint64_t return_to = 18446744073709551459LLU; | |
4861 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
4862 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
4863 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
4864 | + heap.data[0].elem1 = heap.data[0].elem0; | |
4865 | + heap.data[0].elem0 = restore; | |
4866 | + state.addr = 18446744073709551514LLU; // 999999998Z''''''''''''''' | |
4867 | + break; | |
4868 | + } | |
4869 | + case 18446744073709551459LLU: // 999999997h''''''''''''''' | |
4870 | + { | |
4871 | + // ACCUMULATE ARGUMENTS - BEGIN | |
5248 | 4872 | { |
4873 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 3LLU); | |
4874 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
4875 | + } | |
4876 | + { | |
5249 | 4877 | uint64_t arg = /*cont1_____*/*LOCAL_ACCESS(heap.data, 12LLU, 8LLU); |
5250 | 4878 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5251 | 4879 | } |
5252 | 4880 | // ACCUMULATE ARGUMENTS - END |
5253 | - uint64_t return_to = 18446744073709551442LLU; | |
4881 | + uint64_t return_to = 18446744073709551458LLU; | |
5254 | 4882 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5255 | 4883 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5256 | 4884 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
5257 | 4885 | heap.data[0].elem1 = heap.data[0].elem0; |
5258 | 4886 | heap.data[0].elem0 = restore; |
5259 | - state.addr = 552664889133754368LLU; // cpbalance_ | |
4887 | + state.addr = 58555672873677120LLU; // CPBALANCE_ | |
5260 | 4888 | break; |
5261 | 4889 | } |
5262 | - case 18446744073709551442LLU: // 999999997R''''''''''''''' | |
4890 | + case 18446744073709551458LLU: // 999999997g''''''''''''''' | |
5263 | 4891 | { |
5264 | 4892 | |
5265 | 4893 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 4LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 9LLU)); |
@@ -5271,16 +4899,16 @@ | ||
5271 | 4899 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5272 | 4900 | } |
5273 | 4901 | // ACCUMULATE ARGUMENTS - END |
5274 | - uint64_t return_to = 18446744073709551441LLU; | |
4902 | + uint64_t return_to = 18446744073709551457LLU; | |
5275 | 4903 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5276 | 4904 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5277 | 4905 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
5278 | 4906 | heap.data[0].elem1 = heap.data[0].elem0; |
5279 | 4907 | heap.data[0].elem0 = restore; |
5280 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
4908 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
5281 | 4909 | break; |
5282 | 4910 | } |
5283 | - case 18446744073709551441LLU: // 999999997Q''''''''''''''' | |
4911 | + case 18446744073709551457LLU: // 999999997f''''''''''''''' | |
5284 | 4912 | { |
5285 | 4913 | // ACCUMULATE ARGUMENTS - BEGIN |
5286 | 4914 | { |
@@ -5292,7 +4920,7 @@ | ||
5292 | 4920 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5293 | 4921 | } |
5294 | 4922 | // ACCUMULATE ARGUMENTS - END |
5295 | - uint64_t return_to = 18446744073709551440LLU; | |
4923 | + uint64_t return_to = 18446744073709551456LLU; | |
5296 | 4924 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5297 | 4925 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5298 | 4926 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5301,7 +4929,7 @@ | ||
5301 | 4929 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
5302 | 4930 | break; |
5303 | 4931 | } |
5304 | - case 18446744073709551440LLU: // 999999997P''''''''''''''' | |
4932 | + case 18446744073709551456LLU: // 999999997e''''''''''''''' | |
5305 | 4933 | { |
5306 | 4934 | |
5307 | 4935 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 6LLU)) = /*curidx1___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 11LLU)); |
@@ -5354,7 +4982,7 @@ | ||
5354 | 4982 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5355 | 4983 | } |
5356 | 4984 | // ACCUMULATE ARGUMENTS - END |
5357 | - uint64_t return_to = 18446744073709551439LLU; | |
4985 | + uint64_t return_to = 18446744073709551455LLU; | |
5358 | 4986 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
5359 | 4987 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5360 | 4988 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5363,7 +4991,7 @@ | ||
5363 | 4991 | state.addr = 589060043891015680LLU; // equtype___ |
5364 | 4992 | break; |
5365 | 4993 | } |
5366 | - case 18446744073709551439LLU: // 999999997O''''''''''''''' | |
4994 | + case 18446744073709551455LLU: // 999999997d''''''''''''''' | |
5367 | 4995 | { |
5368 | 4996 | { |
5369 | 4997 | uint64_t arg = 0; |
@@ -5370,22 +4998,22 @@ | ||
5370 | 4998 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5371 | 4999 | } |
5372 | 5000 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5373 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551438LLU : 18446744073709551437LLU; | |
5001 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551454LLU : 18446744073709551453LLU; | |
5374 | 5002 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5375 | 5003 | break; |
5376 | 5004 | } |
5377 | - case 18446744073709551438LLU: // 999999997N''''''''''''''' | |
5005 | + case 18446744073709551454LLU: // 999999997c''''''''''''''' | |
5378 | 5006 | { |
5379 | - state.addr = 18446744073709551436LLU; // 999999997L''''''''''''''' | |
5007 | + state.addr = 18446744073709551452LLU; // 999999997a''''''''''''''' | |
5380 | 5008 | break; |
5381 | 5009 | } |
5382 | - case 18446744073709551437LLU: // 999999997M''''''''''''''' | |
5010 | + case 18446744073709551453LLU: // 999999997b''''''''''''''' | |
5383 | 5011 | { |
5384 | 5012 | fprintf(stderr, "%s", "type"); |
5385 | - state.addr = 18446744073709551436LLU; // 999999997L''''''''''''''' | |
5013 | + state.addr = 18446744073709551452LLU; // 999999997a''''''''''''''' | |
5386 | 5014 | break; |
5387 | 5015 | } |
5388 | - case 18446744073709551436LLU: // 999999997L''''''''''''''' | |
5016 | + case 18446744073709551452LLU: // 999999997a''''''''''''''' | |
5389 | 5017 | { |
5390 | 5018 | { |
5391 | 5019 | uint64_t arg = 0; |
@@ -5392,11 +5020,11 @@ | ||
5392 | 5020 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5393 | 5021 | } |
5394 | 5022 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5395 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551435LLU : 18446744073709551434LLU; | |
5023 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551451LLU : 18446744073709551450LLU; | |
5396 | 5024 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5397 | 5025 | break; |
5398 | 5026 | } |
5399 | - case 18446744073709551435LLU: // 999999997K''''''''''''''' | |
5027 | + case 18446744073709551451LLU: // 999999997$''''''''''''''' | |
5400 | 5028 | { |
5401 | 5029 | |
5402 | 5030 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU)); |
@@ -5405,22 +5033,22 @@ | ||
5405 | 5033 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5406 | 5034 | } |
5407 | 5035 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5408 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551433LLU : 18446744073709551432LLU; | |
5036 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551449LLU : 18446744073709551448LLU; | |
5409 | 5037 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5410 | 5038 | break; |
5411 | 5039 | } |
5412 | - case 18446744073709551433LLU: // 999999997I''''''''''''''' | |
5040 | + case 18446744073709551449LLU: // 999999997Y''''''''''''''' | |
5413 | 5041 | { |
5414 | - state.addr = 18446744073709551431LLU; // 999999997G''''''''''''''' | |
5042 | + state.addr = 18446744073709551447LLU; // 999999997W''''''''''''''' | |
5415 | 5043 | break; |
5416 | 5044 | } |
5417 | - case 18446744073709551432LLU: // 999999997H''''''''''''''' | |
5045 | + case 18446744073709551448LLU: // 999999997X''''''''''''''' | |
5418 | 5046 | { |
5419 | 5047 | fprintf(stderr, "%s", "mutable"); |
5420 | - state.addr = 18446744073709551431LLU; // 999999997G''''''''''''''' | |
5048 | + state.addr = 18446744073709551447LLU; // 999999997W''''''''''''''' | |
5421 | 5049 | break; |
5422 | 5050 | } |
5423 | - case 18446744073709551431LLU: // 999999997G''''''''''''''' | |
5051 | + case 18446744073709551447LLU: // 999999997W''''''''''''''' | |
5424 | 5052 | { |
5425 | 5053 | { |
5426 | 5054 | uint64_t arg = 0; |
@@ -5427,11 +5055,11 @@ | ||
5427 | 5055 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5428 | 5056 | } |
5429 | 5057 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5430 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551430LLU : 18446744073709551429LLU; | |
5058 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551446LLU : 18446744073709551445LLU; | |
5431 | 5059 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5432 | 5060 | break; |
5433 | 5061 | } |
5434 | - case 18446744073709551430LLU: // 999999997F''''''''''''''' | |
5062 | + case 18446744073709551446LLU: // 999999997V''''''''''''''' | |
5435 | 5063 | { |
5436 | 5064 | |
5437 | 5065 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -5448,7 +5076,7 @@ | ||
5448 | 5076 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5449 | 5077 | } |
5450 | 5078 | // ACCUMULATE ARGUMENTS - END |
5451 | - uint64_t return_to = 18446744073709551428LLU; | |
5079 | + uint64_t return_to = 18446744073709551444LLU; | |
5452 | 5080 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
5453 | 5081 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5454 | 5082 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5457,7 +5085,7 @@ | ||
5457 | 5085 | state.addr = 589058781102643104LLU; // equbalance |
5458 | 5086 | break; |
5459 | 5087 | } |
5460 | - case 18446744073709551428LLU: // 999999997D''''''''''''''' | |
5088 | + case 18446744073709551444LLU: // 999999997T''''''''''''''' | |
5461 | 5089 | { |
5462 | 5090 | { |
5463 | 5091 | uint64_t arg = 0; |
@@ -5464,22 +5092,22 @@ | ||
5464 | 5092 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5465 | 5093 | } |
5466 | 5094 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5467 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551427LLU : 18446744073709551426LLU; | |
5095 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551443LLU : 18446744073709551442LLU; | |
5468 | 5096 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5469 | 5097 | break; |
5470 | 5098 | } |
5471 | - case 18446744073709551427LLU: // 999999997C''''''''''''''' | |
5099 | + case 18446744073709551443LLU: // 999999997S''''''''''''''' | |
5472 | 5100 | { |
5473 | - state.addr = 18446744073709551425LLU; // 999999997A''''''''''''''' | |
5101 | + state.addr = 18446744073709551441LLU; // 999999997Q''''''''''''''' | |
5474 | 5102 | break; |
5475 | 5103 | } |
5476 | - case 18446744073709551426LLU: // 999999997B''''''''''''''' | |
5104 | + case 18446744073709551442LLU: // 999999997R''''''''''''''' | |
5477 | 5105 | { |
5478 | 5106 | fprintf(stderr, "%s", "continuity"); |
5479 | - state.addr = 18446744073709551425LLU; // 999999997A''''''''''''''' | |
5107 | + state.addr = 18446744073709551441LLU; // 999999997Q''''''''''''''' | |
5480 | 5108 | break; |
5481 | 5109 | } |
5482 | - case 18446744073709551425LLU: // 999999997A''''''''''''''' | |
5110 | + case 18446744073709551441LLU: // 999999997Q''''''''''''''' | |
5483 | 5111 | { |
5484 | 5112 | { |
5485 | 5113 | uint64_t arg = 0; |
@@ -5486,11 +5114,11 @@ | ||
5486 | 5114 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5487 | 5115 | } |
5488 | 5116 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5489 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551424LLU : 18446744073709551423LLU; | |
5117 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551440LLU : 18446744073709551439LLU; | |
5490 | 5118 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5491 | 5119 | break; |
5492 | 5120 | } |
5493 | - case 18446744073709551424LLU: // 999999997_''''''''''''''' | |
5121 | + case 18446744073709551440LLU: // 999999997P''''''''''''''' | |
5494 | 5122 | { |
5495 | 5123 | |
5496 | 5124 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 3LLU)) == /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 3LLU)); |
@@ -5499,37 +5127,37 @@ | ||
5499 | 5127 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5500 | 5128 | } |
5501 | 5129 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5502 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551422LLU : 18446744073709551421LLU; | |
5130 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551438LLU : 18446744073709551437LLU; | |
5503 | 5131 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5504 | 5132 | break; |
5505 | 5133 | } |
5506 | - case 18446744073709551422LLU: // 9999999968''''''''''''''' | |
5134 | + case 18446744073709551438LLU: // 999999997N''''''''''''''' | |
5507 | 5135 | { |
5508 | - state.addr = 18446744073709551420LLU; // 9999999966''''''''''''''' | |
5136 | + state.addr = 18446744073709551436LLU; // 999999997L''''''''''''''' | |
5509 | 5137 | break; |
5510 | 5138 | } |
5511 | - case 18446744073709551421LLU: // 9999999967''''''''''''''' | |
5139 | + case 18446744073709551437LLU: // 999999997M''''''''''''''' | |
5512 | 5140 | { |
5513 | 5141 | fprintf(stderr, "%s", "REFERENCE"); |
5514 | - state.addr = 18446744073709551420LLU; // 9999999966''''''''''''''' | |
5142 | + state.addr = 18446744073709551436LLU; // 999999997L''''''''''''''' | |
5515 | 5143 | break; |
5516 | 5144 | } |
5517 | - case 18446744073709551420LLU: // 9999999966''''''''''''''' | |
5145 | + case 18446744073709551436LLU: // 999999997L''''''''''''''' | |
5518 | 5146 | { |
5519 | - state.addr = 18446744073709551423LLU; // 9999999969''''''''''''''' | |
5147 | + state.addr = 18446744073709551439LLU; // 999999997O''''''''''''''' | |
5520 | 5148 | break; |
5521 | 5149 | } |
5522 | - case 18446744073709551423LLU: // 9999999969''''''''''''''' | |
5150 | + case 18446744073709551439LLU: // 999999997O''''''''''''''' | |
5523 | 5151 | { |
5524 | - state.addr = 18446744073709551429LLU; // 999999997E''''''''''''''' | |
5152 | + state.addr = 18446744073709551445LLU; // 999999997U''''''''''''''' | |
5525 | 5153 | break; |
5526 | 5154 | } |
5527 | - case 18446744073709551429LLU: // 999999997E''''''''''''''' | |
5155 | + case 18446744073709551445LLU: // 999999997U''''''''''''''' | |
5528 | 5156 | { |
5529 | - state.addr = 18446744073709551434LLU; // 999999997J''''''''''''''' | |
5157 | + state.addr = 18446744073709551450LLU; // 999999997Z''''''''''''''' | |
5530 | 5158 | break; |
5531 | 5159 | } |
5532 | - case 18446744073709551434LLU: // 999999997J''''''''''''''' | |
5160 | + case 18446744073709551450LLU: // 999999997Z''''''''''''''' | |
5533 | 5161 | { |
5534 | 5162 | // parameter-reference pardef____ y_________ goes out of scope |
5535 | 5163 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3 |
@@ -5554,11 +5182,11 @@ | ||
5554 | 5182 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5555 | 5183 | } |
5556 | 5184 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
5557 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551419LLU : 18446744073709551418LLU; | |
5185 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551435LLU : 18446744073709551434LLU; | |
5558 | 5186 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5559 | 5187 | break; |
5560 | 5188 | } |
5561 | - case 18446744073709551419LLU: // 9999999965''''''''''''''' | |
5189 | + case 18446744073709551435LLU: // 999999997K''''''''''''''' | |
5562 | 5190 | { |
5563 | 5191 | |
5564 | 5192 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -5575,7 +5203,7 @@ | ||
5575 | 5203 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5576 | 5204 | } |
5577 | 5205 | // ACCUMULATE ARGUMENTS - END |
5578 | - uint64_t return_to = 18446744073709551417LLU; | |
5206 | + uint64_t return_to = 18446744073709551433LLU; | |
5579 | 5207 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
5580 | 5208 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5581 | 5209 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5584,12 +5212,12 @@ | ||
5584 | 5212 | state.addr = 589060043891015680LLU; // equtype___ |
5585 | 5213 | break; |
5586 | 5214 | } |
5587 | - case 18446744073709551417LLU: // 9999999963''''''''''''''' | |
5215 | + case 18446744073709551433LLU: // 999999997I''''''''''''''' | |
5588 | 5216 | { |
5589 | - state.addr = 18446744073709551418LLU; // 9999999964''''''''''''''' | |
5217 | + state.addr = 18446744073709551434LLU; // 999999997J''''''''''''''' | |
5590 | 5218 | break; |
5591 | 5219 | } |
5592 | - case 18446744073709551418LLU: // 9999999964''''''''''''''' | |
5220 | + case 18446744073709551434LLU: // 999999997J''''''''''''''' | |
5593 | 5221 | { |
5594 | 5222 | // parameter-reference elemdef___ y_________ goes out of scope |
5595 | 5223 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3 |
@@ -5647,16 +5275,16 @@ | ||
5647 | 5275 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5648 | 5276 | } |
5649 | 5277 | // ACCUMULATE ARGUMENTS - END |
5650 | - uint64_t return_to = 18446744073709551415LLU; | |
5278 | + uint64_t return_to = 18446744073709551431LLU; | |
5651 | 5279 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5652 | 5280 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5653 | 5281 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
5654 | 5282 | heap.data[0].elem1 = heap.data[0].elem0; |
5655 | 5283 | heap.data[0].elem0 = restore; |
5656 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
5284 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
5657 | 5285 | break; |
5658 | 5286 | } |
5659 | - case 18446744073709551415LLU: // 9999999961''''''''''''''' | |
5287 | + case 18446744073709551431LLU: // 999999997G''''''''''''''' | |
5660 | 5288 | { |
5661 | 5289 | // ACCUMULATE ARGUMENTS - BEGIN |
5662 | 5290 | { |
@@ -5668,7 +5296,7 @@ | ||
5668 | 5296 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5669 | 5297 | } |
5670 | 5298 | // ACCUMULATE ARGUMENTS - END |
5671 | - uint64_t return_to = 18446744073709551414LLU; | |
5299 | + uint64_t return_to = 18446744073709551430LLU; | |
5672 | 5300 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5673 | 5301 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5674 | 5302 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5677,28 +5305,47 @@ | ||
5677 | 5305 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
5678 | 5306 | break; |
5679 | 5307 | } |
5680 | - case 18446744073709551414LLU: // 9999999960''''''''''''''' | |
5308 | + case 18446744073709551430LLU: // 999999997F''''''''''''''' | |
5681 | 5309 | { |
5310 | + | |
5311 | + // emitted destructur for type continuity | |
5682 | 5312 | // ACCUMULATE ARGUMENTS - BEGIN |
5683 | 5313 | { |
5684 | - uint64_t arg = /*balance0__*/*LOCAL_ACCESS(heap.data, 10LLU, 4LLU); | |
5314 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU); | |
5685 | 5315 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5686 | 5316 | } |
5317 | + // ACCUMULATE ARGUMENTS - END | |
5318 | + uint64_t return_to = 18446744073709551429LLU; | |
5319 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
5320 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
5321 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
5322 | + heap.data[0].elem1 = heap.data[0].elem0; | |
5323 | + heap.data[0].elem0 = restore; | |
5324 | + state.addr = 18446744073709551514LLU; // 999999998Z''''''''''''''' | |
5325 | + break; | |
5326 | + } | |
5327 | + case 18446744073709551429LLU: // 999999997E''''''''''''''' | |
5328 | + { | |
5329 | + // ACCUMULATE ARGUMENTS - BEGIN | |
5687 | 5330 | { |
5331 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU); | |
5332 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
5333 | + } | |
5334 | + { | |
5688 | 5335 | uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU); |
5689 | 5336 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5690 | 5337 | } |
5691 | 5338 | // ACCUMULATE ARGUMENTS - END |
5692 | - uint64_t return_to = 18446744073709551413LLU; | |
5339 | + uint64_t return_to = 18446744073709551428LLU; | |
5693 | 5340 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5694 | 5341 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5695 | 5342 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
5696 | 5343 | heap.data[0].elem1 = heap.data[0].elem0; |
5697 | 5344 | heap.data[0].elem0 = restore; |
5698 | - state.addr = 552664889133754368LLU; // cpbalance_ | |
5345 | + state.addr = 58555672873677120LLU; // CPBALANCE_ | |
5699 | 5346 | break; |
5700 | 5347 | } |
5701 | - case 18446744073709551413LLU: // 999999996z''''''''''''''' | |
5348 | + case 18446744073709551428LLU: // 999999997D''''''''''''''' | |
5702 | 5349 | { |
5703 | 5350 | |
5704 | 5351 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 7LLU)); |
@@ -5778,7 +5425,7 @@ | ||
5778 | 5425 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5779 | 5426 | } |
5780 | 5427 | // ACCUMULATE ARGUMENTS - END |
5781 | - uint64_t return_to = 18446744073709551411LLU; | |
5428 | + uint64_t return_to = 18446744073709551426LLU; | |
5782 | 5429 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5783 | 5430 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5784 | 5431 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5787,7 +5434,7 @@ | ||
5787 | 5434 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
5788 | 5435 | break; |
5789 | 5436 | } |
5790 | - case 18446744073709551411LLU: // 999999996x''''''''''''''' | |
5437 | + case 18446744073709551426LLU: // 999999997B''''''''''''''' | |
5791 | 5438 | { |
5792 | 5439 | |
5793 | 5440 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -5800,7 +5447,7 @@ | ||
5800 | 5447 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5801 | 5448 | } |
5802 | 5449 | // ACCUMULATE ARGUMENTS - END |
5803 | - uint64_t return_to = 18446744073709551410LLU; | |
5450 | + uint64_t return_to = 18446744073709551425LLU; | |
5804 | 5451 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5805 | 5452 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5806 | 5453 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5809,7 +5456,7 @@ | ||
5809 | 5456 | state.addr = 58555672873677120LLU; // CPBALANCE_ |
5810 | 5457 | break; |
5811 | 5458 | } |
5812 | - case 18446744073709551410LLU: // 999999996w''''''''''''''' | |
5459 | + case 18446744073709551425LLU: // 999999997A''''''''''''''' | |
5813 | 5460 | { |
5814 | 5461 | |
5815 | 5462 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 7LLU)); |
@@ -5884,7 +5531,7 @@ | ||
5884 | 5531 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5885 | 5532 | } |
5886 | 5533 | // ACCUMULATE ARGUMENTS - END |
5887 | - uint64_t return_to = 18446744073709551407LLU; | |
5534 | + uint64_t return_to = 18446744073709551422LLU; | |
5888 | 5535 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5889 | 5536 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5890 | 5537 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5893,7 +5540,7 @@ | ||
5893 | 5540 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
5894 | 5541 | break; |
5895 | 5542 | } |
5896 | - case 18446744073709551407LLU: // 999999996t''''''''''''''' | |
5543 | + case 18446744073709551422LLU: // 9999999968''''''''''''''' | |
5897 | 5544 | { |
5898 | 5545 | { |
5899 | 5546 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -5922,7 +5569,7 @@ | ||
5922 | 5569 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5923 | 5570 | } |
5924 | 5571 | // ACCUMULATE ARGUMENTS - END |
5925 | - uint64_t return_to = 18446744073709551406LLU; | |
5572 | + uint64_t return_to = 18446744073709551421LLU; | |
5926 | 5573 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5927 | 5574 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5928 | 5575 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5931,7 +5578,7 @@ | ||
5931 | 5578 | state.addr = 552446646280519680LLU; // copyu64___ |
5932 | 5579 | break; |
5933 | 5580 | } |
5934 | - case 18446744073709551406LLU: // 999999996s''''''''''''''' | |
5581 | + case 18446744073709551421LLU: // 9999999967''''''''''''''' | |
5935 | 5582 | { |
5936 | 5583 | { |
5937 | 5584 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -5960,7 +5607,7 @@ | ||
5960 | 5607 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5961 | 5608 | } |
5962 | 5609 | // ACCUMULATE ARGUMENTS - END |
5963 | - uint64_t return_to = 18446744073709551405LLU; | |
5610 | + uint64_t return_to = 18446744073709551420LLU; | |
5964 | 5611 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5965 | 5612 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5966 | 5613 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5969,7 +5616,7 @@ | ||
5969 | 5616 | state.addr = 58555672873677120LLU; // CPBALANCE_ |
5970 | 5617 | break; |
5971 | 5618 | } |
5972 | - case 18446744073709551405LLU: // 999999996r''''''''''''''' | |
5619 | + case 18446744073709551420LLU: // 9999999966''''''''''''''' | |
5973 | 5620 | { |
5974 | 5621 | { |
5975 | 5622 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -5998,7 +5645,7 @@ | ||
5998 | 5645 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5999 | 5646 | } |
6000 | 5647 | // ACCUMULATE ARGUMENTS - END |
6001 | - uint64_t return_to = 18446744073709551404LLU; | |
5648 | + uint64_t return_to = 18446744073709551419LLU; | |
6002 | 5649 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6003 | 5650 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6004 | 5651 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6007,7 +5654,7 @@ | ||
6007 | 5654 | state.addr = 552446646280519680LLU; // copyu64___ |
6008 | 5655 | break; |
6009 | 5656 | } |
6010 | - case 18446744073709551404LLU: // 999999996q''''''''''''''' | |
5657 | + case 18446744073709551419LLU: // 9999999965''''''''''''''' | |
6011 | 5658 | { |
6012 | 5659 | { |
6013 | 5660 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -6019,7 +5666,7 @@ | ||
6019 | 5666 | } |
6020 | 5667 | } |
6021 | 5668 | // ACCUMULATE ARGUMENTS - END |
6022 | - uint64_t return_to = 18446744073709551408LLU; | |
5669 | + uint64_t return_to = 18446744073709551423LLU; | |
6023 | 5670 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
6024 | 5671 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6025 | 5672 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6028,7 +5675,7 @@ | ||
6028 | 5675 | state.addr = 782700512565788672LLU; // pardef____ |
6029 | 5676 | break; |
6030 | 5677 | } |
6031 | - case 18446744073709551408LLU: // 999999996u''''''''''''''' | |
5678 | + case 18446744073709551423LLU: // 9999999969''''''''''''''' | |
6032 | 5679 | { |
6033 | 5680 | // parameter-reference u64 reference1 goes out of scope |
6034 | 5681 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 6 |
@@ -6059,10 +5706,10 @@ | ||
6059 | 5706 | uint64_t arg = 0; |
6060 | 5707 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6061 | 5708 | } |
6062 | - state.addr = 18446744073709551403LLU; // 999999996p''''''''''''''' | |
5709 | + state.addr = 18446744073709551418LLU; // 9999999964''''''''''''''' | |
6063 | 5710 | break; |
6064 | 5711 | } |
6065 | - case 18446744073709551403LLU: // 999999996p''''''''''''''' | |
5712 | + case 18446744073709551418LLU: // 9999999964''''''''''''''' | |
6066 | 5713 | { |
6067 | 5714 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)) |
6068 | 5715 | { |
@@ -6069,7 +5716,7 @@ | ||
6069 | 5716 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
6070 | 5717 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
6071 | 5718 | { |
6072 | - state.addr = 18446744073709551402LLU; // 999999996o''''''''''''''' | |
5719 | + state.addr = 18446744073709551417LLU; // 9999999963''''''''''''''' | |
6073 | 5720 | break; |
6074 | 5721 | } |
6075 | 5722 | } |
@@ -6089,7 +5736,7 @@ | ||
6089 | 5736 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6090 | 5737 | } |
6091 | 5738 | // ACCUMULATE ARGUMENTS - END |
6092 | - uint64_t return_to = 18446744073709551398LLU; | |
5739 | + uint64_t return_to = 18446744073709551413LLU; | |
6093 | 5740 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6094 | 5741 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6095 | 5742 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6098,12 +5745,12 @@ | ||
6098 | 5745 | state.addr = 296309897384864500LLU; // ParDefCopy |
6099 | 5746 | break; |
6100 | 5747 | } |
6101 | - case 18446744073709551398LLU: // 999999996k''''''''''''''' | |
5748 | + case 18446744073709551413LLU: // 999999996z''''''''''''''' | |
6102 | 5749 | { |
6103 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 11) ? 18446744073709551401LLU : 18446744073709551400LLU; | |
5750 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 11) ? 18446744073709551416LLU : 18446744073709551415LLU; | |
6104 | 5751 | break; |
6105 | 5752 | } |
6106 | - case 18446744073709551401LLU: // 999999996n''''''''''''''' | |
5753 | + case 18446744073709551416LLU: // 9999999962''''''''''''''' | |
6107 | 5754 | { |
6108 | 5755 | { |
6109 | 5756 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap in pardefscp - recompile with increased heap-size"); |
@@ -6116,35 +5763,35 @@ | ||
6116 | 5763 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6117 | 5764 | } |
6118 | 5765 | // ACCUMULATE ARGUMENTS - END |
6119 | - uint64_t return_to = 18446744073709551397LLU; | |
5766 | + uint64_t return_to = 18446744073709551412LLU; | |
6120 | 5767 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6121 | 5768 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6122 | 5769 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
6123 | 5770 | heap.data[0].elem1 = heap.data[0].elem0; |
6124 | 5771 | heap.data[0].elem0 = restore; |
6125 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
5772 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
6126 | 5773 | break; |
6127 | 5774 | } |
6128 | - case 18446744073709551397LLU: // 999999996j''''''''''''''' | |
5775 | + case 18446744073709551412LLU: // 999999996y''''''''''''''' | |
6129 | 5776 | { |
6130 | 5777 | // parameter pardef____ dst_______ goes out of scope |
6131 | - state.addr = 18446744073709551399LLU; // 999999996l''''''''''''''' | |
5778 | + state.addr = 18446744073709551414LLU; // 9999999960''''''''''''''' | |
6132 | 5779 | break; |
6133 | 5780 | } |
6134 | - case 18446744073709551400LLU: // 999999996m''''''''''''''' | |
5781 | + case 18446744073709551415LLU: // 9999999961''''''''''''''' | |
6135 | 5782 | { |
6136 | - state.addr = 18446744073709551399LLU; // 999999996l''''''''''''''' | |
5783 | + state.addr = 18446744073709551414LLU; // 9999999960''''''''''''''' | |
6137 | 5784 | break; |
6138 | 5785 | } |
6139 | - case 18446744073709551399LLU: // 999999996l''''''''''''''' | |
5786 | + case 18446744073709551414LLU: // 9999999960''''''''''''''' | |
6140 | 5787 | { |
6141 | 5788 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
6142 | 5789 | // parameter-reference pardef____ src_______ goes out of scope |
6143 | 5790 | // parameter-reference list<pardef____> srcs______ goes out of scope |
6144 | - state.addr = 18446744073709551403LLU; // 999999996p''''''''''''''' | |
5791 | + state.addr = 18446744073709551418LLU; // 9999999964''''''''''''''' | |
6145 | 5792 | break; |
6146 | 5793 | } |
6147 | - case 18446744073709551402LLU: // 999999996o''''''''''''''' | |
5794 | + case 18446744073709551417LLU: // 9999999963''''''''''''''' | |
6148 | 5795 | { |
6149 | 5796 | // parameter-reference list<pardef____> srcs______ goes out of scope |
6150 | 5797 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2 |
@@ -6168,10 +5815,10 @@ | ||
6168 | 5815 | uint64_t arg = 0; |
6169 | 5816 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6170 | 5817 | } |
6171 | - state.addr = 18446744073709551396LLU; // 999999996i''''''''''''''' | |
5818 | + state.addr = 18446744073709551411LLU; // 999999996x''''''''''''''' | |
6172 | 5819 | break; |
6173 | 5820 | } |
6174 | - case 18446744073709551396LLU: // 999999996i''''''''''''''' | |
5821 | + case 18446744073709551411LLU: // 999999996x''''''''''''''' | |
6175 | 5822 | { |
6176 | 5823 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
6177 | 5824 | { |
@@ -6178,7 +5825,7 @@ | ||
6178 | 5825 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
6179 | 5826 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
6180 | 5827 | { |
6181 | - state.addr = 18446744073709551395LLU; // 999999996h''''''''''''''' | |
5828 | + state.addr = 18446744073709551410LLU; // 999999996w''''''''''''''' | |
6182 | 5829 | break; |
6183 | 5830 | } |
6184 | 5831 | } |
@@ -6208,7 +5855,7 @@ | ||
6208 | 5855 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6209 | 5856 | } |
6210 | 5857 | // ACCUMULATE ARGUMENTS - END |
6211 | - uint64_t return_to = 18446744073709551394LLU; | |
5858 | + uint64_t return_to = 18446744073709551409LLU; | |
6212 | 5859 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6213 | 5860 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6214 | 5861 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6217,7 +5864,7 @@ | ||
6217 | 5864 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
6218 | 5865 | break; |
6219 | 5866 | } |
6220 | - case 18446744073709551394LLU: // 999999996g''''''''''''''' | |
5867 | + case 18446744073709551409LLU: // 999999996v''''''''''''''' | |
6221 | 5868 | { |
6222 | 5869 | { |
6223 | 5870 | uint64_t arg = 0; |
@@ -6229,7 +5876,7 @@ | ||
6229 | 5876 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6230 | 5877 | } |
6231 | 5878 | // ACCUMULATE ARGUMENTS - END |
6232 | - uint64_t return_to = 18446744073709551393LLU; | |
5879 | + uint64_t return_to = 18446744073709551408LLU; | |
6233 | 5880 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6234 | 5881 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6235 | 5882 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6238,7 +5885,7 @@ | ||
6238 | 5885 | state.addr = 552437437528276992LLU; // consume___ |
6239 | 5886 | break; |
6240 | 5887 | } |
6241 | - case 18446744073709551393LLU: // 999999996f''''''''''''''' | |
5888 | + case 18446744073709551408LLU: // 999999996u''''''''''''''' | |
6242 | 5889 | { |
6243 | 5890 | { |
6244 | 5891 | uint64_t arg = 0; |
@@ -6250,7 +5897,7 @@ | ||
6250 | 5897 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6251 | 5898 | } |
6252 | 5899 | { |
6253 | - uint64_t arg = /*t_________*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU); | |
5900 | + uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU); | |
6254 | 5901 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6255 | 5902 | } |
6256 | 5903 | { |
@@ -6266,7 +5913,7 @@ | ||
6266 | 5913 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6267 | 5914 | } |
6268 | 5915 | // ACCUMULATE ARGUMENTS - END |
6269 | - uint64_t return_to = 18446744073709551389LLU; | |
5916 | + uint64_t return_to = 18446744073709551404LLU; | |
6270 | 5917 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
6271 | 5918 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6272 | 5919 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6275,12 +5922,12 @@ | ||
6275 | 5922 | state.addr = 782700512565788672LLU; // pardef____ |
6276 | 5923 | break; |
6277 | 5924 | } |
6278 | - case 18446744073709551389LLU: // 999999996b''''''''''''''' | |
5925 | + case 18446744073709551404LLU: // 999999996q''''''''''''''' | |
6279 | 5926 | { |
6280 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 10LLU, 9LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)), 11) ? 18446744073709551392LLU : 18446744073709551391LLU; | |
5927 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 10LLU, 9LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)), 11) ? 18446744073709551407LLU : 18446744073709551406LLU; | |
6281 | 5928 | break; |
6282 | 5929 | } |
6283 | - case 18446744073709551392LLU: // 999999996e''''''''''''''' | |
5930 | + case 18446744073709551407LLU: // 999999996t''''''''''''''' | |
6284 | 5931 | { |
6285 | 5932 | fprintf(stderr, "%s", "pushing par "); |
6286 | 5933 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -6289,7 +5936,7 @@ | ||
6289 | 5936 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6290 | 5937 | } |
6291 | 5938 | // ACCUMULATE ARGUMENTS - END |
6292 | - uint64_t return_to = 18446744073709551388LLU; | |
5939 | + uint64_t return_to = 18446744073709551403LLU; | |
6293 | 5940 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6294 | 5941 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6295 | 5942 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6298,7 +5945,7 @@ | ||
6298 | 5945 | state.addr = 819847183518878432LLU; // reporttype |
6299 | 5946 | break; |
6300 | 5947 | } |
6301 | - case 18446744073709551388LLU: // 999999996a''''''''''''''' | |
5948 | + case 18446744073709551403LLU: // 999999996p''''''''''''''' | |
6302 | 5949 | { |
6303 | 5950 | fprintf(stderr, "%s", "\n"); |
6304 | 5951 | { |
@@ -6312,35 +5959,35 @@ | ||
6312 | 5959 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6313 | 5960 | } |
6314 | 5961 | // ACCUMULATE ARGUMENTS - END |
6315 | - uint64_t return_to = 18446744073709551387LLU; | |
5962 | + uint64_t return_to = 18446744073709551402LLU; | |
6316 | 5963 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6317 | 5964 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6318 | 5965 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
6319 | 5966 | heap.data[0].elem1 = heap.data[0].elem0; |
6320 | 5967 | heap.data[0].elem0 = restore; |
6321 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
5968 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
6322 | 5969 | break; |
6323 | 5970 | } |
6324 | - case 18446744073709551387LLU: // 999999996$''''''''''''''' | |
5971 | + case 18446744073709551402LLU: // 999999996o''''''''''''''' | |
6325 | 5972 | { |
6326 | 5973 | // parameter pardef____ newpar____ goes out of scope |
6327 | - state.addr = 18446744073709551390LLU; // 999999996c''''''''''''''' | |
5974 | + state.addr = 18446744073709551405LLU; // 999999996r''''''''''''''' | |
6328 | 5975 | break; |
6329 | 5976 | } |
6330 | - case 18446744073709551391LLU: // 999999996d''''''''''''''' | |
5977 | + case 18446744073709551406LLU: // 999999996s''''''''''''''' | |
6331 | 5978 | { |
6332 | - state.addr = 18446744073709551390LLU; // 999999996c''''''''''''''' | |
5979 | + state.addr = 18446744073709551405LLU; // 999999996r''''''''''''''' | |
6333 | 5980 | break; |
6334 | 5981 | } |
6335 | - case 18446744073709551390LLU: // 999999996c''''''''''''''' | |
5982 | + case 18446744073709551405LLU: // 999999996r''''''''''''''' | |
6336 | 5983 | { |
6337 | 5984 | (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 10 |
6338 | 5985 | // variable continuity continuity goes out of scope |
6339 | 5986 | // (uninitialized -> no destructor-call) |
6340 | 5987 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference continuity at 9 |
6341 | - // variable type______ t_________ goes out of scope | |
5988 | + // variable type______ type______ goes out of scope | |
6342 | 5989 | // (uninitialized -> no destructor-call) |
6343 | - (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference t_________ at 8 | |
5990 | + (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 8 | |
6344 | 5991 | // variable u64 reference_ goes out of scope |
6345 | 5992 | // (uninitialized -> no destructor-call) |
6346 | 5993 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 7 |
@@ -6349,10 +5996,10 @@ | ||
6349 | 5996 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 6 |
6350 | 5997 | // parameter-reference elemdef___ src_______ goes out of scope |
6351 | 5998 | // parameter-reference list<elemdef___> srcs______ goes out of scope |
6352 | - state.addr = 18446744073709551396LLU; // 999999996i''''''''''''''' | |
5999 | + state.addr = 18446744073709551411LLU; // 999999996x''''''''''''''' | |
6353 | 6000 | break; |
6354 | 6001 | } |
6355 | - case 18446744073709551395LLU: // 999999996h''''''''''''''' | |
6002 | + case 18446744073709551410LLU: // 999999996w''''''''''''''' | |
6356 | 6003 | { |
6357 | 6004 | // parameter u64 reference_ goes out of scope |
6358 | 6005 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 3 |
@@ -6368,86 +6015,6 @@ | ||
6368 | 6015 | } |
6369 | 6016 | break; |
6370 | 6017 | } |
6371 | - case 587581796494207680LLU: // elemdefcp_ | |
6372 | - { | |
6373 | - { | |
6374 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU); | |
6375 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6376 | - } | |
6377 | - { | |
6378 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU); | |
6379 | - LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6380 | - } | |
6381 | - { | |
6382 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 0LLU); | |
6383 | - LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6384 | - } | |
6385 | - { | |
6386 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 1LLU); | |
6387 | - LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6388 | - } | |
6389 | - | |
6390 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) = /*id1_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)); | |
6391 | - | |
6392 | - // emitted destructur for type type______ | |
6393 | - // ACCUMULATE ARGUMENTS - BEGIN | |
6394 | - { | |
6395 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 3LLU); | |
6396 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
6397 | - } | |
6398 | - // ACCUMULATE ARGUMENTS - END | |
6399 | - uint64_t return_to = 18446744073709551385LLU; | |
6400 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
6401 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
6402 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
6403 | - heap.data[0].elem1 = heap.data[0].elem0; | |
6404 | - heap.data[0].elem0 = restore; | |
6405 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
6406 | - break; | |
6407 | - } | |
6408 | - case 18446744073709551385LLU: // 999999996Y''''''''''''''' | |
6409 | - { | |
6410 | - // ACCUMULATE ARGUMENTS - BEGIN | |
6411 | - { | |
6412 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 3LLU); | |
6413 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
6414 | - } | |
6415 | - { | |
6416 | - uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU); | |
6417 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
6418 | - } | |
6419 | - // ACCUMULATE ARGUMENTS - END | |
6420 | - uint64_t return_to = 18446744073709551384LLU; | |
6421 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
6422 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
6423 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
6424 | - heap.data[0].elem1 = heap.data[0].elem0; | |
6425 | - heap.data[0].elem0 = restore; | |
6426 | - state.addr = 367395560426147840LLU; // TYPECOPY__ | |
6427 | - break; | |
6428 | - } | |
6429 | - case 18446744073709551384LLU: // 999999996X''''''''''''''' | |
6430 | - { | |
6431 | - // parameter-reference type______ type1_____ goes out of scope | |
6432 | - (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 6 | |
6433 | - // parameter-reference u64 id1_______ goes out of scope | |
6434 | - (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 5 | |
6435 | - // parameter-reference elemdef___ __________ goes out of scope | |
6436 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4 | |
6437 | - // parameter-reference type______ type0_____ goes out of scope | |
6438 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 3 | |
6439 | - // parameter-reference u64 id0_______ goes out of scope | |
6440 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id0_______ at 2 | |
6441 | - // parameter-reference elemdef___ __________ goes out of scope | |
6442 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
6443 | - { | |
6444 | - uint64_t baseinfo = heap.data[0].elem1; | |
6445 | - struct pair pair = unpair(&heap, &baseinfo); | |
6446 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
6447 | - state.addr = pair.elem1; | |
6448 | - } | |
6449 | - break; | |
6450 | - } | |
6451 | 6018 | case 101193007747052544LLU: // ElemDefCP_ |
6452 | 6019 | { |
6453 | 6020 | { |
@@ -6481,7 +6048,7 @@ | ||
6481 | 6048 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6482 | 6049 | } |
6483 | 6050 | // ACCUMULATE ARGUMENTS - END |
6484 | - uint64_t return_to = 18446744073709551381LLU; | |
6051 | + uint64_t return_to = 18446744073709551399LLU; | |
6485 | 6052 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6486 | 6053 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6487 | 6054 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6490,7 +6057,7 @@ | ||
6490 | 6057 | state.addr = 552446646280519680LLU; // copyu64___ |
6491 | 6058 | break; |
6492 | 6059 | } |
6493 | - case 18446744073709551381LLU: // 999999996U''''''''''''''' | |
6060 | + case 18446744073709551399LLU: // 999999996l''''''''''''''' | |
6494 | 6061 | { |
6495 | 6062 | { |
6496 | 6063 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/; |
@@ -6519,7 +6086,7 @@ | ||
6519 | 6086 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6520 | 6087 | } |
6521 | 6088 | // ACCUMULATE ARGUMENTS - END |
6522 | - uint64_t return_to = 18446744073709551380LLU; | |
6089 | + uint64_t return_to = 18446744073709551398LLU; | |
6523 | 6090 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6524 | 6091 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6525 | 6092 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6528,7 +6095,7 @@ | ||
6528 | 6095 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
6529 | 6096 | break; |
6530 | 6097 | } |
6531 | - case 18446744073709551380LLU: // 999999996T''''''''''''''' | |
6098 | + case 18446744073709551398LLU: // 999999996k''''''''''''''' | |
6532 | 6099 | { |
6533 | 6100 | { |
6534 | 6101 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/; |
@@ -6540,7 +6107,7 @@ | ||
6540 | 6107 | } |
6541 | 6108 | } |
6542 | 6109 | // ACCUMULATE ARGUMENTS - END |
6543 | - uint64_t return_to = 18446744073709551382LLU; | |
6110 | + uint64_t return_to = 18446744073709551400LLU; | |
6544 | 6111 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
6545 | 6112 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6546 | 6113 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6549,7 +6116,7 @@ | ||
6549 | 6116 | state.addr = 587581796494082048LLU; // elemdef___ |
6550 | 6117 | break; |
6551 | 6118 | } |
6552 | - case 18446744073709551382LLU: // 999999996V''''''''''''''' | |
6119 | + case 18446744073709551400LLU: // 999999996m''''''''''''''' | |
6553 | 6120 | { |
6554 | 6121 | // parameter-reference type______ type1_____ goes out of scope |
6555 | 6122 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 4 |
@@ -6576,10 +6143,10 @@ | ||
6576 | 6143 | uint64_t arg = 0; |
6577 | 6144 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6578 | 6145 | } |
6579 | - state.addr = 18446744073709551379LLU; // 999999996S''''''''''''''' | |
6146 | + state.addr = 18446744073709551397LLU; // 999999996j''''''''''''''' | |
6580 | 6147 | break; |
6581 | 6148 | } |
6582 | - case 18446744073709551379LLU: // 999999996S''''''''''''''' | |
6149 | + case 18446744073709551397LLU: // 999999996j''''''''''''''' | |
6583 | 6150 | { |
6584 | 6151 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)) |
6585 | 6152 | { |
@@ -6586,7 +6153,7 @@ | ||
6586 | 6153 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
6587 | 6154 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
6588 | 6155 | { |
6589 | - state.addr = 18446744073709551378LLU; // 999999996R''''''''''''''' | |
6156 | + state.addr = 18446744073709551396LLU; // 999999996i''''''''''''''' | |
6590 | 6157 | break; |
6591 | 6158 | } |
6592 | 6159 | } |
@@ -6606,7 +6173,7 @@ | ||
6606 | 6173 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6607 | 6174 | } |
6608 | 6175 | // ACCUMULATE ARGUMENTS - END |
6609 | - uint64_t return_to = 18446744073709551374LLU; | |
6176 | + uint64_t return_to = 18446744073709551392LLU; | |
6610 | 6177 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6611 | 6178 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6612 | 6179 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6615,12 +6182,12 @@ | ||
6615 | 6182 | state.addr = 101193007747052544LLU; // ElemDefCP_ |
6616 | 6183 | break; |
6617 | 6184 | } |
6618 | - case 18446744073709551374LLU: // 999999996N''''''''''''''' | |
6185 | + case 18446744073709551392LLU: // 999999996e''''''''''''''' | |
6619 | 6186 | { |
6620 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 7) ? 18446744073709551377LLU : 18446744073709551376LLU; | |
6187 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 7) ? 18446744073709551395LLU : 18446744073709551394LLU; | |
6621 | 6188 | break; |
6622 | 6189 | } |
6623 | - case 18446744073709551377LLU: // 999999996Q''''''''''''''' | |
6190 | + case 18446744073709551395LLU: // 999999996h''''''''''''''' | |
6624 | 6191 | { |
6625 | 6192 | fprintf(stderr, "%s", "pushing par "); |
6626 | 6193 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -6629,7 +6196,7 @@ | ||
6629 | 6196 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6630 | 6197 | } |
6631 | 6198 | // ACCUMULATE ARGUMENTS - END |
6632 | - uint64_t return_to = 18446744073709551373LLU; | |
6199 | + uint64_t return_to = 18446744073709551391LLU; | |
6633 | 6200 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6634 | 6201 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6635 | 6202 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6638,7 +6205,7 @@ | ||
6638 | 6205 | state.addr = 819847183518878432LLU; // reporttype |
6639 | 6206 | break; |
6640 | 6207 | } |
6641 | - case 18446744073709551373LLU: // 999999996M''''''''''''''' | |
6208 | + case 18446744073709551391LLU: // 999999996d''''''''''''''' | |
6642 | 6209 | { |
6643 | 6210 | fprintf(stderr, "%s", "\n"); |
6644 | 6211 | { |
@@ -6652,35 +6219,35 @@ | ||
6652 | 6219 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6653 | 6220 | } |
6654 | 6221 | // ACCUMULATE ARGUMENTS - END |
6655 | - uint64_t return_to = 18446744073709551372LLU; | |
6222 | + uint64_t return_to = 18446744073709551390LLU; | |
6656 | 6223 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6657 | 6224 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6658 | 6225 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
6659 | 6226 | heap.data[0].elem1 = heap.data[0].elem0; |
6660 | 6227 | heap.data[0].elem0 = restore; |
6661 | - state.addr = 18446744073709551448LLU; // 999999997X''''''''''''''' | |
6228 | + state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' | |
6662 | 6229 | break; |
6663 | 6230 | } |
6664 | - case 18446744073709551372LLU: // 999999996L''''''''''''''' | |
6231 | + case 18446744073709551390LLU: // 999999996c''''''''''''''' | |
6665 | 6232 | { |
6666 | 6233 | // parameter elemdef___ dst_______ goes out of scope |
6667 | - state.addr = 18446744073709551375LLU; // 999999996O''''''''''''''' | |
6234 | + state.addr = 18446744073709551393LLU; // 999999996f''''''''''''''' | |
6668 | 6235 | break; |
6669 | 6236 | } |
6670 | - case 18446744073709551376LLU: // 999999996P''''''''''''''' | |
6237 | + case 18446744073709551394LLU: // 999999996g''''''''''''''' | |
6671 | 6238 | { |
6672 | - state.addr = 18446744073709551375LLU; // 999999996O''''''''''''''' | |
6239 | + state.addr = 18446744073709551393LLU; // 999999996f''''''''''''''' | |
6673 | 6240 | break; |
6674 | 6241 | } |
6675 | - case 18446744073709551375LLU: // 999999996O''''''''''''''' | |
6242 | + case 18446744073709551393LLU: // 999999996f''''''''''''''' | |
6676 | 6243 | { |
6677 | 6244 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
6678 | 6245 | // parameter-reference elemdef___ src_______ goes out of scope |
6679 | 6246 | // parameter-reference list<elemdef___> srcs______ goes out of scope |
6680 | - state.addr = 18446744073709551379LLU; // 999999996S''''''''''''''' | |
6247 | + state.addr = 18446744073709551397LLU; // 999999996j''''''''''''''' | |
6681 | 6248 | break; |
6682 | 6249 | } |
6683 | - case 18446744073709551378LLU: // 999999996R''''''''''''''' | |
6250 | + case 18446744073709551396LLU: // 999999996i''''''''''''''' | |
6684 | 6251 | { |
6685 | 6252 | // parameter-reference list<elemdef___> srcs______ goes out of scope |
6686 | 6253 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2 |
@@ -6694,100 +6261,6 @@ | ||
6694 | 6261 | } |
6695 | 6262 | break; |
6696 | 6263 | } |
6697 | - case 819859607546145524LLU: // resdefcopy | |
6698 | - { | |
6699 | - { | |
6700 | - uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU); | |
6701 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6702 | - } | |
6703 | - { | |
6704 | - uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU); | |
6705 | - LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6706 | - } | |
6707 | - { | |
6708 | - uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU); | |
6709 | - LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6710 | - } | |
6711 | - { | |
6712 | - uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 0LLU); | |
6713 | - LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6714 | - } | |
6715 | - { | |
6716 | - uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 1LLU); | |
6717 | - LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6718 | - } | |
6719 | - { | |
6720 | - uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 2LLU); | |
6721 | - LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
6722 | - } | |
6723 | - | |
6724 | - // emitted destructur for type type______ | |
6725 | - // ACCUMULATE ARGUMENTS - BEGIN | |
6726 | - { | |
6727 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 8LLU, 2LLU); | |
6728 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
6729 | - } | |
6730 | - // ACCUMULATE ARGUMENTS - END | |
6731 | - uint64_t return_to = 18446744073709551370LLU; | |
6732 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
6733 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
6734 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
6735 | - heap.data[0].elem1 = heap.data[0].elem0; | |
6736 | - heap.data[0].elem0 = restore; | |
6737 | - state.addr = 18446744073709551571LLU; // 999999999S''''''''''''''' | |
6738 | - break; | |
6739 | - } | |
6740 | - case 18446744073709551370LLU: // 999999996J''''''''''''''' | |
6741 | - { | |
6742 | - // ACCUMULATE ARGUMENTS - BEGIN | |
6743 | - { | |
6744 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 8LLU, 2LLU); | |
6745 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
6746 | - } | |
6747 | - { | |
6748 | - uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU); | |
6749 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
6750 | - } | |
6751 | - // ACCUMULATE ARGUMENTS - END | |
6752 | - uint64_t return_to = 18446744073709551369LLU; | |
6753 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
6754 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
6755 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
6756 | - heap.data[0].elem1 = heap.data[0].elem0; | |
6757 | - heap.data[0].elem0 = restore; | |
6758 | - state.addr = 367395560426147840LLU; // TYPECOPY__ | |
6759 | - break; | |
6760 | - } | |
6761 | - case 18446744073709551369LLU: // 999999996I''''''''''''''' | |
6762 | - { | |
6763 | - | |
6764 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) = /*idx1______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU)); | |
6765 | - | |
6766 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 4LLU)) = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 7LLU)); | |
6767 | - // parameter-reference u64 reference1 goes out of scope | |
6768 | - (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 8 | |
6769 | - // parameter-reference u64 idx1______ goes out of scope | |
6770 | - (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx1______ at 7 | |
6771 | - // parameter-reference type______ type1_____ goes out of scope | |
6772 | - (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 6 | |
6773 | - // parameter-reference resdest___ __________ goes out of scope | |
6774 | - (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5 | |
6775 | - // parameter-reference u64 reference0 goes out of scope | |
6776 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference0 at 4 | |
6777 | - // parameter-reference u64 idx0______ goes out of scope | |
6778 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx0______ at 3 | |
6779 | - // parameter-reference type______ type0_____ goes out of scope | |
6780 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 2 | |
6781 | - // parameter-reference resdest___ __________ goes out of scope | |
6782 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
6783 | - { | |
6784 | - uint64_t baseinfo = heap.data[0].elem1; | |
6785 | - struct pair pair = unpair(&heap, &baseinfo); | |
6786 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
6787 | - state.addr = pair.elem1; | |
6788 | - } | |
6789 | - break; | |
6790 | - } | |
6791 | 6264 | case 325750391286068249LLU: // RESDEFCOPY |
6792 | 6265 | { |
6793 | 6266 | { |
@@ -6825,7 +6298,7 @@ | ||
6825 | 6298 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6826 | 6299 | } |
6827 | 6300 | // ACCUMULATE ARGUMENTS - END |
6828 | - uint64_t return_to = 18446744073709551366LLU; | |
6301 | + uint64_t return_to = 18446744073709551387LLU; | |
6829 | 6302 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6830 | 6303 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6831 | 6304 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6834,7 +6307,7 @@ | ||
6834 | 6307 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
6835 | 6308 | break; |
6836 | 6309 | } |
6837 | - case 18446744073709551366LLU: // 999999996F''''''''''''''' | |
6310 | + case 18446744073709551387LLU: // 999999996$''''''''''''''' | |
6838 | 6311 | { |
6839 | 6312 | { |
6840 | 6313 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -6863,7 +6336,7 @@ | ||
6863 | 6336 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6864 | 6337 | } |
6865 | 6338 | // ACCUMULATE ARGUMENTS - END |
6866 | - uint64_t return_to = 18446744073709551365LLU; | |
6339 | + uint64_t return_to = 18446744073709551386LLU; | |
6867 | 6340 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6868 | 6341 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6869 | 6342 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6872,7 +6345,7 @@ | ||
6872 | 6345 | state.addr = 552446646280519680LLU; // copyu64___ |
6873 | 6346 | break; |
6874 | 6347 | } |
6875 | - case 18446744073709551365LLU: // 999999996E''''''''''''''' | |
6348 | + case 18446744073709551386LLU: // 999999996Z''''''''''''''' | |
6876 | 6349 | { |
6877 | 6350 | { |
6878 | 6351 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -6901,7 +6374,7 @@ | ||
6901 | 6374 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6902 | 6375 | } |
6903 | 6376 | // ACCUMULATE ARGUMENTS - END |
6904 | - uint64_t return_to = 18446744073709551364LLU; | |
6377 | + uint64_t return_to = 18446744073709551385LLU; | |
6905 | 6378 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6906 | 6379 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6907 | 6380 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6910,7 +6383,7 @@ | ||
6910 | 6383 | state.addr = 552446646280519680LLU; // copyu64___ |
6911 | 6384 | break; |
6912 | 6385 | } |
6913 | - case 18446744073709551364LLU: // 999999996D''''''''''''''' | |
6386 | + case 18446744073709551385LLU: // 999999996Y''''''''''''''' | |
6914 | 6387 | { |
6915 | 6388 | { |
6916 | 6389 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -6922,7 +6395,7 @@ | ||
6922 | 6395 | } |
6923 | 6396 | } |
6924 | 6397 | // ACCUMULATE ARGUMENTS - END |
6925 | - uint64_t return_to = 18446744073709551367LLU; | |
6398 | + uint64_t return_to = 18446744073709551388LLU; | |
6926 | 6399 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
6927 | 6400 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6928 | 6401 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6931,7 +6404,7 @@ | ||
6931 | 6404 | state.addr = 819859607768530944LLU; // resdest___ |
6932 | 6405 | break; |
6933 | 6406 | } |
6934 | - case 18446744073709551367LLU: // 999999996G''''''''''''''' | |
6407 | + case 18446744073709551388LLU: // 999999996a''''''''''''''' | |
6935 | 6408 | { |
6936 | 6409 | // parameter-reference u64 reference1 goes out of scope |
6937 | 6410 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 5 |
@@ -6950,7 +6423,7 @@ | ||
6950 | 6423 | } |
6951 | 6424 | break; |
6952 | 6425 | } |
6953 | - case 18446744073709551363LLU: // 999999996C''''''''''''''' | |
6426 | + case 18446744073709551384LLU: // 999999996X''''''''''''''' | |
6954 | 6427 | { |
6955 | 6428 | { |
6956 | 6429 | uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -7007,7 +6480,7 @@ | ||
7007 | 6480 | } |
7008 | 6481 | break; |
7009 | 6482 | } |
7010 | - case 18446744073709551362LLU: // 999999996B''''''''''''''' | |
6483 | + case 18446744073709551383LLU: // 999999996W''''''''''''''' | |
7011 | 6484 | { |
7012 | 6485 | { |
7013 | 6486 | uint64_t arg = tree_pop_move(&heap, 7LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -7049,14 +6522,14 @@ | ||
7049 | 6522 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7050 | 6523 | } |
7051 | 6524 | // emitted destructur for type list<pardef____> |
7052 | - state.addr = 18446744073709551360LLU; // 999999996_''''''''''''''' | |
6525 | + state.addr = 18446744073709551381LLU; // 999999996U''''''''''''''' | |
7053 | 6526 | break; |
7054 | 6527 | } |
7055 | - case 18446744073709551360LLU: // 999999996_''''''''''''''' | |
6528 | + case 18446744073709551381LLU: // 999999996U''''''''''''''' | |
7056 | 6529 | { |
7057 | 6530 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
7058 | 6531 | { |
7059 | - state.addr = 18446744073709551361LLU; // 999999996A''''''''''''''' | |
6532 | + state.addr = 18446744073709551382LLU; // 999999996V''''''''''''''' | |
7060 | 6533 | break; |
7061 | 6534 | } |
7062 | 6535 | // temporary list-element |
@@ -7070,23 +6543,23 @@ | ||
7070 | 6543 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7071 | 6544 | } |
7072 | 6545 | // ACCUMULATE ARGUMENTS - END |
7073 | - uint64_t return_to = 18446744073709551359LLU; | |
6546 | + uint64_t return_to = 18446744073709551380LLU; | |
7074 | 6547 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7075 | 6548 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7076 | 6549 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
7077 | 6550 | heap.data[0].elem1 = heap.data[0].elem0; |
7078 | 6551 | heap.data[0].elem0 = restore; |
7079 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
6552 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
7080 | 6553 | break; |
7081 | 6554 | } |
7082 | - case 18446744073709551359LLU: // 9999999959''''''''''''''' | |
6555 | + case 18446744073709551380LLU: // 999999996T''''''''''''''' | |
7083 | 6556 | { |
7084 | 6557 | // RELEASE temporary destructor-variable |
7085 | 6558 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
7086 | - state.addr = 18446744073709551360LLU; // 999999996_''''''''''''''' | |
6559 | + state.addr = 18446744073709551381LLU; // 999999996U''''''''''''''' | |
7087 | 6560 | break; |
7088 | 6561 | } |
7089 | - case 18446744073709551361LLU: // 999999996A''''''''''''''' | |
6562 | + case 18446744073709551382LLU: // 999999996V''''''''''''''' | |
7090 | 6563 | { |
7091 | 6564 | // RELEASE temporary destructor-variable |
7092 | 6565 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -7095,14 +6568,14 @@ | ||
7095 | 6568 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7096 | 6569 | } |
7097 | 6570 | // emitted destructur for type list<resdest___> |
7098 | - state.addr = 18446744073709551357LLU; // 9999999957''''''''''''''' | |
6571 | + state.addr = 18446744073709551378LLU; // 999999996R''''''''''''''' | |
7099 | 6572 | break; |
7100 | 6573 | } |
7101 | - case 18446744073709551357LLU: // 9999999957''''''''''''''' | |
6574 | + case 18446744073709551378LLU: // 999999996R''''''''''''''' | |
7102 | 6575 | { |
7103 | 6576 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
7104 | 6577 | { |
7105 | - state.addr = 18446744073709551358LLU; // 9999999958''''''''''''''' | |
6578 | + state.addr = 18446744073709551379LLU; // 999999996S''''''''''''''' | |
7106 | 6579 | break; |
7107 | 6580 | } |
7108 | 6581 | // temporary list-element |
@@ -7116,23 +6589,23 @@ | ||
7116 | 6589 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7117 | 6590 | } |
7118 | 6591 | // ACCUMULATE ARGUMENTS - END |
7119 | - uint64_t return_to = 18446744073709551356LLU; | |
6592 | + uint64_t return_to = 18446744073709551377LLU; | |
7120 | 6593 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7121 | 6594 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7122 | 6595 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
7123 | 6596 | heap.data[0].elem1 = heap.data[0].elem0; |
7124 | 6597 | heap.data[0].elem0 = restore; |
7125 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
6598 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
7126 | 6599 | break; |
7127 | 6600 | } |
7128 | - case 18446744073709551356LLU: // 9999999956''''''''''''''' | |
6601 | + case 18446744073709551377LLU: // 999999996Q''''''''''''''' | |
7129 | 6602 | { |
7130 | 6603 | // RELEASE temporary destructor-variable |
7131 | 6604 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
7132 | - state.addr = 18446744073709551357LLU; // 9999999957''''''''''''''' | |
6605 | + state.addr = 18446744073709551378LLU; // 999999996R''''''''''''''' | |
7133 | 6606 | break; |
7134 | 6607 | } |
7135 | - case 18446744073709551358LLU: // 9999999958''''''''''''''' | |
6608 | + case 18446744073709551379LLU: // 999999996S''''''''''''''' | |
7136 | 6609 | { |
7137 | 6610 | // RELEASE temporary destructor-variable |
7138 | 6611 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -7254,10 +6727,10 @@ | ||
7254 | 6727 | uint64_t arg = 0; |
7255 | 6728 | LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7256 | 6729 | } |
7257 | - state.addr = 18446744073709551354LLU; // 9999999954''''''''''''''' | |
6730 | + state.addr = 18446744073709551375LLU; // 999999996O''''''''''''''' | |
7258 | 6731 | break; |
7259 | 6732 | } |
7260 | - case 18446744073709551354LLU: // 9999999954''''''''''''''' | |
6733 | + case 18446744073709551375LLU: // 999999996O''''''''''''''' | |
7261 | 6734 | { |
7262 | 6735 | if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU)) |
7263 | 6736 | { |
@@ -7264,7 +6737,7 @@ | ||
7264 | 6737 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
7265 | 6738 | (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11 |
7266 | 6739 | { |
7267 | - state.addr = 18446744073709551353LLU; // 9999999953''''''''''''''' | |
6740 | + state.addr = 18446744073709551374LLU; // 999999996N''''''''''''''' | |
7268 | 6741 | break; |
7269 | 6742 | } |
7270 | 6743 | } |
@@ -7284,7 +6757,7 @@ | ||
7284 | 6757 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7285 | 6758 | } |
7286 | 6759 | // ACCUMULATE ARGUMENTS - END |
7287 | - uint64_t return_to = 18446744073709551349LLU; | |
6760 | + uint64_t return_to = 18446744073709551370LLU; | |
7288 | 6761 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7289 | 6762 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7290 | 6763 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7293,12 +6766,12 @@ | ||
7293 | 6766 | state.addr = 333468934555566080LLU; // ResCopy___ |
7294 | 6767 | break; |
7295 | 6768 | } |
7296 | - case 18446744073709551349LLU: // 999999995z''''''''''''''' | |
6769 | + case 18446744073709551370LLU: // 999999996J''''''''''''''' | |
7297 | 6770 | { |
7298 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551352LLU : 18446744073709551351LLU; | |
6771 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551373LLU : 18446744073709551372LLU; | |
7299 | 6772 | break; |
7300 | 6773 | } |
7301 | - case 18446744073709551352LLU: // 9999999952''''''''''''''' | |
6774 | + case 18446744073709551373LLU: // 999999996M''''''''''''''' | |
7302 | 6775 | { |
7303 | 6776 | { |
7304 | 6777 | fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap"); |
@@ -7311,35 +6784,35 @@ | ||
7311 | 6784 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7312 | 6785 | } |
7313 | 6786 | // ACCUMULATE ARGUMENTS - END |
7314 | - uint64_t return_to = 18446744073709551348LLU; | |
6787 | + uint64_t return_to = 18446744073709551369LLU; | |
7315 | 6788 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7316 | 6789 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7317 | 6790 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
7318 | 6791 | heap.data[0].elem1 = heap.data[0].elem0; |
7319 | 6792 | heap.data[0].elem0 = restore; |
7320 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
6793 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
7321 | 6794 | break; |
7322 | 6795 | } |
7323 | - case 18446744073709551348LLU: // 999999995y''''''''''''''' | |
6796 | + case 18446744073709551369LLU: // 999999996I''''''''''''''' | |
7324 | 6797 | { |
7325 | 6798 | // parameter resdest___ RP________ goes out of scope |
7326 | - state.addr = 18446744073709551350LLU; // 9999999950''''''''''''''' | |
6799 | + state.addr = 18446744073709551371LLU; // 999999996K''''''''''''''' | |
7327 | 6800 | break; |
7328 | 6801 | } |
7329 | - case 18446744073709551351LLU: // 9999999951''''''''''''''' | |
6802 | + case 18446744073709551372LLU: // 999999996L''''''''''''''' | |
7330 | 6803 | { |
7331 | - state.addr = 18446744073709551350LLU; // 9999999950''''''''''''''' | |
6804 | + state.addr = 18446744073709551371LLU; // 999999996K''''''''''''''' | |
7332 | 6805 | break; |
7333 | 6806 | } |
7334 | - case 18446744073709551350LLU: // 9999999950''''''''''''''' | |
6807 | + case 18446744073709551371LLU: // 999999996K''''''''''''''' | |
7335 | 6808 | { |
7336 | 6809 | (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13 |
7337 | 6810 | // parameter-reference resdest___ rp________ goes out of scope |
7338 | 6811 | // parameter-reference list<resdest___> resultpars goes out of scope |
7339 | - state.addr = 18446744073709551354LLU; // 9999999954''''''''''''''' | |
6812 | + state.addr = 18446744073709551375LLU; // 999999996O''''''''''''''' | |
7340 | 6813 | break; |
7341 | 6814 | } |
7342 | - case 18446744073709551353LLU: // 9999999953''''''''''''''' | |
6815 | + case 18446744073709551374LLU: // 999999996N''''''''''''''' | |
7343 | 6816 | { |
7344 | 6817 | list_reverse(heap.data, &/*RESULTPARS*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU)); |
7345 | 6818 | { |
@@ -7354,10 +6827,10 @@ | ||
7354 | 6827 | uint64_t arg = 0; |
7355 | 6828 | LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7356 | 6829 | } |
7357 | - state.addr = 18446744073709551347LLU; // 999999995x''''''''''''''' | |
6830 | + state.addr = 18446744073709551368LLU; // 999999996H''''''''''''''' | |
7358 | 6831 | break; |
7359 | 6832 | } |
7360 | - case 18446744073709551347LLU: // 999999995x''''''''''''''' | |
6833 | + case 18446744073709551368LLU: // 999999996H''''''''''''''' | |
7361 | 6834 | { |
7362 | 6835 | if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU)) |
7363 | 6836 | { |
@@ -7364,7 +6837,7 @@ | ||
7364 | 6837 | (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13 |
7365 | 6838 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
7366 | 6839 | { |
7367 | - state.addr = 18446744073709551346LLU; // 999999995w''''''''''''''' | |
6840 | + state.addr = 18446744073709551367LLU; // 999999996G''''''''''''''' | |
7368 | 6841 | break; |
7369 | 6842 | } |
7370 | 6843 | } |
@@ -7384,7 +6857,7 @@ | ||
7384 | 6857 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7385 | 6858 | } |
7386 | 6859 | // ACCUMULATE ARGUMENTS - END |
7387 | - uint64_t return_to = 18446744073709551342LLU; | |
6860 | + uint64_t return_to = 18446744073709551363LLU; | |
7388 | 6861 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7389 | 6862 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7390 | 6863 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7393,12 +6866,12 @@ | ||
7393 | 6866 | state.addr = 296309897384864500LLU; // ParDefCopy |
7394 | 6867 | break; |
7395 | 6868 | } |
7396 | - case 18446744073709551342LLU: // 999999995s''''''''''''''' | |
6869 | + case 18446744073709551363LLU: // 999999996C''''''''''''''' | |
7397 | 6870 | { |
7398 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &*LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551345LLU : 18446744073709551344LLU; | |
6871 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &*LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551366LLU : 18446744073709551365LLU; | |
7399 | 6872 | break; |
7400 | 6873 | } |
7401 | - case 18446744073709551345LLU: // 999999995v''''''''''''''' | |
6874 | + case 18446744073709551366LLU: // 999999996F''''''''''''''' | |
7402 | 6875 | { |
7403 | 6876 | { |
7404 | 6877 | fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap"); |
@@ -7411,35 +6884,35 @@ | ||
7411 | 6884 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7412 | 6885 | } |
7413 | 6886 | // ACCUMULATE ARGUMENTS - END |
7414 | - uint64_t return_to = 18446744073709551341LLU; | |
6887 | + uint64_t return_to = 18446744073709551362LLU; | |
7415 | 6888 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7416 | 6889 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7417 | 6890 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
7418 | 6891 | heap.data[0].elem1 = heap.data[0].elem0; |
7419 | 6892 | heap.data[0].elem0 = restore; |
7420 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
6893 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
7421 | 6894 | break; |
7422 | 6895 | } |
7423 | - case 18446744073709551341LLU: // 999999995r''''''''''''''' | |
6896 | + case 18446744073709551362LLU: // 999999996B''''''''''''''' | |
7424 | 6897 | { |
7425 | 6898 | // parameter pardef____ DP________ goes out of scope |
7426 | - state.addr = 18446744073709551343LLU; // 999999995t''''''''''''''' | |
6899 | + state.addr = 18446744073709551364LLU; // 999999996D''''''''''''''' | |
7427 | 6900 | break; |
7428 | 6901 | } |
7429 | - case 18446744073709551344LLU: // 999999995u''''''''''''''' | |
6902 | + case 18446744073709551365LLU: // 999999996E''''''''''''''' | |
7430 | 6903 | { |
7431 | - state.addr = 18446744073709551343LLU; // 999999995t''''''''''''''' | |
6904 | + state.addr = 18446744073709551364LLU; // 999999996D''''''''''''''' | |
7432 | 6905 | break; |
7433 | 6906 | } |
7434 | - case 18446744073709551343LLU: // 999999995t''''''''''''''' | |
6907 | + case 18446744073709551364LLU: // 999999996D''''''''''''''' | |
7435 | 6908 | { |
7436 | 6909 | (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 14 |
7437 | 6910 | // parameter-reference pardef____ dp________ goes out of scope |
7438 | 6911 | // parameter-reference list<pardef____> defpars___ goes out of scope |
7439 | - state.addr = 18446744073709551347LLU; // 999999995x''''''''''''''' | |
6912 | + state.addr = 18446744073709551368LLU; // 999999996H''''''''''''''' | |
7440 | 6913 | break; |
7441 | 6914 | } |
7442 | - case 18446744073709551346LLU: // 999999995w''''''''''''''' | |
6915 | + case 18446744073709551367LLU: // 999999996G''''''''''''''' | |
7443 | 6916 | { |
7444 | 6917 | list_reverse(heap.data, &/*DEFPARS___*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU)); |
7445 | 6918 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -7473,7 +6946,7 @@ | ||
7473 | 6946 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7474 | 6947 | } |
7475 | 6948 | // ACCUMULATE ARGUMENTS - END |
7476 | - uint64_t return_to = 18446744073709551339LLU; | |
6949 | + uint64_t return_to = 18446744073709551360LLU; | |
7477 | 6950 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7478 | 6951 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7479 | 6952 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7482,7 +6955,7 @@ | ||
7482 | 6955 | state.addr = 552446646280519680LLU; // copyu64___ |
7483 | 6956 | break; |
7484 | 6957 | } |
7485 | - case 18446744073709551339LLU: // 999999995p''''''''''''''' | |
6958 | + case 18446744073709551360LLU: // 999999996_''''''''''''''' | |
7486 | 6959 | { |
7487 | 6960 | { |
7488 | 6961 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7511,7 +6984,7 @@ | ||
7511 | 6984 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7512 | 6985 | } |
7513 | 6986 | // ACCUMULATE ARGUMENTS - END |
7514 | - uint64_t return_to = 18446744073709551338LLU; | |
6987 | + uint64_t return_to = 18446744073709551359LLU; | |
7515 | 6988 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7516 | 6989 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7517 | 6990 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7520,7 +6993,7 @@ | ||
7520 | 6993 | state.addr = 552446646280519680LLU; // copyu64___ |
7521 | 6994 | break; |
7522 | 6995 | } |
7523 | - case 18446744073709551338LLU: // 999999995o''''''''''''''' | |
6996 | + case 18446744073709551359LLU: // 9999999959''''''''''''''' | |
7524 | 6997 | { |
7525 | 6998 | { |
7526 | 6999 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7549,7 +7022,7 @@ | ||
7549 | 7022 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7550 | 7023 | } |
7551 | 7024 | // ACCUMULATE ARGUMENTS - END |
7552 | - uint64_t return_to = 18446744073709551337LLU; | |
7025 | + uint64_t return_to = 18446744073709551358LLU; | |
7553 | 7026 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7554 | 7027 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7555 | 7028 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7558,7 +7031,7 @@ | ||
7558 | 7031 | state.addr = 552446646280519680LLU; // copyu64___ |
7559 | 7032 | break; |
7560 | 7033 | } |
7561 | - case 18446744073709551337LLU: // 999999995n''''''''''''''' | |
7034 | + case 18446744073709551358LLU: // 9999999958''''''''''''''' | |
7562 | 7035 | { |
7563 | 7036 | { |
7564 | 7037 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7587,7 +7060,7 @@ | ||
7587 | 7060 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7588 | 7061 | } |
7589 | 7062 | // ACCUMULATE ARGUMENTS - END |
7590 | - uint64_t return_to = 18446744073709551336LLU; | |
7063 | + uint64_t return_to = 18446744073709551357LLU; | |
7591 | 7064 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7592 | 7065 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7593 | 7066 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7596,7 +7069,7 @@ | ||
7596 | 7069 | state.addr = 552446646280519680LLU; // copyu64___ |
7597 | 7070 | break; |
7598 | 7071 | } |
7599 | - case 18446744073709551336LLU: // 999999995m''''''''''''''' | |
7072 | + case 18446744073709551357LLU: // 9999999957''''''''''''''' | |
7600 | 7073 | { |
7601 | 7074 | { |
7602 | 7075 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7625,7 +7098,7 @@ | ||
7625 | 7098 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7626 | 7099 | } |
7627 | 7100 | // ACCUMULATE ARGUMENTS - END |
7628 | - uint64_t return_to = 18446744073709551335LLU; | |
7101 | + uint64_t return_to = 18446744073709551356LLU; | |
7629 | 7102 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7630 | 7103 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7631 | 7104 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7634,7 +7107,7 @@ | ||
7634 | 7107 | state.addr = 552446646280519680LLU; // copyu64___ |
7635 | 7108 | break; |
7636 | 7109 | } |
7637 | - case 18446744073709551335LLU: // 999999995l''''''''''''''' | |
7110 | + case 18446744073709551356LLU: // 9999999956''''''''''''''' | |
7638 | 7111 | { |
7639 | 7112 | { |
7640 | 7113 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7646,7 +7119,7 @@ | ||
7646 | 7119 | } |
7647 | 7120 | } |
7648 | 7121 | // ACCUMULATE ARGUMENTS - END |
7649 | - uint64_t return_to = 18446744073709551340LLU; | |
7122 | + uint64_t return_to = 18446744073709551361LLU; | |
7650 | 7123 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)); |
7651 | 7124 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7652 | 7125 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7655,7 +7128,7 @@ | ||
7655 | 7128 | state.addr = 608168382267297792LLU; // function__ |
7656 | 7129 | break; |
7657 | 7130 | } |
7658 | - case 18446744073709551340LLU: // 999999995q''''''''''''''' | |
7131 | + case 18446744073709551361LLU: // 999999996A''''''''''''''' | |
7659 | 7132 | { |
7660 | 7133 | // variable list<pardef____> DEFPARS___ goes out of scope |
7661 | 7134 | // (uninitialized -> no destructor-call) |
@@ -7770,10 +7243,10 @@ | ||
7770 | 7243 | uint64_t arg = 0; |
7771 | 7244 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7772 | 7245 | } |
7773 | - state.addr = 18446744073709551334LLU; // 999999995k''''''''''''''' | |
7246 | + state.addr = 18446744073709551355LLU; // 9999999955''''''''''''''' | |
7774 | 7247 | break; |
7775 | 7248 | } |
7776 | - case 18446744073709551334LLU: // 999999995k''''''''''''''' | |
7249 | + case 18446744073709551355LLU: // 9999999955''''''''''''''' | |
7777 | 7250 | { |
7778 | 7251 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
7779 | 7252 | { |
@@ -7780,7 +7253,7 @@ | ||
7780 | 7253 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
7781 | 7254 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7782 | 7255 | { |
7783 | - state.addr = 18446744073709551333LLU; // 999999995j''''''''''''''' | |
7256 | + state.addr = 18446744073709551354LLU; // 9999999954''''''''''''''' | |
7784 | 7257 | break; |
7785 | 7258 | } |
7786 | 7259 | } |
@@ -7800,7 +7273,7 @@ | ||
7800 | 7273 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7801 | 7274 | } |
7802 | 7275 | // ACCUMULATE ARGUMENTS - END |
7803 | - uint64_t return_to = 18446744073709551329LLU; | |
7276 | + uint64_t return_to = 18446744073709551350LLU; | |
7804 | 7277 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7805 | 7278 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7806 | 7279 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7809,12 +7282,12 @@ | ||
7809 | 7282 | state.addr = 325750391286068249LLU; // RESDEFCOPY |
7810 | 7283 | break; |
7811 | 7284 | } |
7812 | - case 18446744073709551329LLU: // 999999995f''''''''''''''' | |
7285 | + case 18446744073709551350LLU: // 9999999950''''''''''''''' | |
7813 | 7286 | { |
7814 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551332LLU : 18446744073709551331LLU; | |
7287 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551353LLU : 18446744073709551352LLU; | |
7815 | 7288 | break; |
7816 | 7289 | } |
7817 | - case 18446744073709551332LLU: // 999999995i''''''''''''''' | |
7290 | + case 18446744073709551353LLU: // 9999999953''''''''''''''' | |
7818 | 7291 | { |
7819 | 7292 | { |
7820 | 7293 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -7827,35 +7300,35 @@ | ||
7827 | 7300 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7828 | 7301 | } |
7829 | 7302 | // ACCUMULATE ARGUMENTS - END |
7830 | - uint64_t return_to = 18446744073709551328LLU; | |
7303 | + uint64_t return_to = 18446744073709551349LLU; | |
7831 | 7304 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7832 | 7305 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7833 | 7306 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
7834 | 7307 | heap.data[0].elem1 = heap.data[0].elem0; |
7835 | 7308 | heap.data[0].elem0 = restore; |
7836 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
7309 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
7837 | 7310 | break; |
7838 | 7311 | } |
7839 | - case 18446744073709551328LLU: // 999999995e''''''''''''''' | |
7312 | + case 18446744073709551349LLU: // 999999995z''''''''''''''' | |
7840 | 7313 | { |
7841 | 7314 | // parameter resdest___ new_______ goes out of scope |
7842 | - state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
7315 | + state.addr = 18446744073709551351LLU; // 9999999951''''''''''''''' | |
7843 | 7316 | break; |
7844 | 7317 | } |
7845 | - case 18446744073709551331LLU: // 999999995h''''''''''''''' | |
7318 | + case 18446744073709551352LLU: // 9999999952''''''''''''''' | |
7846 | 7319 | { |
7847 | - state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
7320 | + state.addr = 18446744073709551351LLU; // 9999999951''''''''''''''' | |
7848 | 7321 | break; |
7849 | 7322 | } |
7850 | - case 18446744073709551330LLU: // 999999995g''''''''''''''' | |
7323 | + case 18446744073709551351LLU: // 9999999951''''''''''''''' | |
7851 | 7324 | { |
7852 | 7325 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
7853 | 7326 | // parameter-reference resdest___ respar1___ goes out of scope |
7854 | 7327 | // parameter-reference list<resdest___> yresults__ goes out of scope |
7855 | - state.addr = 18446744073709551334LLU; // 999999995k''''''''''''''' | |
7328 | + state.addr = 18446744073709551355LLU; // 9999999955''''''''''''''' | |
7856 | 7329 | break; |
7857 | 7330 | } |
7858 | - case 18446744073709551333LLU: // 999999995j''''''''''''''' | |
7331 | + case 18446744073709551354LLU: // 9999999954''''''''''''''' | |
7859 | 7332 | { |
7860 | 7333 | list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)); |
7861 | 7334 | { |
@@ -7866,10 +7339,10 @@ | ||
7866 | 7339 | uint64_t arg = 0; |
7867 | 7340 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7868 | 7341 | } |
7869 | - state.addr = 18446744073709551327LLU; // 999999995d''''''''''''''' | |
7342 | + state.addr = 18446744073709551348LLU; // 999999995y''''''''''''''' | |
7870 | 7343 | break; |
7871 | 7344 | } |
7872 | - case 18446744073709551327LLU: // 999999995d''''''''''''''' | |
7345 | + case 18446744073709551348LLU: // 999999995y''''''''''''''' | |
7873 | 7346 | { |
7874 | 7347 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
7875 | 7348 | { |
@@ -7876,16 +7349,16 @@ | ||
7876 | 7349 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
7877 | 7350 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7878 | 7351 | { |
7879 | - state.addr = 18446744073709551326LLU; // 999999995c''''''''''''''' | |
7352 | + state.addr = 18446744073709551347LLU; // 999999995x''''''''''''''' | |
7880 | 7353 | break; |
7881 | 7354 | } |
7882 | 7355 | } |
7883 | 7356 | /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU; |
7884 | 7357 | *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0; |
7885 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551325LLU : 18446744073709551324LLU; | |
7358 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551346LLU : 18446744073709551345LLU; | |
7886 | 7359 | break; |
7887 | 7360 | } |
7888 | - case 18446744073709551325LLU: // 999999995b''''''''''''''' | |
7361 | + case 18446744073709551346LLU: // 999999995w''''''''''''''' | |
7889 | 7362 | { |
7890 | 7363 | { |
7891 | 7364 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 8); |
@@ -7910,7 +7383,7 @@ | ||
7910 | 7383 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7911 | 7384 | } |
7912 | 7385 | // ACCUMULATE ARGUMENTS - END |
7913 | - uint64_t return_to = 18446744073709551322LLU; | |
7386 | + uint64_t return_to = 18446744073709551343LLU; | |
7914 | 7387 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
7915 | 7388 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7916 | 7389 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7919,7 +7392,7 @@ | ||
7919 | 7392 | state.addr = 589059885019168768LLU; // equres____ |
7920 | 7393 | break; |
7921 | 7394 | } |
7922 | - case 18446744073709551322LLU: // 999999995Z''''''''''''''' | |
7395 | + case 18446744073709551343LLU: // 999999995t''''''''''''''' | |
7923 | 7396 | { |
7924 | 7397 | |
7925 | 7398 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU); |
@@ -7934,41 +7407,41 @@ | ||
7934 | 7407 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7935 | 7408 | } |
7936 | 7409 | // ACCUMULATE ARGUMENTS - END |
7937 | - uint64_t return_to = 18446744073709551321LLU; | |
7410 | + uint64_t return_to = 18446744073709551342LLU; | |
7938 | 7411 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7939 | 7412 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7940 | 7413 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
7941 | 7414 | heap.data[0].elem1 = heap.data[0].elem0; |
7942 | 7415 | heap.data[0].elem0 = restore; |
7943 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
7416 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
7944 | 7417 | break; |
7945 | 7418 | } |
7946 | - case 18446744073709551321LLU: // 999999995Y''''''''''''''' | |
7419 | + case 18446744073709551342LLU: // 999999995s''''''''''''''' | |
7947 | 7420 | { |
7948 | 7421 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 9 |
7949 | - state.addr = 18446744073709551323LLU; // 999999995$''''''''''''''' | |
7422 | + state.addr = 18446744073709551344LLU; // 999999995u''''''''''''''' | |
7950 | 7423 | break; |
7951 | 7424 | } |
7952 | - case 18446744073709551324LLU: // 999999995a''''''''''''''' | |
7425 | + case 18446744073709551345LLU: // 999999995v''''''''''''''' | |
7953 | 7426 | { |
7954 | 7427 | |
7955 | 7428 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0; |
7956 | - state.addr = 18446744073709551323LLU; // 999999995$''''''''''''''' | |
7429 | + state.addr = 18446744073709551344LLU; // 999999995u''''''''''''''' | |
7957 | 7430 | break; |
7958 | 7431 | } |
7959 | - case 18446744073709551323LLU: // 999999995$''''''''''''''' | |
7432 | + case 18446744073709551344LLU: // 999999995u''''''''''''''' | |
7960 | 7433 | { |
7961 | 7434 | // parameter-reference resdest___ res0______ goes out of scope |
7962 | 7435 | // parameter-reference list<resdest___> xresults__ goes out of scope |
7963 | - state.addr = 18446744073709551327LLU; // 999999995d''''''''''''''' | |
7436 | + state.addr = 18446744073709551348LLU; // 999999995y''''''''''''''' | |
7964 | 7437 | break; |
7965 | 7438 | } |
7966 | - case 18446744073709551326LLU: // 999999995c''''''''''''''' | |
7439 | + case 18446744073709551347LLU: // 999999995x''''''''''''''' | |
7967 | 7440 | { |
7968 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551320LLU : 18446744073709551319LLU; | |
7441 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551341LLU : 18446744073709551340LLU; | |
7969 | 7442 | break; |
7970 | 7443 | } |
7971 | - case 18446744073709551320LLU: // 999999995X''''''''''''''' | |
7444 | + case 18446744073709551341LLU: // 999999995r''''''''''''''' | |
7972 | 7445 | { |
7973 | 7446 | { |
7974 | 7447 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 8); |
@@ -7984,38 +7457,38 @@ | ||
7984 | 7457 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7985 | 7458 | } |
7986 | 7459 | // ACCUMULATE ARGUMENTS - END |
7987 | - uint64_t return_to = 18446744073709551317LLU; | |
7460 | + uint64_t return_to = 18446744073709551338LLU; | |
7988 | 7461 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7989 | 7462 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7990 | 7463 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
7991 | 7464 | heap.data[0].elem1 = heap.data[0].elem0; |
7992 | 7465 | heap.data[0].elem0 = restore; |
7993 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
7466 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
7994 | 7467 | break; |
7995 | 7468 | } |
7996 | - case 18446744073709551317LLU: // 999999995U''''''''''''''' | |
7469 | + case 18446744073709551338LLU: // 999999995o''''''''''''''' | |
7997 | 7470 | { |
7998 | 7471 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7 |
7999 | - state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
7472 | + state.addr = 18446744073709551339LLU; // 999999995p''''''''''''''' | |
8000 | 7473 | break; |
8001 | 7474 | } |
8002 | - case 18446744073709551319LLU: // 999999995W''''''''''''''' | |
7475 | + case 18446744073709551340LLU: // 999999995q''''''''''''''' | |
8003 | 7476 | { |
8004 | - state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
7477 | + state.addr = 18446744073709551339LLU; // 999999995p''''''''''''''' | |
8005 | 7478 | break; |
8006 | 7479 | } |
8007 | - case 18446744073709551318LLU: // 999999995V''''''''''''''' | |
7480 | + case 18446744073709551339LLU: // 999999995p''''''''''''''' | |
8008 | 7481 | { |
8009 | 7482 | // variable list<resdest___> yres______ goes out of scope |
8010 | 7483 | // emitted destructur for type list<resdest___> |
8011 | - state.addr = 18446744073709551315LLU; // 999999995S''''''''''''''' | |
7484 | + state.addr = 18446744073709551336LLU; // 999999995m''''''''''''''' | |
8012 | 7485 | break; |
8013 | 7486 | } |
8014 | - case 18446744073709551315LLU: // 999999995S''''''''''''''' | |
7487 | + case 18446744073709551336LLU: // 999999995m''''''''''''''' | |
8015 | 7488 | { |
8016 | 7489 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/) |
8017 | 7490 | { |
8018 | - state.addr = 18446744073709551316LLU; // 999999995T''''''''''''''' | |
7491 | + state.addr = 18446744073709551337LLU; // 999999995n''''''''''''''' | |
8019 | 7492 | break; |
8020 | 7493 | } |
8021 | 7494 | // temporary list-element |
@@ -8029,23 +7502,23 @@ | ||
8029 | 7502 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8030 | 7503 | } |
8031 | 7504 | // ACCUMULATE ARGUMENTS - END |
8032 | - uint64_t return_to = 18446744073709551314LLU; | |
7505 | + uint64_t return_to = 18446744073709551335LLU; | |
8033 | 7506 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8034 | 7507 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8035 | 7508 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8036 | 7509 | heap.data[0].elem1 = heap.data[0].elem0; |
8037 | 7510 | heap.data[0].elem0 = restore; |
8038 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
7511 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
8039 | 7512 | break; |
8040 | 7513 | } |
8041 | - case 18446744073709551314LLU: // 999999995R''''''''''''''' | |
7514 | + case 18446744073709551335LLU: // 999999995l''''''''''''''' | |
8042 | 7515 | { |
8043 | 7516 | // RELEASE temporary destructor-variable |
8044 | 7517 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
8045 | - state.addr = 18446744073709551315LLU; // 999999995S''''''''''''''' | |
7518 | + state.addr = 18446744073709551336LLU; // 999999995m''''''''''''''' | |
8046 | 7519 | break; |
8047 | 7520 | } |
8048 | - case 18446744073709551316LLU: // 999999995T''''''''''''''' | |
7521 | + case 18446744073709551337LLU: // 999999995n''''''''''''''' | |
8049 | 7522 | { |
8050 | 7523 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 6 |
8051 | 7524 | { |
@@ -8060,10 +7533,10 @@ | ||
8060 | 7533 | uint64_t arg = 0; |
8061 | 7534 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8062 | 7535 | } |
8063 | - state.addr = 18446744073709551313LLU; // 999999995Q''''''''''''''' | |
7536 | + state.addr = 18446744073709551334LLU; // 999999995k''''''''''''''' | |
8064 | 7537 | break; |
8065 | 7538 | } |
8066 | - case 18446744073709551313LLU: // 999999995Q''''''''''''''' | |
7539 | + case 18446744073709551334LLU: // 999999995k''''''''''''''' | |
8067 | 7540 | { |
8068 | 7541 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
8069 | 7542 | { |
@@ -8070,7 +7543,7 @@ | ||
8070 | 7543 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
8071 | 7544 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
8072 | 7545 | { |
8073 | - state.addr = 18446744073709551312LLU; // 999999995P''''''''''''''' | |
7546 | + state.addr = 18446744073709551333LLU; // 999999995j''''''''''''''' | |
8074 | 7547 | break; |
8075 | 7548 | } |
8076 | 7549 | } |
@@ -8090,7 +7563,7 @@ | ||
8090 | 7563 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8091 | 7564 | } |
8092 | 7565 | // ACCUMULATE ARGUMENTS - END |
8093 | - uint64_t return_to = 18446744073709551308LLU; | |
7566 | + uint64_t return_to = 18446744073709551329LLU; | |
8094 | 7567 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
8095 | 7568 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8096 | 7569 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8099,12 +7572,12 @@ | ||
8099 | 7572 | state.addr = 296309897384864500LLU; // ParDefCopy |
8100 | 7573 | break; |
8101 | 7574 | } |
8102 | - case 18446744073709551308LLU: // 999999995L''''''''''''''' | |
7575 | + case 18446744073709551329LLU: // 999999995f''''''''''''''' | |
8103 | 7576 | { |
8104 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551311LLU : 18446744073709551310LLU; | |
7577 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551332LLU : 18446744073709551331LLU; | |
8105 | 7578 | break; |
8106 | 7579 | } |
8107 | - case 18446744073709551311LLU: // 999999995O''''''''''''''' | |
7580 | + case 18446744073709551332LLU: // 999999995i''''''''''''''' | |
8108 | 7581 | { |
8109 | 7582 | { |
8110 | 7583 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -8117,35 +7590,35 @@ | ||
8117 | 7590 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8118 | 7591 | } |
8119 | 7592 | // ACCUMULATE ARGUMENTS - END |
8120 | - uint64_t return_to = 18446744073709551307LLU; | |
7593 | + uint64_t return_to = 18446744073709551328LLU; | |
8121 | 7594 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8122 | 7595 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8123 | 7596 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8124 | 7597 | heap.data[0].elem1 = heap.data[0].elem0; |
8125 | 7598 | heap.data[0].elem0 = restore; |
8126 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
7599 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8127 | 7600 | break; |
8128 | 7601 | } |
8129 | - case 18446744073709551307LLU: // 999999995K''''''''''''''' | |
7602 | + case 18446744073709551328LLU: // 999999995e''''''''''''''' | |
8130 | 7603 | { |
8131 | 7604 | // parameter pardef____ new_______ goes out of scope |
8132 | - state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
7605 | + state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
8133 | 7606 | break; |
8134 | 7607 | } |
8135 | - case 18446744073709551310LLU: // 999999995N''''''''''''''' | |
7608 | + case 18446744073709551331LLU: // 999999995h''''''''''''''' | |
8136 | 7609 | { |
8137 | - state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
7610 | + state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
8138 | 7611 | break; |
8139 | 7612 | } |
8140 | - case 18446744073709551309LLU: // 999999995M''''''''''''''' | |
7613 | + case 18446744073709551330LLU: // 999999995g''''''''''''''' | |
8141 | 7614 | { |
8142 | 7615 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
8143 | 7616 | // parameter-reference pardef____ par1______ goes out of scope |
8144 | 7617 | // parameter-reference list<pardef____> ydefpars__ goes out of scope |
8145 | - state.addr = 18446744073709551313LLU; // 999999995Q''''''''''''''' | |
7618 | + state.addr = 18446744073709551334LLU; // 999999995k''''''''''''''' | |
8146 | 7619 | break; |
8147 | 7620 | } |
8148 | - case 18446744073709551312LLU: // 999999995P''''''''''''''' | |
7621 | + case 18446744073709551333LLU: // 999999995j''''''''''''''' | |
8149 | 7622 | { |
8150 | 7623 | list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)); |
8151 | 7624 | { |
@@ -8156,10 +7629,10 @@ | ||
8156 | 7629 | uint64_t arg = 0; |
8157 | 7630 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8158 | 7631 | } |
8159 | - state.addr = 18446744073709551306LLU; // 999999995J''''''''''''''' | |
7632 | + state.addr = 18446744073709551327LLU; // 999999995d''''''''''''''' | |
8160 | 7633 | break; |
8161 | 7634 | } |
8162 | - case 18446744073709551306LLU: // 999999995J''''''''''''''' | |
7635 | + case 18446744073709551327LLU: // 999999995d''''''''''''''' | |
8163 | 7636 | { |
8164 | 7637 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
8165 | 7638 | { |
@@ -8166,16 +7639,16 @@ | ||
8166 | 7639 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
8167 | 7640 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
8168 | 7641 | { |
8169 | - state.addr = 18446744073709551305LLU; // 999999995I''''''''''''''' | |
7642 | + state.addr = 18446744073709551326LLU; // 999999995c''''''''''''''' | |
8170 | 7643 | break; |
8171 | 7644 | } |
8172 | 7645 | } |
8173 | 7646 | /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU; |
8174 | 7647 | *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0; |
8175 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551304LLU : 18446744073709551303LLU; | |
7648 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551325LLU : 18446744073709551324LLU; | |
8176 | 7649 | break; |
8177 | 7650 | } |
8178 | - case 18446744073709551304LLU: // 999999995H''''''''''''''' | |
7651 | + case 18446744073709551325LLU: // 999999995b''''''''''''''' | |
8179 | 7652 | { |
8180 | 7653 | { |
8181 | 7654 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 11); |
@@ -8200,7 +7673,7 @@ | ||
8200 | 7673 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8201 | 7674 | } |
8202 | 7675 | // ACCUMULATE ARGUMENTS - END |
8203 | - uint64_t return_to = 18446744073709551301LLU; | |
7676 | + uint64_t return_to = 18446744073709551322LLU; | |
8204 | 7677 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
8205 | 7678 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8206 | 7679 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8209,7 +7682,7 @@ | ||
8209 | 7682 | state.addr = 589059743276730432LLU; // equpardef_ |
8210 | 7683 | break; |
8211 | 7684 | } |
8212 | - case 18446744073709551301LLU: // 999999995E''''''''''''''' | |
7685 | + case 18446744073709551322LLU: // 999999995Z''''''''''''''' | |
8213 | 7686 | { |
8214 | 7687 | |
8215 | 7688 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU); |
@@ -8224,41 +7697,41 @@ | ||
8224 | 7697 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8225 | 7698 | } |
8226 | 7699 | // ACCUMULATE ARGUMENTS - END |
8227 | - uint64_t return_to = 18446744073709551300LLU; | |
7700 | + uint64_t return_to = 18446744073709551321LLU; | |
8228 | 7701 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8229 | 7702 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8230 | 7703 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8231 | 7704 | heap.data[0].elem1 = heap.data[0].elem0; |
8232 | 7705 | heap.data[0].elem0 = restore; |
8233 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
7706 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8234 | 7707 | break; |
8235 | 7708 | } |
8236 | - case 18446744073709551300LLU: // 999999995D''''''''''''''' | |
7709 | + case 18446744073709551321LLU: // 999999995Y''''''''''''''' | |
8237 | 7710 | { |
8238 | 7711 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 9 |
8239 | - state.addr = 18446744073709551302LLU; // 999999995F''''''''''''''' | |
7712 | + state.addr = 18446744073709551323LLU; // 999999995$''''''''''''''' | |
8240 | 7713 | break; |
8241 | 7714 | } |
8242 | - case 18446744073709551303LLU: // 999999995G''''''''''''''' | |
7715 | + case 18446744073709551324LLU: // 999999995a''''''''''''''' | |
8243 | 7716 | { |
8244 | 7717 | |
8245 | 7718 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0; |
8246 | - state.addr = 18446744073709551302LLU; // 999999995F''''''''''''''' | |
7719 | + state.addr = 18446744073709551323LLU; // 999999995$''''''''''''''' | |
8247 | 7720 | break; |
8248 | 7721 | } |
8249 | - case 18446744073709551302LLU: // 999999995F''''''''''''''' | |
7722 | + case 18446744073709551323LLU: // 999999995$''''''''''''''' | |
8250 | 7723 | { |
8251 | 7724 | // parameter-reference pardef____ par0______ goes out of scope |
8252 | 7725 | // parameter-reference list<pardef____> xdefpars__ goes out of scope |
8253 | - state.addr = 18446744073709551306LLU; // 999999995J''''''''''''''' | |
7726 | + state.addr = 18446744073709551327LLU; // 999999995d''''''''''''''' | |
8254 | 7727 | break; |
8255 | 7728 | } |
8256 | - case 18446744073709551305LLU: // 999999995I''''''''''''''' | |
7729 | + case 18446744073709551326LLU: // 999999995c''''''''''''''' | |
8257 | 7730 | { |
8258 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551299LLU : 18446744073709551298LLU; | |
7731 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551320LLU : 18446744073709551319LLU; | |
8259 | 7732 | break; |
8260 | 7733 | } |
8261 | - case 18446744073709551299LLU: // 999999995C''''''''''''''' | |
7734 | + case 18446744073709551320LLU: // 999999995X''''''''''''''' | |
8262 | 7735 | { |
8263 | 7736 | { |
8264 | 7737 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 11); |
@@ -8274,38 +7747,38 @@ | ||
8274 | 7747 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8275 | 7748 | } |
8276 | 7749 | // ACCUMULATE ARGUMENTS - END |
8277 | - uint64_t return_to = 18446744073709551296LLU; | |
7750 | + uint64_t return_to = 18446744073709551317LLU; | |
8278 | 7751 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8279 | 7752 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8280 | 7753 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8281 | 7754 | heap.data[0].elem1 = heap.data[0].elem0; |
8282 | 7755 | heap.data[0].elem0 = restore; |
8283 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
7756 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8284 | 7757 | break; |
8285 | 7758 | } |
8286 | - case 18446744073709551296LLU: // 999999995_''''''''''''''' | |
7759 | + case 18446744073709551317LLU: // 999999995U''''''''''''''' | |
8287 | 7760 | { |
8288 | 7761 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 7 |
8289 | - state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
7762 | + state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
8290 | 7763 | break; |
8291 | 7764 | } |
8292 | - case 18446744073709551298LLU: // 999999995B''''''''''''''' | |
7765 | + case 18446744073709551319LLU: // 999999995W''''''''''''''' | |
8293 | 7766 | { |
8294 | - state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
7767 | + state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
8295 | 7768 | break; |
8296 | 7769 | } |
8297 | - case 18446744073709551297LLU: // 999999995A''''''''''''''' | |
7770 | + case 18446744073709551318LLU: // 999999995V''''''''''''''' | |
8298 | 7771 | { |
8299 | 7772 | // variable list<pardef____> ypars_____ goes out of scope |
8300 | 7773 | // emitted destructur for type list<pardef____> |
8301 | - state.addr = 18446744073709551294LLU; // 9999999948''''''''''''''' | |
7774 | + state.addr = 18446744073709551315LLU; // 999999995S''''''''''''''' | |
8302 | 7775 | break; |
8303 | 7776 | } |
8304 | - case 18446744073709551294LLU: // 9999999948''''''''''''''' | |
7777 | + case 18446744073709551315LLU: // 999999995S''''''''''''''' | |
8305 | 7778 | { |
8306 | 7779 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/) |
8307 | 7780 | { |
8308 | - state.addr = 18446744073709551295LLU; // 9999999949''''''''''''''' | |
7781 | + state.addr = 18446744073709551316LLU; // 999999995T''''''''''''''' | |
8309 | 7782 | break; |
8310 | 7783 | } |
8311 | 7784 | // temporary list-element |
@@ -8319,23 +7792,23 @@ | ||
8319 | 7792 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8320 | 7793 | } |
8321 | 7794 | // ACCUMULATE ARGUMENTS - END |
8322 | - uint64_t return_to = 18446744073709551293LLU; | |
7795 | + uint64_t return_to = 18446744073709551314LLU; | |
8323 | 7796 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8324 | 7797 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8325 | 7798 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8326 | 7799 | heap.data[0].elem1 = heap.data[0].elem0; |
8327 | 7800 | heap.data[0].elem0 = restore; |
8328 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
7801 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8329 | 7802 | break; |
8330 | 7803 | } |
8331 | - case 18446744073709551293LLU: // 9999999947''''''''''''''' | |
7804 | + case 18446744073709551314LLU: // 999999995R''''''''''''''' | |
8332 | 7805 | { |
8333 | 7806 | // RELEASE temporary destructor-variable |
8334 | 7807 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
8335 | - state.addr = 18446744073709551294LLU; // 9999999948''''''''''''''' | |
7808 | + state.addr = 18446744073709551315LLU; // 999999995S''''''''''''''' | |
8336 | 7809 | break; |
8337 | 7810 | } |
8338 | - case 18446744073709551295LLU: // 9999999949''''''''''''''' | |
7811 | + case 18446744073709551316LLU: // 999999995T''''''''''''''' | |
8339 | 7812 | { |
8340 | 7813 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 6 |
8341 | 7814 | // parameter-reference list<pardef____> ydefpars__ goes out of scope |
@@ -8372,10 +7845,10 @@ | ||
8372 | 7845 | uint64_t arg = 0; |
8373 | 7846 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8374 | 7847 | } |
8375 | - state.addr = 18446744073709551292LLU; // 9999999946''''''''''''''' | |
7848 | + state.addr = 18446744073709551313LLU; // 999999995Q''''''''''''''' | |
8376 | 7849 | break; |
8377 | 7850 | } |
8378 | - case 18446744073709551292LLU: // 9999999946''''''''''''''' | |
7851 | + case 18446744073709551313LLU: // 999999995Q''''''''''''''' | |
8379 | 7852 | { |
8380 | 7853 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
8381 | 7854 | { |
@@ -8382,7 +7855,7 @@ | ||
8382 | 7855 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
8383 | 7856 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8384 | 7857 | { |
8385 | - state.addr = 18446744073709551291LLU; // 9999999945''''''''''''''' | |
7858 | + state.addr = 18446744073709551312LLU; // 999999995P''''''''''''''' | |
8386 | 7859 | break; |
8387 | 7860 | } |
8388 | 7861 | } |
@@ -8402,7 +7875,7 @@ | ||
8402 | 7875 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8403 | 7876 | } |
8404 | 7877 | // ACCUMULATE ARGUMENTS - END |
8405 | - uint64_t return_to = 18446744073709551287LLU; | |
7878 | + uint64_t return_to = 18446744073709551308LLU; | |
8406 | 7879 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
8407 | 7880 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8408 | 7881 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8411,12 +7884,12 @@ | ||
8411 | 7884 | state.addr = 325750391286068249LLU; // RESDEFCOPY |
8412 | 7885 | break; |
8413 | 7886 | } |
8414 | - case 18446744073709551287LLU: // 9999999941''''''''''''''' | |
7887 | + case 18446744073709551308LLU: // 999999995L''''''''''''''' | |
8415 | 7888 | { |
8416 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551290LLU : 18446744073709551289LLU; | |
7889 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551311LLU : 18446744073709551310LLU; | |
8417 | 7890 | break; |
8418 | 7891 | } |
8419 | - case 18446744073709551290LLU: // 9999999944''''''''''''''' | |
7892 | + case 18446744073709551311LLU: // 999999995O''''''''''''''' | |
8420 | 7893 | { |
8421 | 7894 | { |
8422 | 7895 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -8429,35 +7902,35 @@ | ||
8429 | 7902 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8430 | 7903 | } |
8431 | 7904 | // ACCUMULATE ARGUMENTS - END |
8432 | - uint64_t return_to = 18446744073709551286LLU; | |
7905 | + uint64_t return_to = 18446744073709551307LLU; | |
8433 | 7906 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8434 | 7907 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8435 | 7908 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8436 | 7909 | heap.data[0].elem1 = heap.data[0].elem0; |
8437 | 7910 | heap.data[0].elem0 = restore; |
8438 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
7911 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
8439 | 7912 | break; |
8440 | 7913 | } |
8441 | - case 18446744073709551286LLU: // 9999999940''''''''''''''' | |
7914 | + case 18446744073709551307LLU: // 999999995K''''''''''''''' | |
8442 | 7915 | { |
8443 | 7916 | // parameter resdest___ new_______ goes out of scope |
8444 | - state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
7917 | + state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
8445 | 7918 | break; |
8446 | 7919 | } |
8447 | - case 18446744073709551289LLU: // 9999999943''''''''''''''' | |
7920 | + case 18446744073709551310LLU: // 999999995N''''''''''''''' | |
8448 | 7921 | { |
8449 | - state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
7922 | + state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
8450 | 7923 | break; |
8451 | 7924 | } |
8452 | - case 18446744073709551288LLU: // 9999999942''''''''''''''' | |
7925 | + case 18446744073709551309LLU: // 999999995M''''''''''''''' | |
8453 | 7926 | { |
8454 | 7927 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
8455 | 7928 | // parameter-reference resdest___ respar1___ goes out of scope |
8456 | 7929 | // parameter-reference list<resdest___> yresults__ goes out of scope |
8457 | - state.addr = 18446744073709551292LLU; // 9999999946''''''''''''''' | |
7930 | + state.addr = 18446744073709551313LLU; // 999999995Q''''''''''''''' | |
8458 | 7931 | break; |
8459 | 7932 | } |
8460 | - case 18446744073709551291LLU: // 9999999945''''''''''''''' | |
7933 | + case 18446744073709551312LLU: // 999999995P''''''''''''''' | |
8461 | 7934 | { |
8462 | 7935 | list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)); |
8463 | 7936 | { |
@@ -8468,10 +7941,10 @@ | ||
8468 | 7941 | uint64_t arg = 0; |
8469 | 7942 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8470 | 7943 | } |
8471 | - state.addr = 18446744073709551285LLU; // 999999994z''''''''''''''' | |
7944 | + state.addr = 18446744073709551306LLU; // 999999995J''''''''''''''' | |
8472 | 7945 | break; |
8473 | 7946 | } |
8474 | - case 18446744073709551285LLU: // 999999994z''''''''''''''' | |
7947 | + case 18446744073709551306LLU: // 999999995J''''''''''''''' | |
8475 | 7948 | { |
8476 | 7949 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
8477 | 7950 | { |
@@ -8478,16 +7951,16 @@ | ||
8478 | 7951 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
8479 | 7952 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8480 | 7953 | { |
8481 | - state.addr = 18446744073709551284LLU; // 999999994y''''''''''''''' | |
7954 | + state.addr = 18446744073709551305LLU; // 999999995I''''''''''''''' | |
8482 | 7955 | break; |
8483 | 7956 | } |
8484 | 7957 | } |
8485 | 7958 | /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU; |
8486 | 7959 | *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0; |
8487 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551283LLU : 18446744073709551282LLU; | |
7960 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551304LLU : 18446744073709551303LLU; | |
8488 | 7961 | break; |
8489 | 7962 | } |
8490 | - case 18446744073709551283LLU: // 999999994x''''''''''''''' | |
7963 | + case 18446744073709551304LLU: // 999999995H''''''''''''''' | |
8491 | 7964 | { |
8492 | 7965 | { |
8493 | 7966 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 8); |
@@ -8512,7 +7985,7 @@ | ||
8512 | 7985 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8513 | 7986 | } |
8514 | 7987 | // ACCUMULATE ARGUMENTS - END |
8515 | - uint64_t return_to = 18446744073709551280LLU; | |
7988 | + uint64_t return_to = 18446744073709551301LLU; | |
8516 | 7989 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
8517 | 7990 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8518 | 7991 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8521,7 +7994,7 @@ | ||
8521 | 7994 | state.addr = 589059885019168768LLU; // equres____ |
8522 | 7995 | break; |
8523 | 7996 | } |
8524 | - case 18446744073709551280LLU: // 999999994u''''''''''''''' | |
7997 | + case 18446744073709551301LLU: // 999999995E''''''''''''''' | |
8525 | 7998 | { |
8526 | 7999 | |
8527 | 8000 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU); |
@@ -8536,41 +8009,41 @@ | ||
8536 | 8009 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8537 | 8010 | } |
8538 | 8011 | // ACCUMULATE ARGUMENTS - END |
8539 | - uint64_t return_to = 18446744073709551279LLU; | |
8012 | + uint64_t return_to = 18446744073709551300LLU; | |
8540 | 8013 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8541 | 8014 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8542 | 8015 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8543 | 8016 | heap.data[0].elem1 = heap.data[0].elem0; |
8544 | 8017 | heap.data[0].elem0 = restore; |
8545 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
8018 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
8546 | 8019 | break; |
8547 | 8020 | } |
8548 | - case 18446744073709551279LLU: // 999999994t''''''''''''''' | |
8021 | + case 18446744073709551300LLU: // 999999995D''''''''''''''' | |
8549 | 8022 | { |
8550 | 8023 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 19 |
8551 | - state.addr = 18446744073709551281LLU; // 999999994v''''''''''''''' | |
8024 | + state.addr = 18446744073709551302LLU; // 999999995F''''''''''''''' | |
8552 | 8025 | break; |
8553 | 8026 | } |
8554 | - case 18446744073709551282LLU: // 999999994w''''''''''''''' | |
8027 | + case 18446744073709551303LLU: // 999999995G''''''''''''''' | |
8555 | 8028 | { |
8556 | 8029 | |
8557 | 8030 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0; |
8558 | - state.addr = 18446744073709551281LLU; // 999999994v''''''''''''''' | |
8031 | + state.addr = 18446744073709551302LLU; // 999999995F''''''''''''''' | |
8559 | 8032 | break; |
8560 | 8033 | } |
8561 | - case 18446744073709551281LLU: // 999999994v''''''''''''''' | |
8034 | + case 18446744073709551302LLU: // 999999995F''''''''''''''' | |
8562 | 8035 | { |
8563 | 8036 | // parameter-reference resdest___ res0______ goes out of scope |
8564 | 8037 | // parameter-reference list<resdest___> xresults__ goes out of scope |
8565 | - state.addr = 18446744073709551285LLU; // 999999994z''''''''''''''' | |
8038 | + state.addr = 18446744073709551306LLU; // 999999995J''''''''''''''' | |
8566 | 8039 | break; |
8567 | 8040 | } |
8568 | - case 18446744073709551284LLU: // 999999994y''''''''''''''' | |
8041 | + case 18446744073709551305LLU: // 999999995I''''''''''''''' | |
8569 | 8042 | { |
8570 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551278LLU : 18446744073709551277LLU; | |
8043 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551299LLU : 18446744073709551298LLU; | |
8571 | 8044 | break; |
8572 | 8045 | } |
8573 | - case 18446744073709551278LLU: // 999999994s''''''''''''''' | |
8046 | + case 18446744073709551299LLU: // 999999995C''''''''''''''' | |
8574 | 8047 | { |
8575 | 8048 | { |
8576 | 8049 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 8); |
@@ -8586,38 +8059,38 @@ | ||
8586 | 8059 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8587 | 8060 | } |
8588 | 8061 | // ACCUMULATE ARGUMENTS - END |
8589 | - uint64_t return_to = 18446744073709551275LLU; | |
8062 | + uint64_t return_to = 18446744073709551296LLU; | |
8590 | 8063 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8591 | 8064 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8592 | 8065 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8593 | 8066 | heap.data[0].elem1 = heap.data[0].elem0; |
8594 | 8067 | heap.data[0].elem0 = restore; |
8595 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
8068 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
8596 | 8069 | break; |
8597 | 8070 | } |
8598 | - case 18446744073709551275LLU: // 999999994p''''''''''''''' | |
8071 | + case 18446744073709551296LLU: // 999999995_''''''''''''''' | |
8599 | 8072 | { |
8600 | 8073 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 17 |
8601 | - state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8074 | + state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
8602 | 8075 | break; |
8603 | 8076 | } |
8604 | - case 18446744073709551277LLU: // 999999994r''''''''''''''' | |
8077 | + case 18446744073709551298LLU: // 999999995B''''''''''''''' | |
8605 | 8078 | { |
8606 | - state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8079 | + state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
8607 | 8080 | break; |
8608 | 8081 | } |
8609 | - case 18446744073709551276LLU: // 999999994q''''''''''''''' | |
8082 | + case 18446744073709551297LLU: // 999999995A''''''''''''''' | |
8610 | 8083 | { |
8611 | 8084 | // variable list<resdest___> yres______ goes out of scope |
8612 | 8085 | // emitted destructur for type list<resdest___> |
8613 | - state.addr = 18446744073709551273LLU; // 999999994n''''''''''''''' | |
8086 | + state.addr = 18446744073709551294LLU; // 9999999948''''''''''''''' | |
8614 | 8087 | break; |
8615 | 8088 | } |
8616 | - case 18446744073709551273LLU: // 999999994n''''''''''''''' | |
8089 | + case 18446744073709551294LLU: // 9999999948''''''''''''''' | |
8617 | 8090 | { |
8618 | 8091 | if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/) |
8619 | 8092 | { |
8620 | - state.addr = 18446744073709551274LLU; // 999999994o''''''''''''''' | |
8093 | + state.addr = 18446744073709551295LLU; // 9999999949''''''''''''''' | |
8621 | 8094 | break; |
8622 | 8095 | } |
8623 | 8096 | // temporary list-element |
@@ -8631,23 +8104,23 @@ | ||
8631 | 8104 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8632 | 8105 | } |
8633 | 8106 | // ACCUMULATE ARGUMENTS - END |
8634 | - uint64_t return_to = 18446744073709551272LLU; | |
8107 | + uint64_t return_to = 18446744073709551293LLU; | |
8635 | 8108 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8636 | 8109 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8637 | 8110 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8638 | 8111 | heap.data[0].elem1 = heap.data[0].elem0; |
8639 | 8112 | heap.data[0].elem0 = restore; |
8640 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
8113 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
8641 | 8114 | break; |
8642 | 8115 | } |
8643 | - case 18446744073709551272LLU: // 999999994m''''''''''''''' | |
8116 | + case 18446744073709551293LLU: // 9999999947''''''''''''''' | |
8644 | 8117 | { |
8645 | 8118 | // RELEASE temporary destructor-variable |
8646 | 8119 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8647 | - state.addr = 18446744073709551273LLU; // 999999994n''''''''''''''' | |
8120 | + state.addr = 18446744073709551294LLU; // 9999999948''''''''''''''' | |
8648 | 8121 | break; |
8649 | 8122 | } |
8650 | - case 18446744073709551274LLU: // 999999994o''''''''''''''' | |
8123 | + case 18446744073709551295LLU: // 9999999949''''''''''''''' | |
8651 | 8124 | { |
8652 | 8125 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 16 |
8653 | 8126 | { |
@@ -8662,10 +8135,10 @@ | ||
8662 | 8135 | uint64_t arg = 0; |
8663 | 8136 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8664 | 8137 | } |
8665 | - state.addr = 18446744073709551271LLU; // 999999994l''''''''''''''' | |
8138 | + state.addr = 18446744073709551292LLU; // 9999999946''''''''''''''' | |
8666 | 8139 | break; |
8667 | 8140 | } |
8668 | - case 18446744073709551271LLU: // 999999994l''''''''''''''' | |
8141 | + case 18446744073709551292LLU: // 9999999946''''''''''''''' | |
8669 | 8142 | { |
8670 | 8143 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
8671 | 8144 | { |
@@ -8672,7 +8145,7 @@ | ||
8672 | 8145 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
8673 | 8146 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8674 | 8147 | { |
8675 | - state.addr = 18446744073709551270LLU; // 999999994k''''''''''''''' | |
8148 | + state.addr = 18446744073709551291LLU; // 9999999945''''''''''''''' | |
8676 | 8149 | break; |
8677 | 8150 | } |
8678 | 8151 | } |
@@ -8692,7 +8165,7 @@ | ||
8692 | 8165 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8693 | 8166 | } |
8694 | 8167 | // ACCUMULATE ARGUMENTS - END |
8695 | - uint64_t return_to = 18446744073709551266LLU; | |
8168 | + uint64_t return_to = 18446744073709551287LLU; | |
8696 | 8169 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
8697 | 8170 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8698 | 8171 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8701,12 +8174,12 @@ | ||
8701 | 8174 | state.addr = 296309897384864500LLU; // ParDefCopy |
8702 | 8175 | break; |
8703 | 8176 | } |
8704 | - case 18446744073709551266LLU: // 999999994g''''''''''''''' | |
8177 | + case 18446744073709551287LLU: // 9999999941''''''''''''''' | |
8705 | 8178 | { |
8706 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551269LLU : 18446744073709551268LLU; | |
8179 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551290LLU : 18446744073709551289LLU; | |
8707 | 8180 | break; |
8708 | 8181 | } |
8709 | - case 18446744073709551269LLU: // 999999994j''''''''''''''' | |
8182 | + case 18446744073709551290LLU: // 9999999944''''''''''''''' | |
8710 | 8183 | { |
8711 | 8184 | { |
8712 | 8185 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -8719,35 +8192,35 @@ | ||
8719 | 8192 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8720 | 8193 | } |
8721 | 8194 | // ACCUMULATE ARGUMENTS - END |
8722 | - uint64_t return_to = 18446744073709551265LLU; | |
8195 | + uint64_t return_to = 18446744073709551286LLU; | |
8723 | 8196 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8724 | 8197 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8725 | 8198 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8726 | 8199 | heap.data[0].elem1 = heap.data[0].elem0; |
8727 | 8200 | heap.data[0].elem0 = restore; |
8728 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
8201 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8729 | 8202 | break; |
8730 | 8203 | } |
8731 | - case 18446744073709551265LLU: // 999999994f''''''''''''''' | |
8204 | + case 18446744073709551286LLU: // 9999999940''''''''''''''' | |
8732 | 8205 | { |
8733 | 8206 | // parameter pardef____ new_______ goes out of scope |
8734 | - state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
8207 | + state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
8735 | 8208 | break; |
8736 | 8209 | } |
8737 | - case 18446744073709551268LLU: // 999999994i''''''''''''''' | |
8210 | + case 18446744073709551289LLU: // 9999999943''''''''''''''' | |
8738 | 8211 | { |
8739 | - state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
8212 | + state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
8740 | 8213 | break; |
8741 | 8214 | } |
8742 | - case 18446744073709551267LLU: // 999999994h''''''''''''''' | |
8215 | + case 18446744073709551288LLU: // 9999999942''''''''''''''' | |
8743 | 8216 | { |
8744 | 8217 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
8745 | 8218 | // parameter-reference pardef____ par1______ goes out of scope |
8746 | 8219 | // parameter-reference list<pardef____> ydefpars__ goes out of scope |
8747 | - state.addr = 18446744073709551271LLU; // 999999994l''''''''''''''' | |
8220 | + state.addr = 18446744073709551292LLU; // 9999999946''''''''''''''' | |
8748 | 8221 | break; |
8749 | 8222 | } |
8750 | - case 18446744073709551270LLU: // 999999994k''''''''''''''' | |
8223 | + case 18446744073709551291LLU: // 9999999945''''''''''''''' | |
8751 | 8224 | { |
8752 | 8225 | list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)); |
8753 | 8226 | { |
@@ -8758,10 +8231,10 @@ | ||
8758 | 8231 | uint64_t arg = 0; |
8759 | 8232 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8760 | 8233 | } |
8761 | - state.addr = 18446744073709551264LLU; // 999999994e''''''''''''''' | |
8234 | + state.addr = 18446744073709551285LLU; // 999999994z''''''''''''''' | |
8762 | 8235 | break; |
8763 | 8236 | } |
8764 | - case 18446744073709551264LLU: // 999999994e''''''''''''''' | |
8237 | + case 18446744073709551285LLU: // 999999994z''''''''''''''' | |
8765 | 8238 | { |
8766 | 8239 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
8767 | 8240 | { |
@@ -8768,16 +8241,16 @@ | ||
8768 | 8241 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
8769 | 8242 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8770 | 8243 | { |
8771 | - state.addr = 18446744073709551263LLU; // 999999994d''''''''''''''' | |
8244 | + state.addr = 18446744073709551284LLU; // 999999994y''''''''''''''' | |
8772 | 8245 | break; |
8773 | 8246 | } |
8774 | 8247 | } |
8775 | 8248 | /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU; |
8776 | 8249 | *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0; |
8777 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551262LLU : 18446744073709551261LLU; | |
8250 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551283LLU : 18446744073709551282LLU; | |
8778 | 8251 | break; |
8779 | 8252 | } |
8780 | - case 18446744073709551262LLU: // 999999994c''''''''''''''' | |
8253 | + case 18446744073709551283LLU: // 999999994x''''''''''''''' | |
8781 | 8254 | { |
8782 | 8255 | { |
8783 | 8256 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 11); |
@@ -8802,7 +8275,7 @@ | ||
8802 | 8275 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8803 | 8276 | } |
8804 | 8277 | // ACCUMULATE ARGUMENTS - END |
8805 | - uint64_t return_to = 18446744073709551259LLU; | |
8278 | + uint64_t return_to = 18446744073709551280LLU; | |
8806 | 8279 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
8807 | 8280 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8808 | 8281 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8811,7 +8284,7 @@ | ||
8811 | 8284 | state.addr = 589059743276730432LLU; // equpardef_ |
8812 | 8285 | break; |
8813 | 8286 | } |
8814 | - case 18446744073709551259LLU: // 999999994$''''''''''''''' | |
8287 | + case 18446744073709551280LLU: // 999999994u''''''''''''''' | |
8815 | 8288 | { |
8816 | 8289 | |
8817 | 8290 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU); |
@@ -8826,41 +8299,41 @@ | ||
8826 | 8299 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8827 | 8300 | } |
8828 | 8301 | // ACCUMULATE ARGUMENTS - END |
8829 | - uint64_t return_to = 18446744073709551258LLU; | |
8302 | + uint64_t return_to = 18446744073709551279LLU; | |
8830 | 8303 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8831 | 8304 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8832 | 8305 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8833 | 8306 | heap.data[0].elem1 = heap.data[0].elem0; |
8834 | 8307 | heap.data[0].elem0 = restore; |
8835 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
8308 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8836 | 8309 | break; |
8837 | 8310 | } |
8838 | - case 18446744073709551258LLU: // 999999994Z''''''''''''''' | |
8311 | + case 18446744073709551279LLU: // 999999994t''''''''''''''' | |
8839 | 8312 | { |
8840 | 8313 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 19 |
8841 | - state.addr = 18446744073709551260LLU; // 999999994a''''''''''''''' | |
8314 | + state.addr = 18446744073709551281LLU; // 999999994v''''''''''''''' | |
8842 | 8315 | break; |
8843 | 8316 | } |
8844 | - case 18446744073709551261LLU: // 999999994b''''''''''''''' | |
8317 | + case 18446744073709551282LLU: // 999999994w''''''''''''''' | |
8845 | 8318 | { |
8846 | 8319 | |
8847 | 8320 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0; |
8848 | - state.addr = 18446744073709551260LLU; // 999999994a''''''''''''''' | |
8321 | + state.addr = 18446744073709551281LLU; // 999999994v''''''''''''''' | |
8849 | 8322 | break; |
8850 | 8323 | } |
8851 | - case 18446744073709551260LLU: // 999999994a''''''''''''''' | |
8324 | + case 18446744073709551281LLU: // 999999994v''''''''''''''' | |
8852 | 8325 | { |
8853 | 8326 | // parameter-reference pardef____ par0______ goes out of scope |
8854 | 8327 | // parameter-reference list<pardef____> xdefpars__ goes out of scope |
8855 | - state.addr = 18446744073709551264LLU; // 999999994e''''''''''''''' | |
8328 | + state.addr = 18446744073709551285LLU; // 999999994z''''''''''''''' | |
8856 | 8329 | break; |
8857 | 8330 | } |
8858 | - case 18446744073709551263LLU: // 999999994d''''''''''''''' | |
8331 | + case 18446744073709551284LLU: // 999999994y''''''''''''''' | |
8859 | 8332 | { |
8860 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551257LLU : 18446744073709551256LLU; | |
8333 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551278LLU : 18446744073709551277LLU; | |
8861 | 8334 | break; |
8862 | 8335 | } |
8863 | - case 18446744073709551257LLU: // 999999994Y''''''''''''''' | |
8336 | + case 18446744073709551278LLU: // 999999994s''''''''''''''' | |
8864 | 8337 | { |
8865 | 8338 | { |
8866 | 8339 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 11); |
@@ -8876,38 +8349,38 @@ | ||
8876 | 8349 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8877 | 8350 | } |
8878 | 8351 | // ACCUMULATE ARGUMENTS - END |
8879 | - uint64_t return_to = 18446744073709551254LLU; | |
8352 | + uint64_t return_to = 18446744073709551275LLU; | |
8880 | 8353 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8881 | 8354 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8882 | 8355 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8883 | 8356 | heap.data[0].elem1 = heap.data[0].elem0; |
8884 | 8357 | heap.data[0].elem0 = restore; |
8885 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
8358 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8886 | 8359 | break; |
8887 | 8360 | } |
8888 | - case 18446744073709551254LLU: // 999999994V''''''''''''''' | |
8361 | + case 18446744073709551275LLU: // 999999994p''''''''''''''' | |
8889 | 8362 | { |
8890 | 8363 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 17 |
8891 | - state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
8364 | + state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8892 | 8365 | break; |
8893 | 8366 | } |
8894 | - case 18446744073709551256LLU: // 999999994X''''''''''''''' | |
8367 | + case 18446744073709551277LLU: // 999999994r''''''''''''''' | |
8895 | 8368 | { |
8896 | - state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
8369 | + state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8897 | 8370 | break; |
8898 | 8371 | } |
8899 | - case 18446744073709551255LLU: // 999999994W''''''''''''''' | |
8372 | + case 18446744073709551276LLU: // 999999994q''''''''''''''' | |
8900 | 8373 | { |
8901 | 8374 | // variable list<pardef____> ypars_____ goes out of scope |
8902 | 8375 | // emitted destructur for type list<pardef____> |
8903 | - state.addr = 18446744073709551252LLU; // 999999994T''''''''''''''' | |
8376 | + state.addr = 18446744073709551273LLU; // 999999994n''''''''''''''' | |
8904 | 8377 | break; |
8905 | 8378 | } |
8906 | - case 18446744073709551252LLU: // 999999994T''''''''''''''' | |
8379 | + case 18446744073709551273LLU: // 999999994n''''''''''''''' | |
8907 | 8380 | { |
8908 | 8381 | if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/) |
8909 | 8382 | { |
8910 | - state.addr = 18446744073709551253LLU; // 999999994U''''''''''''''' | |
8383 | + state.addr = 18446744073709551274LLU; // 999999994o''''''''''''''' | |
8911 | 8384 | break; |
8912 | 8385 | } |
8913 | 8386 | // temporary list-element |
@@ -8921,23 +8394,23 @@ | ||
8921 | 8394 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8922 | 8395 | } |
8923 | 8396 | // ACCUMULATE ARGUMENTS - END |
8924 | - uint64_t return_to = 18446744073709551251LLU; | |
8397 | + uint64_t return_to = 18446744073709551272LLU; | |
8925 | 8398 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8926 | 8399 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8927 | 8400 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
8928 | 8401 | heap.data[0].elem1 = heap.data[0].elem0; |
8929 | 8402 | heap.data[0].elem0 = restore; |
8930 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
8403 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
8931 | 8404 | break; |
8932 | 8405 | } |
8933 | - case 18446744073709551251LLU: // 999999994S''''''''''''''' | |
8406 | + case 18446744073709551272LLU: // 999999994m''''''''''''''' | |
8934 | 8407 | { |
8935 | 8408 | // RELEASE temporary destructor-variable |
8936 | 8409 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8937 | - state.addr = 18446744073709551252LLU; // 999999994T''''''''''''''' | |
8410 | + state.addr = 18446744073709551273LLU; // 999999994n''''''''''''''' | |
8938 | 8411 | break; |
8939 | 8412 | } |
8940 | - case 18446744073709551253LLU: // 999999994U''''''''''''''' | |
8413 | + case 18446744073709551274LLU: // 999999994o''''''''''''''' | |
8941 | 8414 | { |
8942 | 8415 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 16 |
8943 | 8416 | { |
@@ -9044,10 +8517,10 @@ | ||
9044 | 8517 | uint64_t arg = 0; |
9045 | 8518 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9046 | 8519 | } |
9047 | - state.addr = 18446744073709551250LLU; // 999999994R''''''''''''''' | |
8520 | + state.addr = 18446744073709551271LLU; // 999999994l''''''''''''''' | |
9048 | 8521 | break; |
9049 | 8522 | } |
9050 | - case 18446744073709551250LLU: // 999999994R''''''''''''''' | |
8523 | + case 18446744073709551271LLU: // 999999994l''''''''''''''' | |
9051 | 8524 | { |
9052 | 8525 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
9053 | 8526 | { |
@@ -9054,7 +8527,7 @@ | ||
9054 | 8527 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
9055 | 8528 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9056 | 8529 | { |
9057 | - state.addr = 18446744073709551249LLU; // 999999994Q''''''''''''''' | |
8530 | + state.addr = 18446744073709551270LLU; // 999999994k''''''''''''''' | |
9058 | 8531 | break; |
9059 | 8532 | } |
9060 | 8533 | } |
@@ -9074,7 +8547,7 @@ | ||
9074 | 8547 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9075 | 8548 | } |
9076 | 8549 | // ACCUMULATE ARGUMENTS - END |
9077 | - uint64_t return_to = 18446744073709551245LLU; | |
8550 | + uint64_t return_to = 18446744073709551266LLU; | |
9078 | 8551 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9079 | 8552 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9080 | 8553 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9083,12 +8556,12 @@ | ||
9083 | 8556 | state.addr = 325750391286068249LLU; // RESDEFCOPY |
9084 | 8557 | break; |
9085 | 8558 | } |
9086 | - case 18446744073709551245LLU: // 999999994M''''''''''''''' | |
8559 | + case 18446744073709551266LLU: // 999999994g''''''''''''''' | |
9087 | 8560 | { |
9088 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551248LLU : 18446744073709551247LLU; | |
8561 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551269LLU : 18446744073709551268LLU; | |
9089 | 8562 | break; |
9090 | 8563 | } |
9091 | - case 18446744073709551248LLU: // 999999994P''''''''''''''' | |
8564 | + case 18446744073709551269LLU: // 999999994j''''''''''''''' | |
9092 | 8565 | { |
9093 | 8566 | { |
9094 | 8567 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -9101,35 +8574,35 @@ | ||
9101 | 8574 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9102 | 8575 | } |
9103 | 8576 | // ACCUMULATE ARGUMENTS - END |
9104 | - uint64_t return_to = 18446744073709551244LLU; | |
8577 | + uint64_t return_to = 18446744073709551265LLU; | |
9105 | 8578 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9106 | 8579 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9107 | 8580 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9108 | 8581 | heap.data[0].elem1 = heap.data[0].elem0; |
9109 | 8582 | heap.data[0].elem0 = restore; |
9110 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
8583 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
9111 | 8584 | break; |
9112 | 8585 | } |
9113 | - case 18446744073709551244LLU: // 999999994L''''''''''''''' | |
8586 | + case 18446744073709551265LLU: // 999999994f''''''''''''''' | |
9114 | 8587 | { |
9115 | 8588 | // parameter resdest___ new_______ goes out of scope |
9116 | - state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
8589 | + state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
9117 | 8590 | break; |
9118 | 8591 | } |
9119 | - case 18446744073709551247LLU: // 999999994O''''''''''''''' | |
8592 | + case 18446744073709551268LLU: // 999999994i''''''''''''''' | |
9120 | 8593 | { |
9121 | - state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
8594 | + state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
9122 | 8595 | break; |
9123 | 8596 | } |
9124 | - case 18446744073709551246LLU: // 999999994N''''''''''''''' | |
8597 | + case 18446744073709551267LLU: // 999999994h''''''''''''''' | |
9125 | 8598 | { |
9126 | 8599 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
9127 | 8600 | // parameter-reference resdest___ respar1___ goes out of scope |
9128 | 8601 | // parameter-reference function__ y_________ goes out of scope |
9129 | - state.addr = 18446744073709551250LLU; // 999999994R''''''''''''''' | |
8602 | + state.addr = 18446744073709551271LLU; // 999999994l''''''''''''''' | |
9130 | 8603 | break; |
9131 | 8604 | } |
9132 | - case 18446744073709551249LLU: // 999999994Q''''''''''''''' | |
8605 | + case 18446744073709551270LLU: // 999999994k''''''''''''''' | |
9133 | 8606 | { |
9134 | 8607 | list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)); |
9135 | 8608 | { |
@@ -9140,10 +8613,10 @@ | ||
9140 | 8613 | uint64_t arg = 0; |
9141 | 8614 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9142 | 8615 | } |
9143 | - state.addr = 18446744073709551243LLU; // 999999994K''''''''''''''' | |
8616 | + state.addr = 18446744073709551264LLU; // 999999994e''''''''''''''' | |
9144 | 8617 | break; |
9145 | 8618 | } |
9146 | - case 18446744073709551243LLU: // 999999994K''''''''''''''' | |
8619 | + case 18446744073709551264LLU: // 999999994e''''''''''''''' | |
9147 | 8620 | { |
9148 | 8621 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
9149 | 8622 | { |
@@ -9150,16 +8623,16 @@ | ||
9150 | 8623 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
9151 | 8624 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9152 | 8625 | { |
9153 | - state.addr = 18446744073709551242LLU; // 999999994J''''''''''''''' | |
8626 | + state.addr = 18446744073709551263LLU; // 999999994d''''''''''''''' | |
9154 | 8627 | break; |
9155 | 8628 | } |
9156 | 8629 | } |
9157 | 8630 | /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU; |
9158 | 8631 | *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0; |
9159 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551241LLU : 18446744073709551240LLU; | |
8632 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551262LLU : 18446744073709551261LLU; | |
9160 | 8633 | break; |
9161 | 8634 | } |
9162 | - case 18446744073709551241LLU: // 999999994I''''''''''''''' | |
8635 | + case 18446744073709551262LLU: // 999999994c''''''''''''''' | |
9163 | 8636 | { |
9164 | 8637 | { |
9165 | 8638 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/*list*/, 8); |
@@ -9184,7 +8657,7 @@ | ||
9184 | 8657 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9185 | 8658 | } |
9186 | 8659 | // ACCUMULATE ARGUMENTS - END |
9187 | - uint64_t return_to = 18446744073709551238LLU; | |
8660 | + uint64_t return_to = 18446744073709551259LLU; | |
9188 | 8661 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
9189 | 8662 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9190 | 8663 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9193,7 +8666,7 @@ | ||
9193 | 8666 | state.addr = 589059885019168768LLU; // equres____ |
9194 | 8667 | break; |
9195 | 8668 | } |
9196 | - case 18446744073709551238LLU: // 999999994F''''''''''''''' | |
8669 | + case 18446744073709551259LLU: // 999999994$''''''''''''''' | |
9197 | 8670 | { |
9198 | 8671 | |
9199 | 8672 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU); |
@@ -9208,41 +8681,41 @@ | ||
9208 | 8681 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9209 | 8682 | } |
9210 | 8683 | // ACCUMULATE ARGUMENTS - END |
9211 | - uint64_t return_to = 18446744073709551237LLU; | |
8684 | + uint64_t return_to = 18446744073709551258LLU; | |
9212 | 8685 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9213 | 8686 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9214 | 8687 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9215 | 8688 | heap.data[0].elem1 = heap.data[0].elem0; |
9216 | 8689 | heap.data[0].elem0 = restore; |
9217 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
8690 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
9218 | 8691 | break; |
9219 | 8692 | } |
9220 | - case 18446744073709551237LLU: // 999999994E''''''''''''''' | |
8693 | + case 18446744073709551258LLU: // 999999994Z''''''''''''''' | |
9221 | 8694 | { |
9222 | 8695 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7 |
9223 | - state.addr = 18446744073709551239LLU; // 999999994G''''''''''''''' | |
8696 | + state.addr = 18446744073709551260LLU; // 999999994a''''''''''''''' | |
9224 | 8697 | break; |
9225 | 8698 | } |
9226 | - case 18446744073709551240LLU: // 999999994H''''''''''''''' | |
8699 | + case 18446744073709551261LLU: // 999999994b''''''''''''''' | |
9227 | 8700 | { |
9228 | 8701 | |
9229 | 8702 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0; |
9230 | - state.addr = 18446744073709551239LLU; // 999999994G''''''''''''''' | |
8703 | + state.addr = 18446744073709551260LLU; // 999999994a''''''''''''''' | |
9231 | 8704 | break; |
9232 | 8705 | } |
9233 | - case 18446744073709551239LLU: // 999999994G''''''''''''''' | |
8706 | + case 18446744073709551260LLU: // 999999994a''''''''''''''' | |
9234 | 8707 | { |
9235 | 8708 | // parameter-reference resdest___ res0______ goes out of scope |
9236 | 8709 | // parameter-reference function__ x_________ goes out of scope |
9237 | - state.addr = 18446744073709551243LLU; // 999999994K''''''''''''''' | |
8710 | + state.addr = 18446744073709551264LLU; // 999999994e''''''''''''''' | |
9238 | 8711 | break; |
9239 | 8712 | } |
9240 | - case 18446744073709551242LLU: // 999999994J''''''''''''''' | |
8713 | + case 18446744073709551263LLU: // 999999994d''''''''''''''' | |
9241 | 8714 | { |
9242 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551236LLU : 18446744073709551235LLU; | |
8715 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551257LLU : 18446744073709551256LLU; | |
9243 | 8716 | break; |
9244 | 8717 | } |
9245 | - case 18446744073709551236LLU: // 999999994D''''''''''''''' | |
8718 | + case 18446744073709551257LLU: // 999999994Y''''''''''''''' | |
9246 | 8719 | { |
9247 | 8720 | { |
9248 | 8721 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 8); |
@@ -9258,38 +8731,38 @@ | ||
9258 | 8731 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9259 | 8732 | } |
9260 | 8733 | // ACCUMULATE ARGUMENTS - END |
9261 | - uint64_t return_to = 18446744073709551233LLU; | |
8734 | + uint64_t return_to = 18446744073709551254LLU; | |
9262 | 8735 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9263 | 8736 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9264 | 8737 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9265 | 8738 | heap.data[0].elem1 = heap.data[0].elem0; |
9266 | 8739 | heap.data[0].elem0 = restore; |
9267 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
8740 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
9268 | 8741 | break; |
9269 | 8742 | } |
9270 | - case 18446744073709551233LLU: // 999999994A''''''''''''''' | |
8743 | + case 18446744073709551254LLU: // 999999994V''''''''''''''' | |
9271 | 8744 | { |
9272 | 8745 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 5 |
9273 | - state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
8746 | + state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
9274 | 8747 | break; |
9275 | 8748 | } |
9276 | - case 18446744073709551235LLU: // 999999994C''''''''''''''' | |
8749 | + case 18446744073709551256LLU: // 999999994X''''''''''''''' | |
9277 | 8750 | { |
9278 | - state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
8751 | + state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
9279 | 8752 | break; |
9280 | 8753 | } |
9281 | - case 18446744073709551234LLU: // 999999994B''''''''''''''' | |
8754 | + case 18446744073709551255LLU: // 999999994W''''''''''''''' | |
9282 | 8755 | { |
9283 | 8756 | // variable list<resdest___> yres______ goes out of scope |
9284 | 8757 | // emitted destructur for type list<resdest___> |
9285 | - state.addr = 18446744073709551231LLU; // 9999999939''''''''''''''' | |
8758 | + state.addr = 18446744073709551252LLU; // 999999994T''''''''''''''' | |
9286 | 8759 | break; |
9287 | 8760 | } |
9288 | - case 18446744073709551231LLU: // 9999999939''''''''''''''' | |
8761 | + case 18446744073709551252LLU: // 999999994T''''''''''''''' | |
9289 | 8762 | { |
9290 | 8763 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/) |
9291 | 8764 | { |
9292 | - state.addr = 18446744073709551232LLU; // 999999994_''''''''''''''' | |
8765 | + state.addr = 18446744073709551253LLU; // 999999994U''''''''''''''' | |
9293 | 8766 | break; |
9294 | 8767 | } |
9295 | 8768 | // temporary list-element |
@@ -9303,23 +8776,23 @@ | ||
9303 | 8776 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9304 | 8777 | } |
9305 | 8778 | // ACCUMULATE ARGUMENTS - END |
9306 | - uint64_t return_to = 18446744073709551230LLU; | |
8779 | + uint64_t return_to = 18446744073709551251LLU; | |
9307 | 8780 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9308 | 8781 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9309 | 8782 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9310 | 8783 | heap.data[0].elem1 = heap.data[0].elem0; |
9311 | 8784 | heap.data[0].elem0 = restore; |
9312 | - state.addr = 18446744073709551526LLU; // 999999998k''''''''''''''' | |
8785 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
9313 | 8786 | break; |
9314 | 8787 | } |
9315 | - case 18446744073709551230LLU: // 9999999938''''''''''''''' | |
8788 | + case 18446744073709551251LLU: // 999999994S''''''''''''''' | |
9316 | 8789 | { |
9317 | 8790 | // RELEASE temporary destructor-variable |
9318 | 8791 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9319 | - state.addr = 18446744073709551231LLU; // 9999999939''''''''''''''' | |
8792 | + state.addr = 18446744073709551252LLU; // 999999994T''''''''''''''' | |
9320 | 8793 | break; |
9321 | 8794 | } |
9322 | - case 18446744073709551232LLU: // 999999994_''''''''''''''' | |
8795 | + case 18446744073709551253LLU: // 999999994U''''''''''''''' | |
9323 | 8796 | { |
9324 | 8797 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 4 |
9325 | 8798 | { |
@@ -9334,10 +8807,10 @@ | ||
9334 | 8807 | uint64_t arg = 0; |
9335 | 8808 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9336 | 8809 | } |
9337 | - state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
8810 | + state.addr = 18446744073709551250LLU; // 999999994R''''''''''''''' | |
9338 | 8811 | break; |
9339 | 8812 | } |
9340 | - case 18446744073709551229LLU: // 9999999937''''''''''''''' | |
8813 | + case 18446744073709551250LLU: // 999999994R''''''''''''''' | |
9341 | 8814 | { |
9342 | 8815 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
9343 | 8816 | { |
@@ -9344,7 +8817,7 @@ | ||
9344 | 8817 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
9345 | 8818 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9346 | 8819 | { |
9347 | - state.addr = 18446744073709551228LLU; // 9999999936''''''''''''''' | |
8820 | + state.addr = 18446744073709551249LLU; // 999999994Q''''''''''''''' | |
9348 | 8821 | break; |
9349 | 8822 | } |
9350 | 8823 | } |
@@ -9364,7 +8837,7 @@ | ||
9364 | 8837 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9365 | 8838 | } |
9366 | 8839 | // ACCUMULATE ARGUMENTS - END |
9367 | - uint64_t return_to = 18446744073709551224LLU; | |
8840 | + uint64_t return_to = 18446744073709551245LLU; | |
9368 | 8841 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9369 | 8842 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9370 | 8843 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9373,12 +8846,12 @@ | ||
9373 | 8846 | state.addr = 296309897384864500LLU; // ParDefCopy |
9374 | 8847 | break; |
9375 | 8848 | } |
9376 | - case 18446744073709551224LLU: // 9999999932''''''''''''''' | |
8849 | + case 18446744073709551245LLU: // 999999994M''''''''''''''' | |
9377 | 8850 | { |
9378 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 11) ? 18446744073709551227LLU : 18446744073709551226LLU; | |
8851 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 11) ? 18446744073709551248LLU : 18446744073709551247LLU; | |
9379 | 8852 | break; |
9380 | 8853 | } |
9381 | - case 18446744073709551227LLU: // 9999999935''''''''''''''' | |
8854 | + case 18446744073709551248LLU: // 999999994P''''''''''''''' | |
9382 | 8855 | { |
9383 | 8856 | { |
9384 | 8857 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -9391,35 +8864,35 @@ | ||
9391 | 8864 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9392 | 8865 | } |
9393 | 8866 | // ACCUMULATE ARGUMENTS - END |
9394 | - uint64_t return_to = 18446744073709551223LLU; | |
8867 | + uint64_t return_to = 18446744073709551244LLU; | |
9395 | 8868 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9396 | 8869 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9397 | 8870 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9398 | 8871 | heap.data[0].elem1 = heap.data[0].elem0; |
9399 | 8872 | heap.data[0].elem0 = restore; |
9400 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
8873 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
9401 | 8874 | break; |
9402 | 8875 | } |
9403 | - case 18446744073709551223LLU: // 9999999931''''''''''''''' | |
8876 | + case 18446744073709551244LLU: // 999999994L''''''''''''''' | |
9404 | 8877 | { |
9405 | 8878 | // parameter pardef____ new_______ goes out of scope |
9406 | - state.addr = 18446744073709551225LLU; // 9999999933''''''''''''''' | |
8879 | + state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
9407 | 8880 | break; |
9408 | 8881 | } |
9409 | - case 18446744073709551226LLU: // 9999999934''''''''''''''' | |
8882 | + case 18446744073709551247LLU: // 999999994O''''''''''''''' | |
9410 | 8883 | { |
9411 | - state.addr = 18446744073709551225LLU; // 9999999933''''''''''''''' | |
8884 | + state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
9412 | 8885 | break; |
9413 | 8886 | } |
9414 | - case 18446744073709551225LLU: // 9999999933''''''''''''''' | |
8887 | + case 18446744073709551246LLU: // 999999994N''''''''''''''' | |
9415 | 8888 | { |
9416 | 8889 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
9417 | 8890 | // parameter-reference pardef____ par1______ goes out of scope |
9418 | 8891 | // parameter-reference function__ y_________ goes out of scope |
9419 | - state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
8892 | + state.addr = 18446744073709551250LLU; // 999999994R''''''''''''''' | |
9420 | 8893 | break; |
9421 | 8894 | } |
9422 | - case 18446744073709551228LLU: // 9999999936''''''''''''''' | |
8895 | + case 18446744073709551249LLU: // 999999994Q''''''''''''''' | |
9423 | 8896 | { |
9424 | 8897 | list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)); |
9425 | 8898 | { |
@@ -9430,10 +8903,10 @@ | ||
9430 | 8903 | uint64_t arg = 0; |
9431 | 8904 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9432 | 8905 | } |
9433 | - state.addr = 18446744073709551222LLU; // 9999999930''''''''''''''' | |
8906 | + state.addr = 18446744073709551243LLU; // 999999994K''''''''''''''' | |
9434 | 8907 | break; |
9435 | 8908 | } |
9436 | - case 18446744073709551222LLU: // 9999999930''''''''''''''' | |
8909 | + case 18446744073709551243LLU: // 999999994K''''''''''''''' | |
9437 | 8910 | { |
9438 | 8911 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
9439 | 8912 | { |
@@ -9440,16 +8913,16 @@ | ||
9440 | 8913 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
9441 | 8914 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9442 | 8915 | { |
9443 | - state.addr = 18446744073709551221LLU; // 999999993z''''''''''''''' | |
8916 | + state.addr = 18446744073709551242LLU; // 999999994J''''''''''''''' | |
9444 | 8917 | break; |
9445 | 8918 | } |
9446 | 8919 | } |
9447 | 8920 | /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU; |
9448 | 8921 | *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0; |
9449 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551220LLU : 18446744073709551219LLU; | |
8922 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551241LLU : 18446744073709551240LLU; | |
9450 | 8923 | break; |
9451 | 8924 | } |
9452 | - case 18446744073709551220LLU: // 999999993y''''''''''''''' | |
8925 | + case 18446744073709551241LLU: // 999999994I''''''''''''''' | |
9453 | 8926 | { |
9454 | 8927 | { |
9455 | 8928 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/*list*/, 11); |
@@ -9474,7 +8947,7 @@ | ||
9474 | 8947 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9475 | 8948 | } |
9476 | 8949 | // ACCUMULATE ARGUMENTS - END |
9477 | - uint64_t return_to = 18446744073709551217LLU; | |
8950 | + uint64_t return_to = 18446744073709551238LLU; | |
9478 | 8951 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
9479 | 8952 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9480 | 8953 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9483,7 +8956,7 @@ | ||
9483 | 8956 | state.addr = 589059743276730432LLU; // equpardef_ |
9484 | 8957 | break; |
9485 | 8958 | } |
9486 | - case 18446744073709551217LLU: // 999999993v''''''''''''''' | |
8959 | + case 18446744073709551238LLU: // 999999994F''''''''''''''' | |
9487 | 8960 | { |
9488 | 8961 | |
9489 | 8962 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU); |
@@ -9498,41 +8971,41 @@ | ||
9498 | 8971 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9499 | 8972 | } |
9500 | 8973 | // ACCUMULATE ARGUMENTS - END |
9501 | - uint64_t return_to = 18446744073709551216LLU; | |
8974 | + uint64_t return_to = 18446744073709551237LLU; | |
9502 | 8975 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9503 | 8976 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9504 | 8977 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9505 | 8978 | heap.data[0].elem1 = heap.data[0].elem0; |
9506 | 8979 | heap.data[0].elem0 = restore; |
9507 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
8980 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
9508 | 8981 | break; |
9509 | 8982 | } |
9510 | - case 18446744073709551216LLU: // 999999993u''''''''''''''' | |
8983 | + case 18446744073709551237LLU: // 999999994E''''''''''''''' | |
9511 | 8984 | { |
9512 | 8985 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 7 |
9513 | - state.addr = 18446744073709551218LLU; // 999999993w''''''''''''''' | |
8986 | + state.addr = 18446744073709551239LLU; // 999999994G''''''''''''''' | |
9514 | 8987 | break; |
9515 | 8988 | } |
9516 | - case 18446744073709551219LLU: // 999999993x''''''''''''''' | |
8989 | + case 18446744073709551240LLU: // 999999994H''''''''''''''' | |
9517 | 8990 | { |
9518 | 8991 | |
9519 | 8992 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0; |
9520 | - state.addr = 18446744073709551218LLU; // 999999993w''''''''''''''' | |
8993 | + state.addr = 18446744073709551239LLU; // 999999994G''''''''''''''' | |
9521 | 8994 | break; |
9522 | 8995 | } |
9523 | - case 18446744073709551218LLU: // 999999993w''''''''''''''' | |
8996 | + case 18446744073709551239LLU: // 999999994G''''''''''''''' | |
9524 | 8997 | { |
9525 | 8998 | // parameter-reference pardef____ par0______ goes out of scope |
9526 | 8999 | // parameter-reference function__ x_________ goes out of scope |
9527 | - state.addr = 18446744073709551222LLU; // 9999999930''''''''''''''' | |
9000 | + state.addr = 18446744073709551243LLU; // 999999994K''''''''''''''' | |
9528 | 9001 | break; |
9529 | 9002 | } |
9530 | - case 18446744073709551221LLU: // 999999993z''''''''''''''' | |
9003 | + case 18446744073709551242LLU: // 999999994J''''''''''''''' | |
9531 | 9004 | { |
9532 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551215LLU : 18446744073709551214LLU; | |
9005 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551236LLU : 18446744073709551235LLU; | |
9533 | 9006 | break; |
9534 | 9007 | } |
9535 | - case 18446744073709551215LLU: // 999999993t''''''''''''''' | |
9008 | + case 18446744073709551236LLU: // 999999994D''''''''''''''' | |
9536 | 9009 | { |
9537 | 9010 | { |
9538 | 9011 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 11); |
@@ -9548,38 +9021,38 @@ | ||
9548 | 9021 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9549 | 9022 | } |
9550 | 9023 | // ACCUMULATE ARGUMENTS - END |
9551 | - uint64_t return_to = 18446744073709551212LLU; | |
9024 | + uint64_t return_to = 18446744073709551233LLU; | |
9552 | 9025 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9553 | 9026 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9554 | 9027 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9555 | 9028 | heap.data[0].elem1 = heap.data[0].elem0; |
9556 | 9029 | heap.data[0].elem0 = restore; |
9557 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
9030 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
9558 | 9031 | break; |
9559 | 9032 | } |
9560 | - case 18446744073709551212LLU: // 999999993q''''''''''''''' | |
9033 | + case 18446744073709551233LLU: // 999999994A''''''''''''''' | |
9561 | 9034 | { |
9562 | 9035 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 5 |
9563 | - state.addr = 18446744073709551213LLU; // 999999993r''''''''''''''' | |
9036 | + state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
9564 | 9037 | break; |
9565 | 9038 | } |
9566 | - case 18446744073709551214LLU: // 999999993s''''''''''''''' | |
9039 | + case 18446744073709551235LLU: // 999999994C''''''''''''''' | |
9567 | 9040 | { |
9568 | - state.addr = 18446744073709551213LLU; // 999999993r''''''''''''''' | |
9041 | + state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
9569 | 9042 | break; |
9570 | 9043 | } |
9571 | - case 18446744073709551213LLU: // 999999993r''''''''''''''' | |
9044 | + case 18446744073709551234LLU: // 999999994B''''''''''''''' | |
9572 | 9045 | { |
9573 | 9046 | // variable list<pardef____> ypars_____ goes out of scope |
9574 | 9047 | // emitted destructur for type list<pardef____> |
9575 | - state.addr = 18446744073709551210LLU; // 999999993o''''''''''''''' | |
9048 | + state.addr = 18446744073709551231LLU; // 9999999939''''''''''''''' | |
9576 | 9049 | break; |
9577 | 9050 | } |
9578 | - case 18446744073709551210LLU: // 999999993o''''''''''''''' | |
9051 | + case 18446744073709551231LLU: // 9999999939''''''''''''''' | |
9579 | 9052 | { |
9580 | 9053 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/) |
9581 | 9054 | { |
9582 | - state.addr = 18446744073709551211LLU; // 999999993p''''''''''''''' | |
9055 | + state.addr = 18446744073709551232LLU; // 999999994_''''''''''''''' | |
9583 | 9056 | break; |
9584 | 9057 | } |
9585 | 9058 | // temporary list-element |
@@ -9593,23 +9066,23 @@ | ||
9593 | 9066 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9594 | 9067 | } |
9595 | 9068 | // ACCUMULATE ARGUMENTS - END |
9596 | - uint64_t return_to = 18446744073709551209LLU; | |
9069 | + uint64_t return_to = 18446744073709551230LLU; | |
9597 | 9070 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9598 | 9071 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9599 | 9072 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9600 | 9073 | heap.data[0].elem1 = heap.data[0].elem0; |
9601 | 9074 | heap.data[0].elem0 = restore; |
9602 | - state.addr = 18446744073709551451LLU; // 999999997$''''''''''''''' | |
9075 | + state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' | |
9603 | 9076 | break; |
9604 | 9077 | } |
9605 | - case 18446744073709551209LLU: // 999999993n''''''''''''''' | |
9078 | + case 18446744073709551230LLU: // 9999999938''''''''''''''' | |
9606 | 9079 | { |
9607 | 9080 | // RELEASE temporary destructor-variable |
9608 | 9081 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9609 | - state.addr = 18446744073709551210LLU; // 999999993o''''''''''''''' | |
9082 | + state.addr = 18446744073709551231LLU; // 9999999939''''''''''''''' | |
9610 | 9083 | break; |
9611 | 9084 | } |
9612 | - case 18446744073709551211LLU: // 999999993p''''''''''''''' | |
9085 | + case 18446744073709551232LLU: // 999999994_''''''''''''''' | |
9613 | 9086 | { |
9614 | 9087 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 4 |
9615 | 9088 | { |
@@ -9676,7 +9149,7 @@ | ||
9676 | 9149 | } |
9677 | 9150 | break; |
9678 | 9151 | } |
9679 | - case 18446744073709551208LLU: // 999999993m''''''''''''''' | |
9152 | + case 18446744073709551229LLU: // 9999999937''''''''''''''' | |
9680 | 9153 | { |
9681 | 9154 | { |
9682 | 9155 | uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -9683,14 +9156,14 @@ | ||
9683 | 9156 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9684 | 9157 | } |
9685 | 9158 | // emitted destructur for type list<elemdef___> |
9686 | - state.addr = 18446744073709551206LLU; // 999999993k''''''''''''''' | |
9159 | + state.addr = 18446744073709551227LLU; // 9999999935''''''''''''''' | |
9687 | 9160 | break; |
9688 | 9161 | } |
9689 | - case 18446744073709551206LLU: // 999999993k''''''''''''''' | |
9162 | + case 18446744073709551227LLU: // 9999999935''''''''''''''' | |
9690 | 9163 | { |
9691 | 9164 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
9692 | 9165 | { |
9693 | - state.addr = 18446744073709551207LLU; // 999999993l''''''''''''''' | |
9166 | + state.addr = 18446744073709551228LLU; // 9999999936''''''''''''''' | |
9694 | 9167 | break; |
9695 | 9168 | } |
9696 | 9169 | // temporary list-element |
@@ -9704,23 +9177,23 @@ | ||
9704 | 9177 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9705 | 9178 | } |
9706 | 9179 | // ACCUMULATE ARGUMENTS - END |
9707 | - uint64_t return_to = 18446744073709551205LLU; | |
9180 | + uint64_t return_to = 18446744073709551226LLU; | |
9708 | 9181 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9709 | 9182 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9710 | 9183 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9711 | 9184 | heap.data[0].elem1 = heap.data[0].elem0; |
9712 | 9185 | heap.data[0].elem0 = restore; |
9713 | - state.addr = 18446744073709551448LLU; // 999999997X''''''''''''''' | |
9186 | + state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' | |
9714 | 9187 | break; |
9715 | 9188 | } |
9716 | - case 18446744073709551205LLU: // 999999993j''''''''''''''' | |
9189 | + case 18446744073709551226LLU: // 9999999934''''''''''''''' | |
9717 | 9190 | { |
9718 | 9191 | // RELEASE temporary destructor-variable |
9719 | 9192 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
9720 | - state.addr = 18446744073709551206LLU; // 999999993k''''''''''''''' | |
9193 | + state.addr = 18446744073709551227LLU; // 9999999935''''''''''''''' | |
9721 | 9194 | break; |
9722 | 9195 | } |
9723 | - case 18446744073709551207LLU: // 999999993l''''''''''''''' | |
9196 | + case 18446744073709551228LLU: // 9999999936''''''''''''''' | |
9724 | 9197 | { |
9725 | 9198 | // RELEASE temporary destructor-variable |
9726 | 9199 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -9772,141 +9245,6 @@ | ||
9772 | 9245 | } |
9773 | 9246 | break; |
9774 | 9247 | } |
9775 | - case 552446646813982720LLU: // copyvar___ | |
9776 | - { | |
9777 | - { | |
9778 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU); | |
9779 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9780 | - } | |
9781 | - { | |
9782 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU); | |
9783 | - LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9784 | - } | |
9785 | - { | |
9786 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 0LLU); | |
9787 | - LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9788 | - } | |
9789 | - { | |
9790 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 1LLU); | |
9791 | - LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9792 | - } | |
9793 | - | |
9794 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) = /*srcid_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)); | |
9795 | - { | |
9796 | - uint64_t arg = /*srcpars___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU)); | |
9797 | - LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9798 | - } | |
9799 | - { | |
9800 | - uint64_t arg = 0; | |
9801 | - LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9802 | - } | |
9803 | - state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
9804 | - break; | |
9805 | - } | |
9806 | - case 18446744073709551203LLU: // 999999993h''''''''''''''' | |
9807 | - { | |
9808 | - if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) | |
9809 | - { | |
9810 | - (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 | |
9811 | - (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 | |
9812 | - { | |
9813 | - state.addr = 18446744073709551202LLU; // 999999993g''''''''''''''' | |
9814 | - break; | |
9815 | - } | |
9816 | - } | |
9817 | - /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU; | |
9818 | - *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0; | |
9819 | - { | |
9820 | - uint64_t arg = 0; | |
9821 | - LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9822 | - } | |
9823 | - // ACCUMULATE ARGUMENTS - BEGIN | |
9824 | - { | |
9825 | - uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU); | |
9826 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
9827 | - } | |
9828 | - { | |
9829 | - uint64_t arg = /*srcpar____*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU); | |
9830 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
9831 | - } | |
9832 | - // ACCUMULATE ARGUMENTS - END | |
9833 | - uint64_t return_to = 18446744073709551198LLU; | |
9834 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
9835 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
9836 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
9837 | - heap.data[0].elem1 = heap.data[0].elem0; | |
9838 | - heap.data[0].elem0 = restore; | |
9839 | - state.addr = 101193007747052544LLU; // ElemDefCP_ | |
9840 | - break; | |
9841 | - } | |
9842 | - case 18446744073709551198LLU: // 999999993c''''''''''''''' | |
9843 | - { | |
9844 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 3LLU)), 7) ? 18446744073709551201LLU : 18446744073709551200LLU; | |
9845 | - break; | |
9846 | - } | |
9847 | - case 18446744073709551201LLU: // 999999993f''''''''''''''' | |
9848 | - { | |
9849 | - { | |
9850 | - fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvar - recompile compiler with more dynamic heap"); | |
9851 | - exit(-1); | |
9852 | - } | |
9853 | - // emitted destructur for type elemdef___ | |
9854 | - // ACCUMULATE ARGUMENTS - BEGIN | |
9855 | - { | |
9856 | - uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU); | |
9857 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
9858 | - } | |
9859 | - // ACCUMULATE ARGUMENTS - END | |
9860 | - uint64_t return_to = 18446744073709551197LLU; | |
9861 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
9862 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
9863 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
9864 | - heap.data[0].elem1 = heap.data[0].elem0; | |
9865 | - heap.data[0].elem0 = restore; | |
9866 | - state.addr = 18446744073709551448LLU; // 999999997X''''''''''''''' | |
9867 | - break; | |
9868 | - } | |
9869 | - case 18446744073709551197LLU: // 999999993b''''''''''''''' | |
9870 | - { | |
9871 | - // parameter elemdef___ dstpar____ goes out of scope | |
9872 | - state.addr = 18446744073709551199LLU; // 999999993d''''''''''''''' | |
9873 | - break; | |
9874 | - } | |
9875 | - case 18446744073709551200LLU: // 999999993e''''''''''''''' | |
9876 | - { | |
9877 | - state.addr = 18446744073709551199LLU; // 999999993d''''''''''''''' | |
9878 | - break; | |
9879 | - } | |
9880 | - case 18446744073709551199LLU: // 999999993d''''''''''''''' | |
9881 | - { | |
9882 | - (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 | |
9883 | - // parameter-reference elemdef___ srcpar____ goes out of scope | |
9884 | - // parameter-reference list<elemdef___> srcpars___ goes out of scope | |
9885 | - state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
9886 | - break; | |
9887 | - } | |
9888 | - case 18446744073709551202LLU: // 999999993g''''''''''''''' | |
9889 | - { | |
9890 | - // parameter-reference list<elemdef___> srcpars___ goes out of scope | |
9891 | - (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcpars___ at 6 | |
9892 | - // parameter-reference u64 srcid_____ goes out of scope | |
9893 | - (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcid_____ at 5 | |
9894 | - // parameter-reference variant___ __________ goes out of scope | |
9895 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4 | |
9896 | - // parameter-reference list<elemdef___> dstpars___ goes out of scope | |
9897 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dstpars___ at 3 | |
9898 | - // parameter-reference u64 dstid_____ goes out of scope | |
9899 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dstid_____ at 2 | |
9900 | - // parameter-reference variant___ __________ goes out of scope | |
9901 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
9902 | - { | |
9903 | - uint64_t baseinfo = heap.data[0].elem1; | |
9904 | - struct pair pair = unpair(&heap, &baseinfo); | |
9905 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
9906 | - state.addr = pair.elem1; | |
9907 | - } | |
9908 | - break; | |
9909 | - } | |
9910 | 9248 | case 66057858066939904LLU: // CopyVar___ |
9911 | 9249 | { |
9912 | 9250 | { |
@@ -9934,10 +9272,10 @@ | ||
9934 | 9272 | uint64_t arg = 0; |
9935 | 9273 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9936 | 9274 | } |
9937 | - state.addr = 18446744073709551195LLU; // 999999993$''''''''''''''' | |
9275 | + state.addr = 18446744073709551224LLU; // 9999999932''''''''''''''' | |
9938 | 9276 | break; |
9939 | 9277 | } |
9940 | - case 18446744073709551195LLU: // 999999993$''''''''''''''' | |
9278 | + case 18446744073709551224LLU: // 9999999932''''''''''''''' | |
9941 | 9279 | { |
9942 | 9280 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
9943 | 9281 | { |
@@ -9944,7 +9282,7 @@ | ||
9944 | 9282 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
9945 | 9283 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
9946 | 9284 | { |
9947 | - state.addr = 18446744073709551194LLU; // 999999993Z''''''''''''''' | |
9285 | + state.addr = 18446744073709551223LLU; // 9999999931''''''''''''''' | |
9948 | 9286 | break; |
9949 | 9287 | } |
9950 | 9288 | } |
@@ -9964,7 +9302,7 @@ | ||
9964 | 9302 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9965 | 9303 | } |
9966 | 9304 | // ACCUMULATE ARGUMENTS - END |
9967 | - uint64_t return_to = 18446744073709551190LLU; | |
9305 | + uint64_t return_to = 18446744073709551219LLU; | |
9968 | 9306 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9969 | 9307 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9970 | 9308 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9973,12 +9311,12 @@ | ||
9973 | 9311 | state.addr = 101193007747052544LLU; // ElemDefCP_ |
9974 | 9312 | break; |
9975 | 9313 | } |
9976 | - case 18446744073709551190LLU: // 999999993V''''''''''''''' | |
9314 | + case 18446744073709551219LLU: // 999999993x''''''''''''''' | |
9977 | 9315 | { |
9978 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551193LLU : 18446744073709551192LLU; | |
9316 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551222LLU : 18446744073709551221LLU; | |
9979 | 9317 | break; |
9980 | 9318 | } |
9981 | - case 18446744073709551193LLU: // 999999993Y''''''''''''''' | |
9319 | + case 18446744073709551222LLU: // 9999999930''''''''''''''' | |
9982 | 9320 | { |
9983 | 9321 | { |
9984 | 9322 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvar - recompile compiler with more dynamic heap"); |
@@ -9991,35 +9329,35 @@ | ||
9991 | 9329 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9992 | 9330 | } |
9993 | 9331 | // ACCUMULATE ARGUMENTS - END |
9994 | - uint64_t return_to = 18446744073709551189LLU; | |
9332 | + uint64_t return_to = 18446744073709551218LLU; | |
9995 | 9333 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9996 | 9334 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9997 | 9335 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9998 | 9336 | heap.data[0].elem1 = heap.data[0].elem0; |
9999 | 9337 | heap.data[0].elem0 = restore; |
10000 | - state.addr = 18446744073709551448LLU; // 999999997X''''''''''''''' | |
9338 | + state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' | |
10001 | 9339 | break; |
10002 | 9340 | } |
10003 | - case 18446744073709551189LLU: // 999999993U''''''''''''''' | |
9341 | + case 18446744073709551218LLU: // 999999993w''''''''''''''' | |
10004 | 9342 | { |
10005 | 9343 | // parameter elemdef___ dstpar____ goes out of scope |
10006 | - state.addr = 18446744073709551191LLU; // 999999993W''''''''''''''' | |
9344 | + state.addr = 18446744073709551220LLU; // 999999993y''''''''''''''' | |
10007 | 9345 | break; |
10008 | 9346 | } |
10009 | - case 18446744073709551192LLU: // 999999993X''''''''''''''' | |
9347 | + case 18446744073709551221LLU: // 999999993z''''''''''''''' | |
10010 | 9348 | { |
10011 | - state.addr = 18446744073709551191LLU; // 999999993W''''''''''''''' | |
9349 | + state.addr = 18446744073709551220LLU; // 999999993y''''''''''''''' | |
10012 | 9350 | break; |
10013 | 9351 | } |
10014 | - case 18446744073709551191LLU: // 999999993W''''''''''''''' | |
9352 | + case 18446744073709551220LLU: // 999999993y''''''''''''''' | |
10015 | 9353 | { |
10016 | 9354 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
10017 | 9355 | // parameter-reference elemdef___ srcpar____ goes out of scope |
10018 | 9356 | // parameter-reference list<elemdef___> srcpars___ goes out of scope |
10019 | - state.addr = 18446744073709551195LLU; // 999999993$''''''''''''''' | |
9357 | + state.addr = 18446744073709551224LLU; // 9999999932''''''''''''''' | |
10020 | 9358 | break; |
10021 | 9359 | } |
10022 | - case 18446744073709551194LLU: // 999999993Z''''''''''''''' | |
9360 | + case 18446744073709551223LLU: // 9999999931''''''''''''''' | |
10023 | 9361 | { |
10024 | 9362 | // ACCUMULATE ARGUMENTS - BEGIN |
10025 | 9363 | { |
@@ -10035,7 +9373,7 @@ | ||
10035 | 9373 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10036 | 9374 | } |
10037 | 9375 | // ACCUMULATE ARGUMENTS - END |
10038 | - uint64_t return_to = 18446744073709551188LLU; | |
9376 | + uint64_t return_to = 18446744073709551217LLU; | |
10039 | 9377 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
10040 | 9378 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10041 | 9379 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10044,7 +9382,7 @@ | ||
10044 | 9382 | state.addr = 890787243071635456LLU; // variant___ |
10045 | 9383 | break; |
10046 | 9384 | } |
10047 | - case 18446744073709551188LLU: // 999999993T''''''''''''''' | |
9385 | + case 18446744073709551217LLU: // 999999993v''''''''''''''' | |
10048 | 9386 | { |
10049 | 9387 | // variable list<elemdef___> dstpars___ goes out of scope |
10050 | 9388 | // (uninitialized -> no destructor-call) |
@@ -10094,10 +9432,10 @@ | ||
10094 | 9432 | uint64_t arg = 0; |
10095 | 9433 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10096 | 9434 | } |
10097 | - state.addr = 18446744073709551186LLU; // 999999993R''''''''''''''' | |
9435 | + state.addr = 18446744073709551215LLU; // 999999993t''''''''''''''' | |
10098 | 9436 | break; |
10099 | 9437 | } |
10100 | - case 18446744073709551186LLU: // 999999993R''''''''''''''' | |
9438 | + case 18446744073709551215LLU: // 999999993t''''''''''''''' | |
10101 | 9439 | { |
10102 | 9440 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
10103 | 9441 | { |
@@ -10104,7 +9442,7 @@ | ||
10104 | 9442 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
10105 | 9443 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
10106 | 9444 | { |
10107 | - state.addr = 18446744073709551185LLU; // 999999993Q''''''''''''''' | |
9445 | + state.addr = 18446744073709551214LLU; // 999999993s''''''''''''''' | |
10108 | 9446 | break; |
10109 | 9447 | } |
10110 | 9448 | } |
@@ -10124,7 +9462,7 @@ | ||
10124 | 9462 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10125 | 9463 | } |
10126 | 9464 | // ACCUMULATE ARGUMENTS - END |
10127 | - uint64_t return_to = 18446744073709551181LLU; | |
9465 | + uint64_t return_to = 18446744073709551210LLU; | |
10128 | 9466 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10129 | 9467 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10130 | 9468 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10133,12 +9471,12 @@ | ||
10133 | 9471 | state.addr = 101193007747052544LLU; // ElemDefCP_ |
10134 | 9472 | break; |
10135 | 9473 | } |
10136 | - case 18446744073709551181LLU: // 999999993M''''''''''''''' | |
9474 | + case 18446744073709551210LLU: // 999999993o''''''''''''''' | |
10137 | 9475 | { |
10138 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551184LLU : 18446744073709551183LLU; | |
9476 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551213LLU : 18446744073709551212LLU; | |
10139 | 9477 | break; |
10140 | 9478 | } |
10141 | - case 18446744073709551184LLU: // 999999993P''''''''''''''' | |
9479 | + case 18446744073709551213LLU: // 999999993r''''''''''''''' | |
10142 | 9480 | { |
10143 | 9481 | { |
10144 | 9482 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvar - recompile compiler with more dynamic heap"); |
@@ -10151,35 +9489,35 @@ | ||
10151 | 9489 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10152 | 9490 | } |
10153 | 9491 | // ACCUMULATE ARGUMENTS - END |
10154 | - uint64_t return_to = 18446744073709551180LLU; | |
9492 | + uint64_t return_to = 18446744073709551209LLU; | |
10155 | 9493 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10156 | 9494 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10157 | 9495 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10158 | 9496 | heap.data[0].elem1 = heap.data[0].elem0; |
10159 | 9497 | heap.data[0].elem0 = restore; |
10160 | - state.addr = 18446744073709551448LLU; // 999999997X''''''''''''''' | |
9498 | + state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' | |
10161 | 9499 | break; |
10162 | 9500 | } |
10163 | - case 18446744073709551180LLU: // 999999993L''''''''''''''' | |
9501 | + case 18446744073709551209LLU: // 999999993n''''''''''''''' | |
10164 | 9502 | { |
10165 | 9503 | // parameter elemdef___ dstpar____ goes out of scope |
10166 | - state.addr = 18446744073709551182LLU; // 999999993N''''''''''''''' | |
9504 | + state.addr = 18446744073709551211LLU; // 999999993p''''''''''''''' | |
10167 | 9505 | break; |
10168 | 9506 | } |
10169 | - case 18446744073709551183LLU: // 999999993O''''''''''''''' | |
9507 | + case 18446744073709551212LLU: // 999999993q''''''''''''''' | |
10170 | 9508 | { |
10171 | - state.addr = 18446744073709551182LLU; // 999999993N''''''''''''''' | |
9509 | + state.addr = 18446744073709551211LLU; // 999999993p''''''''''''''' | |
10172 | 9510 | break; |
10173 | 9511 | } |
10174 | - case 18446744073709551182LLU: // 999999993N''''''''''''''' | |
9512 | + case 18446744073709551211LLU: // 999999993p''''''''''''''' | |
10175 | 9513 | { |
10176 | 9514 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
10177 | 9515 | // parameter-reference elemdef___ srcpar____ goes out of scope |
10178 | 9516 | // parameter-reference list<elemdef___> srcpars___ goes out of scope |
10179 | - state.addr = 18446744073709551186LLU; // 999999993R''''''''''''''' | |
9517 | + state.addr = 18446744073709551215LLU; // 999999993t''''''''''''''' | |
10180 | 9518 | break; |
10181 | 9519 | } |
10182 | - case 18446744073709551185LLU: // 999999993Q''''''''''''''' | |
9520 | + case 18446744073709551214LLU: // 999999993s''''''''''''''' | |
10183 | 9521 | { |
10184 | 9522 | list_reverse(heap.data, &/*dstpars___*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)); |
10185 | 9523 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -10196,7 +9534,7 @@ | ||
10196 | 9534 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10197 | 9535 | } |
10198 | 9536 | // ACCUMULATE ARGUMENTS - END |
10199 | - uint64_t return_to = 18446744073709551179LLU; | |
9537 | + uint64_t return_to = 18446744073709551208LLU; | |
10200 | 9538 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
10201 | 9539 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10202 | 9540 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10205,7 +9543,7 @@ | ||
10205 | 9543 | state.addr = 890787243071635456LLU; // variant___ |
10206 | 9544 | break; |
10207 | 9545 | } |
10208 | - case 18446744073709551179LLU: // 999999993K''''''''''''''' | |
9546 | + case 18446744073709551208LLU: // 999999993m''''''''''''''' | |
10209 | 9547 | { |
10210 | 9548 | // variable list<elemdef___> dstpars___ goes out of scope |
10211 | 9549 | // (uninitialized -> no destructor-call) |
@@ -10238,10 +9576,10 @@ | ||
10238 | 9576 | uint64_t arg = 0; |
10239 | 9577 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10240 | 9578 | } |
10241 | - state.addr = 18446744073709551178LLU; // 999999993J''''''''''''''' | |
9579 | + state.addr = 18446744073709551207LLU; // 999999993l''''''''''''''' | |
10242 | 9580 | break; |
10243 | 9581 | } |
10244 | - case 18446744073709551178LLU: // 999999993J''''''''''''''' | |
9582 | + case 18446744073709551207LLU: // 999999993l''''''''''''''' | |
10245 | 9583 | { |
10246 | 9584 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)) |
10247 | 9585 | { |
@@ -10248,7 +9586,7 @@ | ||
10248 | 9586 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
10249 | 9587 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
10250 | 9588 | { |
10251 | - state.addr = 18446744073709551177LLU; // 999999993I''''''''''''''' | |
9589 | + state.addr = 18446744073709551206LLU; // 999999993k''''''''''''''' | |
10252 | 9590 | break; |
10253 | 9591 | } |
10254 | 9592 | } |
@@ -10268,7 +9606,7 @@ | ||
10268 | 9606 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10269 | 9607 | } |
10270 | 9608 | // ACCUMULATE ARGUMENTS - END |
10271 | - uint64_t return_to = 18446744073709551173LLU; | |
9609 | + uint64_t return_to = 18446744073709551202LLU; | |
10272 | 9610 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10273 | 9611 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10274 | 9612 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10277,12 +9615,12 @@ | ||
10277 | 9615 | state.addr = 66057858067013632LLU; // CopyVarR__ |
10278 | 9616 | break; |
10279 | 9617 | } |
10280 | - case 18446744073709551173LLU: // 999999993E''''''''''''''' | |
9618 | + case 18446744073709551202LLU: // 999999993g''''''''''''''' | |
10281 | 9619 | { |
10282 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 4) ? 18446744073709551176LLU : 18446744073709551175LLU; | |
9620 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 4) ? 18446744073709551205LLU : 18446744073709551204LLU; | |
10283 | 9621 | break; |
10284 | 9622 | } |
10285 | - case 18446744073709551176LLU: // 999999993H''''''''''''''' | |
9623 | + case 18446744073709551205LLU: // 999999993j''''''''''''''' | |
10286 | 9624 | { |
10287 | 9625 | { |
10288 | 9626 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvars - recompile compiler with more dynamic heap"); |
@@ -10295,35 +9633,35 @@ | ||
10295 | 9633 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10296 | 9634 | } |
10297 | 9635 | // ACCUMULATE ARGUMENTS - END |
10298 | - uint64_t return_to = 18446744073709551172LLU; | |
9636 | + uint64_t return_to = 18446744073709551201LLU; | |
10299 | 9637 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10300 | 9638 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10301 | 9639 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10302 | 9640 | heap.data[0].elem1 = heap.data[0].elem0; |
10303 | 9641 | heap.data[0].elem0 = restore; |
10304 | - state.addr = 18446744073709551208LLU; // 999999993m''''''''''''''' | |
9642 | + state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
10305 | 9643 | break; |
10306 | 9644 | } |
10307 | - case 18446744073709551172LLU: // 999999993D''''''''''''''' | |
9645 | + case 18446744073709551201LLU: // 999999993f''''''''''''''' | |
10308 | 9646 | { |
10309 | 9647 | // parameter variant___ dst_______ goes out of scope |
10310 | - state.addr = 18446744073709551174LLU; // 999999993F''''''''''''''' | |
9648 | + state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
10311 | 9649 | break; |
10312 | 9650 | } |
10313 | - case 18446744073709551175LLU: // 999999993G''''''''''''''' | |
9651 | + case 18446744073709551204LLU: // 999999993i''''''''''''''' | |
10314 | 9652 | { |
10315 | - state.addr = 18446744073709551174LLU; // 999999993F''''''''''''''' | |
9653 | + state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
10316 | 9654 | break; |
10317 | 9655 | } |
10318 | - case 18446744073709551174LLU: // 999999993F''''''''''''''' | |
9656 | + case 18446744073709551203LLU: // 999999993h''''''''''''''' | |
10319 | 9657 | { |
10320 | 9658 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
10321 | 9659 | // parameter-reference variant___ src_______ goes out of scope |
10322 | 9660 | // parameter-reference list<variant___> srcs______ goes out of scope |
10323 | - state.addr = 18446744073709551178LLU; // 999999993J''''''''''''''' | |
9661 | + state.addr = 18446744073709551207LLU; // 999999993l''''''''''''''' | |
10324 | 9662 | break; |
10325 | 9663 | } |
10326 | - case 18446744073709551177LLU: // 999999993I''''''''''''''' | |
9664 | + case 18446744073709551206LLU: // 999999993k''''''''''''''' | |
10327 | 9665 | { |
10328 | 9666 | // parameter-reference list<variant___> srcs______ goes out of scope |
10329 | 9667 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2 |
@@ -10337,21 +9675,8 @@ | ||
10337 | 9675 | } |
10338 | 9676 | break; |
10339 | 9677 | } |
10340 | - case 18446744073709551170LLU: // 999999993B''''''''''''''' | |
9678 | + case 18446744073709551199LLU: // 999999993d''''''''''''''' | |
10341 | 9679 | { |
10342 | - // destructor for variant tkdummy___ | |
10343 | - // RELEASE destructor-argument | |
10344 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1 | |
10345 | - { | |
10346 | - uint64_t baseinfo = heap.data[0].elem1; | |
10347 | - struct pair pair = unpair(&heap, &baseinfo); | |
10348 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
10349 | - state.addr = pair.elem1; | |
10350 | - } | |
10351 | - break; | |
10352 | - } | |
10353 | - case 18446744073709551169LLU: // 999999993A''''''''''''''' | |
10354 | - { | |
10355 | 9680 | // destructor for variant tkunion___ |
10356 | 9681 | { |
10357 | 9682 | uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -10358,14 +9683,14 @@ | ||
10358 | 9683 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10359 | 9684 | } |
10360 | 9685 | // emitted destructur for type list<variant___> |
10361 | - state.addr = 18446744073709551166LLU; // 9999999928''''''''''''''' | |
9686 | + state.addr = 18446744073709551196LLU; // 999999993a''''''''''''''' | |
10362 | 9687 | break; |
10363 | 9688 | } |
10364 | - case 18446744073709551166LLU: // 9999999928''''''''''''''' | |
9689 | + case 18446744073709551196LLU: // 999999993a''''''''''''''' | |
10365 | 9690 | { |
10366 | 9691 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
10367 | 9692 | { |
10368 | - state.addr = 18446744073709551167LLU; // 9999999929''''''''''''''' | |
9693 | + state.addr = 18446744073709551197LLU; // 999999993b''''''''''''''' | |
10369 | 9694 | break; |
10370 | 9695 | } |
10371 | 9696 | // temporary list-element |
@@ -10379,23 +9704,23 @@ | ||
10379 | 9704 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10380 | 9705 | } |
10381 | 9706 | // ACCUMULATE ARGUMENTS - END |
10382 | - uint64_t return_to = 18446744073709551165LLU; | |
9707 | + uint64_t return_to = 18446744073709551195LLU; | |
10383 | 9708 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10384 | 9709 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10385 | 9710 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10386 | 9711 | heap.data[0].elem1 = heap.data[0].elem0; |
10387 | 9712 | heap.data[0].elem0 = restore; |
10388 | - state.addr = 18446744073709551208LLU; // 999999993m''''''''''''''' | |
9713 | + state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
10389 | 9714 | break; |
10390 | 9715 | } |
10391 | - case 18446744073709551165LLU: // 9999999927''''''''''''''' | |
9716 | + case 18446744073709551195LLU: // 999999993$''''''''''''''' | |
10392 | 9717 | { |
10393 | 9718 | // RELEASE temporary destructor-variable |
10394 | 9719 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
10395 | - state.addr = 18446744073709551166LLU; // 9999999928''''''''''''''' | |
9720 | + state.addr = 18446744073709551196LLU; // 999999993a''''''''''''''' | |
10396 | 9721 | break; |
10397 | 9722 | } |
10398 | - case 18446744073709551167LLU: // 9999999929''''''''''''''' | |
9723 | + case 18446744073709551197LLU: // 999999993b''''''''''''''' | |
10399 | 9724 | { |
10400 | 9725 | // RELEASE temporary destructor-variable |
10401 | 9726 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -10409,7 +9734,7 @@ | ||
10409 | 9734 | } |
10410 | 9735 | break; |
10411 | 9736 | } |
10412 | - case 18446744073709551168LLU: // 999999993_''''''''''''''' | |
9737 | + case 18446744073709551198LLU: // 999999993c''''''''''''''' | |
10413 | 9738 | { |
10414 | 9739 | // destructor for variant tkstruct__ |
10415 | 9740 | { |
@@ -10417,14 +9742,14 @@ | ||
10417 | 9742 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10418 | 9743 | } |
10419 | 9744 | // emitted destructur for type list<elemdef___> |
10420 | - state.addr = 18446744073709551163LLU; // 9999999925''''''''''''''' | |
9745 | + state.addr = 18446744073709551193LLU; // 999999993Y''''''''''''''' | |
10421 | 9746 | break; |
10422 | 9747 | } |
10423 | - case 18446744073709551163LLU: // 9999999925''''''''''''''' | |
9748 | + case 18446744073709551193LLU: // 999999993Y''''''''''''''' | |
10424 | 9749 | { |
10425 | 9750 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
10426 | 9751 | { |
10427 | - state.addr = 18446744073709551164LLU; // 9999999926''''''''''''''' | |
9752 | + state.addr = 18446744073709551194LLU; // 999999993Z''''''''''''''' | |
10428 | 9753 | break; |
10429 | 9754 | } |
10430 | 9755 | // temporary list-element |
@@ -10438,23 +9763,23 @@ | ||
10438 | 9763 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10439 | 9764 | } |
10440 | 9765 | // ACCUMULATE ARGUMENTS - END |
10441 | - uint64_t return_to = 18446744073709551162LLU; | |
9766 | + uint64_t return_to = 18446744073709551192LLU; | |
10442 | 9767 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10443 | 9768 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10444 | 9769 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10445 | 9770 | heap.data[0].elem1 = heap.data[0].elem0; |
10446 | 9771 | heap.data[0].elem0 = restore; |
10447 | - state.addr = 18446744073709551448LLU; // 999999997X''''''''''''''' | |
9772 | + state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' | |
10448 | 9773 | break; |
10449 | 9774 | } |
10450 | - case 18446744073709551162LLU: // 9999999924''''''''''''''' | |
9775 | + case 18446744073709551192LLU: // 999999993X''''''''''''''' | |
10451 | 9776 | { |
10452 | 9777 | // RELEASE temporary destructor-variable |
10453 | 9778 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
10454 | - state.addr = 18446744073709551163LLU; // 9999999925''''''''''''''' | |
9779 | + state.addr = 18446744073709551193LLU; // 999999993Y''''''''''''''' | |
10455 | 9780 | break; |
10456 | 9781 | } |
10457 | - case 18446744073709551164LLU: // 9999999926''''''''''''''' | |
9782 | + case 18446744073709551194LLU: // 999999993Z''''''''''''''' | |
10458 | 9783 | { |
10459 | 9784 | // RELEASE temporary destructor-variable |
10460 | 9785 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -10468,34 +9793,13 @@ | ||
10468 | 9793 | } |
10469 | 9794 | break; |
10470 | 9795 | } |
10471 | - case 18446744073709551171LLU: // 999999993C''''''''''''''' | |
9796 | + case 18446744073709551200LLU: // 999999993e''''''''''''''' | |
10472 | 9797 | { |
10473 | 9798 | struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
10474 | 9799 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1; |
10475 | - state.addr = 18446744073709551168LLU + type_data.elem0; | |
9800 | + state.addr = 18446744073709551198LLU + type_data.elem0; | |
10476 | 9801 | break; |
10477 | 9802 | } |
10478 | - case 857512460671778816LLU: // tkdummy___ | |
10479 | - { | |
10480 | - // union-constructor tkdummy___ | |
10481 | - { | |
10482 | - uint64_t result_tuple = 0; | |
10483 | - // copy references | |
10484 | - // release parameters | |
10485 | - { | |
10486 | - uint64_t constridx = 2LLU; | |
10487 | - uint64_t root = pair_move(&heap, &constridx, &result_tuple); | |
10488 | - *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root; | |
10489 | - } | |
10490 | - } | |
10491 | - { | |
10492 | - uint64_t baseinfo = heap.data[0].elem1; | |
10493 | - struct pair pair = unpair(&heap, &baseinfo); | |
10494 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
10495 | - state.addr = pair.elem1; | |
10496 | - } | |
10497 | - break; | |
10498 | - } | |
10499 | 9803 | case 857586742161833984LLU: // tkunion___ |
10500 | 9804 | { |
10501 | 9805 | // union-constructor tkunion___ |
@@ -10552,11 +9856,11 @@ | ||
10552 | 9856 | } |
10553 | 9857 | break; |
10554 | 9858 | } |
10555 | - case 552446644822474752LLU: // copytk____ | |
9859 | + case 66057855622447104LLU: // CopyTK____ | |
10556 | 9860 | { |
10557 | 9861 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*tkstruct__*/) |
10558 | 9862 | { |
10559 | - state.addr = 18446744073709551161LLU; // 9999999923''''''''''''''' | |
9863 | + state.addr = 18446744073709551191LLU; // 999999993W''''''''''''''' | |
10560 | 9864 | break; |
10561 | 9865 | } |
10562 | 9866 | { |
@@ -10579,10 +9883,10 @@ | ||
10579 | 9883 | uint64_t arg = 0; |
10580 | 9884 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10581 | 9885 | } |
10582 | - state.addr = 18446744073709551160LLU; // 9999999922''''''''''''''' | |
9886 | + state.addr = 18446744073709551190LLU; // 999999993V''''''''''''''' | |
10583 | 9887 | break; |
10584 | 9888 | } |
10585 | - case 18446744073709551160LLU: // 9999999922''''''''''''''' | |
9889 | + case 18446744073709551190LLU: // 999999993V''''''''''''''' | |
10586 | 9890 | { |
10587 | 9891 | if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU)) |
10588 | 9892 | { |
@@ -10589,7 +9893,7 @@ | ||
10589 | 9893 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
10590 | 9894 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
10591 | 9895 | { |
10592 | - state.addr = 18446744073709551159LLU; // 9999999921''''''''''''''' | |
9896 | + state.addr = 18446744073709551189LLU; // 999999993U''''''''''''''' | |
10593 | 9897 | break; |
10594 | 9898 | } |
10595 | 9899 | } |
@@ -10599,34 +9903,54 @@ | ||
10599 | 9903 | uint64_t arg = 0; |
10600 | 9904 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10601 | 9905 | } |
10602 | - *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*defpar____*/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU)); | |
9906 | + // ACCUMULATE ARGUMENTS - BEGIN | |
9907 | + { | |
9908 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU); | |
9909 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
9910 | + } | |
10603 | 9911 | { |
10604 | - uint64_t arg = 0; | |
9912 | + uint64_t arg = heap.data[0].elem0; | |
10605 | 9913 | LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10606 | 9914 | } |
10607 | - | |
9915 | + { | |
9916 | + uint64_t arg = 0; | |
9917 | + LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9918 | + } | |
10608 | 9919 | // ACCUMULATE ARGUMENTS - BEGIN |
10609 | 9920 | { |
10610 | - uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU); | |
9921 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU); | |
10611 | 9922 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10612 | 9923 | } |
10613 | 9924 | { |
10614 | - uint64_t arg = /*defpar____*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 9LLU, 6LLU), 1LLU); | |
9925 | + uint64_t arg = /*defpar____*/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 10LLU, 6LLU), 0LLU)); | |
10615 | 9926 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10616 | 9927 | } |
10617 | 9928 | // ACCUMULATE ARGUMENTS - END |
10618 | - uint64_t return_to = 18446744073709551158LLU; | |
9929 | + uint64_t return_to = 18446744073709551184LLU; | |
10619 | 9930 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10620 | 9931 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10621 | 9932 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10622 | 9933 | heap.data[0].elem1 = heap.data[0].elem0; |
10623 | 9934 | heap.data[0].elem0 = restore; |
10624 | - state.addr = 367395560426147840LLU; // TYPECOPY__ | |
9935 | + state.addr = 552446646280519680LLU; // copyu64___ | |
10625 | 9936 | break; |
10626 | 9937 | } |
10627 | - case 18446744073709551158LLU: // 9999999920''''''''''''''' | |
9938 | + case 18446744073709551184LLU: // 999999993P''''''''''''''' | |
10628 | 9939 | { |
10629 | 9940 | { |
9941 | + uint64_t exchange = LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 10*/; | |
9942 | + heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 9*/; | |
9943 | + | |
9944 | + { | |
9945 | + uint64_t arg = exchange; | |
9946 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
9947 | + } | |
9948 | + } | |
9949 | + { | |
9950 | + uint64_t arg = heap.data[0].elem0; | |
9951 | + LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
9952 | + } | |
9953 | + { | |
10630 | 9954 | uint64_t arg = 0; |
10631 | 9955 | LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10632 | 9956 | } |
@@ -10636,15 +9960,32 @@ | ||
10636 | 9960 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10637 | 9961 | } |
10638 | 9962 | { |
10639 | - uint64_t arg = /*id________*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU); | |
9963 | + uint64_t arg = /*defpar____*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 10LLU, 6LLU), 1LLU); | |
10640 | 9964 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10641 | 9965 | } |
9966 | + // ACCUMULATE ARGUMENTS - END | |
9967 | + uint64_t return_to = 18446744073709551183LLU; | |
9968 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
9969 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
9970 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
9971 | + heap.data[0].elem1 = heap.data[0].elem0; | |
9972 | + heap.data[0].elem0 = restore; | |
9973 | + state.addr = 367395560426147840LLU; // TYPECOPY__ | |
9974 | + break; | |
9975 | + } | |
9976 | + case 18446744073709551183LLU: // 999999993O''''''''''''''' | |
9977 | + { | |
9978 | + { | |
9979 | + uint64_t exchange = LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 10*/; | |
9980 | + heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 9*/; | |
9981 | + | |
10642 | 9982 | { |
10643 | - uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU); | |
9983 | + uint64_t arg = exchange; | |
10644 | 9984 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10645 | 9985 | } |
9986 | + } | |
10646 | 9987 | // ACCUMULATE ARGUMENTS - END |
10647 | - uint64_t return_to = 18446744073709551154LLU; | |
9988 | + uint64_t return_to = 18446744073709551185LLU; | |
10648 | 9989 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
10649 | 9990 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10650 | 9991 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10653,12 +9994,12 @@ | ||
10653 | 9994 | state.addr = 587581796494082048LLU; // elemdef___ |
10654 | 9995 | break; |
10655 | 9996 | } |
10656 | - case 18446744073709551154LLU: // 999999992w''''''''''''''' | |
9997 | + case 18446744073709551185LLU: // 999999993Q''''''''''''''' | |
10657 | 9998 | { |
10658 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 10LLU, 9LLU), &*LOCAL_ACCESS(heap.data, 10LLU, 4LLU), 7) ? 18446744073709551157LLU : 18446744073709551156LLU; | |
9999 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 7) ? 18446744073709551188LLU : 18446744073709551187LLU; | |
10659 | 10000 | break; |
10660 | 10001 | } |
10661 | - case 18446744073709551157LLU: // 999999992z''''''''''''''' | |
10002 | + case 18446744073709551188LLU: // 999999993T''''''''''''''' | |
10662 | 10003 | { |
10663 | 10004 | { |
10664 | 10005 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copytk - recompile compiler with more dynamic heap"); |
@@ -10667,77 +10008,52 @@ | ||
10667 | 10008 | // emitted destructur for type elemdef___ |
10668 | 10009 | // ACCUMULATE ARGUMENTS - BEGIN |
10669 | 10010 | { |
10670 | - uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU); | |
10011 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU); | |
10671 | 10012 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10672 | 10013 | } |
10673 | 10014 | // ACCUMULATE ARGUMENTS - END |
10674 | - uint64_t return_to = 18446744073709551153LLU; | |
10015 | + uint64_t return_to = 18446744073709551182LLU; | |
10675 | 10016 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10676 | 10017 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10677 | 10018 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10678 | 10019 | heap.data[0].elem1 = heap.data[0].elem0; |
10679 | 10020 | heap.data[0].elem0 = restore; |
10680 | - state.addr = 18446744073709551448LLU; // 999999997X''''''''''''''' | |
10021 | + state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' | |
10681 | 10022 | break; |
10682 | 10023 | } |
10683 | - case 18446744073709551153LLU: // 999999992v''''''''''''''' | |
10024 | + case 18446744073709551182LLU: // 999999993N''''''''''''''' | |
10684 | 10025 | { |
10685 | 10026 | // parameter elemdef___ DEFPAR____ goes out of scope |
10686 | - state.addr = 18446744073709551155LLU; // 999999992x''''''''''''''' | |
10027 | + state.addr = 18446744073709551186LLU; // 999999993R''''''''''''''' | |
10687 | 10028 | break; |
10688 | 10029 | } |
10689 | - case 18446744073709551156LLU: // 999999992y''''''''''''''' | |
10030 | + case 18446744073709551187LLU: // 999999993S''''''''''''''' | |
10690 | 10031 | { |
10691 | - state.addr = 18446744073709551155LLU; // 999999992x''''''''''''''' | |
10032 | + state.addr = 18446744073709551186LLU; // 999999993R''''''''''''''' | |
10692 | 10033 | break; |
10693 | 10034 | } |
10694 | - case 18446744073709551155LLU: // 999999992x''''''''''''''' | |
10035 | + case 18446744073709551186LLU: // 999999993R''''''''''''''' | |
10695 | 10036 | { |
10696 | - (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 10 | |
10697 | - // variable type______ type______ goes out of scope | |
10698 | - // (uninitialized -> no destructor-call) | |
10699 | - (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 9 | |
10700 | - // variable u64 id________ goes out of scope | |
10701 | - // (uninitialized -> no destructor-call) | |
10702 | - (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 8 | |
10037 | + (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 | |
10703 | 10038 | // parameter-reference elemdef___ defpar____ goes out of scope |
10704 | 10039 | // parameter-reference list<elemdef___> defpars___ goes out of scope |
10705 | - state.addr = 18446744073709551160LLU; // 9999999922''''''''''''''' | |
10040 | + state.addr = 18446744073709551190LLU; // 999999993V''''''''''''''' | |
10706 | 10041 | break; |
10707 | 10042 | } |
10708 | - case 18446744073709551159LLU: // 9999999921''''''''''''''' | |
10043 | + case 18446744073709551189LLU: // 999999993U''''''''''''''' | |
10709 | 10044 | { |
10710 | 10045 | list_reverse(heap.data, &/*DEFPARS___*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU)); |
10711 | - | |
10712 | - // emitted destructur for type typekind__ | |
10713 | 10046 | // ACCUMULATE ARGUMENTS - BEGIN |
10714 | 10047 | { |
10715 | 10048 | uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU); |
10716 | 10049 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10717 | 10050 | } |
10718 | - // ACCUMULATE ARGUMENTS - END | |
10719 | - uint64_t return_to = 18446744073709551152LLU; | |
10720 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
10721 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
10722 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
10723 | - heap.data[0].elem1 = heap.data[0].elem0; | |
10724 | - heap.data[0].elem0 = restore; | |
10725 | - state.addr = 18446744073709551171LLU; // 999999993C''''''''''''''' | |
10726 | - break; | |
10727 | - } | |
10728 | - case 18446744073709551152LLU: // 999999992u''''''''''''''' | |
10729 | - { | |
10730 | - // ACCUMULATE ARGUMENTS - BEGIN | |
10731 | 10051 | { |
10732 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU); | |
10733 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10734 | - } | |
10735 | - { | |
10736 | 10052 | uint64_t arg = /*DEFPARS___*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU); |
10737 | 10053 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10738 | 10054 | } |
10739 | 10055 | // ACCUMULATE ARGUMENTS - END |
10740 | - uint64_t return_to = 18446744073709551151LLU; | |
10056 | + uint64_t return_to = 18446744073709551181LLU; | |
10741 | 10057 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10742 | 10058 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10743 | 10059 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10746,7 +10062,7 @@ | ||
10746 | 10062 | state.addr = 857578368147320832LLU; // tkstruct__ |
10747 | 10063 | break; |
10748 | 10064 | } |
10749 | - case 18446744073709551151LLU: // 999999992t''''''''''''''' | |
10065 | + case 18446744073709551181LLU: // 999999993M''''''''''''''' | |
10750 | 10066 | { |
10751 | 10067 | // variable list<elemdef___> DEFPARS___ goes out of scope |
10752 | 10068 | // (uninitialized -> no destructor-call) |
@@ -10757,8 +10073,7 @@ | ||
10757 | 10073 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
10758 | 10074 | // parameter typekind__ __________ goes out of scope |
10759 | 10075 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 |
10760 | - // parameter-reference typekind__ dst_______ goes out of scope | |
10761 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1 | |
10076 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
10762 | 10077 | { |
10763 | 10078 | uint64_t baseinfo = heap.data[0].elem1; |
10764 | 10079 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -10767,11 +10082,11 @@ | ||
10767 | 10082 | } |
10768 | 10083 | break; |
10769 | 10084 | } |
10770 | - case 18446744073709551161LLU: // 9999999923''''''''''''''' | |
10085 | + case 18446744073709551191LLU: // 999999993W''''''''''''''' | |
10771 | 10086 | { |
10772 | 10087 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*tkunion___*/) |
10773 | 10088 | { |
10774 | - state.addr = 18446744073709551150LLU; // 999999992s''''''''''''''' | |
10089 | + state.addr = 18446744073709551180LLU; // 999999993L''''''''''''''' | |
10775 | 10090 | break; |
10776 | 10091 | } |
10777 | 10092 | { |
@@ -10794,10 +10109,10 @@ | ||
10794 | 10109 | uint64_t arg = 0; |
10795 | 10110 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10796 | 10111 | } |
10797 | - state.addr = 18446744073709551149LLU; // 999999992r''''''''''''''' | |
10112 | + state.addr = 18446744073709551179LLU; // 999999993K''''''''''''''' | |
10798 | 10113 | break; |
10799 | 10114 | } |
10800 | - case 18446744073709551149LLU: // 999999992r''''''''''''''' | |
10115 | + case 18446744073709551179LLU: // 999999993K''''''''''''''' | |
10801 | 10116 | { |
10802 | 10117 | if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU)) |
10803 | 10118 | { |
@@ -10804,7 +10119,7 @@ | ||
10804 | 10119 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
10805 | 10120 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
10806 | 10121 | { |
10807 | - state.addr = 18446744073709551148LLU; // 999999992q''''''''''''''' | |
10122 | + state.addr = 18446744073709551178LLU; // 999999993J''''''''''''''' | |
10808 | 10123 | break; |
10809 | 10124 | } |
10810 | 10125 | } |
@@ -10824,7 +10139,7 @@ | ||
10824 | 10139 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10825 | 10140 | } |
10826 | 10141 | // ACCUMULATE ARGUMENTS - END |
10827 | - uint64_t return_to = 18446744073709551144LLU; | |
10142 | + uint64_t return_to = 18446744073709551174LLU; | |
10828 | 10143 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10829 | 10144 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10830 | 10145 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10833,12 +10148,12 @@ | ||
10833 | 10148 | state.addr = 66057858066939904LLU; // CopyVar___ |
10834 | 10149 | break; |
10835 | 10150 | } |
10836 | - case 18446744073709551144LLU: // 999999992m''''''''''''''' | |
10151 | + case 18446744073709551174LLU: // 999999993F''''''''''''''' | |
10837 | 10152 | { |
10838 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 4) ? 18446744073709551147LLU : 18446744073709551146LLU; | |
10153 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 4) ? 18446744073709551177LLU : 18446744073709551176LLU; | |
10839 | 10154 | break; |
10840 | 10155 | } |
10841 | - case 18446744073709551147LLU: // 999999992p''''''''''''''' | |
10156 | + case 18446744073709551177LLU: // 999999993I''''''''''''''' | |
10842 | 10157 | { |
10843 | 10158 | { |
10844 | 10159 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copytk - recompile compiler with more dynamic heap"); |
@@ -10851,67 +10166,48 @@ | ||
10851 | 10166 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10852 | 10167 | } |
10853 | 10168 | // ACCUMULATE ARGUMENTS - END |
10854 | - uint64_t return_to = 18446744073709551143LLU; | |
10169 | + uint64_t return_to = 18446744073709551173LLU; | |
10855 | 10170 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10856 | 10171 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10857 | 10172 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10858 | 10173 | heap.data[0].elem1 = heap.data[0].elem0; |
10859 | 10174 | heap.data[0].elem0 = restore; |
10860 | - state.addr = 18446744073709551208LLU; // 999999993m''''''''''''''' | |
10175 | + state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
10861 | 10176 | break; |
10862 | 10177 | } |
10863 | - case 18446744073709551143LLU: // 999999992l''''''''''''''' | |
10178 | + case 18446744073709551173LLU: // 999999993E''''''''''''''' | |
10864 | 10179 | { |
10865 | 10180 | // parameter variant___ tmp_______ goes out of scope |
10866 | - state.addr = 18446744073709551145LLU; // 999999992n''''''''''''''' | |
10181 | + state.addr = 18446744073709551175LLU; // 999999993G''''''''''''''' | |
10867 | 10182 | break; |
10868 | 10183 | } |
10869 | - case 18446744073709551146LLU: // 999999992o''''''''''''''' | |
10184 | + case 18446744073709551176LLU: // 999999993H''''''''''''''' | |
10870 | 10185 | { |
10871 | - state.addr = 18446744073709551145LLU; // 999999992n''''''''''''''' | |
10186 | + state.addr = 18446744073709551175LLU; // 999999993G''''''''''''''' | |
10872 | 10187 | break; |
10873 | 10188 | } |
10874 | - case 18446744073709551145LLU: // 999999992n''''''''''''''' | |
10189 | + case 18446744073709551175LLU: // 999999993G''''''''''''''' | |
10875 | 10190 | { |
10876 | 10191 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
10877 | 10192 | // parameter-reference variant___ constr____ goes out of scope |
10878 | 10193 | // parameter-reference list<variant___> constrs___ goes out of scope |
10879 | - state.addr = 18446744073709551149LLU; // 999999992r''''''''''''''' | |
10194 | + state.addr = 18446744073709551179LLU; // 999999993K''''''''''''''' | |
10880 | 10195 | break; |
10881 | 10196 | } |
10882 | - case 18446744073709551148LLU: // 999999992q''''''''''''''' | |
10197 | + case 18446744073709551178LLU: // 999999993J''''''''''''''' | |
10883 | 10198 | { |
10884 | 10199 | list_reverse(heap.data, &/*CONSTRS___*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU)); |
10885 | - | |
10886 | - // emitted destructur for type typekind__ | |
10887 | 10200 | // ACCUMULATE ARGUMENTS - BEGIN |
10888 | 10201 | { |
10889 | 10202 | uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU); |
10890 | 10203 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10891 | 10204 | } |
10892 | - // ACCUMULATE ARGUMENTS - END | |
10893 | - uint64_t return_to = 18446744073709551142LLU; | |
10894 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
10895 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
10896 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
10897 | - heap.data[0].elem1 = heap.data[0].elem0; | |
10898 | - heap.data[0].elem0 = restore; | |
10899 | - state.addr = 18446744073709551171LLU; // 999999993C''''''''''''''' | |
10900 | - break; | |
10901 | - } | |
10902 | - case 18446744073709551142LLU: // 999999992k''''''''''''''' | |
10903 | - { | |
10904 | - // ACCUMULATE ARGUMENTS - BEGIN | |
10905 | 10205 | { |
10906 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU); | |
10907 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10908 | - } | |
10909 | - { | |
10910 | 10206 | uint64_t arg = /*CONSTRS___*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU); |
10911 | 10207 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10912 | 10208 | } |
10913 | 10209 | // ACCUMULATE ARGUMENTS - END |
10914 | - uint64_t return_to = 18446744073709551141LLU; | |
10210 | + uint64_t return_to = 18446744073709551172LLU; | |
10915 | 10211 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10916 | 10212 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10917 | 10213 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10920,7 +10216,7 @@ | ||
10920 | 10216 | state.addr = 857586742161833984LLU; // tkunion___ |
10921 | 10217 | break; |
10922 | 10218 | } |
10923 | - case 18446744073709551141LLU: // 999999992j''''''''''''''' | |
10219 | + case 18446744073709551172LLU: // 999999993D''''''''''''''' | |
10924 | 10220 | { |
10925 | 10221 | // variable list<variant___> CONSTRS___ goes out of scope |
10926 | 10222 | // (uninitialized -> no destructor-call) |
@@ -10931,8 +10227,7 @@ | ||
10931 | 10227 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
10932 | 10228 | // parameter typekind__ __________ goes out of scope |
10933 | 10229 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 |
10934 | - // parameter-reference typekind__ dst_______ goes out of scope | |
10935 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1 | |
10230 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
10936 | 10231 | { |
10937 | 10232 | uint64_t baseinfo = heap.data[0].elem1; |
10938 | 10233 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -10941,70 +10236,9 @@ | ||
10941 | 10236 | } |
10942 | 10237 | break; |
10943 | 10238 | } |
10944 | - case 18446744073709551150LLU: // 999999992s''''''''''''''' | |
10239 | + case 18446744073709551180LLU: // 999999993L''''''''''''''' | |
10945 | 10240 | { |
10946 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*tkdummy___*/) | |
10947 | - { | |
10948 | - state.addr = 18446744073709551140LLU; // 999999992i''''''''''''''' | |
10949 | - break; | |
10950 | - } | |
10951 | - { | |
10952 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU); | |
10953 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
10954 | - } | |
10955 | - | |
10956 | - // emitted destructur for type typekind__ | |
10957 | - // ACCUMULATE ARGUMENTS - BEGIN | |
10958 | - { | |
10959 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
10960 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10961 | - } | |
10962 | - // ACCUMULATE ARGUMENTS - END | |
10963 | - uint64_t return_to = 18446744073709551139LLU; | |
10964 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
10965 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
10966 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
10967 | - heap.data[0].elem1 = heap.data[0].elem0; | |
10968 | - heap.data[0].elem0 = restore; | |
10969 | - state.addr = 18446744073709551171LLU; // 999999993C''''''''''''''' | |
10970 | - break; | |
10971 | - } | |
10972 | - case 18446744073709551139LLU: // 999999992h''''''''''''''' | |
10973 | - { | |
10974 | - // ACCUMULATE ARGUMENTS - BEGIN | |
10975 | - { | |
10976 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU); | |
10977 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10978 | - } | |
10979 | - // ACCUMULATE ARGUMENTS - END | |
10980 | - uint64_t return_to = 18446744073709551138LLU; | |
10981 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
10982 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
10983 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
10984 | - heap.data[0].elem1 = heap.data[0].elem0; | |
10985 | - heap.data[0].elem0 = restore; | |
10986 | - state.addr = 857512460671778816LLU; // tkdummy___ | |
10987 | - break; | |
10988 | - } | |
10989 | - case 18446744073709551138LLU: // 999999992g''''''''''''''' | |
10990 | - { | |
10991 | - // parameter-reference typekind__ __________ goes out of scope | |
10992 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 | |
10993 | - // parameter typekind__ __________ goes out of scope | |
10994 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
10995 | - // parameter-reference typekind__ dst_______ goes out of scope | |
10996 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1 | |
10997 | - { | |
10998 | - uint64_t baseinfo = heap.data[0].elem1; | |
10999 | - struct pair pair = unpair(&heap, &baseinfo); | |
11000 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
11001 | - state.addr = pair.elem1; | |
11002 | - } | |
11003 | - break; | |
11004 | - } | |
11005 | - case 18446744073709551140LLU: // 999999992i''''''''''''''' | |
11006 | - { | |
11007 | - fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of copytk____\n"); | |
10241 | + fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CopyTK____\n"); | |
11008 | 10242 | exit(-1); |
11009 | 10243 | break; |
11010 | 10244 | } |
@@ -11012,7 +10246,7 @@ | ||
11012 | 10246 | { |
11013 | 10247 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*tkstruct__*/) |
11014 | 10248 | { |
11015 | - state.addr = 18446744073709551137LLU; // 999999992f''''''''''''''' | |
10249 | + state.addr = 18446744073709551171LLU; // 999999993C''''''''''''''' | |
11016 | 10250 | break; |
11017 | 10251 | } |
11018 | 10252 | { |
@@ -11032,11 +10266,11 @@ | ||
11032 | 10266 | } |
11033 | 10267 | break; |
11034 | 10268 | } |
11035 | - case 18446744073709551137LLU: // 999999992f''''''''''''''' | |
10269 | + case 18446744073709551171LLU: // 999999993C''''''''''''''' | |
11036 | 10270 | { |
11037 | 10271 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*tkunion___*/) |
11038 | 10272 | { |
11039 | - state.addr = 18446744073709551136LLU; // 999999992e''''''''''''''' | |
10273 | + state.addr = 18446744073709551170LLU; // 999999993B''''''''''''''' | |
11040 | 10274 | break; |
11041 | 10275 | } |
11042 | 10276 | { |
@@ -11056,37 +10290,13 @@ | ||
11056 | 10290 | } |
11057 | 10291 | break; |
11058 | 10292 | } |
11059 | - case 18446744073709551136LLU: // 999999992e''''''''''''''' | |
10293 | + case 18446744073709551170LLU: // 999999993B''''''''''''''' | |
11060 | 10294 | { |
11061 | - if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*tkdummy___*/) | |
11062 | - { | |
11063 | - state.addr = 18446744073709551135LLU; // 999999992d''''''''''''''' | |
11064 | - break; | |
11065 | - } | |
11066 | - { | |
11067 | - uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU); | |
11068 | - LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11069 | - } | |
11070 | - fprintf(stderr, "%s", "tkdummy"); | |
11071 | - // parameter-reference typekind__ __________ goes out of scope | |
11072 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
11073 | - // parameter typekind__ __________ goes out of scope | |
11074 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
11075 | - { | |
11076 | - uint64_t baseinfo = heap.data[0].elem1; | |
11077 | - struct pair pair = unpair(&heap, &baseinfo); | |
11078 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
11079 | - state.addr = pair.elem1; | |
11080 | - } | |
11081 | - break; | |
11082 | - } | |
11083 | - case 18446744073709551135LLU: // 999999992d''''''''''''''' | |
11084 | - { | |
11085 | 10295 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttyk_\n"); |
11086 | 10296 | exit(-1); |
11087 | 10297 | break; |
11088 | 10298 | } |
11089 | - case 18446744073709551134LLU: // 999999992c''''''''''''''' | |
10299 | + case 18446744073709551169LLU: // 999999993A''''''''''''''' | |
11090 | 10300 | { |
11091 | 10301 | { |
11092 | 10302 | uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -11106,16 +10316,16 @@ | ||
11106 | 10316 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11107 | 10317 | } |
11108 | 10318 | // ACCUMULATE ARGUMENTS - END |
11109 | - uint64_t return_to = 18446744073709551133LLU; | |
10319 | + uint64_t return_to = 18446744073709551168LLU; | |
11110 | 10320 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11111 | 10321 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11112 | 10322 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
11113 | 10323 | heap.data[0].elem1 = heap.data[0].elem0; |
11114 | 10324 | heap.data[0].elem0 = restore; |
11115 | - state.addr = 18446744073709551467LLU; // 999999997p''''''''''''''' | |
10325 | + state.addr = 18446744073709551484LLU; // 9999999976''''''''''''''' | |
11116 | 10326 | break; |
11117 | 10327 | } |
11118 | - case 18446744073709551133LLU: // 999999992b''''''''''''''' | |
10328 | + case 18446744073709551168LLU: // 999999993_''''''''''''''' | |
11119 | 10329 | { |
11120 | 10330 | // RELEASE temporary destructor-variable |
11121 | 10331 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -11160,7 +10370,7 @@ | ||
11160 | 10370 | } |
11161 | 10371 | break; |
11162 | 10372 | } |
11163 | - case 18446744073709551132LLU: // 999999992a''''''''''''''' | |
10373 | + case 18446744073709551167LLU: // 9999999929''''''''''''''' | |
11164 | 10374 | { |
11165 | 10375 | { |
11166 | 10376 | uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -11174,14 +10384,14 @@ | ||
11174 | 10384 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11175 | 10385 | } |
11176 | 10386 | // emitted destructur for type list<varentry__> |
11177 | - state.addr = 18446744073709551130LLU; // 999999992Z''''''''''''''' | |
10387 | + state.addr = 18446744073709551165LLU; // 9999999927''''''''''''''' | |
11178 | 10388 | break; |
11179 | 10389 | } |
11180 | - case 18446744073709551130LLU: // 999999992Z''''''''''''''' | |
10390 | + case 18446744073709551165LLU: // 9999999927''''''''''''''' | |
11181 | 10391 | { |
11182 | 10392 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
11183 | 10393 | { |
11184 | - state.addr = 18446744073709551131LLU; // 999999992$''''''''''''''' | |
10394 | + state.addr = 18446744073709551166LLU; // 9999999928''''''''''''''' | |
11185 | 10395 | break; |
11186 | 10396 | } |
11187 | 10397 | // temporary list-element |
@@ -11195,23 +10405,23 @@ | ||
11195 | 10405 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11196 | 10406 | } |
11197 | 10407 | // ACCUMULATE ARGUMENTS - END |
11198 | - uint64_t return_to = 18446744073709551129LLU; | |
10408 | + uint64_t return_to = 18446744073709551164LLU; | |
11199 | 10409 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11200 | 10410 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11201 | 10411 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
11202 | 10412 | heap.data[0].elem1 = heap.data[0].elem0; |
11203 | 10413 | heap.data[0].elem0 = restore; |
11204 | - state.addr = 18446744073709551134LLU; // 999999992c''''''''''''''' | |
10414 | + state.addr = 18446744073709551169LLU; // 999999993A''''''''''''''' | |
11205 | 10415 | break; |
11206 | 10416 | } |
11207 | - case 18446744073709551129LLU: // 999999992Y''''''''''''''' | |
10417 | + case 18446744073709551164LLU: // 9999999926''''''''''''''' | |
11208 | 10418 | { |
11209 | 10419 | // RELEASE temporary destructor-variable |
11210 | 10420 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
11211 | - state.addr = 18446744073709551130LLU; // 999999992Z''''''''''''''' | |
10421 | + state.addr = 18446744073709551165LLU; // 9999999927''''''''''''''' | |
11212 | 10422 | break; |
11213 | 10423 | } |
11214 | - case 18446744073709551131LLU: // 999999992$''''''''''''''' | |
10424 | + case 18446744073709551166LLU: // 9999999928''''''''''''''' | |
11215 | 10425 | { |
11216 | 10426 | // RELEASE temporary destructor-variable |
11217 | 10427 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -11226,16 +10436,16 @@ | ||
11226 | 10436 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11227 | 10437 | } |
11228 | 10438 | // ACCUMULATE ARGUMENTS - END |
11229 | - uint64_t return_to = 18446744073709551128LLU; | |
10439 | + uint64_t return_to = 18446744073709551163LLU; | |
11230 | 10440 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11231 | 10441 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11232 | 10442 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
11233 | 10443 | heap.data[0].elem1 = heap.data[0].elem0; |
11234 | 10444 | heap.data[0].elem0 = restore; |
11235 | - state.addr = 18446744073709551478LLU; // 9999999970''''''''''''''' | |
10445 | + state.addr = 18446744073709551495LLU; // 999999998G''''''''''''''' | |
11236 | 10446 | break; |
11237 | 10447 | } |
11238 | - case 18446744073709551128LLU: // 999999992X''''''''''''''' | |
10448 | + case 18446744073709551163LLU: // 9999999925''''''''''''''' | |
11239 | 10449 | { |
11240 | 10450 | // RELEASE temporary destructor-variable |
11241 | 10451 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -11287,7 +10497,7 @@ | ||
11287 | 10497 | } |
11288 | 10498 | break; |
11289 | 10499 | } |
11290 | - case 18446744073709551127LLU: // 999999992W''''''''''''''' | |
10500 | + case 18446744073709551162LLU: // 9999999924''''''''''''''' | |
11291 | 10501 | { |
11292 | 10502 | { |
11293 | 10503 | uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -11307,16 +10517,16 @@ | ||
11307 | 10517 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11308 | 10518 | } |
11309 | 10519 | // ACCUMULATE ARGUMENTS - END |
11310 | - uint64_t return_to = 18446744073709551126LLU; | |
10520 | + uint64_t return_to = 18446744073709551161LLU; | |
11311 | 10521 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11312 | 10522 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11313 | 10523 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
11314 | 10524 | heap.data[0].elem1 = heap.data[0].elem0; |
11315 | 10525 | heap.data[0].elem0 = restore; |
11316 | - state.addr = 18446744073709551362LLU; // 999999996B''''''''''''''' | |
10526 | + state.addr = 18446744073709551383LLU; // 999999996W''''''''''''''' | |
11317 | 10527 | break; |
11318 | 10528 | } |
11319 | - case 18446744073709551126LLU: // 999999992V''''''''''''''' | |
10529 | + case 18446744073709551161LLU: // 9999999923''''''''''''''' | |
11320 | 10530 | { |
11321 | 10531 | // RELEASE temporary destructor-variable |
11322 | 10532 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -11375,7 +10585,7 @@ | ||
11375 | 10585 | } |
11376 | 10586 | break; |
11377 | 10587 | } |
11378 | - case 18446744073709551125LLU: // 999999992U''''''''''''''' | |
10588 | + case 18446744073709551160LLU: // 9999999922''''''''''''''' | |
11379 | 10589 | { |
11380 | 10590 | { |
11381 | 10591 | uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -11402,16 +10612,16 @@ | ||
11402 | 10612 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11403 | 10613 | } |
11404 | 10614 | // ACCUMULATE ARGUMENTS - END |
11405 | - uint64_t return_to = 18446744073709551124LLU; | |
10615 | + uint64_t return_to = 18446744073709551159LLU; | |
11406 | 10616 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11407 | 10617 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11408 | 10618 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
11409 | 10619 | heap.data[0].elem1 = heap.data[0].elem0; |
11410 | 10620 | heap.data[0].elem0 = restore; |
11411 | - state.addr = 18446744073709551171LLU; // 999999993C''''''''''''''' | |
10621 | + state.addr = 18446744073709551200LLU; // 999999993e''''''''''''''' | |
11412 | 10622 | break; |
11413 | 10623 | } |
11414 | - case 18446744073709551124LLU: // 999999992T''''''''''''''' | |
10624 | + case 18446744073709551159LLU: // 9999999921''''''''''''''' | |
11415 | 10625 | { |
11416 | 10626 | // RELEASE temporary destructor-variable |
11417 | 10627 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -11514,7 +10724,7 @@ | ||
11514 | 10724 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11515 | 10725 | } |
11516 | 10726 | // ACCUMULATE ARGUMENTS - END |
11517 | - uint64_t return_to = 18446744073709551121LLU; | |
10727 | + uint64_t return_to = 18446744073709551156LLU; | |
11518 | 10728 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
11519 | 10729 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11520 | 10730 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11523,7 +10733,7 @@ | ||
11523 | 10733 | state.addr = 552446646280519680LLU; // copyu64___ |
11524 | 10734 | break; |
11525 | 10735 | } |
11526 | - case 18446744073709551121LLU: // 999999992Q''''''''''''''' | |
10736 | + case 18446744073709551156LLU: // 999999992y''''''''''''''' | |
11527 | 10737 | { |
11528 | 10738 | { |
11529 | 10739 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -11552,7 +10762,7 @@ | ||
11552 | 10762 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11553 | 10763 | } |
11554 | 10764 | // ACCUMULATE ARGUMENTS - END |
11555 | - uint64_t return_to = 18446744073709551120LLU; | |
10765 | + uint64_t return_to = 18446744073709551155LLU; | |
11556 | 10766 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
11557 | 10767 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11558 | 10768 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11561,7 +10771,7 @@ | ||
11561 | 10771 | state.addr = 121779622511284459LLU; // FunctionCp |
11562 | 10772 | break; |
11563 | 10773 | } |
11564 | - case 18446744073709551120LLU: // 999999992P''''''''''''''' | |
10774 | + case 18446744073709551155LLU: // 999999992x''''''''''''''' | |
11565 | 10775 | { |
11566 | 10776 | { |
11567 | 10777 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -11590,7 +10800,7 @@ | ||
11590 | 10800 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11591 | 10801 | } |
11592 | 10802 | // ACCUMULATE ARGUMENTS - END |
11593 | - uint64_t return_to = 18446744073709551119LLU; | |
10803 | + uint64_t return_to = 18446744073709551154LLU; | |
11594 | 10804 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
11595 | 10805 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11596 | 10806 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11599,7 +10809,7 @@ | ||
11599 | 10809 | state.addr = 552446646280519680LLU; // copyu64___ |
11600 | 10810 | break; |
11601 | 10811 | } |
11602 | - case 18446744073709551119LLU: // 999999992O''''''''''''''' | |
10812 | + case 18446744073709551154LLU: // 999999992w''''''''''''''' | |
11603 | 10813 | { |
11604 | 10814 | { |
11605 | 10815 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -11611,7 +10821,7 @@ | ||
11611 | 10821 | } |
11612 | 10822 | } |
11613 | 10823 | // ACCUMULATE ARGUMENTS - END |
11614 | - uint64_t return_to = 18446744073709551122LLU; | |
10824 | + uint64_t return_to = 18446744073709551157LLU; | |
11615 | 10825 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
11616 | 10826 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11617 | 10827 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11620,7 +10830,7 @@ | ||
11620 | 10830 | state.addr = 567601196335104000LLU; // defidfn___ |
11621 | 10831 | break; |
11622 | 10832 | } |
11623 | - case 18446744073709551122LLU: // 999999992R''''''''''''''' | |
10833 | + case 18446744073709551157LLU: // 999999992z''''''''''''''' | |
11624 | 10834 | { |
11625 | 10835 | // parameter-reference u64 defined___ goes out of scope |
11626 | 10836 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defined___ at 5 |
@@ -11661,86 +10871,203 @@ | ||
11661 | 10871 | } |
11662 | 10872 | break; |
11663 | 10873 | } |
11664 | - case 552745707597858880LLU: // cptypedef_ | |
10874 | + case 58638376207779904LLU: // CPTypeDef_ | |
11665 | 10875 | { |
11666 | 10876 | { |
11667 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU); | |
10877 | + uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU); | |
11668 | 10878 | LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11669 | 10879 | } |
11670 | 10880 | { |
11671 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU); | |
10881 | + uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU); | |
11672 | 10882 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11673 | 10883 | } |
11674 | 10884 | { |
11675 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU); | |
10885 | + uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU); | |
11676 | 10886 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11677 | 10887 | } |
11678 | 10888 | { |
11679 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU); | |
10889 | + uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 3LLU); | |
11680 | 10890 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11681 | 10891 | } |
10892 | + // ACCUMULATE ARGUMENTS - BEGIN | |
10893 | + { | |
10894 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 0LLU); | |
10895 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10896 | + } | |
11682 | 10897 | { |
11683 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 0LLU); | |
10898 | + uint64_t arg = heap.data[0].elem0; | |
11684 | 10899 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11685 | 10900 | } |
11686 | 10901 | { |
11687 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 1LLU); | |
10902 | + uint64_t arg = 0; | |
11688 | 10903 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11689 | 10904 | } |
10905 | + // ACCUMULATE ARGUMENTS - BEGIN | |
10906 | + { | |
10907 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU); | |
10908 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10909 | + } | |
10910 | + { | |
10911 | + uint64_t arg = /*id1_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 2LLU)); | |
10912 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10913 | + } | |
10914 | + // ACCUMULATE ARGUMENTS - END | |
10915 | + uint64_t return_to = 18446744073709551151LLU; | |
10916 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
10917 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
10918 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
10919 | + heap.data[0].elem1 = heap.data[0].elem0; | |
10920 | + heap.data[0].elem0 = restore; | |
10921 | + state.addr = 552446646280519680LLU; // copyu64___ | |
10922 | + break; | |
10923 | + } | |
10924 | + case 18446744073709551151LLU: // 999999992t''''''''''''''' | |
10925 | + { | |
11690 | 10926 | { |
11691 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 2LLU); | |
11692 | - LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
10927 | + uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; | |
10928 | + heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; | |
10929 | + | |
10930 | + { | |
10931 | + uint64_t arg = exchange; | |
10932 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10933 | + } | |
11693 | 10934 | } |
11694 | 10935 | { |
11695 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 3LLU); | |
11696 | - LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
10936 | + uint64_t arg = heap.data[0].elem0; | |
10937 | + LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11697 | 10938 | } |
11698 | - | |
11699 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 2LLU)) = /*id1_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 6LLU)); | |
10939 | + { | |
10940 | + uint64_t arg = 0; | |
10941 | + LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
10942 | + } | |
11700 | 10943 | // ACCUMULATE ARGUMENTS - BEGIN |
11701 | 10944 | { |
11702 | - uint64_t arg = /*kind0_____*/*LOCAL_ACCESS(heap.data, 10LLU, 3LLU); | |
10945 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU); | |
11703 | 10946 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11704 | 10947 | } |
11705 | 10948 | { |
11706 | - uint64_t arg = /*kind1_____*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU); | |
10949 | + uint64_t arg = /*kind1_____*/*LOCAL_ACCESS(heap.data, 8LLU, 3LLU); | |
11707 | 10950 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11708 | 10951 | } |
11709 | 10952 | // ACCUMULATE ARGUMENTS - END |
11710 | - uint64_t return_to = 18446744073709551117LLU; | |
10953 | + uint64_t return_to = 18446744073709551150LLU; | |
11711 | 10954 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
11712 | 10955 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11713 | 10956 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
11714 | 10957 | heap.data[0].elem1 = heap.data[0].elem0; |
11715 | 10958 | heap.data[0].elem0 = restore; |
11716 | - state.addr = 552446644822474752LLU; // copytk____ | |
10959 | + state.addr = 66057855622447104LLU; // CopyTK____ | |
11717 | 10960 | break; |
11718 | 10961 | } |
11719 | - case 18446744073709551117LLU: // 999999992M''''''''''''''' | |
10962 | + case 18446744073709551150LLU: // 999999992s''''''''''''''' | |
11720 | 10963 | { |
11721 | - | |
11722 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 4LLU)) = /*sizeoheap1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 8LLU)); | |
11723 | - | |
11724 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)) = /*destraddr1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 9LLU)); | |
10964 | + { | |
10965 | + uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; | |
10966 | + heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; | |
10967 | + | |
10968 | + { | |
10969 | + uint64_t arg = exchange; | |
10970 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10971 | + } | |
10972 | + } | |
10973 | + { | |
10974 | + uint64_t arg = heap.data[0].elem0; | |
10975 | + LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
10976 | + } | |
10977 | + { | |
10978 | + uint64_t arg = 0; | |
10979 | + LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
10980 | + } | |
10981 | + // ACCUMULATE ARGUMENTS - BEGIN | |
10982 | + { | |
10983 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU); | |
10984 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10985 | + } | |
10986 | + { | |
10987 | + uint64_t arg = /*sizeoheap1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 4LLU)); | |
10988 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
10989 | + } | |
10990 | + // ACCUMULATE ARGUMENTS - END | |
10991 | + uint64_t return_to = 18446744073709551149LLU; | |
10992 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
10993 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
10994 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
10995 | + heap.data[0].elem1 = heap.data[0].elem0; | |
10996 | + heap.data[0].elem0 = restore; | |
10997 | + state.addr = 552446646280519680LLU; // copyu64___ | |
10998 | + break; | |
10999 | + } | |
11000 | + case 18446744073709551149LLU: // 999999992r''''''''''''''' | |
11001 | + { | |
11002 | + { | |
11003 | + uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; | |
11004 | + heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; | |
11005 | + | |
11006 | + { | |
11007 | + uint64_t arg = exchange; | |
11008 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
11009 | + } | |
11010 | + } | |
11011 | + { | |
11012 | + uint64_t arg = heap.data[0].elem0; | |
11013 | + LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11014 | + } | |
11015 | + { | |
11016 | + uint64_t arg = 0; | |
11017 | + LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11018 | + } | |
11019 | + // ACCUMULATE ARGUMENTS - BEGIN | |
11020 | + { | |
11021 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU); | |
11022 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
11023 | + } | |
11024 | + { | |
11025 | + uint64_t arg = /*destraddr1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 5LLU)); | |
11026 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
11027 | + } | |
11028 | + // ACCUMULATE ARGUMENTS - END | |
11029 | + uint64_t return_to = 18446744073709551148LLU; | |
11030 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
11031 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
11032 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
11033 | + heap.data[0].elem1 = heap.data[0].elem0; | |
11034 | + heap.data[0].elem0 = restore; | |
11035 | + state.addr = 552446646280519680LLU; // copyu64___ | |
11036 | + break; | |
11037 | + } | |
11038 | + case 18446744073709551148LLU: // 999999992q''''''''''''''' | |
11039 | + { | |
11040 | + { | |
11041 | + uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; | |
11042 | + heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; | |
11043 | + | |
11044 | + { | |
11045 | + uint64_t arg = exchange; | |
11046 | + LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
11047 | + } | |
11048 | + } | |
11049 | + // ACCUMULATE ARGUMENTS - END | |
11050 | + uint64_t return_to = 18446744073709551152LLU; | |
11051 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
11052 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
11053 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
11054 | + heap.data[0].elem1 = heap.data[0].elem0; | |
11055 | + heap.data[0].elem0 = restore; | |
11056 | + state.addr = 861504777589358592LLU; // typedef___ | |
11057 | + break; | |
11058 | + } | |
11059 | + case 18446744073709551152LLU: // 999999992u''''''''''''''' | |
11060 | + { | |
11725 | 11061 | // parameter-reference u64 destraddr1 goes out of scope |
11726 | - (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destraddr1 at 10 | |
11062 | + (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destraddr1 at 6 | |
11727 | 11063 | // parameter-reference u64 sizeoheap1 goes out of scope |
11728 | - (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizeoheap1 at 9 | |
11064 | + (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizeoheap1 at 5 | |
11729 | 11065 | // parameter-reference typekind__ kind1_____ goes out of scope |
11730 | - (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference kind1_____ at 8 | |
11066 | + (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference kind1_____ at 4 | |
11731 | 11067 | // parameter-reference u64 id1_______ goes out of scope |
11732 | - (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 7 | |
11068 | + (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 3 | |
11733 | 11069 | // parameter-reference typedef___ __________ goes out of scope |
11734 | - (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6 | |
11735 | - // parameter-reference u64 destraddr0 goes out of scope | |
11736 | - (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destraddr0 at 5 | |
11737 | - // parameter-reference u64 sizeoheap0 goes out of scope | |
11738 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizeoheap0 at 4 | |
11739 | - // parameter-reference typekind__ kind0_____ goes out of scope | |
11740 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference kind0_____ at 3 | |
11741 | - // parameter-reference u64 id0_______ goes out of scope | |
11742 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id0_______ at 2 | |
11743 | - // parameter-reference typedef___ __________ goes out of scope | |
11070 | + (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2 | |
11744 | 11071 | (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 |
11745 | 11072 | { |
11746 | 11073 | uint64_t baseinfo = heap.data[0].elem1; |
@@ -11762,10 +11089,10 @@ | ||
11762 | 11089 | uint64_t arg = 0; |
11763 | 11090 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11764 | 11091 | } |
11765 | - state.addr = 18446744073709551116LLU; // 999999992L''''''''''''''' | |
11092 | + state.addr = 18446744073709551147LLU; // 999999992p''''''''''''''' | |
11766 | 11093 | break; |
11767 | 11094 | } |
11768 | - case 18446744073709551116LLU: // 999999992L''''''''''''''' | |
11095 | + case 18446744073709551147LLU: // 999999992p''''''''''''''' | |
11769 | 11096 | { |
11770 | 11097 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
11771 | 11098 | { |
@@ -11772,7 +11099,7 @@ | ||
11772 | 11099 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
11773 | 11100 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
11774 | 11101 | { |
11775 | - state.addr = 18446744073709551115LLU; // 999999992K''''''''''''''' | |
11102 | + state.addr = 18446744073709551146LLU; // 999999992o''''''''''''''' | |
11776 | 11103 | break; |
11777 | 11104 | } |
11778 | 11105 | } |
@@ -11783,25 +11110,25 @@ | ||
11783 | 11110 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11784 | 11111 | } |
11785 | 11112 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 0LLU)); |
11786 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551114LLU : 18446744073709551113LLU; | |
11113 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551145LLU : 18446744073709551144LLU; | |
11787 | 11114 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
11788 | 11115 | break; |
11789 | 11116 | } |
11790 | - case 18446744073709551114LLU: // 999999992J''''''''''''''' | |
11117 | + case 18446744073709551145LLU: // 999999992n''''''''''''''' | |
11791 | 11118 | { |
11792 | 11119 | |
11793 | 11120 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1; |
11794 | - state.addr = 18446744073709551113LLU; // 999999992I''''''''''''''' | |
11121 | + state.addr = 18446744073709551144LLU; // 999999992m''''''''''''''' | |
11795 | 11122 | break; |
11796 | 11123 | } |
11797 | - case 18446744073709551113LLU: // 999999992I''''''''''''''' | |
11124 | + case 18446744073709551144LLU: // 999999992m''''''''''''''' | |
11798 | 11125 | { |
11799 | 11126 | // parameter-reference defidfn___ elem______ goes out of scope |
11800 | 11127 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
11801 | - state.addr = 18446744073709551116LLU; // 999999992L''''''''''''''' | |
11128 | + state.addr = 18446744073709551147LLU; // 999999992p''''''''''''''' | |
11802 | 11129 | break; |
11803 | 11130 | } |
11804 | - case 18446744073709551115LLU: // 999999992K''''''''''''''' | |
11131 | + case 18446744073709551146LLU: // 999999992o''''''''''''''' | |
11805 | 11132 | { |
11806 | 11133 | // parameter-reference u64 id________ goes out of scope |
11807 | 11134 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 3 |
@@ -11817,65 +11144,71 @@ | ||
11817 | 11144 | } |
11818 | 11145 | break; |
11819 | 11146 | } |
11820 | - case 590977518136150752LLU: // existstype | |
11147 | + case 104588758373059296LLU: // ExistsType | |
11821 | 11148 | { |
11822 | - | |
11823 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0; | |
11824 | 11149 | { |
11825 | - uint64_t arg = /*typedefs__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)); | |
11150 | + uint64_t arg = 0; | |
11826 | 11151 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11827 | 11152 | } |
11153 | + *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 0; | |
11828 | 11154 | { |
11829 | - uint64_t arg = 0; | |
11155 | + uint64_t arg = /*typedefs__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)); | |
11830 | 11156 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11831 | 11157 | } |
11832 | - state.addr = 18446744073709551112LLU; // 999999992H''''''''''''''' | |
11158 | + { | |
11159 | + uint64_t arg = 0; | |
11160 | + LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11161 | + } | |
11162 | + state.addr = 18446744073709551143LLU; // 999999992l''''''''''''''' | |
11833 | 11163 | break; |
11834 | 11164 | } |
11835 | - case 18446744073709551112LLU: // 999999992H''''''''''''''' | |
11165 | + case 18446744073709551143LLU: // 999999992l''''''''''''''' | |
11836 | 11166 | { |
11837 | - if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) | |
11167 | + if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) | |
11838 | 11168 | { |
11169 | + (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 | |
11839 | 11170 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
11840 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 | |
11841 | 11171 | { |
11842 | - state.addr = 18446744073709551111LLU; // 999999992G''''''''''''''' | |
11172 | + state.addr = 18446744073709551142LLU; // 999999992k''''''''''''''' | |
11843 | 11173 | break; |
11844 | 11174 | } |
11845 | 11175 | } |
11846 | - /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU; | |
11847 | - *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0; | |
11176 | + /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU; | |
11177 | + *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0; | |
11848 | 11178 | { |
11849 | 11179 | uint64_t arg = 0; |
11850 | - LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11180 | + LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11851 | 11181 | } |
11852 | - *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 0LLU)); | |
11853 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551110LLU : 18446744073709551109LLU; | |
11854 | - (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 | |
11182 | + *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 2LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU), 0LLU)); | |
11183 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551141LLU : 18446744073709551140LLU; | |
11184 | + (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 | |
11855 | 11185 | break; |
11856 | 11186 | } |
11857 | - case 18446744073709551110LLU: // 999999992F''''''''''''''' | |
11187 | + case 18446744073709551141LLU: // 999999992j''''''''''''''' | |
11858 | 11188 | { |
11859 | 11189 | |
11860 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1; | |
11861 | - state.addr = 18446744073709551109LLU; // 999999992E''''''''''''''' | |
11190 | + *LOCAL_ACCESS(heap.data, 6LLU, 3LLU) = 1; | |
11191 | + state.addr = 18446744073709551140LLU; // 999999992i''''''''''''''' | |
11862 | 11192 | break; |
11863 | 11193 | } |
11864 | - case 18446744073709551109LLU: // 999999992E''''''''''''''' | |
11194 | + case 18446744073709551140LLU: // 999999992i''''''''''''''' | |
11865 | 11195 | { |
11866 | 11196 | // parameter-reference typedef___ elem______ goes out of scope |
11867 | 11197 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
11868 | - state.addr = 18446744073709551112LLU; // 999999992H''''''''''''''' | |
11198 | + state.addr = 18446744073709551143LLU; // 999999992l''''''''''''''' | |
11869 | 11199 | break; |
11870 | 11200 | } |
11871 | - case 18446744073709551111LLU: // 999999992G''''''''''''''' | |
11201 | + case 18446744073709551142LLU: // 999999992k''''''''''''''' | |
11872 | 11202 | { |
11203 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*found_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU); | |
11204 | + // variable u64 found_____ goes out of scope | |
11205 | + // emitted destructur for type u64 | |
11206 | + (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 4 | |
11873 | 11207 | // parameter-reference u64 id________ goes out of scope |
11874 | 11208 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 3 |
11875 | 11209 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
11876 | 11210 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
11877 | - // parameter-reference u64 found_____ goes out of scope | |
11878 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 1 | |
11211 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
11879 | 11212 | { |
11880 | 11213 | uint64_t baseinfo = heap.data[0].elem1; |
11881 | 11214 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -11884,11 +11217,11 @@ | ||
11884 | 11217 | } |
11885 | 11218 | break; |
11886 | 11219 | } |
11887 | - case 696275822682439680LLU: // knowtype__ | |
11220 | + case 209887033935396864LLU: // KnowType__ | |
11888 | 11221 | { |
11889 | 11222 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 0/*typeu64___*/) |
11890 | 11223 | { |
11891 | - state.addr = 18446744073709551108LLU; // 999999992D''''''''''''''' | |
11224 | + state.addr = 18446744073709551139LLU; // 999999992h''''''''''''''' | |
11892 | 11225 | break; |
11893 | 11226 | } |
11894 | 11227 | { |
@@ -11895,8 +11228,7 @@ | ||
11895 | 11228 | uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU); |
11896 | 11229 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11897 | 11230 | } |
11898 | - | |
11899 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 1; | |
11231 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 1LLU; | |
11900 | 11232 | // parameter-reference type______ __________ goes out of scope |
11901 | 11233 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4 |
11902 | 11234 | // parameter type______ __________ goes out of scope |
@@ -11903,8 +11235,7 @@ | ||
11903 | 11235 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
11904 | 11236 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
11905 | 11237 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
11906 | - // parameter-reference u64 found_____ goes out of scope | |
11907 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 1 | |
11238 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
11908 | 11239 | { |
11909 | 11240 | uint64_t baseinfo = heap.data[0].elem1; |
11910 | 11241 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -11913,11 +11244,11 @@ | ||
11913 | 11244 | } |
11914 | 11245 | break; |
11915 | 11246 | } |
11916 | - case 18446744073709551108LLU: // 999999992D''''''''''''''' | |
11247 | + case 18446744073709551139LLU: // 999999992h''''''''''''''' | |
11917 | 11248 | { |
11918 | 11249 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 1/*typename__*/) |
11919 | 11250 | { |
11920 | - state.addr = 18446744073709551107LLU; // 999999992C''''''''''''''' | |
11251 | + state.addr = 18446744073709551138LLU; // 999999992g''''''''''''''' | |
11921 | 11252 | break; |
11922 | 11253 | } |
11923 | 11254 | { |
@@ -11930,7 +11261,7 @@ | ||
11930 | 11261 | } |
11931 | 11262 | // ACCUMULATE ARGUMENTS - BEGIN |
11932 | 11263 | { |
11933 | - uint64_t arg = /*found_____*/*LOCAL_ACCESS(heap.data, 5LLU, 0LLU); | |
11264 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU); | |
11934 | 11265 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11935 | 11266 | } |
11936 | 11267 | { |
@@ -11942,16 +11273,16 @@ | ||
11942 | 11273 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11943 | 11274 | } |
11944 | 11275 | // ACCUMULATE ARGUMENTS - END |
11945 | - uint64_t return_to = 18446744073709551106LLU; | |
11276 | + uint64_t return_to = 18446744073709551137LLU; | |
11946 | 11277 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
11947 | 11278 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11948 | 11279 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
11949 | 11280 | heap.data[0].elem1 = heap.data[0].elem0; |
11950 | 11281 | heap.data[0].elem0 = restore; |
11951 | - state.addr = 590977518136150752LLU; // existstype | |
11282 | + state.addr = 104588758373059296LLU; // ExistsType | |
11952 | 11283 | break; |
11953 | 11284 | } |
11954 | - case 18446744073709551106LLU: // 999999992B''''''''''''''' | |
11285 | + case 18446744073709551137LLU: // 999999992f''''''''''''''' | |
11955 | 11286 | { |
11956 | 11287 | // parameter-reference u64 maintype__ goes out of scope |
11957 | 11288 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 5 |
@@ -11961,8 +11292,7 @@ | ||
11961 | 11292 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
11962 | 11293 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
11963 | 11294 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
11964 | - // parameter-reference u64 found_____ goes out of scope | |
11965 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 1 | |
11295 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
11966 | 11296 | { |
11967 | 11297 | uint64_t baseinfo = heap.data[0].elem1; |
11968 | 11298 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -11971,11 +11301,11 @@ | ||
11971 | 11301 | } |
11972 | 11302 | break; |
11973 | 11303 | } |
11974 | - case 18446744073709551107LLU: // 999999992C''''''''''''''' | |
11304 | + case 18446744073709551138LLU: // 999999992g''''''''''''''' | |
11975 | 11305 | { |
11976 | 11306 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 2/*typelist__*/) |
11977 | 11307 | { |
11978 | - state.addr = 18446744073709551105LLU; // 999999992A''''''''''''''' | |
11308 | + state.addr = 18446744073709551136LLU; // 999999992e''''''''''''''' | |
11979 | 11309 | break; |
11980 | 11310 | } |
11981 | 11311 | { |
@@ -11991,27 +11321,26 @@ | ||
11991 | 11321 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11992 | 11322 | } |
11993 | 11323 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = 881834713755418624; |
11994 | - | |
11995 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)); | |
11996 | 11324 | { |
11997 | 11325 | uint64_t arg = 0; |
11998 | 11326 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11999 | 11327 | } |
12000 | - *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*found_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)); | |
12001 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551104LLU : 18446744073709551103LLU; | |
11328 | + *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)); | |
11329 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551135LLU : 18446744073709551134LLU; | |
12002 | 11330 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
12003 | 11331 | break; |
12004 | 11332 | } |
12005 | - case 18446744073709551104LLU: // 999999992_''''''''''''''' | |
11333 | + case 18446744073709551135LLU: // 999999992d''''''''''''''' | |
12006 | 11334 | { |
12007 | - state.addr = 18446744073709551102LLU; // 9999999918''''''''''''''' | |
11335 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 1LLU; | |
11336 | + state.addr = 18446744073709551133LLU; // 999999992b''''''''''''''' | |
12008 | 11337 | break; |
12009 | 11338 | } |
12010 | - case 18446744073709551103LLU: // 9999999919''''''''''''''' | |
11339 | + case 18446744073709551134LLU: // 999999992c''''''''''''''' | |
12011 | 11340 | { |
12012 | 11341 | // ACCUMULATE ARGUMENTS - BEGIN |
12013 | 11342 | { |
12014 | - uint64_t arg = /*found_____*/*LOCAL_ACCESS(heap.data, 6LLU, 0LLU); | |
11343 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 0LLU); | |
12015 | 11344 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12016 | 11345 | } |
12017 | 11346 | { |
@@ -12023,21 +11352,21 @@ | ||
12023 | 11352 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12024 | 11353 | } |
12025 | 11354 | // ACCUMULATE ARGUMENTS - END |
12026 | - uint64_t return_to = 18446744073709551101LLU; | |
11355 | + uint64_t return_to = 18446744073709551132LLU; | |
12027 | 11356 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
12028 | 11357 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12029 | 11358 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
12030 | 11359 | heap.data[0].elem1 = heap.data[0].elem0; |
12031 | 11360 | heap.data[0].elem0 = restore; |
12032 | - state.addr = 590977518136150752LLU; // existstype | |
11361 | + state.addr = 104588758373059296LLU; // ExistsType | |
12033 | 11362 | break; |
12034 | 11363 | } |
12035 | - case 18446744073709551101LLU: // 9999999917''''''''''''''' | |
11364 | + case 18446744073709551132LLU: // 999999992a''''''''''''''' | |
12036 | 11365 | { |
12037 | - state.addr = 18446744073709551102LLU; // 9999999918''''''''''''''' | |
11366 | + state.addr = 18446744073709551133LLU; // 999999992b''''''''''''''' | |
12038 | 11367 | break; |
12039 | 11368 | } |
12040 | - case 18446744073709551102LLU: // 9999999918''''''''''''''' | |
11369 | + case 18446744073709551133LLU: // 999999992b''''''''''''''' | |
12041 | 11370 | { |
12042 | 11371 | // variable u64 sym_______ goes out of scope |
12043 | 11372 | // emitted destructur for type u64 |
@@ -12050,8 +11379,7 @@ | ||
12050 | 11379 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
12051 | 11380 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
12052 | 11381 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
12053 | - // parameter-reference u64 found_____ goes out of scope | |
12054 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 1 | |
11382 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
12055 | 11383 | { |
12056 | 11384 | uint64_t baseinfo = heap.data[0].elem1; |
12057 | 11385 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -12060,17 +11388,17 @@ | ||
12060 | 11388 | } |
12061 | 11389 | break; |
12062 | 11390 | } |
12063 | - case 18446744073709551105LLU: // 999999992A''''''''''''''' | |
11391 | + case 18446744073709551136LLU: // 999999992e''''''''''''''' | |
12064 | 11392 | { |
12065 | - fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of knowtype__\n"); | |
11393 | + fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of KnowType__\n"); | |
12066 | 11394 | exit(-1); |
12067 | 11395 | break; |
12068 | 11396 | } |
12069 | - case 696275822682443264LLU: // knowtype2_ | |
11397 | + case 209887033935398019LLU: // KnowTypeRC | |
12070 | 11398 | { |
12071 | 11399 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/) |
12072 | 11400 | { |
12073 | - state.addr = 18446744073709551100LLU; // 9999999916''''''''''''''' | |
11401 | + state.addr = 18446744073709551131LLU; // 999999992$''''''''''''''' | |
12074 | 11402 | break; |
12075 | 11403 | } |
12076 | 11404 | { |
@@ -12077,8 +11405,7 @@ | ||
12077 | 11405 | uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU); |
12078 | 11406 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12079 | 11407 | } |
12080 | - | |
12081 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1; | |
11408 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU; | |
12082 | 11409 | // parameter-reference u64 __________ goes out of scope |
12083 | 11410 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5 |
12084 | 11411 | // parameter-reference type______ __________ goes out of scope |
@@ -12087,8 +11414,7 @@ | ||
12087 | 11414 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
12088 | 11415 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
12089 | 11416 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
12090 | - // parameter-reference u64 found_____ goes out of scope | |
12091 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 1 | |
11417 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
12092 | 11418 | { |
12093 | 11419 | uint64_t baseinfo = heap.data[0].elem1; |
12094 | 11420 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -12097,11 +11423,11 @@ | ||
12097 | 11423 | } |
12098 | 11424 | break; |
12099 | 11425 | } |
12100 | - case 18446744073709551100LLU: // 9999999916''''''''''''''' | |
11426 | + case 18446744073709551131LLU: // 999999992$''''''''''''''' | |
12101 | 11427 | { |
12102 | 11428 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/) |
12103 | 11429 | { |
12104 | - state.addr = 18446744073709551099LLU; // 9999999915''''''''''''''' | |
11430 | + state.addr = 18446744073709551130LLU; // 999999992Z''''''''''''''' | |
12105 | 11431 | break; |
12106 | 11432 | } |
12107 | 11433 | { |
@@ -12114,7 +11440,7 @@ | ||
12114 | 11440 | } |
12115 | 11441 | // ACCUMULATE ARGUMENTS - BEGIN |
12116 | 11442 | { |
12117 | - uint64_t arg = /*found_____*/*LOCAL_ACCESS(heap.data, 6LLU, 0LLU); | |
11443 | + uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 0LLU); | |
12118 | 11444 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12119 | 11445 | } |
12120 | 11446 | { |
@@ -12126,16 +11452,16 @@ | ||
12126 | 11452 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12127 | 11453 | } |
12128 | 11454 | // ACCUMULATE ARGUMENTS - END |
12129 | - uint64_t return_to = 18446744073709551098LLU; | |
11455 | + uint64_t return_to = 18446744073709551129LLU; | |
12130 | 11456 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
12131 | 11457 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12132 | 11458 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
12133 | 11459 | heap.data[0].elem1 = heap.data[0].elem0; |
12134 | 11460 | heap.data[0].elem0 = restore; |
12135 | - state.addr = 590977518136150752LLU; // existstype | |
11461 | + state.addr = 104588758373059296LLU; // ExistsType | |
12136 | 11462 | break; |
12137 | 11463 | } |
12138 | - case 18446744073709551098LLU: // 9999999914''''''''''''''' | |
11464 | + case 18446744073709551129LLU: // 999999992Y''''''''''''''' | |
12139 | 11465 | { |
12140 | 11466 | // parameter-reference u64 __________ goes out of scope |
12141 | 11467 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6 |
@@ -12147,8 +11473,7 @@ | ||
12147 | 11473 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
12148 | 11474 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
12149 | 11475 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
12150 | - // parameter-reference u64 found_____ goes out of scope | |
12151 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 1 | |
11476 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
12152 | 11477 | { |
12153 | 11478 | uint64_t baseinfo = heap.data[0].elem1; |
12154 | 11479 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -12157,11 +11482,11 @@ | ||
12157 | 11482 | } |
12158 | 11483 | break; |
12159 | 11484 | } |
12160 | - case 18446744073709551099LLU: // 9999999915''''''''''''''' | |
11485 | + case 18446744073709551130LLU: // 999999992Z''''''''''''''' | |
12161 | 11486 | { |
12162 | 11487 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/) |
12163 | 11488 | { |
12164 | - state.addr = 18446744073709551097LLU; // 9999999913''''''''''''''' | |
11489 | + state.addr = 18446744073709551128LLU; // 999999992X''''''''''''''' | |
12165 | 11490 | break; |
12166 | 11491 | } |
12167 | 11492 | { |
@@ -12177,76 +11502,74 @@ | ||
12177 | 11502 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12178 | 11503 | } |
12179 | 11504 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = 881834713755418624; |
12180 | - | |
12181 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 7LLU, 6LLU) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU)); | |
12182 | 11505 | { |
12183 | 11506 | uint64_t arg = 0; |
12184 | 11507 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12185 | 11508 | } |
12186 | - *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*found_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)); | |
12187 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551096LLU : 18446744073709551095LLU; | |
11509 | + *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 5LLU)); | |
11510 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551127LLU : 18446744073709551126LLU; | |
12188 | 11511 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
12189 | 11512 | break; |
12190 | 11513 | } |
12191 | - case 18446744073709551096LLU: // 9999999912''''''''''''''' | |
11514 | + case 18446744073709551127LLU: // 999999992W''''''''''''''' | |
12192 | 11515 | { |
12193 | - state.addr = 18446744073709551094LLU; // 9999999910''''''''''''''' | |
11516 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 1LLU; | |
11517 | + state.addr = 18446744073709551125LLU; // 999999992U''''''''''''''' | |
12194 | 11518 | break; |
12195 | 11519 | } |
12196 | - case 18446744073709551095LLU: // 9999999911''''''''''''''' | |
11520 | + case 18446744073709551126LLU: // 999999992V''''''''''''''' | |
12197 | 11521 | { |
11522 | + { | |
11523 | + uint64_t arg = 0; | |
11524 | + LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
11525 | + } | |
12198 | 11526 | // ACCUMULATE ARGUMENTS - BEGIN |
12199 | 11527 | { |
12200 | - uint64_t arg = /*found_____*/*LOCAL_ACCESS(heap.data, 7LLU, 0LLU); | |
11528 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU); | |
12201 | 11529 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12202 | 11530 | } |
12203 | 11531 | { |
12204 | - uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 7LLU, 1LLU); | |
11532 | + uint64_t arg = /*typedefs__*/*LOCAL_ACCESS(heap.data, 8LLU, 1LLU); | |
12205 | 11533 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12206 | 11534 | } |
12207 | 11535 | { |
12208 | - uint64_t arg = /*subtype___*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU); | |
11536 | + uint64_t arg = /*subtype___*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU); | |
12209 | 11537 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12210 | 11538 | } |
12211 | 11539 | // ACCUMULATE ARGUMENTS - END |
12212 | - uint64_t return_to = 18446744073709551093LLU; | |
11540 | + uint64_t return_to = 18446744073709551121LLU; | |
12213 | 11541 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
12214 | 11542 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12215 | 11543 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
12216 | 11544 | heap.data[0].elem1 = heap.data[0].elem0; |
12217 | 11545 | heap.data[0].elem0 = restore; |
12218 | - state.addr = 590977518136150752LLU; // existstype | |
11546 | + state.addr = 104588758373059296LLU; // ExistsType | |
12219 | 11547 | break; |
12220 | 11548 | } |
12221 | - case 18446744073709551093LLU: // 999999991z''''''''''''''' | |
11549 | + case 18446744073709551121LLU: // 999999992Q''''''''''''''' | |
12222 | 11550 | { |
12223 | - { | |
12224 | - uint64_t arg = 0; | |
12225 | - LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
12226 | - } | |
12227 | - *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*found_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)); | |
12228 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551092LLU : 18446744073709551091LLU; | |
11551 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551124LLU : 18446744073709551123LLU; | |
12229 | 11552 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
12230 | 11553 | break; |
12231 | 11554 | } |
12232 | - case 18446744073709551092LLU: // 999999991y''''''''''''''' | |
11555 | + case 18446744073709551124LLU: // 999999992T''''''''''''''' | |
12233 | 11556 | { |
12234 | - state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
11557 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 1LLU; | |
11558 | + state.addr = 18446744073709551122LLU; // 999999992R''''''''''''''' | |
12235 | 11559 | break; |
12236 | 11560 | } |
12237 | - case 18446744073709551091LLU: // 999999991x''''''''''''''' | |
11561 | + case 18446744073709551123LLU: // 999999992S''''''''''''''' | |
12238 | 11562 | { |
12239 | - | |
12240 | 11563 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /*self______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU)) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU)); |
12241 | - state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
11564 | + state.addr = 18446744073709551122LLU; // 999999992R''''''''''''''' | |
12242 | 11565 | break; |
12243 | 11566 | } |
12244 | - case 18446744073709551090LLU: // 999999991w''''''''''''''' | |
11567 | + case 18446744073709551122LLU: // 999999992R''''''''''''''' | |
12245 | 11568 | { |
12246 | - state.addr = 18446744073709551094LLU; // 9999999910''''''''''''''' | |
11569 | + state.addr = 18446744073709551125LLU; // 999999992U''''''''''''''' | |
12247 | 11570 | break; |
12248 | 11571 | } |
12249 | - case 18446744073709551094LLU: // 9999999910''''''''''''''' | |
11572 | + case 18446744073709551125LLU: // 999999992U''''''''''''''' | |
12250 | 11573 | { |
12251 | 11574 | // variable u64 sym_______ goes out of scope |
12252 | 11575 | // emitted destructur for type u64 |
@@ -12261,8 +11584,7 @@ | ||
12261 | 11584 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3 |
12262 | 11585 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
12263 | 11586 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
12264 | - // parameter-reference u64 found_____ goes out of scope | |
12265 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference found_____ at 1 | |
11587 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
12266 | 11588 | { |
12267 | 11589 | uint64_t baseinfo = heap.data[0].elem1; |
12268 | 11590 | struct pair pair = unpair(&heap, &baseinfo); |
@@ -12271,9 +11593,9 @@ | ||
12271 | 11593 | } |
12272 | 11594 | break; |
12273 | 11595 | } |
12274 | - case 18446744073709551097LLU: // 9999999913''''''''''''''' | |
11596 | + case 18446744073709551128LLU: // 999999992X''''''''''''''' | |
12275 | 11597 | { |
12276 | - fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of knowtype2_\n"); | |
11598 | + fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of KnowTypeRC\n"); | |
12277 | 11599 | exit(-1); |
12278 | 11600 | break; |
12279 | 11601 | } |
@@ -12281,7 +11603,7 @@ | ||
12281 | 11603 | { |
12282 | 11604 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*produce___*/) |
12283 | 11605 | { |
12284 | - state.addr = 18446744073709551089LLU; // 999999991v''''''''''''''' | |
11606 | + state.addr = 18446744073709551120LLU; // 999999992P''''''''''''''' | |
12285 | 11607 | break; |
12286 | 11608 | } |
12287 | 11609 | { |
@@ -12301,11 +11623,11 @@ | ||
12301 | 11623 | } |
12302 | 11624 | break; |
12303 | 11625 | } |
12304 | - case 18446744073709551089LLU: // 999999991v''''''''''''''' | |
11626 | + case 18446744073709551120LLU: // 999999992P''''''''''''''' | |
12305 | 11627 | { |
12306 | 11628 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*consume___*/) |
12307 | 11629 | { |
12308 | - state.addr = 18446744073709551088LLU; // 999999991u''''''''''''''' | |
11630 | + state.addr = 18446744073709551119LLU; // 999999992O''''''''''''''' | |
12309 | 11631 | break; |
12310 | 11632 | } |
12311 | 11633 | { |
@@ -12325,11 +11647,11 @@ | ||
12325 | 11647 | } |
12326 | 11648 | break; |
12327 | 11649 | } |
12328 | - case 18446744073709551088LLU: // 999999991u''''''''''''''' | |
11650 | + case 18446744073709551119LLU: // 999999992O''''''''''''''' | |
12329 | 11651 | { |
12330 | 11652 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*maintain__*/) |
12331 | 11653 | { |
12332 | - state.addr = 18446744073709551087LLU; // 999999991t''''''''''''''' | |
11654 | + state.addr = 18446744073709551118LLU; // 999999992N''''''''''''''' | |
12333 | 11655 | break; |
12334 | 11656 | } |
12335 | 11657 | { |
@@ -12349,7 +11671,7 @@ | ||
12349 | 11671 | } |
12350 | 11672 | break; |
12351 | 11673 | } |
12352 | - case 18446744073709551087LLU: // 999999991t''''''''''''''' | |
11674 | + case 18446744073709551118LLU: // 999999992N''''''''''''''' | |
12353 | 11675 | { |
12354 | 11676 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportcont\n"); |
12355 | 11677 | exit(-1); |
@@ -12379,7 +11701,7 @@ | ||
12379 | 11701 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12380 | 11702 | } |
12381 | 11703 | // ACCUMULATE ARGUMENTS - END |
12382 | - uint64_t return_to = 18446744073709551085LLU; | |
11704 | + uint64_t return_to = 18446744073709551116LLU; | |
12383 | 11705 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12384 | 11706 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12385 | 11707 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12388,7 +11710,7 @@ | ||
12388 | 11710 | state.addr = 819847183514380911LLU; // reportcont |
12389 | 11711 | break; |
12390 | 11712 | } |
12391 | - case 18446744073709551085LLU: // 999999991r''''''''''''''' | |
11713 | + case 18446744073709551116LLU: // 999999992L''''''''''''''' | |
12392 | 11714 | { |
12393 | 11715 | { |
12394 | 11716 | uint64_t arg = 0; |
@@ -12395,17 +11717,17 @@ | ||
12395 | 11717 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12396 | 11718 | } |
12397 | 11719 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*mutable___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)); |
12398 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551084LLU : 18446744073709551083LLU; | |
11720 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551115LLU : 18446744073709551114LLU; | |
12399 | 11721 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
12400 | 11722 | break; |
12401 | 11723 | } |
12402 | - case 18446744073709551084LLU: // 999999991q''''''''''''''' | |
11724 | + case 18446744073709551115LLU: // 999999992K''''''''''''''' | |
12403 | 11725 | { |
12404 | 11726 | fprintf(stderr, "%s", "mut "); |
12405 | - state.addr = 18446744073709551083LLU; // 999999991p''''''''''''''' | |
11727 | + state.addr = 18446744073709551114LLU; // 999999992J''''''''''''''' | |
12406 | 11728 | break; |
12407 | 11729 | } |
12408 | - case 18446744073709551083LLU: // 999999991p''''''''''''''' | |
11730 | + case 18446744073709551114LLU: // 999999992J''''''''''''''' | |
12409 | 11731 | { |
12410 | 11732 | // ACCUMULATE ARGUMENTS - BEGIN |
12411 | 11733 | { |
@@ -12413,7 +11735,7 @@ | ||
12413 | 11735 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12414 | 11736 | } |
12415 | 11737 | // ACCUMULATE ARGUMENTS - END |
12416 | - uint64_t return_to = 18446744073709551082LLU; | |
11738 | + uint64_t return_to = 18446744073709551113LLU; | |
12417 | 11739 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12418 | 11740 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12419 | 11741 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12422,7 +11744,7 @@ | ||
12422 | 11744 | state.addr = 819847183518878432LLU; // reporttype |
12423 | 11745 | break; |
12424 | 11746 | } |
12425 | - case 18446744073709551082LLU: // 999999991o''''''''''''''' | |
11747 | + case 18446744073709551113LLU: // 999999992I''''''''''''''' | |
12426 | 11748 | { |
12427 | 11749 | { |
12428 | 11750 | uint64_t arg = 0; |
@@ -12429,17 +11751,17 @@ | ||
12429 | 11751 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12430 | 11752 | } |
12431 | 11753 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)); |
12432 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551081LLU : 18446744073709551080LLU; | |
11754 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551112LLU : 18446744073709551111LLU; | |
12433 | 11755 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
12434 | 11756 | break; |
12435 | 11757 | } |
12436 | - case 18446744073709551081LLU: // 999999991n''''''''''''''' | |
11758 | + case 18446744073709551112LLU: // 999999992H''''''''''''''' | |
12437 | 11759 | { |
12438 | 11760 | fprintf(stderr, "%s", " #"); |
12439 | - state.addr = 18446744073709551080LLU; // 999999991m''''''''''''''' | |
11761 | + state.addr = 18446744073709551111LLU; // 999999992G''''''''''''''' | |
12440 | 11762 | break; |
12441 | 11763 | } |
12442 | - case 18446744073709551080LLU: // 999999991m''''''''''''''' | |
11764 | + case 18446744073709551111LLU: // 999999992G''''''''''''''' | |
12443 | 11765 | { |
12444 | 11766 | // parameter-reference u64 reference_ goes out of scope |
12445 | 11767 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 5 |
@@ -12479,7 +11801,7 @@ | ||
12479 | 11801 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12480 | 11802 | } |
12481 | 11803 | // ACCUMULATE ARGUMENTS - END |
12482 | - uint64_t return_to = 18446744073709551078LLU; | |
11804 | + uint64_t return_to = 18446744073709551109LLU; | |
12483 | 11805 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12484 | 11806 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12485 | 11807 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12488,7 +11810,7 @@ | ||
12488 | 11810 | state.addr = 819847183518878432LLU; // reporttype |
12489 | 11811 | break; |
12490 | 11812 | } |
12491 | - case 18446744073709551078LLU: // 999999991k''''''''''''''' | |
11813 | + case 18446744073709551109LLU: // 999999992E''''''''''''''' | |
12492 | 11814 | { |
12493 | 11815 | { |
12494 | 11816 | uint64_t arg = 0; |
@@ -12495,22 +11817,22 @@ | ||
12495 | 11817 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12496 | 11818 | } |
12497 | 11819 | *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU)); |
12498 | - state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551077LLU : 18446744073709551076LLU; | |
11820 | + state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551108LLU : 18446744073709551107LLU; | |
12499 | 11821 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12500 | 11822 | break; |
12501 | 11823 | } |
12502 | - case 18446744073709551077LLU: // 999999991j''''''''''''''' | |
11824 | + case 18446744073709551108LLU: // 999999992D''''''''''''''' | |
12503 | 11825 | { |
12504 | - state.addr = 18446744073709551075LLU; // 999999991h''''''''''''''' | |
11826 | + state.addr = 18446744073709551106LLU; // 999999992B''''''''''''''' | |
12505 | 11827 | break; |
12506 | 11828 | } |
12507 | - case 18446744073709551076LLU: // 999999991i''''''''''''''' | |
11829 | + case 18446744073709551107LLU: // 999999992C''''''''''''''' | |
12508 | 11830 | { |
12509 | 11831 | fprintf(stderr, "%s", "#"); |
12510 | - state.addr = 18446744073709551075LLU; // 999999991h''''''''''''''' | |
11832 | + state.addr = 18446744073709551106LLU; // 999999992B''''''''''''''' | |
12511 | 11833 | break; |
12512 | 11834 | } |
12513 | - case 18446744073709551075LLU: // 999999991h''''''''''''''' | |
11835 | + case 18446744073709551106LLU: // 999999992B''''''''''''''' | |
12514 | 11836 | { |
12515 | 11837 | fprintf(stderr, "%s", "("); |
12516 | 11838 | fprintf(stderr, "%llu", (unsigned long long)/*idx_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))); |
@@ -12547,7 +11869,7 @@ | ||
12547 | 11869 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12548 | 11870 | } |
12549 | 11871 | // ACCUMULATE ARGUMENTS - END |
12550 | - uint64_t return_to = 18446744073709551073LLU; | |
11872 | + uint64_t return_to = 18446744073709551104LLU; | |
12551 | 11873 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12552 | 11874 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12553 | 11875 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12556,7 +11878,7 @@ | ||
12556 | 11878 | state.addr = 819847183518878432LLU; // reporttype |
12557 | 11879 | break; |
12558 | 11880 | } |
12559 | - case 18446744073709551073LLU: // 999999991f''''''''''''''' | |
11881 | + case 18446744073709551104LLU: // 999999992_''''''''''''''' | |
12560 | 11882 | { |
12561 | 11883 | fprintf(stderr, "%s", " "); |
12562 | 11884 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))); |
@@ -12581,11 +11903,11 @@ | ||
12581 | 11903 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12582 | 11904 | } |
12583 | 11905 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*safe______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
12584 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551072LLU : 18446744073709551071LLU; | |
11906 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551103LLU : 18446744073709551102LLU; | |
12585 | 11907 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12586 | 11908 | break; |
12587 | 11909 | } |
12588 | - case 18446744073709551072LLU: // 999999991e''''''''''''''' | |
11910 | + case 18446744073709551103LLU: // 9999999919''''''''''''''' | |
12589 | 11911 | { |
12590 | 11912 | { |
12591 | 11913 | uint64_t arg = 0; |
@@ -12592,11 +11914,11 @@ | ||
12592 | 11914 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12593 | 11915 | } |
12594 | 11916 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*finite____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)); |
12595 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551069LLU : 18446744073709551068LLU; | |
11917 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551100LLU : 18446744073709551099LLU; | |
12596 | 11918 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12597 | 11919 | break; |
12598 | 11920 | } |
12599 | - case 18446744073709551069LLU: // 999999991b''''''''''''''' | |
11921 | + case 18446744073709551100LLU: // 9999999916''''''''''''''' | |
12600 | 11922 | { |
12601 | 11923 | { |
12602 | 11924 | uint64_t arg = 0; |
@@ -12603,28 +11925,28 @@ | ||
12603 | 11925 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12604 | 11926 | } |
12605 | 11927 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*complete__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
12606 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551066LLU : 18446744073709551065LLU; | |
11928 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551097LLU : 18446744073709551096LLU; | |
12607 | 11929 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12608 | 11930 | break; |
12609 | 11931 | } |
12610 | - case 18446744073709551066LLU: // 999999991Z''''''''''''''' | |
11932 | + case 18446744073709551097LLU: // 9999999913''''''''''''''' | |
12611 | 11933 | { |
12612 | 11934 | fprintf(stderr, "%s", "total"); |
12613 | - state.addr = 18446744073709551064LLU; // 999999991X''''''''''''''' | |
11935 | + state.addr = 18446744073709551095LLU; // 9999999911''''''''''''''' | |
12614 | 11936 | break; |
12615 | 11937 | } |
12616 | - case 18446744073709551065LLU: // 999999991Y''''''''''''''' | |
11938 | + case 18446744073709551096LLU: // 9999999912''''''''''''''' | |
12617 | 11939 | { |
12618 | 11940 | fprintf(stderr, "%s", "finite"); |
12619 | - state.addr = 18446744073709551064LLU; // 999999991X''''''''''''''' | |
11941 | + state.addr = 18446744073709551095LLU; // 9999999911''''''''''''''' | |
12620 | 11942 | break; |
12621 | 11943 | } |
12622 | - case 18446744073709551064LLU: // 999999991X''''''''''''''' | |
11944 | + case 18446744073709551095LLU: // 9999999911''''''''''''''' | |
12623 | 11945 | { |
12624 | - state.addr = 18446744073709551067LLU; // 999999991$''''''''''''''' | |
11946 | + state.addr = 18446744073709551098LLU; // 9999999914''''''''''''''' | |
12625 | 11947 | break; |
12626 | 11948 | } |
12627 | - case 18446744073709551068LLU: // 999999991a''''''''''''''' | |
11949 | + case 18446744073709551099LLU: // 9999999915''''''''''''''' | |
12628 | 11950 | { |
12629 | 11951 | { |
12630 | 11952 | uint64_t arg = 0; |
@@ -12631,39 +11953,39 @@ | ||
12631 | 11953 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12632 | 11954 | } |
12633 | 11955 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*complete__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
12634 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551063LLU : 18446744073709551062LLU; | |
11956 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551094LLU : 18446744073709551093LLU; | |
12635 | 11957 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12636 | 11958 | break; |
12637 | 11959 | } |
12638 | - case 18446744073709551063LLU: // 999999991W''''''''''''''' | |
11960 | + case 18446744073709551094LLU: // 9999999910''''''''''''''' | |
12639 | 11961 | { |
12640 | 11962 | fprintf(stderr, "%s", "complete"); |
12641 | - state.addr = 18446744073709551061LLU; // 999999991U''''''''''''''' | |
11963 | + state.addr = 18446744073709551092LLU; // 999999991y''''''''''''''' | |
12642 | 11964 | break; |
12643 | 11965 | } |
12644 | - case 18446744073709551062LLU: // 999999991V''''''''''''''' | |
11966 | + case 18446744073709551093LLU: // 999999991z''''''''''''''' | |
12645 | 11967 | { |
12646 | 11968 | fprintf(stderr, "%s", "partial"); |
12647 | - state.addr = 18446744073709551061LLU; // 999999991U''''''''''''''' | |
11969 | + state.addr = 18446744073709551092LLU; // 999999991y''''''''''''''' | |
12648 | 11970 | break; |
12649 | 11971 | } |
12650 | - case 18446744073709551061LLU: // 999999991U''''''''''''''' | |
11972 | + case 18446744073709551092LLU: // 999999991y''''''''''''''' | |
12651 | 11973 | { |
12652 | - state.addr = 18446744073709551067LLU; // 999999991$''''''''''''''' | |
11974 | + state.addr = 18446744073709551098LLU; // 9999999914''''''''''''''' | |
12653 | 11975 | break; |
12654 | 11976 | } |
12655 | - case 18446744073709551067LLU: // 999999991$''''''''''''''' | |
11977 | + case 18446744073709551098LLU: // 9999999914''''''''''''''' | |
12656 | 11978 | { |
12657 | - state.addr = 18446744073709551070LLU; // 999999991c''''''''''''''' | |
11979 | + state.addr = 18446744073709551101LLU; // 9999999917''''''''''''''' | |
12658 | 11980 | break; |
12659 | 11981 | } |
12660 | - case 18446744073709551071LLU: // 999999991d''''''''''''''' | |
11982 | + case 18446744073709551102LLU: // 9999999918''''''''''''''' | |
12661 | 11983 | { |
12662 | 11984 | fprintf(stderr, "%s", "unsafe"); |
12663 | - state.addr = 18446744073709551070LLU; // 999999991c''''''''''''''' | |
11985 | + state.addr = 18446744073709551101LLU; // 9999999917''''''''''''''' | |
12664 | 11986 | break; |
12665 | 11987 | } |
12666 | - case 18446744073709551070LLU: // 999999991c''''''''''''''' | |
11988 | + case 18446744073709551101LLU: // 9999999917''''''''''''''' | |
12667 | 11989 | { |
12668 | 11990 | // parameter-reference u64 safe______ goes out of scope |
12669 | 11991 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference safe______ at 3 |
@@ -12695,7 +12017,7 @@ | ||
12695 | 12017 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12696 | 12018 | } |
12697 | 12019 | // ACCUMULATE ARGUMENTS - END |
12698 | - uint64_t return_to = 18446744073709551060LLU; | |
12020 | + uint64_t return_to = 18446744073709551091LLU; | |
12699 | 12021 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
12700 | 12022 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12701 | 12023 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12704,7 +12026,7 @@ | ||
12704 | 12026 | state.addr = 819847183514344320LLU; // reportcfs_ |
12705 | 12027 | break; |
12706 | 12028 | } |
12707 | - case 18446744073709551060LLU: // 999999991T''''''''''''''' | |
12029 | + case 18446744073709551091LLU: // 999999991x''''''''''''''' | |
12708 | 12030 | { |
12709 | 12031 | fprintf(stderr, "%s", " "); |
12710 | 12032 | fprintf(stderr, "%s", "("); |
@@ -12716,10 +12038,10 @@ | ||
12716 | 12038 | uint64_t arg = 0; |
12717 | 12039 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12718 | 12040 | } |
12719 | - state.addr = 18446744073709551059LLU; // 999999991S''''''''''''''' | |
12041 | + state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
12720 | 12042 | break; |
12721 | 12043 | } |
12722 | - case 18446744073709551059LLU: // 999999991S''''''''''''''' | |
12044 | + case 18446744073709551090LLU: // 999999991w''''''''''''''' | |
12723 | 12045 | { |
12724 | 12046 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
12725 | 12047 | { |
@@ -12726,7 +12048,7 @@ | ||
12726 | 12048 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12727 | 12049 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12728 | 12050 | { |
12729 | - state.addr = 18446744073709551058LLU; // 999999991R''''''''''''''' | |
12051 | + state.addr = 18446744073709551089LLU; // 999999991v''''''''''''''' | |
12730 | 12052 | break; |
12731 | 12053 | } |
12732 | 12054 | } |
@@ -12738,7 +12060,7 @@ | ||
12738 | 12060 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12739 | 12061 | } |
12740 | 12062 | // ACCUMULATE ARGUMENTS - END |
12741 | - uint64_t return_to = 18446744073709551057LLU; | |
12063 | + uint64_t return_to = 18446744073709551088LLU; | |
12742 | 12064 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12743 | 12065 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12744 | 12066 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12747,14 +12069,14 @@ | ||
12747 | 12069 | state.addr = 819847183518272384LLU; // reportres_ |
12748 | 12070 | break; |
12749 | 12071 | } |
12750 | - case 18446744073709551057LLU: // 999999991Q''''''''''''''' | |
12072 | + case 18446744073709551088LLU: // 999999991u''''''''''''''' | |
12751 | 12073 | { |
12752 | 12074 | // parameter-reference resdest___ par_______ goes out of scope |
12753 | 12075 | // parameter-reference function__ kind______ goes out of scope |
12754 | - state.addr = 18446744073709551059LLU; // 999999991S''''''''''''''' | |
12076 | + state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
12755 | 12077 | break; |
12756 | 12078 | } |
12757 | - case 18446744073709551058LLU: // 999999991R''''''''''''''' | |
12079 | + case 18446744073709551089LLU: // 999999991v''''''''''''''' | |
12758 | 12080 | { |
12759 | 12081 | fprintf(stderr, "%s", ") "); |
12760 | 12082 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); |
@@ -12767,10 +12089,10 @@ | ||
12767 | 12089 | uint64_t arg = 0; |
12768 | 12090 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12769 | 12091 | } |
12770 | - state.addr = 18446744073709551056LLU; // 999999991P''''''''''''''' | |
12092 | + state.addr = 18446744073709551087LLU; // 999999991t''''''''''''''' | |
12771 | 12093 | break; |
12772 | 12094 | } |
12773 | - case 18446744073709551056LLU: // 999999991P''''''''''''''' | |
12095 | + case 18446744073709551087LLU: // 999999991t''''''''''''''' | |
12774 | 12096 | { |
12775 | 12097 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
12776 | 12098 | { |
@@ -12777,7 +12099,7 @@ | ||
12777 | 12099 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12778 | 12100 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12779 | 12101 | { |
12780 | - state.addr = 18446744073709551055LLU; // 999999991O''''''''''''''' | |
12102 | + state.addr = 18446744073709551086LLU; // 999999991s''''''''''''''' | |
12781 | 12103 | break; |
12782 | 12104 | } |
12783 | 12105 | } |
@@ -12789,7 +12111,7 @@ | ||
12789 | 12111 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12790 | 12112 | } |
12791 | 12113 | // ACCUMULATE ARGUMENTS - END |
12792 | - uint64_t return_to = 18446744073709551054LLU; | |
12114 | + uint64_t return_to = 18446744073709551085LLU; | |
12793 | 12115 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12794 | 12116 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12795 | 12117 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12798,15 +12120,15 @@ | ||
12798 | 12120 | state.addr = 819847183517731648LLU; // reportpar_ |
12799 | 12121 | break; |
12800 | 12122 | } |
12801 | - case 18446744073709551054LLU: // 999999991N''''''''''''''' | |
12123 | + case 18446744073709551085LLU: // 999999991r''''''''''''''' | |
12802 | 12124 | { |
12803 | 12125 | fprintf(stderr, "%s", " "); |
12804 | 12126 | // parameter-reference pardef____ par_______ goes out of scope |
12805 | 12127 | // parameter-reference function__ kind______ goes out of scope |
12806 | - state.addr = 18446744073709551056LLU; // 999999991P''''''''''''''' | |
12128 | + state.addr = 18446744073709551087LLU; // 999999991t''''''''''''''' | |
12807 | 12129 | break; |
12808 | 12130 | } |
12809 | - case 18446744073709551055LLU: // 999999991O''''''''''''''' | |
12131 | + case 18446744073709551086LLU: // 999999991s''''''''''''''' | |
12810 | 12132 | { |
12811 | 12133 | fprintf(stderr, "%s", ") "); |
12812 | 12134 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -12815,7 +12137,7 @@ | ||
12815 | 12137 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12816 | 12138 | } |
12817 | 12139 | // ACCUMULATE ARGUMENTS - END |
12818 | - uint64_t return_to = 18446744073709551053LLU; | |
12140 | + uint64_t return_to = 18446744073709551084LLU; | |
12819 | 12141 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12820 | 12142 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12821 | 12143 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12824,7 +12146,7 @@ | ||
12824 | 12146 | state.addr = 819847183517274112LLU; // reportnr__ |
12825 | 12147 | break; |
12826 | 12148 | } |
12827 | - case 18446744073709551053LLU: // 999999991M''''''''''''''' | |
12149 | + case 18446744073709551084LLU: // 999999991q''''''''''''''' | |
12828 | 12150 | { |
12829 | 12151 | fprintf(stderr, "%s", " "); |
12830 | 12152 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -12833,7 +12155,7 @@ | ||
12833 | 12155 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12834 | 12156 | } |
12835 | 12157 | // ACCUMULATE ARGUMENTS - END |
12836 | - uint64_t return_to = 18446744073709551052LLU; | |
12158 | + uint64_t return_to = 18446744073709551083LLU; | |
12837 | 12159 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12838 | 12160 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12839 | 12161 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12842,7 +12164,7 @@ | ||
12842 | 12164 | state.addr = 819847183517274112LLU; // reportnr__ |
12843 | 12165 | break; |
12844 | 12166 | } |
12845 | - case 18446744073709551052LLU: // 999999991L''''''''''''''' | |
12167 | + case 18446744073709551083LLU: // 999999991p''''''''''''''' | |
12846 | 12168 | { |
12847 | 12169 | fprintf(stderr, "%s", " "); |
12848 | 12170 | { |
@@ -12850,23 +12172,23 @@ | ||
12850 | 12172 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12851 | 12173 | } |
12852 | 12174 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*defined___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
12853 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551051LLU : 18446744073709551050LLU; | |
12175 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551082LLU : 18446744073709551081LLU; | |
12854 | 12176 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12855 | 12177 | break; |
12856 | 12178 | } |
12857 | - case 18446744073709551051LLU: // 999999991K''''''''''''''' | |
12179 | + case 18446744073709551082LLU: // 999999991o''''''''''''''' | |
12858 | 12180 | { |
12859 | 12181 | fprintf(stderr, "%s", "DEFINITION"); |
12860 | - state.addr = 18446744073709551049LLU; // 999999991I''''''''''''''' | |
12182 | + state.addr = 18446744073709551080LLU; // 999999991m''''''''''''''' | |
12861 | 12183 | break; |
12862 | 12184 | } |
12863 | - case 18446744073709551050LLU: // 999999991J''''''''''''''' | |
12185 | + case 18446744073709551081LLU: // 999999991n''''''''''''''' | |
12864 | 12186 | { |
12865 | 12187 | fprintf(stderr, "%s", "DECLARATION"); |
12866 | - state.addr = 18446744073709551049LLU; // 999999991I''''''''''''''' | |
12188 | + state.addr = 18446744073709551080LLU; // 999999991m''''''''''''''' | |
12867 | 12189 | break; |
12868 | 12190 | } |
12869 | - case 18446744073709551049LLU: // 999999991I''''''''''''''' | |
12191 | + case 18446744073709551080LLU: // 999999991m''''''''''''''' | |
12870 | 12192 | { |
12871 | 12193 | fprintf(stderr, "%s", " <- possibly REVERSED parameters!"); |
12872 | 12194 | fprintf(stderr, "%s", "\n"); |
@@ -12894,10 +12216,10 @@ | ||
12894 | 12216 | uint64_t arg = 0; |
12895 | 12217 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12896 | 12218 | } |
12897 | - state.addr = 18446744073709551048LLU; // 999999991H''''''''''''''' | |
12219 | + state.addr = 18446744073709551079LLU; // 999999991l''''''''''''''' | |
12898 | 12220 | break; |
12899 | 12221 | } |
12900 | - case 18446744073709551048LLU: // 999999991H''''''''''''''' | |
12222 | + case 18446744073709551079LLU: // 999999991l''''''''''''''' | |
12901 | 12223 | { |
12902 | 12224 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)) |
12903 | 12225 | { |
@@ -12904,7 +12226,7 @@ | ||
12904 | 12226 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12905 | 12227 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
12906 | 12228 | { |
12907 | - state.addr = 18446744073709551047LLU; // 999999991G''''''''''''''' | |
12229 | + state.addr = 18446744073709551078LLU; // 999999991k''''''''''''''' | |
12908 | 12230 | break; |
12909 | 12231 | } |
12910 | 12232 | } |
@@ -12924,7 +12246,7 @@ | ||
12924 | 12246 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12925 | 12247 | } |
12926 | 12248 | // ACCUMULATE ARGUMENTS - END |
12927 | - uint64_t return_to = 18446744073709551046LLU; | |
12249 | + uint64_t return_to = 18446744073709551077LLU; | |
12928 | 12250 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
12929 | 12251 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12930 | 12252 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12933,14 +12255,14 @@ | ||
12933 | 12255 | state.addr = 819847183514601536LLU; // reportdef_ |
12934 | 12256 | break; |
12935 | 12257 | } |
12936 | - case 18446744073709551046LLU: // 999999991F''''''''''''''' | |
12258 | + case 18446744073709551077LLU: // 999999991j''''''''''''''' | |
12937 | 12259 | { |
12938 | 12260 | // parameter-reference defidfn___ def_______ goes out of scope |
12939 | 12261 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
12940 | - state.addr = 18446744073709551048LLU; // 999999991H''''''''''''''' | |
12262 | + state.addr = 18446744073709551079LLU; // 999999991l''''''''''''''' | |
12941 | 12263 | break; |
12942 | 12264 | } |
12943 | - case 18446744073709551047LLU: // 999999991G''''''''''''''' | |
12265 | + case 18446744073709551078LLU: // 999999991k''''''''''''''' | |
12944 | 12266 | { |
12945 | 12267 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
12946 | 12268 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fndefs____ at 2 |
@@ -12974,10 +12296,10 @@ | ||
12974 | 12296 | uint64_t arg = 0; |
12975 | 12297 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12976 | 12298 | } |
12977 | - state.addr = 18446744073709551044LLU; // 999999991D''''''''''''''' | |
12299 | + state.addr = 18446744073709551075LLU; // 999999991h''''''''''''''' | |
12978 | 12300 | break; |
12979 | 12301 | } |
12980 | - case 18446744073709551044LLU: // 999999991D''''''''''''''' | |
12302 | + case 18446744073709551075LLU: // 999999991h''''''''''''''' | |
12981 | 12303 | { |
12982 | 12304 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
12983 | 12305 | { |
@@ -12984,7 +12306,7 @@ | ||
12984 | 12306 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12985 | 12307 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12986 | 12308 | { |
12987 | - state.addr = 18446744073709551043LLU; // 999999991C''''''''''''''' | |
12309 | + state.addr = 18446744073709551074LLU; // 999999991g''''''''''''''' | |
12988 | 12310 | break; |
12989 | 12311 | } |
12990 | 12312 | } |
@@ -12999,7 +12321,7 @@ | ||
12999 | 12321 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13000 | 12322 | } |
13001 | 12323 | // ACCUMULATE ARGUMENTS - END |
13002 | - uint64_t return_to = 18446744073709551042LLU; | |
12324 | + uint64_t return_to = 18446744073709551073LLU; | |
13003 | 12325 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13004 | 12326 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13005 | 12327 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13008,14 +12330,14 @@ | ||
13008 | 12330 | state.addr = 819847183518878432LLU; // reporttype |
13009 | 12331 | break; |
13010 | 12332 | } |
13011 | - case 18446744073709551042LLU: // 999999991B''''''''''''''' | |
12333 | + case 18446744073709551073LLU: // 999999991f''''''''''''''' | |
13012 | 12334 | { |
13013 | 12335 | // parameter-reference elemdef___ elem______ goes out of scope |
13014 | 12336 | // parameter-reference list<elemdef___> elems_____ goes out of scope |
13015 | - state.addr = 18446744073709551044LLU; // 999999991D''''''''''''''' | |
12337 | + state.addr = 18446744073709551075LLU; // 999999991h''''''''''''''' | |
13016 | 12338 | break; |
13017 | 12339 | } |
13018 | - case 18446744073709551043LLU: // 999999991C''''''''''''''' | |
12340 | + case 18446744073709551074LLU: // 999999991g''''''''''''''' | |
13019 | 12341 | { |
13020 | 12342 | fprintf(stderr, "%s", ")"); |
13021 | 12343 | // parameter-reference list<elemdef___> elems_____ goes out of scope |
@@ -13036,7 +12358,7 @@ | ||
13036 | 12358 | { |
13037 | 12359 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*tkstruct__*/) |
13038 | 12360 | { |
13039 | - state.addr = 18446744073709551041LLU; // 999999991A''''''''''''''' | |
12361 | + state.addr = 18446744073709551072LLU; // 999999991e''''''''''''''' | |
13040 | 12362 | break; |
13041 | 12363 | } |
13042 | 12364 | { |
@@ -13058,10 +12380,10 @@ | ||
13058 | 12380 | uint64_t arg = 0; |
13059 | 12381 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
13060 | 12382 | } |
13061 | - state.addr = 18446744073709551040LLU; // 999999991_''''''''''''''' | |
12383 | + state.addr = 18446744073709551071LLU; // 999999991d''''''''''''''' | |
13062 | 12384 | break; |
13063 | 12385 | } |
13064 | - case 18446744073709551040LLU: // 999999991_''''''''''''''' | |
12386 | + case 18446744073709551071LLU: // 999999991d''''''''''''''' | |
13065 | 12387 | { |
13066 | 12388 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
13067 | 12389 | { |
@@ -13068,7 +12390,7 @@ | ||
13068 | 12390 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
13069 | 12391 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
13070 | 12392 | { |
13071 | - state.addr = 18446744073709551039LLU; // 9999999909''''''''''''''' | |
12393 | + state.addr = 18446744073709551070LLU; // 999999991c''''''''''''''' | |
13072 | 12394 | break; |
13073 | 12395 | } |
13074 | 12396 | } |
@@ -13080,7 +12402,7 @@ | ||
13080 | 12402 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13081 | 12403 | } |
13082 | 12404 | // ACCUMULATE ARGUMENTS - END |
13083 | - uint64_t return_to = 18446744073709551038LLU; | |
12405 | + uint64_t return_to = 18446744073709551069LLU; | |
13084 | 12406 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13085 | 12407 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13086 | 12408 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13089,15 +12411,15 @@ | ||
13089 | 12411 | state.addr = 819847183514892328LLU; // reportelem |
13090 | 12412 | break; |
13091 | 12413 | } |
13092 | - case 18446744073709551038LLU: // 9999999908''''''''''''''' | |
12414 | + case 18446744073709551069LLU: // 999999991b''''''''''''''' | |
13093 | 12415 | { |
13094 | 12416 | fprintf(stderr, "%s", " "); |
13095 | 12417 | // parameter-reference elemdef___ par_______ goes out of scope |
13096 | 12418 | // parameter-reference list<elemdef___> defpars___ goes out of scope |
13097 | - state.addr = 18446744073709551040LLU; // 999999991_''''''''''''''' | |
12419 | + state.addr = 18446744073709551071LLU; // 999999991d''''''''''''''' | |
13098 | 12420 | break; |
13099 | 12421 | } |
13100 | - case 18446744073709551039LLU: // 9999999909''''''''''''''' | |
12422 | + case 18446744073709551070LLU: // 999999991c''''''''''''''' | |
13101 | 12423 | { |
13102 | 12424 | fprintf(stderr, "%s", ");"); |
13103 | 12425 | // parameter-reference list<elemdef___> defpars___ goes out of scope |
@@ -13116,11 +12438,11 @@ | ||
13116 | 12438 | } |
13117 | 12439 | break; |
13118 | 12440 | } |
13119 | - case 18446744073709551041LLU: // 999999991A''''''''''''''' | |
12441 | + case 18446744073709551072LLU: // 999999991e''''''''''''''' | |
13120 | 12442 | { |
13121 | 12443 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*tkunion___*/) |
13122 | 12444 | { |
13123 | - state.addr = 18446744073709551037LLU; // 9999999907''''''''''''''' | |
12445 | + state.a |
Part of diff was cut off due to size limit. Use your local client to view the full diff.