• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1172 (tree)
Time2021-02-24 08:03:28
Authorjakobthomsen

Log Message

fix including results into deleter-chain on exception after successful function-call

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1171)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1172)
@@ -863,10 +863,46 @@
863863 //#define res0 0
864864 //#define res1 1
865865 //#define arg0 2
866+ label = 6LLU; // skip deleter
867+ break;
868+ }
869+ case 5LLU: // deleter
870+ {
871+ // throw from ParseToken
872+ if(!stack[base + 3])
873+ {
874+ fprintf(stderr, "in function ParseToken: unrolling stack, skipping already deleted/unscoped variable u64 variant\n");
875+ label = 4LLU; // skip, variable already deleted/unscoped
876+ break;
877+ }
878+ fprintf(stderr, "in function ParseToken: unrolling stack, variable u64 variant\n");
879+ label = 4LLU; // continue unrolling stack, delete next variable
880+ break;
881+ }
882+ case 6LLU: // skipped deleter
883+ {
884+ label = 8LLU; // skip deleter
885+ break;
886+ }
887+ case 7LLU: // deleter
888+ {
889+ // throw from ParseToken
890+ if(!stack[base + 4])
891+ {
892+ fprintf(stderr, "in function ParseToken: unrolling stack, skipping already deleted/unscoped variable u64 content\n");
893+ label = 5LLU; // skip, variable already deleted/unscoped
894+ break;
895+ }
896+ fprintf(stderr, "in function ParseToken: unrolling stack, variable u64 content\n");
897+ label = 5LLU; // continue unrolling stack, delete next variable
898+ break;
899+ }
900+ case 8LLU: // skipped deleter
901+ {
866902 // call PARSETOKEN from ParseToken
867- stack[base + 5LLU] = 5LLU/*throw to this address*/;
903+ stack[base + 5LLU] = 9LLU/*throw to this address*/;
868904 stack[base + 6LLU] = base;
869- stack[base + 7LLU] = 6LLU;
905+ stack[base + 7LLU] = 10LLU;
870906 // arguments for call to PARSETOKEN
871907 stack[base + 10LLU] = stack[base + 2]/*lookahead*/;
872908 // set stack-base & callee-address
@@ -874,7 +910,7 @@
874910 label = 18446744073709551584LLU; // PARSETOKEN
875911 break;
876912 }
877- case 5LLU: // copy-back deleter (PARSETOKEN to ParseToken)
913+ case 9LLU: // copy-back deleter (PARSETOKEN to ParseToken)
878914 {
879915 fprintf(stderr, "in function ParseToken: unrolling stack, copy-back (PARSETOKEN to ParseToken)\n");
880916 // copy mutable arguments back from call to PARSETOKEN
@@ -881,7 +917,7 @@
881917 label = 4LLU; // continue to roll stack
882918 break;
883919 }
884- case 6LLU: // return from PARSETOKEN to ParseToken
920+ case 10LLU: // return from PARSETOKEN to ParseToken
885921 {
886922 // copy mutable arguments back from call to PARSETOKEN
887923 // copy back results provided by call to PARSETOKEN
@@ -888,9 +924,9 @@
888924 stack[base + 3] = stack[base + 8LLU];
889925 stack[base + 4] = stack[base + 9LLU];
890926 // call getbyte from ParseToken
891- stack[base + 5LLU] = 7LLU/*throw to this address*/;
927+ stack[base + 5LLU] = 11LLU/*throw to this address*/;
892928 stack[base + 6LLU] = base;
893- stack[base + 7LLU] = 8LLU;
929+ stack[base + 7LLU] = 12LLU;
894930 // arguments for call to getbyte
895931 // set stack-base & callee-address
896932 base += 8LLU;
@@ -897,54 +933,54 @@
897933 label = 18446744073709551593LLU; // getbyte
898934 break;
899935 }
900- case 7LLU: // copy-back deleter (getbyte to ParseToken)
936+ case 11LLU: // copy-back deleter (getbyte to ParseToken)
901937 {
902938 fprintf(stderr, "in function ParseToken: unrolling stack, copy-back (getbyte to ParseToken)\n");
903939 // copy mutable arguments back from call to getbyte
904- label = 4LLU; // continue to roll stack
940+ label = 7LLU; // continue to roll stack
905941 break;
906942 }
907- case 8LLU: // return from getbyte to ParseToken
943+ case 12LLU: // return from getbyte to ParseToken
908944 {
909945 // copy mutable arguments back from call to getbyte
910946 // copy back results provided by call to getbyte
911947 stack[base + 2] = stack[base + 8LLU];
912- label = 10LLU; // skip deleter
948+ label = 14LLU; // skip deleter
913949 break;
914950 }
915- case 9LLU: // deleter
951+ case 13LLU: // deleter
916952 {
917953 // throw from ParseToken
918954 if(!stack[base + 0])
919955 {
920956 fprintf(stderr, "in function ParseToken: unrolling stack, skipping already deleted/unscoped variable u64 \n");
921- label = 4LLU; // skip, variable already deleted/unscoped
957+ label = 7LLU; // skip, variable already deleted/unscoped
922958 break;
923959 }
924960 fprintf(stderr, "in function ParseToken: unrolling stack, variable u64 \n");
925- label = 4LLU; // continue unrolling stack, delete next variable
961+ label = 7LLU; // continue unrolling stack, delete next variable
926962 break;
927963 }
928- case 10LLU: // skipped deleter
964+ case 14LLU: // skipped deleter
929965 {
930966 stack[base + 0] = stack[base + 3]/*variant*/;
931- label = 12LLU; // skip deleter
967+ label = 16LLU; // skip deleter
932968 break;
933969 }
934- case 11LLU: // deleter
970+ case 15LLU: // deleter
935971 {
936972 // throw from ParseToken
937973 if(!stack[base + 1])
938974 {
939975 fprintf(stderr, "in function ParseToken: unrolling stack, skipping already deleted/unscoped variable u64 \n");
940- label = 9LLU; // skip, variable already deleted/unscoped
976+ label = 13LLU; // skip, variable already deleted/unscoped
941977 break;
942978 }
943979 fprintf(stderr, "in function ParseToken: unrolling stack, variable u64 \n");
944- label = 9LLU; // continue unrolling stack, delete next variable
980+ label = 13LLU; // continue unrolling stack, delete next variable
945981 break;
946982 }
947- case 12LLU: // skipped deleter
983+ case 16LLU: // skipped deleter
948984 {
949985 stack[base + 1] = stack[base + 4]/*content*/;
950986 // return from ParseToken
@@ -952,7 +988,7 @@
952988 base = stack[base - 2];
953989 break;
954990 }
955- case 14LLU: // function DELIMITER failed
991+ case 18LLU: // function DELIMITER failed
956992 {
957993 fprintf(stderr, "function DELIMITER failed\n");
958994 label = stack[base - 3];
@@ -959,14 +995,14 @@
959995 base = stack[base - 2];
960996 break;
961997 }
962- case 13LLU: // DELIMITER
998+ case 17LLU: // DELIMITER
963999 {
9641000 //#define arg0 0
9651001 //#define arg1 1
9661002 // call skipwscmnt from DELIMITER
967- stack[base + 2LLU] = 15LLU/*throw to this address*/;
1003+ stack[base + 2LLU] = 19LLU/*throw to this address*/;
9681004 stack[base + 3LLU] = base;
969- stack[base + 4LLU] = 16LLU;
1005+ stack[base + 4LLU] = 20LLU;
9701006 // arguments for call to skipwscmnt
9711007 stack[base + 6LLU] = stack[base + 1]/*lookahead*/;
9721008 // set stack-base & callee-address
@@ -974,22 +1010,40 @@
9741010 label = 18446744073709551580LLU; // skipwscmnt
9751011 break;
9761012 }
977- case 15LLU: // copy-back deleter (skipwscmnt to DELIMITER)
1013+ case 19LLU: // copy-back deleter (skipwscmnt to DELIMITER)
9781014 {
9791015 fprintf(stderr, "in function DELIMITER: unrolling stack, copy-back (skipwscmnt to DELIMITER)\n");
9801016 // copy mutable arguments back from call to skipwscmnt
981- label = 14LLU; // continue to roll stack
1017+ label = 18LLU; // continue to roll stack
9821018 break;
9831019 }
984- case 16LLU: // return from skipwscmnt to DELIMITER
1020+ case 20LLU: // return from skipwscmnt to DELIMITER
9851021 {
9861022 // copy mutable arguments back from call to skipwscmnt
9871023 // copy back results provided by call to skipwscmnt
9881024 stack[base + 1] = stack[base + 5LLU];
1025+ label = 22LLU; // skip deleter
1026+ break;
1027+ }
1028+ case 21LLU: // deleter
1029+ {
1030+ // throw from DELIMITER
1031+ if(!stack[base + 2])
1032+ {
1033+ fprintf(stderr, "in function DELIMITER: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1034+ label = 18LLU; // skip, variable already deleted/unscoped
1035+ break;
1036+ }
1037+ fprintf(stderr, "in function DELIMITER: unrolling stack, variable u64 isequal\n");
1038+ label = 18LLU; // continue unrolling stack, delete next variable
1039+ break;
1040+ }
1041+ case 22LLU: // skipped deleter
1042+ {
9891043 // call equ from DELIMITER
990- stack[base + 3LLU] = 17LLU/*throw to this address*/;
1044+ stack[base + 3LLU] = 23LLU/*throw to this address*/;
9911045 stack[base + 4LLU] = base;
992- stack[base + 5LLU] = 18LLU;
1046+ stack[base + 5LLU] = 24LLU;
9931047 // arguments for call to equ
9941048 stack[base + 7LLU] = 59LLU;
9951049 stack[base + 8LLU] = stack[base + 1]/*lookahead*/;
@@ -998,14 +1052,14 @@
9981052 label = 18446744073709551600LLU; // equ
9991053 break;
10001054 }
1001- case 17LLU: // copy-back deleter (equ to DELIMITER)
1055+ case 23LLU: // copy-back deleter (equ to DELIMITER)
10021056 {
10031057 fprintf(stderr, "in function DELIMITER: unrolling stack, copy-back (equ to DELIMITER)\n");
10041058 // copy mutable arguments back from call to equ
1005- label = 14LLU; // continue to roll stack
1059+ label = 18LLU; // continue to roll stack
10061060 break;
10071061 }
1008- case 18LLU: // return from equ to DELIMITER
1062+ case 24LLU: // return from equ to DELIMITER
10091063 {
10101064 // copy mutable arguments back from call to equ
10111065 // copy back results provided by call to equ
@@ -1012,21 +1066,21 @@
10121066 stack[base + 2] = stack[base + 6LLU];
10131067 if(!stack[base + 2]/*isequal*/)
10141068 {
1015- label = 19LLU; // jump to alternative
1069+ label = 25LLU; // jump to alternative
10161070 break;
10171071 }
10181072
10191073 // consequent
1020- label = 20LLU; // consequent complete
1074+ label = 26LLU; // consequent complete
10211075 break;
10221076 }
1023- case 19LLU: // alternative
1077+ case 25LLU: // alternative
10241078 {
10251079 fprintf(stderr, "%s", "in function ");
10261080 // call reportid from DELIMITER
1027- stack[base + 3LLU] = 21LLU/*throw to this address*/;
1081+ stack[base + 3LLU] = 27LLU/*throw to this address*/;
10281082 stack[base + 4LLU] = base;
1029- stack[base + 5LLU] = 22LLU;
1083+ stack[base + 5LLU] = 28LLU;
10301084 // arguments for call to reportid
10311085 stack[base + 6LLU] = stack[base + 0]/*fnid*/;
10321086 // set stack-base & callee-address
@@ -1034,22 +1088,22 @@
10341088 label = 18446744073709551586LLU; // reportid
10351089 break;
10361090 }
1037- case 21LLU: // copy-back deleter (reportid to DELIMITER)
1091+ case 27LLU: // copy-back deleter (reportid to DELIMITER)
10381092 {
10391093 fprintf(stderr, "in function DELIMITER: unrolling stack, copy-back (reportid to DELIMITER)\n");
10401094 // copy mutable arguments back from call to reportid
1041- label = 14LLU; // continue to roll stack
1095+ label = 21LLU; // continue to roll stack
10421096 break;
10431097 }
1044- case 22LLU: // return from reportid to DELIMITER
1098+ case 28LLU: // return from reportid to DELIMITER
10451099 {
10461100 // copy mutable arguments back from call to reportid
10471101 fprintf(stderr, "%s", " missing ';'\n");
10481102 exit(-1);
1049- label = 20LLU; // alternative complete
1103+ label = 26LLU; // alternative complete
10501104 break;
10511105 }
1052- case 20LLU: // completed if-then-else
1106+ case 26LLU: // completed if-then-else
10531107 {
10541108 // return from DELIMITER
10551109 label = stack[base - 1];
@@ -1056,7 +1110,7 @@
10561110 base = stack[base - 2];
10571111 break;
10581112 }
1059- case 24LLU: // function delimiter failed
1113+ case 30LLU: // function delimiter failed
10601114 {
10611115 fprintf(stderr, "function delimiter failed\n");
10621116 label = stack[base - 3];
@@ -1063,38 +1117,38 @@
10631117 base = stack[base - 2];
10641118 break;
10651119 }
1066- case 23LLU: // delimiter
1120+ case 29LLU: // delimiter
10671121 {
10681122 //#define arg0 0
10691123 //#define arg1 1
10701124 // call DELIMITER from delimiter
1071- stack[base + 2LLU] = 25LLU/*throw to this address*/;
1125+ stack[base + 2LLU] = 31LLU/*throw to this address*/;
10721126 stack[base + 3LLU] = base;
1073- stack[base + 4LLU] = 26LLU;
1127+ stack[base + 4LLU] = 32LLU;
10741128 // arguments for call to DELIMITER
10751129 stack[base + 5LLU] = stack[base + 0]/*fnid*/;
10761130 stack[base + 6LLU] = stack[base + 1]/*lookahead*/;
10771131 // set stack-base & callee-address
10781132 base += 5LLU;
1079- label = 13LLU; // DELIMITER
1133+ label = 17LLU; // DELIMITER
10801134 break;
10811135 }
1082- case 25LLU: // copy-back deleter (DELIMITER to delimiter)
1136+ case 31LLU: // copy-back deleter (DELIMITER to delimiter)
10831137 {
10841138 fprintf(stderr, "in function delimiter: unrolling stack, copy-back (DELIMITER to delimiter)\n");
10851139 // copy mutable arguments back from call to DELIMITER
10861140 stack[base + 1]/*lookahead*/ = stack[base + 6LLU];
1087- label = 24LLU; // continue to roll stack
1141+ label = 30LLU; // continue to roll stack
10881142 break;
10891143 }
1090- case 26LLU: // return from DELIMITER to delimiter
1144+ case 32LLU: // return from DELIMITER to delimiter
10911145 {
10921146 // copy mutable arguments back from call to DELIMITER
10931147 stack[base + 1]/*lookahead*/ = stack[base + 6LLU];
10941148 // call getbyte from delimiter
1095- stack[base + 2LLU] = 27LLU/*throw to this address*/;
1149+ stack[base + 2LLU] = 33LLU/*throw to this address*/;
10961150 stack[base + 3LLU] = base;
1097- stack[base + 4LLU] = 28LLU;
1151+ stack[base + 4LLU] = 34LLU;
10981152 // arguments for call to getbyte
10991153 // set stack-base & callee-address
11001154 base += 5LLU;
@@ -1101,14 +1155,14 @@
11011155 label = 18446744073709551593LLU; // getbyte
11021156 break;
11031157 }
1104- case 27LLU: // copy-back deleter (getbyte to delimiter)
1158+ case 33LLU: // copy-back deleter (getbyte to delimiter)
11051159 {
11061160 fprintf(stderr, "in function delimiter: unrolling stack, copy-back (getbyte to delimiter)\n");
11071161 // copy mutable arguments back from call to getbyte
1108- label = 24LLU; // continue to roll stack
1162+ label = 30LLU; // continue to roll stack
11091163 break;
11101164 }
1111- case 28LLU: // return from getbyte to delimiter
1165+ case 34LLU: // return from getbyte to delimiter
11121166 {
11131167 // copy mutable arguments back from call to getbyte
11141168 // copy back results provided by call to getbyte
@@ -1118,7 +1172,7 @@
11181172 base = stack[base - 2];
11191173 break;
11201174 }
1121- case 30LLU: // function isalpha failed
1175+ case 36LLU: // function isalpha failed
11221176 {
11231177 fprintf(stderr, "function isalpha failed\n");
11241178 label = stack[base - 3];
@@ -1125,33 +1179,33 @@
11251179 base = stack[base - 2];
11261180 break;
11271181 }
1128- case 29LLU: // isalpha
1182+ case 35LLU: // isalpha
11291183 {
11301184 //#define res0 0
11311185 //#define arg0 1
1132- label = 32LLU; // skip deleter
1186+ label = 38LLU; // skip deleter
11331187 break;
11341188 }
1135- case 31LLU: // deleter
1189+ case 37LLU: // deleter
11361190 {
11371191 // throw from isalpha
11381192 if(!stack[base + 2])
11391193 {
11401194 fprintf(stderr, "in function isalpha: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1141- label = 30LLU; // skip, variable already deleted/unscoped
1195+ label = 36LLU; // skip, variable already deleted/unscoped
11421196 break;
11431197 }
11441198 fprintf(stderr, "in function isalpha: unrolling stack, variable u64 isequal\n");
1145- label = 30LLU; // continue unrolling stack, delete next variable
1199+ label = 36LLU; // continue unrolling stack, delete next variable
11461200 break;
11471201 }
1148- case 32LLU: // skipped deleter
1202+ case 38LLU: // skipped deleter
11491203 {
11501204 stack[base + 2] = 0;
11511205 // call geq from isalpha
1152- stack[base + 3LLU] = 33LLU/*throw to this address*/;
1206+ stack[base + 3LLU] = 39LLU/*throw to this address*/;
11531207 stack[base + 4LLU] = base;
1154- stack[base + 5LLU] = 34LLU;
1208+ stack[base + 5LLU] = 40LLU;
11551209 // arguments for call to geq
11561210 stack[base + 7LLU] = stack[base + 1]/*c*/;
11571211 stack[base + 8LLU] = 97LLU;
@@ -1160,14 +1214,14 @@
11601214 label = 18446744073709551596LLU; // geq
11611215 break;
11621216 }
1163- case 33LLU: // copy-back deleter (geq to isalpha)
1217+ case 39LLU: // copy-back deleter (geq to isalpha)
11641218 {
11651219 fprintf(stderr, "in function isalpha: unrolling stack, copy-back (geq to isalpha)\n");
11661220 // copy mutable arguments back from call to geq
1167- label = 31LLU; // continue to roll stack
1221+ label = 37LLU; // continue to roll stack
11681222 break;
11691223 }
1170- case 34LLU: // return from geq to isalpha
1224+ case 40LLU: // return from geq to isalpha
11711225 {
11721226 // copy mutable arguments back from call to geq
11731227 // copy back results provided by call to geq
@@ -1174,15 +1228,15 @@
11741228 stack[base + 2] = stack[base + 6LLU];
11751229 if(!stack[base + 2]/*isequal*/)
11761230 {
1177- label = 35LLU; // jump to alternative
1231+ label = 41LLU; // jump to alternative
11781232 break;
11791233 }
11801234
11811235 // consequent
11821236 // call leq from isalpha
1183- stack[base + 3LLU] = 37LLU/*throw to this address*/;
1237+ stack[base + 3LLU] = 43LLU/*throw to this address*/;
11841238 stack[base + 4LLU] = base;
1185- stack[base + 5LLU] = 38LLU;
1239+ stack[base + 5LLU] = 44LLU;
11861240 // arguments for call to leq
11871241 stack[base + 7LLU] = stack[base + 1]/*c*/;
11881242 stack[base + 8LLU] = 122LLU;
@@ -1191,27 +1245,27 @@
11911245 label = 18446744073709551598LLU; // leq
11921246 break;
11931247 }
1194- case 37LLU: // copy-back deleter (leq to isalpha)
1248+ case 43LLU: // copy-back deleter (leq to isalpha)
11951249 {
11961250 fprintf(stderr, "in function isalpha: unrolling stack, copy-back (leq to isalpha)\n");
11971251 // copy mutable arguments back from call to leq
1198- label = 31LLU; // continue to roll stack
1252+ label = 37LLU; // continue to roll stack
11991253 break;
12001254 }
1201- case 38LLU: // return from leq to isalpha
1255+ case 44LLU: // return from leq to isalpha
12021256 {
12031257 // copy mutable arguments back from call to leq
12041258 // copy back results provided by call to leq
12051259 stack[base + 0] = stack[base + 6LLU];
1206- label = 36LLU; // consequent complete
1260+ label = 42LLU; // consequent complete
12071261 break;
12081262 }
1209- case 35LLU: // alternative
1263+ case 41LLU: // alternative
12101264 {
12111265 // call geq from isalpha
1212- stack[base + 3LLU] = 39LLU/*throw to this address*/;
1266+ stack[base + 3LLU] = 45LLU/*throw to this address*/;
12131267 stack[base + 4LLU] = base;
1214- stack[base + 5LLU] = 40LLU;
1268+ stack[base + 5LLU] = 46LLU;
12151269 // arguments for call to geq
12161270 stack[base + 7LLU] = stack[base + 1]/*c*/;
12171271 stack[base + 8LLU] = 65LLU;
@@ -1220,14 +1274,14 @@
12201274 label = 18446744073709551596LLU; // geq
12211275 break;
12221276 }
1223- case 39LLU: // copy-back deleter (geq to isalpha)
1277+ case 45LLU: // copy-back deleter (geq to isalpha)
12241278 {
12251279 fprintf(stderr, "in function isalpha: unrolling stack, copy-back (geq to isalpha)\n");
12261280 // copy mutable arguments back from call to geq
1227- label = 31LLU; // continue to roll stack
1281+ label = 37LLU; // continue to roll stack
12281282 break;
12291283 }
1230- case 40LLU: // return from geq to isalpha
1284+ case 46LLU: // return from geq to isalpha
12311285 {
12321286 // copy mutable arguments back from call to geq
12331287 // copy back results provided by call to geq
@@ -1234,15 +1288,15 @@
12341288 stack[base + 2] = stack[base + 6LLU];
12351289 if(!stack[base + 2]/*isequal*/)
12361290 {
1237- label = 41LLU; // jump to alternative
1291+ label = 47LLU; // jump to alternative
12381292 break;
12391293 }
12401294
12411295 // consequent
12421296 // call leq from isalpha
1243- stack[base + 3LLU] = 43LLU/*throw to this address*/;
1297+ stack[base + 3LLU] = 49LLU/*throw to this address*/;
12441298 stack[base + 4LLU] = base;
1245- stack[base + 5LLU] = 44LLU;
1299+ stack[base + 5LLU] = 50LLU;
12461300 // arguments for call to leq
12471301 stack[base + 7LLU] = stack[base + 1]/*c*/;
12481302 stack[base + 8LLU] = 90LLU;
@@ -1251,51 +1305,51 @@
12511305 label = 18446744073709551598LLU; // leq
12521306 break;
12531307 }
1254- case 43LLU: // copy-back deleter (leq to isalpha)
1308+ case 49LLU: // copy-back deleter (leq to isalpha)
12551309 {
12561310 fprintf(stderr, "in function isalpha: unrolling stack, copy-back (leq to isalpha)\n");
12571311 // copy mutable arguments back from call to leq
1258- label = 31LLU; // continue to roll stack
1312+ label = 37LLU; // continue to roll stack
12591313 break;
12601314 }
1261- case 44LLU: // return from leq to isalpha
1315+ case 50LLU: // return from leq to isalpha
12621316 {
12631317 // copy mutable arguments back from call to leq
12641318 // copy back results provided by call to leq
12651319 stack[base + 0] = stack[base + 6LLU];
1266- label = 42LLU; // consequent complete
1320+ label = 48LLU; // consequent complete
12671321 break;
12681322 }
1269- case 41LLU: // alternative
1323+ case 47LLU: // alternative
12701324 {
1271- label = 46LLU; // skip deleter
1325+ label = 52LLU; // skip deleter
12721326 break;
12731327 }
1274- case 45LLU: // deleter
1328+ case 51LLU: // deleter
12751329 {
12761330 // throw from isalpha
12771331 if(!stack[base + 0])
12781332 {
12791333 fprintf(stderr, "in function isalpha: unrolling stack, skipping already deleted/unscoped variable u64 \n");
1280- label = 31LLU; // skip, variable already deleted/unscoped
1334+ label = 37LLU; // skip, variable already deleted/unscoped
12811335 break;
12821336 }
12831337 fprintf(stderr, "in function isalpha: unrolling stack, variable u64 \n");
1284- label = 31LLU; // continue unrolling stack, delete next variable
1338+ label = 37LLU; // continue unrolling stack, delete next variable
12851339 break;
12861340 }
1287- case 46LLU: // skipped deleter
1341+ case 52LLU: // skipped deleter
12881342 {
12891343 stack[base + 0] = 0;
1290- label = 42LLU; // alternative complete
1344+ label = 48LLU; // alternative complete
12911345 break;
12921346 }
1293- case 42LLU: // completed if-then-else
1347+ case 48LLU: // completed if-then-else
12941348 {
1295- label = 36LLU; // alternative complete
1349+ label = 42LLU; // alternative complete
12961350 break;
12971351 }
1298- case 36LLU: // completed if-then-else
1352+ case 42LLU: // completed if-then-else
12991353 {
13001354 // return from isalpha
13011355 label = stack[base - 1];
@@ -1302,7 +1356,7 @@
13021356 base = stack[base - 2];
13031357 break;
13041358 }
1305- case 48LLU: // function isspace failed
1359+ case 54LLU: // function isspace failed
13061360 {
13071361 fprintf(stderr, "function isspace failed\n");
13081362 label = stack[base - 3];
@@ -1309,33 +1363,33 @@
13091363 base = stack[base - 2];
13101364 break;
13111365 }
1312- case 47LLU: // isspace
1366+ case 53LLU: // isspace
13131367 {
13141368 //#define res0 0
13151369 //#define arg0 1
1316- label = 50LLU; // skip deleter
1370+ label = 56LLU; // skip deleter
13171371 break;
13181372 }
1319- case 49LLU: // deleter
1373+ case 55LLU: // deleter
13201374 {
13211375 // throw from isspace
13221376 if(!stack[base + 2])
13231377 {
13241378 fprintf(stderr, "in function isspace: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1325- label = 48LLU; // skip, variable already deleted/unscoped
1379+ label = 54LLU; // skip, variable already deleted/unscoped
13261380 break;
13271381 }
13281382 fprintf(stderr, "in function isspace: unrolling stack, variable u64 isequal\n");
1329- label = 48LLU; // continue unrolling stack, delete next variable
1383+ label = 54LLU; // continue unrolling stack, delete next variable
13301384 break;
13311385 }
1332- case 50LLU: // skipped deleter
1386+ case 56LLU: // skipped deleter
13331387 {
13341388 stack[base + 2] = 0;
13351389 // call geq from isspace
1336- stack[base + 3LLU] = 51LLU/*throw to this address*/;
1390+ stack[base + 3LLU] = 57LLU/*throw to this address*/;
13371391 stack[base + 4LLU] = base;
1338- stack[base + 5LLU] = 52LLU;
1392+ stack[base + 5LLU] = 58LLU;
13391393 // arguments for call to geq
13401394 stack[base + 7LLU] = stack[base + 1]/*c*/;
13411395 stack[base + 8LLU] = 32LLU;
@@ -1344,14 +1398,14 @@
13441398 label = 18446744073709551596LLU; // geq
13451399 break;
13461400 }
1347- case 51LLU: // copy-back deleter (geq to isspace)
1401+ case 57LLU: // copy-back deleter (geq to isspace)
13481402 {
13491403 fprintf(stderr, "in function isspace: unrolling stack, copy-back (geq to isspace)\n");
13501404 // copy mutable arguments back from call to geq
1351- label = 49LLU; // continue to roll stack
1405+ label = 55LLU; // continue to roll stack
13521406 break;
13531407 }
1354- case 52LLU: // return from geq to isspace
1408+ case 58LLU: // return from geq to isspace
13551409 {
13561410 // copy mutable arguments back from call to geq
13571411 // copy back results provided by call to geq
@@ -1358,15 +1412,15 @@
13581412 stack[base + 2] = stack[base + 6LLU];
13591413 if(!stack[base + 2]/*isequal*/)
13601414 {
1361- label = 53LLU; // jump to alternative
1415+ label = 59LLU; // jump to alternative
13621416 break;
13631417 }
13641418
13651419 // consequent
13661420 // call leq from isspace
1367- stack[base + 3LLU] = 55LLU/*throw to this address*/;
1421+ stack[base + 3LLU] = 61LLU/*throw to this address*/;
13681422 stack[base + 4LLU] = base;
1369- stack[base + 5LLU] = 56LLU;
1423+ stack[base + 5LLU] = 62LLU;
13701424 // arguments for call to leq
13711425 stack[base + 7LLU] = stack[base + 1]/*c*/;
13721426 stack[base + 8LLU] = 10LLU;
@@ -1375,27 +1429,27 @@
13751429 label = 18446744073709551598LLU; // leq
13761430 break;
13771431 }
1378- case 55LLU: // copy-back deleter (leq to isspace)
1432+ case 61LLU: // copy-back deleter (leq to isspace)
13791433 {
13801434 fprintf(stderr, "in function isspace: unrolling stack, copy-back (leq to isspace)\n");
13811435 // copy mutable arguments back from call to leq
1382- label = 49LLU; // continue to roll stack
1436+ label = 55LLU; // continue to roll stack
13831437 break;
13841438 }
1385- case 56LLU: // return from leq to isspace
1439+ case 62LLU: // return from leq to isspace
13861440 {
13871441 // copy mutable arguments back from call to leq
13881442 // copy back results provided by call to leq
13891443 stack[base + 0] = stack[base + 6LLU];
1390- label = 54LLU; // consequent complete
1444+ label = 60LLU; // consequent complete
13911445 break;
13921446 }
1393- case 53LLU: // alternative
1447+ case 59LLU: // alternative
13941448 {
13951449 // call geq from isspace
1396- stack[base + 3LLU] = 57LLU/*throw to this address*/;
1450+ stack[base + 3LLU] = 63LLU/*throw to this address*/;
13971451 stack[base + 4LLU] = base;
1398- stack[base + 5LLU] = 58LLU;
1452+ stack[base + 5LLU] = 64LLU;
13991453 // arguments for call to geq
14001454 stack[base + 7LLU] = stack[base + 1]/*c*/;
14011455 stack[base + 8LLU] = 13LLU;
@@ -1404,14 +1458,14 @@
14041458 label = 18446744073709551596LLU; // geq
14051459 break;
14061460 }
1407- case 57LLU: // copy-back deleter (geq to isspace)
1461+ case 63LLU: // copy-back deleter (geq to isspace)
14081462 {
14091463 fprintf(stderr, "in function isspace: unrolling stack, copy-back (geq to isspace)\n");
14101464 // copy mutable arguments back from call to geq
1411- label = 49LLU; // continue to roll stack
1465+ label = 55LLU; // continue to roll stack
14121466 break;
14131467 }
1414- case 58LLU: // return from geq to isspace
1468+ case 64LLU: // return from geq to isspace
14151469 {
14161470 // copy mutable arguments back from call to geq
14171471 // copy back results provided by call to geq
@@ -1418,15 +1472,15 @@
14181472 stack[base + 2] = stack[base + 6LLU];
14191473 if(!stack[base + 2]/*isequal*/)
14201474 {
1421- label = 59LLU; // jump to alternative
1475+ label = 65LLU; // jump to alternative
14221476 break;
14231477 }
14241478
14251479 // consequent
14261480 // call geq from isspace
1427- stack[base + 3LLU] = 61LLU/*throw to this address*/;
1481+ stack[base + 3LLU] = 67LLU/*throw to this address*/;
14281482 stack[base + 4LLU] = base;
1429- stack[base + 5LLU] = 62LLU;
1483+ stack[base + 5LLU] = 68LLU;
14301484 // arguments for call to geq
14311485 stack[base + 7LLU] = stack[base + 1]/*c*/;
14321486 stack[base + 8LLU] = 11LLU;
@@ -1435,14 +1489,14 @@
14351489 label = 18446744073709551596LLU; // geq
14361490 break;
14371491 }
1438- case 61LLU: // copy-back deleter (geq to isspace)
1492+ case 67LLU: // copy-back deleter (geq to isspace)
14391493 {
14401494 fprintf(stderr, "in function isspace: unrolling stack, copy-back (geq to isspace)\n");
14411495 // copy mutable arguments back from call to geq
1442- label = 49LLU; // continue to roll stack
1496+ label = 55LLU; // continue to roll stack
14431497 break;
14441498 }
1445- case 62LLU: // return from geq to isspace
1499+ case 68LLU: // return from geq to isspace
14461500 {
14471501 // copy mutable arguments back from call to geq
14481502 // copy back results provided by call to geq
@@ -1449,15 +1503,15 @@
14491503 stack[base + 2] = stack[base + 6LLU];
14501504 if(!stack[base + 2]/*isequal*/)
14511505 {
1452- label = 63LLU; // jump to alternative
1506+ label = 69LLU; // jump to alternative
14531507 break;
14541508 }
14551509
14561510 // consequent
14571511 // call leq from isspace
1458- stack[base + 3LLU] = 65LLU/*throw to this address*/;
1512+ stack[base + 3LLU] = 71LLU/*throw to this address*/;
14591513 stack[base + 4LLU] = base;
1460- stack[base + 5LLU] = 66LLU;
1514+ stack[base + 5LLU] = 72LLU;
14611515 // arguments for call to leq
14621516 stack[base + 7LLU] = stack[base + 1]/*c*/;
14631517 stack[base + 8LLU] = 9LLU;
@@ -1466,80 +1520,80 @@
14661520 label = 18446744073709551598LLU; // leq
14671521 break;
14681522 }
1469- case 65LLU: // copy-back deleter (leq to isspace)
1523+ case 71LLU: // copy-back deleter (leq to isspace)
14701524 {
14711525 fprintf(stderr, "in function isspace: unrolling stack, copy-back (leq to isspace)\n");
14721526 // copy mutable arguments back from call to leq
1473- label = 49LLU; // continue to roll stack
1527+ label = 55LLU; // continue to roll stack
14741528 break;
14751529 }
1476- case 66LLU: // return from leq to isspace
1530+ case 72LLU: // return from leq to isspace
14771531 {
14781532 // copy mutable arguments back from call to leq
14791533 // copy back results provided by call to leq
14801534 stack[base + 0] = stack[base + 6LLU];
1481- label = 64LLU; // consequent complete
1535+ label = 70LLU; // consequent complete
14821536 break;
14831537 }
1484- case 63LLU: // alternative
1538+ case 69LLU: // alternative
14851539 {
1486- label = 68LLU; // skip deleter
1540+ label = 74LLU; // skip deleter
14871541 break;
14881542 }
1489- case 67LLU: // deleter
1543+ case 73LLU: // deleter
14901544 {
14911545 // throw from isspace
14921546 if(!stack[base + 0])
14931547 {
14941548 fprintf(stderr, "in function isspace: unrolling stack, skipping already deleted/unscoped variable u64 \n");
1495- label = 49LLU; // skip, variable already deleted/unscoped
1549+ label = 55LLU; // skip, variable already deleted/unscoped
14961550 break;
14971551 }
14981552 fprintf(stderr, "in function isspace: unrolling stack, variable u64 \n");
1499- label = 49LLU; // continue unrolling stack, delete next variable
1553+ label = 55LLU; // continue unrolling stack, delete next variable
15001554 break;
15011555 }
1502- case 68LLU: // skipped deleter
1556+ case 74LLU: // skipped deleter
15031557 {
15041558 stack[base + 0] = 0;
1505- label = 64LLU; // alternative complete
1559+ label = 70LLU; // alternative complete
15061560 break;
15071561 }
1508- case 64LLU: // completed if-then-else
1562+ case 70LLU: // completed if-then-else
15091563 {
1510- label = 60LLU; // consequent complete
1564+ label = 66LLU; // consequent complete
15111565 break;
15121566 }
1513- case 59LLU: // alternative
1567+ case 65LLU: // alternative
15141568 {
1515- label = 70LLU; // skip deleter
1569+ label = 76LLU; // skip deleter
15161570 break;
15171571 }
1518- case 69LLU: // deleter
1572+ case 75LLU: // deleter
15191573 {
15201574 // throw from isspace
15211575 if(!stack[base + 0])
15221576 {
15231577 fprintf(stderr, "in function isspace: unrolling stack, skipping already deleted/unscoped variable u64 \n");
1524- label = 49LLU; // skip, variable already deleted/unscoped
1578+ label = 55LLU; // skip, variable already deleted/unscoped
15251579 break;
15261580 }
15271581 fprintf(stderr, "in function isspace: unrolling stack, variable u64 \n");
1528- label = 49LLU; // continue unrolling stack, delete next variable
1582+ label = 55LLU; // continue unrolling stack, delete next variable
15291583 break;
15301584 }
1531- case 70LLU: // skipped deleter
1585+ case 76LLU: // skipped deleter
15321586 {
15331587 stack[base + 0] = 0;
1534- label = 60LLU; // alternative complete
1588+ label = 66LLU; // alternative complete
15351589 break;
15361590 }
1537- case 60LLU: // completed if-then-else
1591+ case 66LLU: // completed if-then-else
15381592 {
1539- label = 54LLU; // alternative complete
1593+ label = 60LLU; // alternative complete
15401594 break;
15411595 }
1542- case 54LLU: // completed if-then-else
1596+ case 60LLU: // completed if-then-else
15431597 {
15441598 // return from isspace
15451599 label = stack[base - 1];
@@ -1546,7 +1600,7 @@
15461600 base = stack[base - 2];
15471601 break;
15481602 }
1549- case 72LLU: // function EOSbyte failed
1603+ case 78LLU: // function EOSbyte failed
15501604 {
15511605 fprintf(stderr, "function EOSbyte failed\n");
15521606 label = stack[base - 3];
@@ -1553,13 +1607,13 @@
15531607 base = stack[base - 2];
15541608 break;
15551609 }
1556- case 71LLU: // EOSbyte
1610+ case 77LLU: // EOSbyte
15571611 {
15581612 //#define res0 0
15591613 // call sub from EOSbyte
1560- stack[base + 1LLU] = 73LLU/*throw to this address*/;
1614+ stack[base + 1LLU] = 79LLU/*throw to this address*/;
15611615 stack[base + 2LLU] = base;
1562- stack[base + 3LLU] = 74LLU;
1616+ stack[base + 3LLU] = 80LLU;
15631617 // arguments for call to sub
15641618 stack[base + 5LLU] = 0LLU;
15651619 stack[base + 6LLU] = 1LLU;
@@ -1568,14 +1622,14 @@
15681622 label = 18446744073709551604LLU; // sub
15691623 break;
15701624 }
1571- case 73LLU: // copy-back deleter (sub to EOSbyte)
1625+ case 79LLU: // copy-back deleter (sub to EOSbyte)
15721626 {
15731627 fprintf(stderr, "in function EOSbyte: unrolling stack, copy-back (sub to EOSbyte)\n");
15741628 // copy mutable arguments back from call to sub
1575- label = 72LLU; // continue to roll stack
1629+ label = 78LLU; // continue to roll stack
15761630 break;
15771631 }
1578- case 74LLU: // return from sub to EOSbyte
1632+ case 80LLU: // return from sub to EOSbyte
15791633 {
15801634 // copy mutable arguments back from call to sub
15811635 // copy back results provided by call to sub
@@ -1585,7 +1639,7 @@
15851639 base = stack[base - 2];
15861640 break;
15871641 }
1588- case 76LLU: // function skip failed
1642+ case 82LLU: // function skip failed
15891643 {
15901644 fprintf(stderr, "function skip failed\n");
15911645 label = stack[base - 3];
@@ -1592,63 +1646,63 @@
15921646 base = stack[base - 2];
15931647 break;
15941648 }
1595- case 75LLU: // skip
1649+ case 81LLU: // skip
15961650 {
15971651 //#define arg0 0
1598- label = 78LLU; // skip deleter
1652+ label = 84LLU; // skip deleter
15991653 break;
16001654 }
1601- case 77LLU: // deleter
1655+ case 83LLU: // deleter
16021656 {
16031657 // throw from skip
16041658 if(!stack[base + 1])
16051659 {
16061660 fprintf(stderr, "in function skip: unrolling stack, skipping already deleted/unscoped variable u64 lookahead\n");
1607- label = 76LLU; // skip, variable already deleted/unscoped
1661+ label = 82LLU; // skip, variable already deleted/unscoped
16081662 break;
16091663 }
16101664 fprintf(stderr, "in function skip: unrolling stack, variable u64 lookahead\n");
1611- label = 76LLU; // continue unrolling stack, delete next variable
1665+ label = 82LLU; // continue unrolling stack, delete next variable
16121666 break;
16131667 }
1614- case 78LLU: // skipped deleter
1668+ case 84LLU: // skipped deleter
16151669 {
16161670 stack[base + 1] = stack[base + 0]/*LOOKAHEAD*/;
1617- label = 80LLU; // skip deleter
1671+ label = 86LLU; // skip deleter
16181672 break;
16191673 }
1620- case 79LLU: // deleter
1674+ case 85LLU: // deleter
16211675 {
16221676 // throw from skip
16231677 if(!stack[base + 2])
16241678 {
16251679 fprintf(stderr, "in function skip: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1626- label = 77LLU; // skip, variable already deleted/unscoped
1680+ label = 83LLU; // skip, variable already deleted/unscoped
16271681 break;
16281682 }
16291683 fprintf(stderr, "in function skip: unrolling stack, variable u64 isequal\n");
1630- label = 77LLU; // continue unrolling stack, delete next variable
1684+ label = 83LLU; // continue unrolling stack, delete next variable
16311685 break;
16321686 }
1633- case 80LLU: // skipped deleter
1687+ case 86LLU: // skipped deleter
16341688 {
16351689 stack[base + 2] = 0;
1636- label = 81LLU; // start to repeat
1690+ label = 87LLU; // start to repeat
16371691 break;
16381692 }
1639- case 81LLU: // repeat from here
1693+ case 87LLU: // repeat from here
16401694 {
16411695 if(stack[base + 1]/*lookahead*/ > 0xFF)
16421696 {
1643- label = 82LLU; // break loop
1697+ label = 88LLU; // break loop
16441698 break;
16451699 }
16461700
16471701 // loop body
16481702 // call equ from skip
1649- stack[base + 3LLU] = 83LLU/*throw to this address*/;
1703+ stack[base + 3LLU] = 89LLU/*throw to this address*/;
16501704 stack[base + 4LLU] = base;
1651- stack[base + 5LLU] = 84LLU;
1705+ stack[base + 5LLU] = 90LLU;
16521706 // arguments for call to equ
16531707 stack[base + 7LLU] = stack[base + 1]/*lookahead*/;
16541708 stack[base + 8LLU] = 47LLU;
@@ -1657,14 +1711,14 @@
16571711 label = 18446744073709551600LLU; // equ
16581712 break;
16591713 }
1660- case 83LLU: // copy-back deleter (equ to skip)
1714+ case 89LLU: // copy-back deleter (equ to skip)
16611715 {
16621716 fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
16631717 // copy mutable arguments back from call to equ
1664- label = 79LLU; // continue to roll stack
1718+ label = 85LLU; // continue to roll stack
16651719 break;
16661720 }
1667- case 84LLU: // return from equ to skip
1721+ case 90LLU: // return from equ to skip
16681722 {
16691723 // copy mutable arguments back from call to equ
16701724 // copy back results provided by call to equ
@@ -1671,15 +1725,33 @@
16711725 stack[base + 2] = stack[base + 6LLU];
16721726 if(!stack[base + 2]/*isequal*/)
16731727 {
1674- label = 85LLU; // jump to alternative
1728+ label = 91LLU; // jump to alternative
16751729 break;
16761730 }
16771731
16781732 // consequent
1733+ label = 94LLU; // skip deleter
1734+ break;
1735+ }
1736+ case 93LLU: // deleter
1737+ {
1738+ // throw from skip
1739+ if(!stack[base + 3])
1740+ {
1741+ fprintf(stderr, "in function skip: unrolling stack, skipping already deleted/unscoped variable u64 secondary\n");
1742+ label = 85LLU; // skip, variable already deleted/unscoped
1743+ break;
1744+ }
1745+ fprintf(stderr, "in function skip: unrolling stack, variable u64 secondary\n");
1746+ label = 85LLU; // continue unrolling stack, delete next variable
1747+ break;
1748+ }
1749+ case 94LLU: // skipped deleter
1750+ {
16791751 // call peekbyte from skip
1680- stack[base + 4LLU] = 87LLU/*throw to this address*/;
1752+ stack[base + 4LLU] = 95LLU/*throw to this address*/;
16811753 stack[base + 5LLU] = base;
1682- stack[base + 6LLU] = 88LLU;
1754+ stack[base + 6LLU] = 96LLU;
16831755 // arguments for call to peekbyte
16841756 // set stack-base & callee-address
16851757 base += 7LLU;
@@ -1686,22 +1758,22 @@
16861758 label = 18446744073709551594LLU; // peekbyte
16871759 break;
16881760 }
1689- case 87LLU: // copy-back deleter (peekbyte to skip)
1761+ case 95LLU: // copy-back deleter (peekbyte to skip)
16901762 {
16911763 fprintf(stderr, "in function skip: unrolling stack, copy-back (peekbyte to skip)\n");
16921764 // copy mutable arguments back from call to peekbyte
1693- label = 79LLU; // continue to roll stack
1765+ label = 85LLU; // continue to roll stack
16941766 break;
16951767 }
1696- case 88LLU: // return from peekbyte to skip
1768+ case 96LLU: // return from peekbyte to skip
16971769 {
16981770 // copy mutable arguments back from call to peekbyte
16991771 // copy back results provided by call to peekbyte
17001772 stack[base + 3] = stack[base + 7LLU];
17011773 // call equ from skip
1702- stack[base + 4LLU] = 89LLU/*throw to this address*/;
1774+ stack[base + 4LLU] = 97LLU/*throw to this address*/;
17031775 stack[base + 5LLU] = base;
1704- stack[base + 6LLU] = 90LLU;
1776+ stack[base + 6LLU] = 98LLU;
17051777 // arguments for call to equ
17061778 stack[base + 8LLU] = stack[base + 3]/*secondary*/;
17071779 stack[base + 9LLU] = 47LLU;
@@ -1710,14 +1782,14 @@
17101782 label = 18446744073709551600LLU; // equ
17111783 break;
17121784 }
1713- case 89LLU: // copy-back deleter (equ to skip)
1785+ case 97LLU: // copy-back deleter (equ to skip)
17141786 {
17151787 fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
17161788 // copy mutable arguments back from call to equ
1717- label = 79LLU; // continue to roll stack
1789+ label = 93LLU; // continue to roll stack
17181790 break;
17191791 }
1720- case 90LLU: // return from equ to skip
1792+ case 98LLU: // return from equ to skip
17211793 {
17221794 // copy mutable arguments back from call to equ
17231795 // copy back results provided by call to equ
@@ -1724,15 +1796,15 @@
17241796 stack[base + 2] = stack[base + 7LLU];
17251797 if(!stack[base + 2]/*isequal*/)
17261798 {
1727- label = 91LLU; // jump to alternative
1799+ label = 99LLU; // jump to alternative
17281800 break;
17291801 }
17301802
17311803 // consequent
17321804 // call getbyte from skip
1733- stack[base + 4LLU] = 93LLU/*throw to this address*/;
1805+ stack[base + 4LLU] = 101LLU/*throw to this address*/;
17341806 stack[base + 5LLU] = base;
1735- stack[base + 6LLU] = 94LLU;
1807+ stack[base + 6LLU] = 102LLU;
17361808 // arguments for call to getbyte
17371809 // set stack-base & callee-address
17381810 base += 7LLU;
@@ -1739,34 +1811,34 @@
17391811 label = 18446744073709551593LLU; // getbyte
17401812 break;
17411813 }
1742- case 93LLU: // copy-back deleter (getbyte to skip)
1814+ case 101LLU: // copy-back deleter (getbyte to skip)
17431815 {
17441816 fprintf(stderr, "in function skip: unrolling stack, copy-back (getbyte to skip)\n");
17451817 // copy mutable arguments back from call to getbyte
1746- label = 79LLU; // continue to roll stack
1818+ label = 93LLU; // continue to roll stack
17471819 break;
17481820 }
1749- case 94LLU: // return from getbyte to skip
1821+ case 102LLU: // return from getbyte to skip
17501822 {
17511823 // copy mutable arguments back from call to getbyte
17521824 // copy back results provided by call to getbyte
17531825 stack[base + 1] = stack[base + 7LLU];
1754- label = 95LLU; // start to repeat
1826+ label = 103LLU; // start to repeat
17551827 break;
17561828 }
1757- case 95LLU: // repeat from here
1829+ case 103LLU: // repeat from here
17581830 {
17591831 if(stack[base + 1]/*lookahead*/ > 0xFF)
17601832 {
1761- label = 96LLU; // break loop
1833+ label = 104LLU; // break loop
17621834 break;
17631835 }
17641836
17651837 // loop body
17661838 // call equ from skip
1767- stack[base + 4LLU] = 97LLU/*throw to this address*/;
1839+ stack[base + 4LLU] = 105LLU/*throw to this address*/;
17681840 stack[base + 5LLU] = base;
1769- stack[base + 6LLU] = 98LLU;
1841+ stack[base + 6LLU] = 106LLU;
17701842 // arguments for call to equ
17711843 stack[base + 8LLU] = stack[base + 1]/*lookahead*/;
17721844 stack[base + 9LLU] = 10LLU;
@@ -1775,14 +1847,14 @@
17751847 label = 18446744073709551600LLU; // equ
17761848 break;
17771849 }
1778- case 97LLU: // copy-back deleter (equ to skip)
1850+ case 105LLU: // copy-back deleter (equ to skip)
17791851 {
17801852 fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
17811853 // copy mutable arguments back from call to equ
1782- label = 79LLU; // continue to roll stack
1854+ label = 93LLU; // continue to roll stack
17831855 break;
17841856 }
1785- case 98LLU: // return from equ to skip
1857+ case 106LLU: // return from equ to skip
17861858 {
17871859 // copy mutable arguments back from call to equ
17881860 // copy back results provided by call to equ
@@ -1789,59 +1861,59 @@
17891861 stack[base + 2] = stack[base + 7LLU];
17901862 if(!stack[base + 2]/*isequal*/)
17911863 {
1792- label = 99LLU; // jump to alternative
1864+ label = 107LLU; // jump to alternative
17931865 break;
17941866 }
17951867
17961868 // consequent
17971869 // call EOSbyte from skip
1798- stack[base + 4LLU] = 101LLU/*throw to this address*/;
1870+ stack[base + 4LLU] = 109LLU/*throw to this address*/;
17991871 stack[base + 5LLU] = base;
1800- stack[base + 6LLU] = 102LLU;
1872+ stack[base + 6LLU] = 110LLU;
18011873 // arguments for call to EOSbyte
18021874 // set stack-base & callee-address
18031875 base += 7LLU;
1804- label = 71LLU; // EOSbyte
1876+ label = 77LLU; // EOSbyte
18051877 break;
18061878 }
1807- case 101LLU: // copy-back deleter (EOSbyte to skip)
1879+ case 109LLU: // copy-back deleter (EOSbyte to skip)
18081880 {
18091881 fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
18101882 // copy mutable arguments back from call to EOSbyte
1811- label = 79LLU; // continue to roll stack
1883+ label = 93LLU; // continue to roll stack
18121884 break;
18131885 }
1814- case 102LLU: // return from EOSbyte to skip
1886+ case 110LLU: // return from EOSbyte to skip
18151887 {
18161888 // copy mutable arguments back from call to EOSbyte
18171889 // copy back results provided by call to EOSbyte
18181890 stack[base + 1] = stack[base + 7LLU];
1819- label = 100LLU; // consequent complete
1891+ label = 108LLU; // consequent complete
18201892 break;
18211893 }
1822- case 99LLU: // alternative
1894+ case 107LLU: // alternative
18231895 {
1824- label = 100LLU; // alternative complete
1896+ label = 108LLU; // alternative complete
18251897 break;
18261898 }
1827- case 100LLU: // completed if-then-else
1899+ case 108LLU: // completed if-then-else
18281900 {
18291901 if(stack[base + 1]/*lookahead*/ <= 0xFF) stack[base + 1]/*lookahead*/ = getchar();
1830- label = 95LLU; // repeat
1902+ label = 103LLU; // repeat
18311903 break;
18321904 }
1833- case 96LLU: // loop finished
1905+ case 104LLU: // loop finished
18341906 {
18351907 stack[base + 1]/*lookahead*/ = 0;
1836- label = 92LLU; // consequent complete
1908+ label = 100LLU; // consequent complete
18371909 break;
18381910 }
1839- case 91LLU: // alternative
1911+ case 99LLU: // alternative
18401912 {
18411913 // call equ from skip
1842- stack[base + 4LLU] = 103LLU/*throw to this address*/;
1914+ stack[base + 4LLU] = 111LLU/*throw to this address*/;
18431915 stack[base + 5LLU] = base;
1844- stack[base + 6LLU] = 104LLU;
1916+ stack[base + 6LLU] = 112LLU;
18451917 // arguments for call to equ
18461918 stack[base + 8LLU] = stack[base + 3]/*secondary*/;
18471919 stack[base + 9LLU] = 42LLU;
@@ -1850,14 +1922,14 @@
18501922 label = 18446744073709551600LLU; // equ
18511923 break;
18521924 }
1853- case 103LLU: // copy-back deleter (equ to skip)
1925+ case 111LLU: // copy-back deleter (equ to skip)
18541926 {
18551927 fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
18561928 // copy mutable arguments back from call to equ
1857- label = 79LLU; // continue to roll stack
1929+ label = 93LLU; // continue to roll stack
18581930 break;
18591931 }
1860- case 104LLU: // return from equ to skip
1932+ case 112LLU: // return from equ to skip
18611933 {
18621934 // copy mutable arguments back from call to equ
18631935 // copy back results provided by call to equ
@@ -1864,15 +1936,15 @@
18641936 stack[base + 2] = stack[base + 7LLU];
18651937 if(!stack[base + 2]/*isequal*/)
18661938 {
1867- label = 105LLU; // jump to alternative
1939+ label = 113LLU; // jump to alternative
18681940 break;
18691941 }
18701942
18711943 // consequent
18721944 // call getbyte from skip
1873- stack[base + 4LLU] = 107LLU/*throw to this address*/;
1945+ stack[base + 4LLU] = 115LLU/*throw to this address*/;
18741946 stack[base + 5LLU] = base;
1875- stack[base + 6LLU] = 108LLU;
1947+ stack[base + 6LLU] = 116LLU;
18761948 // arguments for call to getbyte
18771949 // set stack-base & callee-address
18781950 base += 7LLU;
@@ -1879,34 +1951,34 @@
18791951 label = 18446744073709551593LLU; // getbyte
18801952 break;
18811953 }
1882- case 107LLU: // copy-back deleter (getbyte to skip)
1954+ case 115LLU: // copy-back deleter (getbyte to skip)
18831955 {
18841956 fprintf(stderr, "in function skip: unrolling stack, copy-back (getbyte to skip)\n");
18851957 // copy mutable arguments back from call to getbyte
1886- label = 79LLU; // continue to roll stack
1958+ label = 93LLU; // continue to roll stack
18871959 break;
18881960 }
1889- case 108LLU: // return from getbyte to skip
1961+ case 116LLU: // return from getbyte to skip
18901962 {
18911963 // copy mutable arguments back from call to getbyte
18921964 // copy back results provided by call to getbyte
18931965 stack[base + 1] = stack[base + 7LLU];
1894- label = 109LLU; // start to repeat
1966+ label = 117LLU; // start to repeat
18951967 break;
18961968 }
1897- case 109LLU: // repeat from here
1969+ case 117LLU: // repeat from here
18981970 {
18991971 if(stack[base + 1]/*lookahead*/ > 0xFF)
19001972 {
1901- label = 110LLU; // break loop
1973+ label = 118LLU; // break loop
19021974 break;
19031975 }
19041976
19051977 // loop body
19061978 // call equ from skip
1907- stack[base + 4LLU] = 111LLU/*throw to this address*/;
1979+ stack[base + 4LLU] = 119LLU/*throw to this address*/;
19081980 stack[base + 5LLU] = base;
1909- stack[base + 6LLU] = 112LLU;
1981+ stack[base + 6LLU] = 120LLU;
19101982 // arguments for call to equ
19111983 stack[base + 8LLU] = stack[base + 1]/*lookahead*/;
19121984 stack[base + 9LLU] = 42LLU;
@@ -1915,14 +1987,14 @@
19151987 label = 18446744073709551600LLU; // equ
19161988 break;
19171989 }
1918- case 111LLU: // copy-back deleter (equ to skip)
1990+ case 119LLU: // copy-back deleter (equ to skip)
19191991 {
19201992 fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
19211993 // copy mutable arguments back from call to equ
1922- label = 79LLU; // continue to roll stack
1994+ label = 93LLU; // continue to roll stack
19231995 break;
19241996 }
1925- case 112LLU: // return from equ to skip
1997+ case 120LLU: // return from equ to skip
19261998 {
19271999 // copy mutable arguments back from call to equ
19282000 // copy back results provided by call to equ
@@ -1929,15 +2001,15 @@
19292001 stack[base + 2] = stack[base + 7LLU];
19302002 if(!stack[base + 2]/*isequal*/)
19312003 {
1932- label = 113LLU; // jump to alternative
2004+ label = 121LLU; // jump to alternative
19332005 break;
19342006 }
19352007
19362008 // consequent
19372009 // call peekbyte from skip
1938- stack[base + 4LLU] = 115LLU/*throw to this address*/;
2010+ stack[base + 4LLU] = 123LLU/*throw to this address*/;
19392011 stack[base + 5LLU] = base;
1940- stack[base + 6LLU] = 116LLU;
2012+ stack[base + 6LLU] = 124LLU;
19412013 // arguments for call to peekbyte
19422014 // set stack-base & callee-address
19432015 base += 7LLU;
@@ -1944,22 +2016,22 @@
19442016 label = 18446744073709551594LLU; // peekbyte
19452017 break;
19462018 }
1947- case 115LLU: // copy-back deleter (peekbyte to skip)
2019+ case 123LLU: // copy-back deleter (peekbyte to skip)
19482020 {
19492021 fprintf(stderr, "in function skip: unrolling stack, copy-back (peekbyte to skip)\n");
19502022 // copy mutable arguments back from call to peekbyte
1951- label = 79LLU; // continue to roll stack
2023+ label = 93LLU; // continue to roll stack
19522024 break;
19532025 }
1954- case 116LLU: // return from peekbyte to skip
2026+ case 124LLU: // return from peekbyte to skip
19552027 {
19562028 // copy mutable arguments back from call to peekbyte
19572029 // copy back results provided by call to peekbyte
19582030 stack[base + 3] = stack[base + 7LLU];
19592031 // call equ from skip
1960- stack[base + 4LLU] = 117LLU/*throw to this address*/;
2032+ stack[base + 4LLU] = 125LLU/*throw to this address*/;
19612033 stack[base + 5LLU] = base;
1962- stack[base + 6LLU] = 118LLU;
2034+ stack[base + 6LLU] = 126LLU;
19632035 // arguments for call to equ
19642036 stack[base + 8LLU] = stack[base + 3]/*secondary*/;
19652037 stack[base + 9LLU] = 47LLU;
@@ -1968,14 +2040,14 @@
19682040 label = 18446744073709551600LLU; // equ
19692041 break;
19702042 }
1971- case 117LLU: // copy-back deleter (equ to skip)
2043+ case 125LLU: // copy-back deleter (equ to skip)
19722044 {
19732045 fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
19742046 // copy mutable arguments back from call to equ
1975- label = 79LLU; // continue to roll stack
2047+ label = 93LLU; // continue to roll stack
19762048 break;
19772049 }
1978- case 118LLU: // return from equ to skip
2050+ case 126LLU: // return from equ to skip
19792051 {
19802052 // copy mutable arguments back from call to equ
19812053 // copy back results provided by call to equ
@@ -1982,15 +2054,15 @@
19822054 stack[base + 2] = stack[base + 7LLU];
19832055 if(!stack[base + 2]/*isequal*/)
19842056 {
1985- label = 119LLU; // jump to alternative
2057+ label = 127LLU; // jump to alternative
19862058 break;
19872059 }
19882060
19892061 // consequent
19902062 // call getbyte from skip
1991- stack[base + 4LLU] = 121LLU/*throw to this address*/;
2063+ stack[base + 4LLU] = 129LLU/*throw to this address*/;
19922064 stack[base + 5LLU] = base;
1993- stack[base + 6LLU] = 122LLU;
2065+ stack[base + 6LLU] = 130LLU;
19942066 // arguments for call to getbyte
19952067 // set stack-base & callee-address
19962068 base += 7LLU;
@@ -1997,129 +2069,129 @@
19972069 label = 18446744073709551593LLU; // getbyte
19982070 break;
19992071 }
2000- case 121LLU: // copy-back deleter (getbyte to skip)
2072+ case 129LLU: // copy-back deleter (getbyte to skip)
20012073 {
20022074 fprintf(stderr, "in function skip: unrolling stack, copy-back (getbyte to skip)\n");
20032075 // copy mutable arguments back from call to getbyte
2004- label = 79LLU; // continue to roll stack
2076+ label = 93LLU; // continue to roll stack
20052077 break;
20062078 }
2007- case 122LLU: // return from getbyte to skip
2079+ case 130LLU: // return from getbyte to skip
20082080 {
20092081 // copy mutable arguments back from call to getbyte
20102082 // copy back results provided by call to getbyte
20112083 stack[base + 1] = stack[base + 7LLU];
20122084 // call EOSbyte from skip
2013- stack[base + 4LLU] = 123LLU/*throw to this address*/;
2085+ stack[base + 4LLU] = 131LLU/*throw to this address*/;
20142086 stack[base + 5LLU] = base;
2015- stack[base + 6LLU] = 124LLU;
2087+ stack[base + 6LLU] = 132LLU;
20162088 // arguments for call to EOSbyte
20172089 // set stack-base & callee-address
20182090 base += 7LLU;
2019- label = 71LLU; // EOSbyte
2091+ label = 77LLU; // EOSbyte
20202092 break;
20212093 }
2022- case 123LLU: // copy-back deleter (EOSbyte to skip)
2094+ case 131LLU: // copy-back deleter (EOSbyte to skip)
20232095 {
20242096 fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
20252097 // copy mutable arguments back from call to EOSbyte
2026- label = 79LLU; // continue to roll stack
2098+ label = 93LLU; // continue to roll stack
20272099 break;
20282100 }
2029- case 124LLU: // return from EOSbyte to skip
2101+ case 132LLU: // return from EOSbyte to skip
20302102 {
20312103 // copy mutable arguments back from call to EOSbyte
20322104 // copy back results provided by call to EOSbyte
20332105 stack[base + 1] = stack[base + 7LLU];
2034- label = 120LLU; // consequent complete
2106+ label = 128LLU; // consequent complete
20352107 break;
20362108 }
2037- case 119LLU: // alternative
2109+ case 127LLU: // alternative
20382110 {
2039- label = 120LLU; // alternative complete
2111+ label = 128LLU; // alternative complete
20402112 break;
20412113 }
2042- case 120LLU: // completed if-then-else
2114+ case 128LLU: // completed if-then-else
20432115 {
2044- label = 114LLU; // consequent complete
2116+ label = 122LLU; // consequent complete
20452117 break;
20462118 }
2047- case 113LLU: // alternative
2119+ case 121LLU: // alternative
20482120 {
2049- label = 114LLU; // alternative complete
2121+ label = 122LLU; // alternative complete
20502122 break;
20512123 }
2052- case 114LLU: // completed if-then-else
2124+ case 122LLU: // completed if-then-else
20532125 {
20542126 if(stack[base + 1]/*lookahead*/ <= 0xFF) stack[base + 1]/*lookahead*/ = getchar();
2055- label = 109LLU; // repeat
2127+ label = 117LLU; // repeat
20562128 break;
20572129 }
2058- case 110LLU: // loop finished
2130+ case 118LLU: // loop finished
20592131 {
20602132 stack[base + 1]/*lookahead*/ = 0;
2061- label = 106LLU; // consequent complete
2133+ label = 114LLU; // consequent complete
20622134 break;
20632135 }
2064- case 105LLU: // alternative
2136+ case 113LLU: // alternative
20652137 {
20662138 stack[base + 0]/*LOOKAHEAD*/ = stack[base + 1]/*lookahead*/;
20672139 // call EOSbyte from skip
2068- stack[base + 4LLU] = 125LLU/*throw to this address*/;
2140+ stack[base + 4LLU] = 133LLU/*throw to this address*/;
20692141 stack[base + 5LLU] = base;
2070- stack[base + 6LLU] = 126LLU;
2142+ stack[base + 6LLU] = 134LLU;
20712143 // arguments for call to EOSbyte
20722144 // set stack-base & callee-address
20732145 base += 7LLU;
2074- label = 71LLU; // EOSbyte
2146+ label = 77LLU; // EOSbyte
20752147 break;
20762148 }
2077- case 125LLU: // copy-back deleter (EOSbyte to skip)
2149+ case 133LLU: // copy-back deleter (EOSbyte to skip)
20782150 {
20792151 fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
20802152 // copy mutable arguments back from call to EOSbyte
2081- label = 79LLU; // continue to roll stack
2153+ label = 93LLU; // continue to roll stack
20822154 break;
20832155 }
2084- case 126LLU: // return from EOSbyte to skip
2156+ case 134LLU: // return from EOSbyte to skip
20852157 {
20862158 // copy mutable arguments back from call to EOSbyte
20872159 // copy back results provided by call to EOSbyte
20882160 stack[base + 1] = stack[base + 7LLU];
2089- label = 106LLU; // alternative complete
2161+ label = 114LLU; // alternative complete
20902162 break;
20912163 }
2092- case 106LLU: // completed if-then-else
2164+ case 114LLU: // completed if-then-else
20932165 {
2094- label = 92LLU; // alternative complete
2166+ label = 100LLU; // alternative complete
20952167 break;
20962168 }
2097- case 92LLU: // completed if-then-else
2169+ case 100LLU: // completed if-then-else
20982170 {
2099- label = 86LLU; // consequent complete
2171+ label = 92LLU; // consequent complete
21002172 break;
21012173 }
2102- case 85LLU: // alternative
2174+ case 91LLU: // alternative
21032175 {
21042176 // call isspace from skip
2105- stack[base + 3LLU] = 127LLU/*throw to this address*/;
2177+ stack[base + 3LLU] = 135LLU/*throw to this address*/;
21062178 stack[base + 4LLU] = base;
2107- stack[base + 5LLU] = 128LLU;
2179+ stack[base + 5LLU] = 136LLU;
21082180 // arguments for call to isspace
21092181 stack[base + 7LLU] = stack[base + 1]/*lookahead*/;
21102182 // set stack-base & callee-address
21112183 base += 6LLU;
2112- label = 47LLU; // isspace
2184+ label = 53LLU; // isspace
21132185 break;
21142186 }
2115- case 127LLU: // copy-back deleter (isspace to skip)
2187+ case 135LLU: // copy-back deleter (isspace to skip)
21162188 {
21172189 fprintf(stderr, "in function skip: unrolling stack, copy-back (isspace to skip)\n");
21182190 // copy mutable arguments back from call to isspace
2119- label = 79LLU; // continue to roll stack
2191+ label = 85LLU; // continue to roll stack
21202192 break;
21212193 }
2122- case 128LLU: // return from isspace to skip
2194+ case 136LLU: // return from isspace to skip
21232195 {
21242196 // copy mutable arguments back from call to isspace
21252197 // copy back results provided by call to isspace
@@ -2126,54 +2198,54 @@
21262198 stack[base + 2] = stack[base + 6LLU];
21272199 if(!stack[base + 2]/*isequal*/)
21282200 {
2129- label = 129LLU; // jump to alternative
2201+ label = 137LLU; // jump to alternative
21302202 break;
21312203 }
21322204
21332205 // consequent
2134- label = 130LLU; // consequent complete
2206+ label = 138LLU; // consequent complete
21352207 break;
21362208 }
2137- case 129LLU: // alternative
2209+ case 137LLU: // alternative
21382210 {
21392211 stack[base + 0]/*LOOKAHEAD*/ = stack[base + 1]/*lookahead*/;
21402212 // call EOSbyte from skip
2141- stack[base + 3LLU] = 131LLU/*throw to this address*/;
2213+ stack[base + 3LLU] = 139LLU/*throw to this address*/;
21422214 stack[base + 4LLU] = base;
2143- stack[base + 5LLU] = 132LLU;
2215+ stack[base + 5LLU] = 140LLU;
21442216 // arguments for call to EOSbyte
21452217 // set stack-base & callee-address
21462218 base += 6LLU;
2147- label = 71LLU; // EOSbyte
2219+ label = 77LLU; // EOSbyte
21482220 break;
21492221 }
2150- case 131LLU: // copy-back deleter (EOSbyte to skip)
2222+ case 139LLU: // copy-back deleter (EOSbyte to skip)
21512223 {
21522224 fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
21532225 // copy mutable arguments back from call to EOSbyte
2154- label = 79LLU; // continue to roll stack
2226+ label = 85LLU; // continue to roll stack
21552227 break;
21562228 }
2157- case 132LLU: // return from EOSbyte to skip
2229+ case 140LLU: // return from EOSbyte to skip
21582230 {
21592231 // copy mutable arguments back from call to EOSbyte
21602232 // copy back results provided by call to EOSbyte
21612233 stack[base + 1] = stack[base + 6LLU];
2162- label = 130LLU; // alternative complete
2234+ label = 138LLU; // alternative complete
21632235 break;
21642236 }
2165- case 130LLU: // completed if-then-else
2237+ case 138LLU: // completed if-then-else
21662238 {
2167- label = 86LLU; // alternative complete
2239+ label = 92LLU; // alternative complete
21682240 break;
21692241 }
2170- case 86LLU: // completed if-then-else
2242+ case 92LLU: // completed if-then-else
21712243 {
21722244 if(stack[base + 1]/*lookahead*/ <= 0xFF) stack[base + 1]/*lookahead*/ = getchar();
2173- label = 81LLU; // repeat
2245+ label = 87LLU; // repeat
21742246 break;
21752247 }
2176- case 82LLU: // loop finished
2248+ case 88LLU: // loop finished
21772249 {
21782250 // return from skip
21792251 label = stack[base - 1];
@@ -2180,7 +2252,7 @@
21802252 base = stack[base - 2];
21812253 break;
21822254 }
2183- case 134LLU: // function deloffset failed
2255+ case 142LLU: // function deloffset failed
21842256 {
21852257 fprintf(stderr, "function deloffset failed\n");
21862258 label = stack[base - 3];
@@ -2187,7 +2259,7 @@
21872259 base = stack[base - 2];
21882260 break;
21892261 }
2190- case 133LLU: // deloffset
2262+ case 141LLU: // deloffset
21912263 {
21922264 printf("%s", "4");
21932265 // return from deloffset
@@ -2195,7 +2267,7 @@
21952267 base = stack[base - 2];
21962268 break;
21972269 }
2198- case 136LLU: // function emitinit failed
2270+ case 144LLU: // function emitinit failed
21992271 {
22002272 fprintf(stderr, "function emitinit failed\n");
22012273 label = stack[base - 3];
@@ -2202,7 +2274,7 @@
22022274 base = stack[base - 2];
22032275 break;
22042276 }
2205- case 135LLU: // emitinit
2277+ case 143LLU: // emitinit
22062278 {
22072279 printf("%s", "\n#include <ctype.h>");
22082280 printf("%s", "\n#include <inttypes.h>");
@@ -2452,23 +2524,23 @@
24522524 printf("%s", "\n{");
24532525 printf("%s", "\n uint64_t memory = (uint64_t)Calloc(2 + ");
24542526 // call deloffset from emitinit
2455- stack[base + 0LLU] = 137LLU/*throw to this address*/;
2527+ stack[base + 0LLU] = 145LLU/*throw to this address*/;
24562528 stack[base + 1LLU] = base;
2457- stack[base + 2LLU] = 138LLU;
2529+ stack[base + 2LLU] = 146LLU;
24582530 // arguments for call to deloffset
24592531 // set stack-base & callee-address
24602532 base += 3LLU;
2461- label = 133LLU; // deloffset
2533+ label = 141LLU; // deloffset
24622534 break;
24632535 }
2464- case 137LLU: // copy-back deleter (deloffset to emitinit)
2536+ case 145LLU: // copy-back deleter (deloffset to emitinit)
24652537 {
24662538 fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
24672539 // copy mutable arguments back from call to deloffset
2468- label = 136LLU; // continue to roll stack
2540+ label = 144LLU; // continue to roll stack
24692541 break;
24702542 }
2471- case 138LLU: // return from deloffset to emitinit
2543+ case 146LLU: // return from deloffset to emitinit
24722544 {
24732545 // copy mutable arguments back from call to deloffset
24742546 printf("%s", ", sizeof(uint64_t));");
@@ -2475,23 +2547,23 @@
24752547 printf("%s", "\n if(!memory) return 0;");
24762548 printf("%s", "\n if(!(((uint64_t *)memory)[1 + ");
24772549 // call deloffset from emitinit
2478- stack[base + 0LLU] = 139LLU/*throw to this address*/;
2550+ stack[base + 0LLU] = 147LLU/*throw to this address*/;
24792551 stack[base + 1LLU] = base;
2480- stack[base + 2LLU] = 140LLU;
2552+ stack[base + 2LLU] = 148LLU;
24812553 // arguments for call to deloffset
24822554 // set stack-base & callee-address
24832555 base += 3LLU;
2484- label = 133LLU; // deloffset
2556+ label = 141LLU; // deloffset
24852557 break;
24862558 }
2487- case 139LLU: // copy-back deleter (deloffset to emitinit)
2559+ case 147LLU: // copy-back deleter (deloffset to emitinit)
24882560 {
24892561 fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
24902562 // copy mutable arguments back from call to deloffset
2491- label = 136LLU; // continue to roll stack
2563+ label = 144LLU; // continue to roll stack
24922564 break;
24932565 }
2494- case 140LLU: // return from deloffset to emitinit
2566+ case 148LLU: // return from deloffset to emitinit
24952567 {
24962568 // copy mutable arguments back from call to deloffset
24972569 printf("%s", "] = (uint64_t)Calloc(varsize, sizeof(uint64_t))))");
@@ -2498,23 +2570,23 @@
24982570 printf("%s", "\n {");
24992571 printf("%s", "\n Free(2 + ");
25002572 // call deloffset from emitinit
2501- stack[base + 0LLU] = 141LLU/*throw to this address*/;
2573+ stack[base + 0LLU] = 149LLU/*throw to this address*/;
25022574 stack[base + 1LLU] = base;
2503- stack[base + 2LLU] = 142LLU;
2575+ stack[base + 2LLU] = 150LLU;
25042576 // arguments for call to deloffset
25052577 // set stack-base & callee-address
25062578 base += 3LLU;
2507- label = 133LLU; // deloffset
2579+ label = 141LLU; // deloffset
25082580 break;
25092581 }
2510- case 141LLU: // copy-back deleter (deloffset to emitinit)
2582+ case 149LLU: // copy-back deleter (deloffset to emitinit)
25112583 {
25122584 fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
25132585 // copy mutable arguments back from call to deloffset
2514- label = 136LLU; // continue to roll stack
2586+ label = 144LLU; // continue to roll stack
25152587 break;
25162588 }
2517- case 142LLU: // return from deloffset to emitinit
2589+ case 150LLU: // return from deloffset to emitinit
25182590 {
25192591 // copy mutable arguments back from call to deloffset
25202592 printf("%s", ", sizeof(uint64_t), (void *)memory);");
@@ -2522,23 +2594,23 @@
25222594 printf("%s", "\n }");
25232595 printf("%s", "\n return memory + sizeof(uint64_t) * ");
25242596 // call deloffset from emitinit
2525- stack[base + 0LLU] = 143LLU/*throw to this address*/;
2597+ stack[base + 0LLU] = 151LLU/*throw to this address*/;
25262598 stack[base + 1LLU] = base;
2527- stack[base + 2LLU] = 144LLU;
2599+ stack[base + 2LLU] = 152LLU;
25282600 // arguments for call to deloffset
25292601 // set stack-base & callee-address
25302602 base += 3LLU;
2531- label = 133LLU; // deloffset
2603+ label = 141LLU; // deloffset
25322604 break;
25332605 }
2534- case 143LLU: // copy-back deleter (deloffset to emitinit)
2606+ case 151LLU: // copy-back deleter (deloffset to emitinit)
25352607 {
25362608 fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
25372609 // copy mutable arguments back from call to deloffset
2538- label = 136LLU; // continue to roll stack
2610+ label = 144LLU; // continue to roll stack
25392611 break;
25402612 }
2541- case 144LLU: // return from deloffset to emitinit
2613+ case 152LLU: // return from deloffset to emitinit
25422614 {
25432615 // copy mutable arguments back from call to deloffset
25442616 printf("%s", ";");
@@ -2563,7 +2635,7 @@
25632635 base = stack[base - 2];
25642636 break;
25652637 }
2566- case 146LLU: // function existsid failed
2638+ case 154LLU: // function existsid failed
25672639 {
25682640 fprintf(stderr, "function existsid failed\n");
25692641 label = stack[base - 3];
@@ -2570,39 +2642,39 @@
25702642 base = stack[base - 2];
25712643 break;
25722644 }
2573- case 145LLU: // existsid
2645+ case 153LLU: // existsid
25742646 {
25752647 //#define res0 0
25762648 //#define arg0 1
25772649 //#define arg1 2
2578- label = 148LLU; // skip deleter
2650+ label = 156LLU; // skip deleter
25792651 break;
25802652 }
2581- case 147LLU: // deleter
2653+ case 155LLU: // deleter
25822654 {
25832655 // throw from existsid
25842656 if(!stack[base + 3])
25852657 {
25862658 fprintf(stderr, "in function existsid: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
2587- label = 146LLU; // skip, variable already deleted/unscoped
2659+ label = 154LLU; // skip, variable already deleted/unscoped
25882660 break;
25892661 }
25902662 fprintf(stderr, "in function existsid: unrolling stack, variable u64 found\n");
2591- label = 146LLU; // continue unrolling stack, delete next variable
2663+ label = 154LLU; // continue unrolling stack, delete next variable
25922664 break;
25932665 }
2594- case 148LLU: // skipped deleter
2666+ case 156LLU: // skipped deleter
25952667 {
25962668 stack[base + 3] = 0;
25972669 flippedassign(stack[base + 1]/*ids*/, &stack[base + 4]);
2598- label = 149LLU; // start to repeat
2670+ label = 157LLU; // start to repeat
25992671 break;
26002672 }
2601- case 149LLU: // repeat from here
2673+ case 157LLU: // repeat from here
26022674 {
26032675 if(!stack[base + 4])
26042676 {
2605- label = 150LLU; // break loop
2677+ label = 158LLU; // break loop
26062678 break;
26072679 }
26082680
@@ -2612,20 +2684,20 @@
26122684 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
26132685 if(!stack[base + 3]/*found*/)
26142686 {
2615- label = 152LLU; // jump to alternative
2687+ label = 160LLU; // jump to alternative
26162688 break;
26172689 }
26182690
26192691 // consequent
2620- label = 153LLU; // consequent complete
2692+ label = 161LLU; // consequent complete
26212693 break;
26222694 }
2623- case 152LLU: // alternative
2695+ case 160LLU: // alternative
26242696 {
26252697 // call equ from existsid
2626- stack[base + 7LLU] = 154LLU/*throw to this address*/;
2698+ stack[base + 7LLU] = 162LLU/*throw to this address*/;
26272699 stack[base + 8LLU] = base;
2628- stack[base + 9LLU] = 155LLU;
2700+ stack[base + 9LLU] = 163LLU;
26292701 // arguments for call to equ
26302702 stack[base + 11LLU] = stack[base + 5]/*current*/;
26312703 stack[base + 12LLU] = stack[base + 2]/*wanted*/;
@@ -2634,52 +2706,52 @@
26342706 label = 18446744073709551600LLU; // equ
26352707 break;
26362708 }
2637- case 154LLU: // copy-back deleter (equ to existsid)
2709+ case 162LLU: // copy-back deleter (equ to existsid)
26382710 {
26392711 fprintf(stderr, "in function existsid: unrolling stack, copy-back (equ to existsid)\n");
26402712 // copy mutable arguments back from call to equ
2641- label = 151LLU; // continue to roll stack
2713+ label = 159LLU; // continue to roll stack
26422714 break;
26432715 }
2644- case 155LLU: // return from equ to existsid
2716+ case 163LLU: // return from equ to existsid
26452717 {
26462718 // copy mutable arguments back from call to equ
26472719 // copy back results provided by call to equ
26482720 stack[base + 3] = stack[base + 10LLU];
2649- label = 153LLU; // alternative complete
2721+ label = 161LLU; // alternative complete
26502722 break;
26512723 }
2652- case 153LLU: // completed if-then-else
2724+ case 161LLU: // completed if-then-else
26532725 {
26542726 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
2655- label = 149LLU; // repeat
2727+ label = 157LLU; // repeat
26562728 break;
26572729 }
2658- case 151LLU: // copy-back deleter for while next
2730+ case 159LLU: // copy-back deleter for while next
26592731 {
26602732 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
2661- label = 147LLU; // continue to unroll stack
2733+ label = 155LLU; // continue to unroll stack
26622734 break;
26632735 }
2664- case 150LLU: // loop finished
2736+ case 158LLU: // loop finished
26652737 {
2666- label = 157LLU; // skip deleter
2738+ label = 165LLU; // skip deleter
26672739 break;
26682740 }
2669- case 156LLU: // deleter
2741+ case 164LLU: // deleter
26702742 {
26712743 // throw from existsid
26722744 if(!stack[base + 0])
26732745 {
26742746 fprintf(stderr, "in function existsid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2675- label = 147LLU; // skip, variable already deleted/unscoped
2747+ label = 155LLU; // skip, variable already deleted/unscoped
26762748 break;
26772749 }
26782750 fprintf(stderr, "in function existsid: unrolling stack, variable u64 \n");
2679- label = 147LLU; // continue unrolling stack, delete next variable
2751+ label = 155LLU; // continue unrolling stack, delete next variable
26802752 break;
26812753 }
2682- case 157LLU: // skipped deleter
2754+ case 165LLU: // skipped deleter
26832755 {
26842756 stack[base + 0] = stack[base + 3]/*found*/;
26852757 // return from existsid
@@ -2687,7 +2759,7 @@
26872759 base = stack[base - 2];
26882760 break;
26892761 }
2690- case 159LLU: // function issimple failed
2762+ case 167LLU: // function issimple failed
26912763 {
26922764 fprintf(stderr, "function issimple failed\n");
26932765 label = stack[base - 3];
@@ -2694,35 +2766,35 @@
26942766 base = stack[base - 2];
26952767 break;
26962768 }
2697- case 158LLU: // issimple
2769+ case 166LLU: // issimple
26982770 {
26992771 //#define res0 0
27002772 //#define arg0 1
27012773 //#define arg1 2
27022774 //#define arg2 3
2703- label = 161LLU; // skip deleter
2775+ label = 169LLU; // skip deleter
27042776 break;
27052777 }
2706- case 160LLU: // deleter
2778+ case 168LLU: // deleter
27072779 {
27082780 // throw from issimple
27092781 if(!stack[base + 4])
27102782 {
27112783 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
2712- label = 159LLU; // skip, variable already deleted/unscoped
2784+ label = 167LLU; // skip, variable already deleted/unscoped
27132785 break;
27142786 }
27152787 fprintf(stderr, "in function issimple: unrolling stack, variable u64 isequal\n");
2716- label = 159LLU; // continue unrolling stack, delete next variable
2788+ label = 167LLU; // continue unrolling stack, delete next variable
27172789 break;
27182790 }
2719- case 161LLU: // skipped deleter
2791+ case 169LLU: // skipped deleter
27202792 {
27212793 stack[base + 4] = 0;
27222794 // call equ from issimple
2723- stack[base + 5LLU] = 162LLU/*throw to this address*/;
2795+ stack[base + 5LLU] = 170LLU/*throw to this address*/;
27242796 stack[base + 6LLU] = base;
2725- stack[base + 7LLU] = 163LLU;
2797+ stack[base + 7LLU] = 171LLU;
27262798 // arguments for call to equ
27272799 stack[base + 9LLU] = stack[base + 1]/*variant*/;
27282800 stack[base + 10LLU] = 0LLU;
@@ -2731,14 +2803,14 @@
27312803 label = 18446744073709551600LLU; // equ
27322804 break;
27332805 }
2734- case 162LLU: // copy-back deleter (equ to issimple)
2806+ case 170LLU: // copy-back deleter (equ to issimple)
27352807 {
27362808 fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
27372809 // copy mutable arguments back from call to equ
2738- label = 160LLU; // continue to roll stack
2810+ label = 168LLU; // continue to roll stack
27392811 break;
27402812 }
2741- case 163LLU: // return from equ to issimple
2813+ case 171LLU: // return from equ to issimple
27422814 {
27432815 // copy mutable arguments back from call to equ
27442816 // copy back results provided by call to equ
@@ -2745,15 +2817,15 @@
27452817 stack[base + 4] = stack[base + 8LLU];
27462818 if(!stack[base + 4]/*isequal*/)
27472819 {
2748- label = 164LLU; // jump to alternative
2820+ label = 172LLU; // jump to alternative
27492821 break;
27502822 }
27512823
27522824 // consequent
27532825 // call equ from issimple
2754- stack[base + 5LLU] = 166LLU/*throw to this address*/;
2826+ stack[base + 5LLU] = 174LLU/*throw to this address*/;
27552827 stack[base + 6LLU] = base;
2756- stack[base + 7LLU] = 167LLU;
2828+ stack[base + 7LLU] = 175LLU;
27572829 // arguments for call to equ
27582830 stack[base + 9LLU] = stack[base + 3]/*sym*/;
27592831 stack[base + 10LLU] = stack[base + 2]/*content*/;
@@ -2762,14 +2834,14 @@
27622834 label = 18446744073709551600LLU; // equ
27632835 break;
27642836 }
2765- case 166LLU: // copy-back deleter (equ to issimple)
2837+ case 174LLU: // copy-back deleter (equ to issimple)
27662838 {
27672839 fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
27682840 // copy mutable arguments back from call to equ
2769- label = 160LLU; // continue to roll stack
2841+ label = 168LLU; // continue to roll stack
27702842 break;
27712843 }
2772- case 167LLU: // return from equ to issimple
2844+ case 175LLU: // return from equ to issimple
27732845 {
27742846 // copy mutable arguments back from call to equ
27752847 // copy back results provided by call to equ
@@ -2776,87 +2848,87 @@
27762848 stack[base + 4] = stack[base + 8LLU];
27772849 if(!stack[base + 4]/*isequal*/)
27782850 {
2779- label = 168LLU; // jump to alternative
2851+ label = 176LLU; // jump to alternative
27802852 break;
27812853 }
27822854
27832855 // consequent
2784- label = 171LLU; // skip deleter
2856+ label = 179LLU; // skip deleter
27852857 break;
27862858 }
2787- case 170LLU: // deleter
2859+ case 178LLU: // deleter
27882860 {
27892861 // throw from issimple
27902862 if(!stack[base + 0])
27912863 {
27922864 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2793- label = 160LLU; // skip, variable already deleted/unscoped
2865+ label = 168LLU; // skip, variable already deleted/unscoped
27942866 break;
27952867 }
27962868 fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2797- label = 160LLU; // continue unrolling stack, delete next variable
2869+ label = 168LLU; // continue unrolling stack, delete next variable
27982870 break;
27992871 }
2800- case 171LLU: // skipped deleter
2872+ case 179LLU: // skipped deleter
28012873 {
28022874 stack[base + 0] = 1;
2803- label = 169LLU; // consequent complete
2875+ label = 177LLU; // consequent complete
28042876 break;
28052877 }
2806- case 168LLU: // alternative
2878+ case 176LLU: // alternative
28072879 {
2808- label = 173LLU; // skip deleter
2880+ label = 181LLU; // skip deleter
28092881 break;
28102882 }
2811- case 172LLU: // deleter
2883+ case 180LLU: // deleter
28122884 {
28132885 // throw from issimple
28142886 if(!stack[base + 0])
28152887 {
28162888 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2817- label = 160LLU; // skip, variable already deleted/unscoped
2889+ label = 168LLU; // skip, variable already deleted/unscoped
28182890 break;
28192891 }
28202892 fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2821- label = 160LLU; // continue unrolling stack, delete next variable
2893+ label = 168LLU; // continue unrolling stack, delete next variable
28222894 break;
28232895 }
2824- case 173LLU: // skipped deleter
2896+ case 181LLU: // skipped deleter
28252897 {
28262898 stack[base + 0] = 0;
2827- label = 169LLU; // alternative complete
2899+ label = 177LLU; // alternative complete
28282900 break;
28292901 }
2830- case 169LLU: // completed if-then-else
2902+ case 177LLU: // completed if-then-else
28312903 {
2832- label = 165LLU; // consequent complete
2904+ label = 173LLU; // consequent complete
28332905 break;
28342906 }
2835- case 164LLU: // alternative
2907+ case 172LLU: // alternative
28362908 {
2837- label = 175LLU; // skip deleter
2909+ label = 183LLU; // skip deleter
28382910 break;
28392911 }
2840- case 174LLU: // deleter
2912+ case 182LLU: // deleter
28412913 {
28422914 // throw from issimple
28432915 if(!stack[base + 0])
28442916 {
28452917 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2846- label = 160LLU; // skip, variable already deleted/unscoped
2918+ label = 168LLU; // skip, variable already deleted/unscoped
28472919 break;
28482920 }
28492921 fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2850- label = 160LLU; // continue unrolling stack, delete next variable
2922+ label = 168LLU; // continue unrolling stack, delete next variable
28512923 break;
28522924 }
2853- case 175LLU: // skipped deleter
2925+ case 183LLU: // skipped deleter
28542926 {
28552927 stack[base + 0] = 0;
2856- label = 165LLU; // alternative complete
2928+ label = 173LLU; // alternative complete
28572929 break;
28582930 }
2859- case 165LLU: // completed if-then-else
2931+ case 173LLU: // completed if-then-else
28602932 {
28612933 // return from issimple
28622934 label = stack[base - 1];
@@ -2863,7 +2935,7 @@
28632935 base = stack[base - 2];
28642936 break;
28652937 }
2866- case 177LLU: // function isident failed
2938+ case 185LLU: // function isident failed
28672939 {
28682940 fprintf(stderr, "function isident failed\n");
28692941 label = stack[base - 3];
@@ -2870,35 +2942,35 @@
28702942 base = stack[base - 2];
28712943 break;
28722944 }
2873- case 176LLU: // isident
2945+ case 184LLU: // isident
28742946 {
28752947 //#define res0 0
28762948 //#define arg0 1
28772949 //#define arg1 2
28782950 //#define arg2 3
2879- label = 179LLU; // skip deleter
2951+ label = 187LLU; // skip deleter
28802952 break;
28812953 }
2882- case 178LLU: // deleter
2954+ case 186LLU: // deleter
28832955 {
28842956 // throw from isident
28852957 if(!stack[base + 4])
28862958 {
28872959 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
2888- label = 177LLU; // skip, variable already deleted/unscoped
2960+ label = 185LLU; // skip, variable already deleted/unscoped
28892961 break;
28902962 }
28912963 fprintf(stderr, "in function isident: unrolling stack, variable u64 isequal\n");
2892- label = 177LLU; // continue unrolling stack, delete next variable
2964+ label = 185LLU; // continue unrolling stack, delete next variable
28932965 break;
28942966 }
2895- case 179LLU: // skipped deleter
2967+ case 187LLU: // skipped deleter
28962968 {
28972969 stack[base + 4] = 0;
28982970 // call equ from isident
2899- stack[base + 5LLU] = 180LLU/*throw to this address*/;
2971+ stack[base + 5LLU] = 188LLU/*throw to this address*/;
29002972 stack[base + 6LLU] = base;
2901- stack[base + 7LLU] = 181LLU;
2973+ stack[base + 7LLU] = 189LLU;
29022974 // arguments for call to equ
29032975 stack[base + 9LLU] = stack[base + 1]/*variant*/;
29042976 stack[base + 10LLU] = 4LLU;
@@ -2907,14 +2979,14 @@
29072979 label = 18446744073709551600LLU; // equ
29082980 break;
29092981 }
2910- case 180LLU: // copy-back deleter (equ to isident)
2982+ case 188LLU: // copy-back deleter (equ to isident)
29112983 {
29122984 fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
29132985 // copy mutable arguments back from call to equ
2914- label = 178LLU; // continue to roll stack
2986+ label = 186LLU; // continue to roll stack
29152987 break;
29162988 }
2917- case 181LLU: // return from equ to isident
2989+ case 189LLU: // return from equ to isident
29182990 {
29192991 // copy mutable arguments back from call to equ
29202992 // copy back results provided by call to equ
@@ -2921,15 +2993,15 @@
29212993 stack[base + 4] = stack[base + 8LLU];
29222994 if(!stack[base + 4]/*isequal*/)
29232995 {
2924- label = 182LLU; // jump to alternative
2996+ label = 190LLU; // jump to alternative
29252997 break;
29262998 }
29272999
29283000 // consequent
29293001 // call equ from isident
2930- stack[base + 5LLU] = 184LLU/*throw to this address*/;
3002+ stack[base + 5LLU] = 192LLU/*throw to this address*/;
29313003 stack[base + 6LLU] = base;
2932- stack[base + 7LLU] = 185LLU;
3004+ stack[base + 7LLU] = 193LLU;
29333005 // arguments for call to equ
29343006 stack[base + 9LLU] = stack[base + 3]/*ident*/;
29353007 stack[base + 10LLU] = stack[base + 2]/*content*/;
@@ -2938,14 +3010,14 @@
29383010 label = 18446744073709551600LLU; // equ
29393011 break;
29403012 }
2941- case 184LLU: // copy-back deleter (equ to isident)
3013+ case 192LLU: // copy-back deleter (equ to isident)
29423014 {
29433015 fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
29443016 // copy mutable arguments back from call to equ
2945- label = 178LLU; // continue to roll stack
3017+ label = 186LLU; // continue to roll stack
29463018 break;
29473019 }
2948- case 185LLU: // return from equ to isident
3020+ case 193LLU: // return from equ to isident
29493021 {
29503022 // copy mutable arguments back from call to equ
29513023 // copy back results provided by call to equ
@@ -2952,87 +3024,87 @@
29523024 stack[base + 4] = stack[base + 8LLU];
29533025 if(!stack[base + 4]/*isequal*/)
29543026 {
2955- label = 186LLU; // jump to alternative
3027+ label = 194LLU; // jump to alternative
29563028 break;
29573029 }
29583030
29593031 // consequent
2960- label = 189LLU; // skip deleter
3032+ label = 197LLU; // skip deleter
29613033 break;
29623034 }
2963- case 188LLU: // deleter
3035+ case 196LLU: // deleter
29643036 {
29653037 // throw from isident
29663038 if(!stack[base + 0])
29673039 {
29683040 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2969- label = 178LLU; // skip, variable already deleted/unscoped
3041+ label = 186LLU; // skip, variable already deleted/unscoped
29703042 break;
29713043 }
29723044 fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
2973- label = 178LLU; // continue unrolling stack, delete next variable
3045+ label = 186LLU; // continue unrolling stack, delete next variable
29743046 break;
29753047 }
2976- case 189LLU: // skipped deleter
3048+ case 197LLU: // skipped deleter
29773049 {
29783050 stack[base + 0] = 1;
2979- label = 187LLU; // consequent complete
3051+ label = 195LLU; // consequent complete
29803052 break;
29813053 }
2982- case 186LLU: // alternative
3054+ case 194LLU: // alternative
29833055 {
2984- label = 191LLU; // skip deleter
3056+ label = 199LLU; // skip deleter
29853057 break;
29863058 }
2987- case 190LLU: // deleter
3059+ case 198LLU: // deleter
29883060 {
29893061 // throw from isident
29903062 if(!stack[base + 0])
29913063 {
29923064 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2993- label = 178LLU; // skip, variable already deleted/unscoped
3065+ label = 186LLU; // skip, variable already deleted/unscoped
29943066 break;
29953067 }
29963068 fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
2997- label = 178LLU; // continue unrolling stack, delete next variable
3069+ label = 186LLU; // continue unrolling stack, delete next variable
29983070 break;
29993071 }
3000- case 191LLU: // skipped deleter
3072+ case 199LLU: // skipped deleter
30013073 {
30023074 stack[base + 0] = 0;
3003- label = 187LLU; // alternative complete
3075+ label = 195LLU; // alternative complete
30043076 break;
30053077 }
3006- case 187LLU: // completed if-then-else
3078+ case 195LLU: // completed if-then-else
30073079 {
3008- label = 183LLU; // consequent complete
3080+ label = 191LLU; // consequent complete
30093081 break;
30103082 }
3011- case 182LLU: // alternative
3083+ case 190LLU: // alternative
30123084 {
3013- label = 193LLU; // skip deleter
3085+ label = 201LLU; // skip deleter
30143086 break;
30153087 }
3016- case 192LLU: // deleter
3088+ case 200LLU: // deleter
30173089 {
30183090 // throw from isident
30193091 if(!stack[base + 0])
30203092 {
30213093 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3022- label = 178LLU; // skip, variable already deleted/unscoped
3094+ label = 186LLU; // skip, variable already deleted/unscoped
30233095 break;
30243096 }
30253097 fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
3026- label = 178LLU; // continue unrolling stack, delete next variable
3098+ label = 186LLU; // continue unrolling stack, delete next variable
30273099 break;
30283100 }
3029- case 193LLU: // skipped deleter
3101+ case 201LLU: // skipped deleter
30303102 {
30313103 stack[base + 0] = 0;
3032- label = 183LLU; // alternative complete
3104+ label = 191LLU; // alternative complete
30333105 break;
30343106 }
3035- case 183LLU: // completed if-then-else
3107+ case 191LLU: // completed if-then-else
30363108 {
30373109 // return from isident
30383110 label = stack[base - 1];
@@ -3039,7 +3111,7 @@
30393111 base = stack[base - 2];
30403112 break;
30413113 }
3042- case 195LLU: // function iseos failed
3114+ case 203LLU: // function iseos failed
30433115 {
30443116 fprintf(stderr, "function iseos failed\n");
30453117 label = stack[base - 3];
@@ -3046,14 +3118,14 @@
30463118 base = stack[base - 2];
30473119 break;
30483120 }
3049- case 194LLU: // iseos
3121+ case 202LLU: // iseos
30503122 {
30513123 //#define res0 0
30523124 //#define arg0 1
30533125 // call equ from iseos
3054- stack[base + 2LLU] = 196LLU/*throw to this address*/;
3126+ stack[base + 2LLU] = 204LLU/*throw to this address*/;
30553127 stack[base + 3LLU] = base;
3056- stack[base + 4LLU] = 197LLU;
3128+ stack[base + 4LLU] = 205LLU;
30573129 // arguments for call to equ
30583130 stack[base + 6LLU] = stack[base + 1]/*variantnr*/;
30593131 stack[base + 7LLU] = 5LLU;
@@ -3062,14 +3134,14 @@
30623134 label = 18446744073709551600LLU; // equ
30633135 break;
30643136 }
3065- case 196LLU: // copy-back deleter (equ to iseos)
3137+ case 204LLU: // copy-back deleter (equ to iseos)
30663138 {
30673139 fprintf(stderr, "in function iseos: unrolling stack, copy-back (equ to iseos)\n");
30683140 // copy mutable arguments back from call to equ
3069- label = 195LLU; // continue to roll stack
3141+ label = 203LLU; // continue to roll stack
30703142 break;
30713143 }
3072- case 197LLU: // return from equ to iseos
3144+ case 205LLU: // return from equ to iseos
30733145 {
30743146 // copy mutable arguments back from call to equ
30753147 // copy back results provided by call to equ
@@ -3079,7 +3151,7 @@
30793151 base = stack[base - 2];
30803152 break;
30813153 }
3082- case 199LLU: // function MATCHPEEK failed
3154+ case 207LLU: // function MATCHPEEK failed
30833155 {
30843156 fprintf(stderr, "function MATCHPEEK failed\n");
30853157 label = stack[base - 3];
@@ -3086,15 +3158,15 @@
30863158 base = stack[base - 2];
30873159 break;
30883160 }
3089- case 198LLU: // MATCHPEEK
3161+ case 206LLU: // MATCHPEEK
30903162 {
30913163 //#define arg0 0
30923164 //#define arg1 1
30933165 //#define arg2 2
30943166 // call skipwscmnt from MATCHPEEK
3095- stack[base + 3LLU] = 200LLU/*throw to this address*/;
3167+ stack[base + 3LLU] = 208LLU/*throw to this address*/;
30963168 stack[base + 4LLU] = base;
3097- stack[base + 5LLU] = 201LLU;
3169+ stack[base + 5LLU] = 209LLU;
30983170 // arguments for call to skipwscmnt
30993171 stack[base + 7LLU] = stack[base + 2]/*lookahead*/;
31003172 // set stack-base & callee-address
@@ -3102,22 +3174,40 @@
31023174 label = 18446744073709551580LLU; // skipwscmnt
31033175 break;
31043176 }
3105- case 200LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
3177+ case 208LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
31063178 {
31073179 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (skipwscmnt to MATCHPEEK)\n");
31083180 // copy mutable arguments back from call to skipwscmnt
3109- label = 199LLU; // continue to roll stack
3181+ label = 207LLU; // continue to roll stack
31103182 break;
31113183 }
3112- case 201LLU: // return from skipwscmnt to MATCHPEEK
3184+ case 209LLU: // return from skipwscmnt to MATCHPEEK
31133185 {
31143186 // copy mutable arguments back from call to skipwscmnt
31153187 // copy back results provided by call to skipwscmnt
31163188 stack[base + 2] = stack[base + 6LLU];
3189+ label = 211LLU; // skip deleter
3190+ break;
3191+ }
3192+ case 210LLU: // deleter
3193+ {
3194+ // throw from MATCHPEEK
3195+ if(!stack[base + 3])
3196+ {
3197+ fprintf(stderr, "in function MATCHPEEK: unrolling stack, skipping already deleted/unscoped variable u64 isqual\n");
3198+ label = 207LLU; // skip, variable already deleted/unscoped
3199+ break;
3200+ }
3201+ fprintf(stderr, "in function MATCHPEEK: unrolling stack, variable u64 isqual\n");
3202+ label = 207LLU; // continue unrolling stack, delete next variable
3203+ break;
3204+ }
3205+ case 211LLU: // skipped deleter
3206+ {
31173207 // call equ from MATCHPEEK
3118- stack[base + 4LLU] = 202LLU/*throw to this address*/;
3208+ stack[base + 4LLU] = 212LLU/*throw to this address*/;
31193209 stack[base + 5LLU] = base;
3120- stack[base + 6LLU] = 203LLU;
3210+ stack[base + 6LLU] = 213LLU;
31213211 // arguments for call to equ
31223212 stack[base + 8LLU] = stack[base + 2]/*lookahead*/;
31233213 stack[base + 9LLU] = stack[base + 1]/*sym*/;
@@ -3126,14 +3216,14 @@
31263216 label = 18446744073709551600LLU; // equ
31273217 break;
31283218 }
3129- case 202LLU: // copy-back deleter (equ to MATCHPEEK)
3219+ case 212LLU: // copy-back deleter (equ to MATCHPEEK)
31303220 {
31313221 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (equ to MATCHPEEK)\n");
31323222 // copy mutable arguments back from call to equ
3133- label = 199LLU; // continue to roll stack
3223+ label = 207LLU; // continue to roll stack
31343224 break;
31353225 }
3136- case 203LLU: // return from equ to MATCHPEEK
3226+ case 213LLU: // return from equ to MATCHPEEK
31373227 {
31383228 // copy mutable arguments back from call to equ
31393229 // copy back results provided by call to equ
@@ -3140,21 +3230,21 @@
31403230 stack[base + 3] = stack[base + 7LLU];
31413231 if(!stack[base + 3]/*isqual*/)
31423232 {
3143- label = 204LLU; // jump to alternative
3233+ label = 214LLU; // jump to alternative
31443234 break;
31453235 }
31463236
31473237 // consequent
3148- label = 205LLU; // consequent complete
3238+ label = 215LLU; // consequent complete
31493239 break;
31503240 }
3151- case 204LLU: // alternative
3241+ case 214LLU: // alternative
31523242 {
31533243 fprintf(stderr, "%s", "in function ");
31543244 // call reportid from MATCHPEEK
3155- stack[base + 4LLU] = 206LLU/*throw to this address*/;
3245+ stack[base + 4LLU] = 216LLU/*throw to this address*/;
31563246 stack[base + 5LLU] = base;
3157- stack[base + 6LLU] = 207LLU;
3247+ stack[base + 6LLU] = 217LLU;
31583248 // arguments for call to reportid
31593249 stack[base + 7LLU] = stack[base + 0]/*fnid*/;
31603250 // set stack-base & callee-address
@@ -3162,22 +3252,22 @@
31623252 label = 18446744073709551586LLU; // reportid
31633253 break;
31643254 }
3165- case 206LLU: // copy-back deleter (reportid to MATCHPEEK)
3255+ case 216LLU: // copy-back deleter (reportid to MATCHPEEK)
31663256 {
31673257 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportid to MATCHPEEK)\n");
31683258 // copy mutable arguments back from call to reportid
3169- label = 199LLU; // continue to roll stack
3259+ label = 210LLU; // continue to roll stack
31703260 break;
31713261 }
3172- case 207LLU: // return from reportid to MATCHPEEK
3262+ case 217LLU: // return from reportid to MATCHPEEK
31733263 {
31743264 // copy mutable arguments back from call to reportid
31753265 fprintf(stderr, "%s", ": ");
31763266 fprintf(stderr, "%s", "expected '");
31773267 // call reportbyte from MATCHPEEK
3178- stack[base + 4LLU] = 208LLU/*throw to this address*/;
3268+ stack[base + 4LLU] = 218LLU/*throw to this address*/;
31793269 stack[base + 5LLU] = base;
3180- stack[base + 6LLU] = 209LLU;
3270+ stack[base + 6LLU] = 219LLU;
31813271 // arguments for call to reportbyte
31823272 stack[base + 7LLU] = stack[base + 1]/*sym*/;
31833273 // set stack-base & callee-address
@@ -3185,21 +3275,21 @@
31853275 label = 18446744073709551591LLU; // reportbyte
31863276 break;
31873277 }
3188- case 208LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3278+ case 218LLU: // copy-back deleter (reportbyte to MATCHPEEK)
31893279 {
31903280 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
31913281 // copy mutable arguments back from call to reportbyte
3192- label = 199LLU; // continue to roll stack
3282+ label = 210LLU; // continue to roll stack
31933283 break;
31943284 }
3195- case 209LLU: // return from reportbyte to MATCHPEEK
3285+ case 219LLU: // return from reportbyte to MATCHPEEK
31963286 {
31973287 // copy mutable arguments back from call to reportbyte
31983288 fprintf(stderr, "%s", "' but found token ");
31993289 // call reportbyte from MATCHPEEK
3200- stack[base + 4LLU] = 210LLU/*throw to this address*/;
3290+ stack[base + 4LLU] = 220LLU/*throw to this address*/;
32013291 stack[base + 5LLU] = base;
3202- stack[base + 6LLU] = 211LLU;
3292+ stack[base + 6LLU] = 221LLU;
32033293 // arguments for call to reportbyte
32043294 stack[base + 7LLU] = stack[base + 2]/*lookahead*/;
32053295 // set stack-base & callee-address
@@ -3207,22 +3297,22 @@
32073297 label = 18446744073709551591LLU; // reportbyte
32083298 break;
32093299 }
3210- case 210LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3300+ case 220LLU: // copy-back deleter (reportbyte to MATCHPEEK)
32113301 {
32123302 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
32133303 // copy mutable arguments back from call to reportbyte
3214- label = 199LLU; // continue to roll stack
3304+ label = 210LLU; // continue to roll stack
32153305 break;
32163306 }
3217- case 211LLU: // return from reportbyte to MATCHPEEK
3307+ case 221LLU: // return from reportbyte to MATCHPEEK
32183308 {
32193309 // copy mutable arguments back from call to reportbyte
32203310 fprintf(stderr, "%s", "\n");
32213311 exit(-1);
3222- label = 205LLU; // alternative complete
3312+ label = 215LLU; // alternative complete
32233313 break;
32243314 }
3225- case 205LLU: // completed if-then-else
3315+ case 215LLU: // completed if-then-else
32263316 {
32273317 // return from MATCHPEEK
32283318 label = stack[base - 1];
@@ -3229,7 +3319,7 @@
32293319 base = stack[base - 2];
32303320 break;
32313321 }
3232- case 213LLU: // function matchsym failed
3322+ case 223LLU: // function matchsym failed
32333323 {
32343324 fprintf(stderr, "function matchsym failed\n");
32353325 label = stack[base - 3];
@@ -3236,53 +3326,53 @@
32363326 base = stack[base - 2];
32373327 break;
32383328 }
3239- case 212LLU: // matchsym
3329+ case 222LLU: // matchsym
32403330 {
32413331 //#define arg0 0
32423332 //#define arg1 1
32433333 //#define arg2 2
3244- label = 215LLU; // skip deleter
3334+ label = 225LLU; // skip deleter
32453335 break;
32463336 }
3247- case 214LLU: // deleter
3337+ case 224LLU: // deleter
32483338 {
32493339 // throw from matchsym
32503340 if(!stack[base + 3])
32513341 {
32523342 fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 variant\n");
3253- label = 213LLU; // skip, variable already deleted/unscoped
3343+ label = 223LLU; // skip, variable already deleted/unscoped
32543344 break;
32553345 }
32563346 fprintf(stderr, "in function matchsym: unrolling stack, variable u64 variant\n");
3257- label = 213LLU; // continue unrolling stack, delete next variable
3347+ label = 223LLU; // continue unrolling stack, delete next variable
32583348 break;
32593349 }
3260- case 215LLU: // skipped deleter
3350+ case 225LLU: // skipped deleter
32613351 {
32623352 stack[base + 3] = 0;
3263- label = 217LLU; // skip deleter
3353+ label = 227LLU; // skip deleter
32643354 break;
32653355 }
3266- case 216LLU: // deleter
3356+ case 226LLU: // deleter
32673357 {
32683358 // throw from matchsym
32693359 if(!stack[base + 4])
32703360 {
32713361 fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 content\n");
3272- label = 214LLU; // skip, variable already deleted/unscoped
3362+ label = 224LLU; // skip, variable already deleted/unscoped
32733363 break;
32743364 }
32753365 fprintf(stderr, "in function matchsym: unrolling stack, variable u64 content\n");
3276- label = 214LLU; // continue unrolling stack, delete next variable
3366+ label = 224LLU; // continue unrolling stack, delete next variable
32773367 break;
32783368 }
3279- case 217LLU: // skipped deleter
3369+ case 227LLU: // skipped deleter
32803370 {
32813371 stack[base + 4] = 0;
32823372 // call ParseToken from matchsym
3283- stack[base + 5LLU] = 218LLU/*throw to this address*/;
3373+ stack[base + 5LLU] = 228LLU/*throw to this address*/;
32843374 stack[base + 6LLU] = base;
3285- stack[base + 7LLU] = 219LLU;
3375+ stack[base + 7LLU] = 229LLU;
32863376 // arguments for call to ParseToken
32873377 stack[base + 10LLU] = stack[base + 2]/*lookahead*/;
32883378 // set stack-base & callee-address
@@ -3290,15 +3380,15 @@
32903380 label = 3LLU; // ParseToken
32913381 break;
32923382 }
3293- case 218LLU: // copy-back deleter (ParseToken to matchsym)
3383+ case 228LLU: // copy-back deleter (ParseToken to matchsym)
32943384 {
32953385 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (ParseToken to matchsym)\n");
32963386 // copy mutable arguments back from call to ParseToken
32973387 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
3298- label = 216LLU; // continue to roll stack
3388+ label = 226LLU; // continue to roll stack
32993389 break;
33003390 }
3301- case 219LLU: // return from ParseToken to matchsym
3391+ case 229LLU: // return from ParseToken to matchsym
33023392 {
33033393 // copy mutable arguments back from call to ParseToken
33043394 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
@@ -3305,29 +3395,29 @@
33053395 // copy back results provided by call to ParseToken
33063396 stack[base + 3] = stack[base + 8LLU];
33073397 stack[base + 4] = stack[base + 9LLU];
3308- label = 221LLU; // skip deleter
3398+ label = 231LLU; // skip deleter
33093399 break;
33103400 }
3311- case 220LLU: // deleter
3401+ case 230LLU: // deleter
33123402 {
33133403 // throw from matchsym
33143404 if(!stack[base + 5])
33153405 {
33163406 fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 isqual\n");
3317- label = 216LLU; // skip, variable already deleted/unscoped
3407+ label = 226LLU; // skip, variable already deleted/unscoped
33183408 break;
33193409 }
33203410 fprintf(stderr, "in function matchsym: unrolling stack, variable u64 isqual\n");
3321- label = 216LLU; // continue unrolling stack, delete next variable
3411+ label = 226LLU; // continue unrolling stack, delete next variable
33223412 break;
33233413 }
3324- case 221LLU: // skipped deleter
3414+ case 231LLU: // skipped deleter
33253415 {
33263416 stack[base + 5] = 0;
33273417 // call equ from matchsym
3328- stack[base + 6LLU] = 222LLU/*throw to this address*/;
3418+ stack[base + 6LLU] = 232LLU/*throw to this address*/;
33293419 stack[base + 7LLU] = base;
3330- stack[base + 8LLU] = 223LLU;
3420+ stack[base + 8LLU] = 233LLU;
33313421 // arguments for call to equ
33323422 stack[base + 10LLU] = stack[base + 3]/*variant*/;
33333423 stack[base + 11LLU] = 0LLU;
@@ -3336,14 +3426,14 @@
33363426 label = 18446744073709551600LLU; // equ
33373427 break;
33383428 }
3339- case 222LLU: // copy-back deleter (equ to matchsym)
3429+ case 232LLU: // copy-back deleter (equ to matchsym)
33403430 {
33413431 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
33423432 // copy mutable arguments back from call to equ
3343- label = 220LLU; // continue to roll stack
3433+ label = 230LLU; // continue to roll stack
33443434 break;
33453435 }
3346- case 223LLU: // return from equ to matchsym
3436+ case 233LLU: // return from equ to matchsym
33473437 {
33483438 // copy mutable arguments back from call to equ
33493439 // copy back results provided by call to equ
@@ -3350,15 +3440,15 @@
33503440 stack[base + 5] = stack[base + 9LLU];
33513441 if(!stack[base + 5]/*isqual*/)
33523442 {
3353- label = 224LLU; // jump to alternative
3443+ label = 234LLU; // jump to alternative
33543444 break;
33553445 }
33563446
33573447 // consequent
33583448 // call equ from matchsym
3359- stack[base + 6LLU] = 226LLU/*throw to this address*/;
3449+ stack[base + 6LLU] = 236LLU/*throw to this address*/;
33603450 stack[base + 7LLU] = base;
3361- stack[base + 8LLU] = 227LLU;
3451+ stack[base + 8LLU] = 237LLU;
33623452 // arguments for call to equ
33633453 stack[base + 10LLU] = stack[base + 1]/*sym*/;
33643454 stack[base + 11LLU] = stack[base + 4]/*content*/;
@@ -3367,14 +3457,14 @@
33673457 label = 18446744073709551600LLU; // equ
33683458 break;
33693459 }
3370- case 226LLU: // copy-back deleter (equ to matchsym)
3460+ case 236LLU: // copy-back deleter (equ to matchsym)
33713461 {
33723462 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
33733463 // copy mutable arguments back from call to equ
3374- label = 220LLU; // continue to roll stack
3464+ label = 230LLU; // continue to roll stack
33753465 break;
33763466 }
3377- case 227LLU: // return from equ to matchsym
3467+ case 237LLU: // return from equ to matchsym
33783468 {
33793469 // copy mutable arguments back from call to equ
33803470 // copy back results provided by call to equ
@@ -3381,21 +3471,21 @@
33813471 stack[base + 5] = stack[base + 9LLU];
33823472 if(!stack[base + 5]/*isqual*/)
33833473 {
3384- label = 228LLU; // jump to alternative
3474+ label = 238LLU; // jump to alternative
33853475 break;
33863476 }
33873477
33883478 // consequent
3389- label = 229LLU; // consequent complete
3479+ label = 239LLU; // consequent complete
33903480 break;
33913481 }
3392- case 228LLU: // alternative
3482+ case 238LLU: // alternative
33933483 {
33943484 fprintf(stderr, "%s", "in function ");
33953485 // call reportid from matchsym
3396- stack[base + 6LLU] = 230LLU/*throw to this address*/;
3486+ stack[base + 6LLU] = 240LLU/*throw to this address*/;
33973487 stack[base + 7LLU] = base;
3398- stack[base + 8LLU] = 231LLU;
3488+ stack[base + 8LLU] = 241LLU;
33993489 // arguments for call to reportid
34003490 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
34013491 // set stack-base & callee-address
@@ -3403,22 +3493,22 @@
34033493 label = 18446744073709551586LLU; // reportid
34043494 break;
34053495 }
3406- case 230LLU: // copy-back deleter (reportid to matchsym)
3496+ case 240LLU: // copy-back deleter (reportid to matchsym)
34073497 {
34083498 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
34093499 // copy mutable arguments back from call to reportid
3410- label = 220LLU; // continue to roll stack
3500+ label = 230LLU; // continue to roll stack
34113501 break;
34123502 }
3413- case 231LLU: // return from reportid to matchsym
3503+ case 241LLU: // return from reportid to matchsym
34143504 {
34153505 // copy mutable arguments back from call to reportid
34163506 fprintf(stderr, "%s", ": ");
34173507 fprintf(stderr, "%s", "expected '");
34183508 // call reportbyte from matchsym
3419- stack[base + 6LLU] = 232LLU/*throw to this address*/;
3509+ stack[base + 6LLU] = 242LLU/*throw to this address*/;
34203510 stack[base + 7LLU] = base;
3421- stack[base + 8LLU] = 233LLU;
3511+ stack[base + 8LLU] = 243LLU;
34223512 // arguments for call to reportbyte
34233513 stack[base + 9LLU] = stack[base + 1]/*sym*/;
34243514 // set stack-base & callee-address
@@ -3426,21 +3516,21 @@
34263516 label = 18446744073709551591LLU; // reportbyte
34273517 break;
34283518 }
3429- case 232LLU: // copy-back deleter (reportbyte to matchsym)
3519+ case 242LLU: // copy-back deleter (reportbyte to matchsym)
34303520 {
34313521 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
34323522 // copy mutable arguments back from call to reportbyte
3433- label = 220LLU; // continue to roll stack
3523+ label = 230LLU; // continue to roll stack
34343524 break;
34353525 }
3436- case 233LLU: // return from reportbyte to matchsym
3526+ case 243LLU: // return from reportbyte to matchsym
34373527 {
34383528 // copy mutable arguments back from call to reportbyte
34393529 fprintf(stderr, "%s", "' but found token ");
34403530 // call reporttok from matchsym
3441- stack[base + 6LLU] = 234LLU/*throw to this address*/;
3531+ stack[base + 6LLU] = 244LLU/*throw to this address*/;
34423532 stack[base + 7LLU] = base;
3443- stack[base + 8LLU] = 235LLU;
3533+ stack[base + 8LLU] = 245LLU;
34443534 // arguments for call to reporttok
34453535 stack[base + 9LLU] = stack[base + 3]/*variant*/;
34463536 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3449,33 +3539,33 @@
34493539 label = 18446744073709551582LLU; // reporttok
34503540 break;
34513541 }
3452- case 234LLU: // copy-back deleter (reporttok to matchsym)
3542+ case 244LLU: // copy-back deleter (reporttok to matchsym)
34533543 {
34543544 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
34553545 // copy mutable arguments back from call to reporttok
3456- label = 220LLU; // continue to roll stack
3546+ label = 230LLU; // continue to roll stack
34573547 break;
34583548 }
3459- case 235LLU: // return from reporttok to matchsym
3549+ case 245LLU: // return from reporttok to matchsym
34603550 {
34613551 // copy mutable arguments back from call to reporttok
34623552 fprintf(stderr, "%s", "\n");
34633553 exit(-1);
3464- label = 229LLU; // alternative complete
3554+ label = 239LLU; // alternative complete
34653555 break;
34663556 }
3467- case 229LLU: // completed if-then-else
3557+ case 239LLU: // completed if-then-else
34683558 {
3469- label = 225LLU; // consequent complete
3559+ label = 235LLU; // consequent complete
34703560 break;
34713561 }
3472- case 224LLU: // alternative
3562+ case 234LLU: // alternative
34733563 {
34743564 fprintf(stderr, "%s", "in function ");
34753565 // call reportid from matchsym
3476- stack[base + 6LLU] = 236LLU/*throw to this address*/;
3566+ stack[base + 6LLU] = 246LLU/*throw to this address*/;
34773567 stack[base + 7LLU] = base;
3478- stack[base + 8LLU] = 237LLU;
3568+ stack[base + 8LLU] = 247LLU;
34793569 // arguments for call to reportid
34803570 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
34813571 // set stack-base & callee-address
@@ -3483,22 +3573,22 @@
34833573 label = 18446744073709551586LLU; // reportid
34843574 break;
34853575 }
3486- case 236LLU: // copy-back deleter (reportid to matchsym)
3576+ case 246LLU: // copy-back deleter (reportid to matchsym)
34873577 {
34883578 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
34893579 // copy mutable arguments back from call to reportid
3490- label = 220LLU; // continue to roll stack
3580+ label = 230LLU; // continue to roll stack
34913581 break;
34923582 }
3493- case 237LLU: // return from reportid to matchsym
3583+ case 247LLU: // return from reportid to matchsym
34943584 {
34953585 // copy mutable arguments back from call to reportid
34963586 fprintf(stderr, "%s", ": ");
34973587 fprintf(stderr, "%s", "expected '");
34983588 // call reportbyte from matchsym
3499- stack[base + 6LLU] = 238LLU/*throw to this address*/;
3589+ stack[base + 6LLU] = 248LLU/*throw to this address*/;
35003590 stack[base + 7LLU] = base;
3501- stack[base + 8LLU] = 239LLU;
3591+ stack[base + 8LLU] = 249LLU;
35023592 // arguments for call to reportbyte
35033593 stack[base + 9LLU] = stack[base + 1]/*sym*/;
35043594 // set stack-base & callee-address
@@ -3506,21 +3596,21 @@
35063596 label = 18446744073709551591LLU; // reportbyte
35073597 break;
35083598 }
3509- case 238LLU: // copy-back deleter (reportbyte to matchsym)
3599+ case 248LLU: // copy-back deleter (reportbyte to matchsym)
35103600 {
35113601 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
35123602 // copy mutable arguments back from call to reportbyte
3513- label = 220LLU; // continue to roll stack
3603+ label = 230LLU; // continue to roll stack
35143604 break;
35153605 }
3516- case 239LLU: // return from reportbyte to matchsym
3606+ case 249LLU: // return from reportbyte to matchsym
35173607 {
35183608 // copy mutable arguments back from call to reportbyte
35193609 fprintf(stderr, "%s", "' but found token ");
35203610 // call reporttok from matchsym
3521- stack[base + 6LLU] = 240LLU/*throw to this address*/;
3611+ stack[base + 6LLU] = 250LLU/*throw to this address*/;
35223612 stack[base + 7LLU] = base;
3523- stack[base + 8LLU] = 241LLU;
3613+ stack[base + 8LLU] = 251LLU;
35243614 // arguments for call to reporttok
35253615 stack[base + 9LLU] = stack[base + 3]/*variant*/;
35263616 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3529,22 +3619,22 @@
35293619 label = 18446744073709551582LLU; // reporttok
35303620 break;
35313621 }
3532- case 240LLU: // copy-back deleter (reporttok to matchsym)
3622+ case 250LLU: // copy-back deleter (reporttok to matchsym)
35333623 {
35343624 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
35353625 // copy mutable arguments back from call to reporttok
3536- label = 220LLU; // continue to roll stack
3626+ label = 230LLU; // continue to roll stack
35373627 break;
35383628 }
3539- case 241LLU: // return from reporttok to matchsym
3629+ case 251LLU: // return from reporttok to matchsym
35403630 {
35413631 // copy mutable arguments back from call to reporttok
35423632 fprintf(stderr, "%s", "\n");
35433633 exit(-1);
3544- label = 225LLU; // alternative complete
3634+ label = 235LLU; // alternative complete
35453635 break;
35463636 }
3547- case 225LLU: // completed if-then-else
3637+ case 235LLU: // completed if-then-else
35483638 {
35493639 // return from matchsym
35503640 label = stack[base - 1];
@@ -3551,7 +3641,7 @@
35513641 base = stack[base - 2];
35523642 break;
35533643 }
3554- case 243LLU: // function matchid failed
3644+ case 253LLU: // function matchid failed
35553645 {
35563646 fprintf(stderr, "function matchid failed\n");
35573647 label = stack[base - 3];
@@ -3558,53 +3648,53 @@
35583648 base = stack[base - 2];
35593649 break;
35603650 }
3561- case 242LLU: // matchid
3651+ case 252LLU: // matchid
35623652 {
35633653 //#define arg0 0
35643654 //#define arg1 1
35653655 //#define arg2 2
3566- label = 245LLU; // skip deleter
3656+ label = 255LLU; // skip deleter
35673657 break;
35683658 }
3569- case 244LLU: // deleter
3659+ case 254LLU: // deleter
35703660 {
35713661 // throw from matchid
35723662 if(!stack[base + 3])
35733663 {
35743664 fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 variant\n");
3575- label = 243LLU; // skip, variable already deleted/unscoped
3665+ label = 253LLU; // skip, variable already deleted/unscoped
35763666 break;
35773667 }
35783668 fprintf(stderr, "in function matchid: unrolling stack, variable u64 variant\n");
3579- label = 243LLU; // continue unrolling stack, delete next variable
3669+ label = 253LLU; // continue unrolling stack, delete next variable
35803670 break;
35813671 }
3582- case 245LLU: // skipped deleter
3672+ case 255LLU: // skipped deleter
35833673 {
35843674 stack[base + 3] = 0;
3585- label = 247LLU; // skip deleter
3675+ label = 257LLU; // skip deleter
35863676 break;
35873677 }
3588- case 246LLU: // deleter
3678+ case 256LLU: // deleter
35893679 {
35903680 // throw from matchid
35913681 if(!stack[base + 4])
35923682 {
35933683 fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 content\n");
3594- label = 244LLU; // skip, variable already deleted/unscoped
3684+ label = 254LLU; // skip, variable already deleted/unscoped
35953685 break;
35963686 }
35973687 fprintf(stderr, "in function matchid: unrolling stack, variable u64 content\n");
3598- label = 244LLU; // continue unrolling stack, delete next variable
3688+ label = 254LLU; // continue unrolling stack, delete next variable
35993689 break;
36003690 }
3601- case 247LLU: // skipped deleter
3691+ case 257LLU: // skipped deleter
36023692 {
36033693 stack[base + 4] = 0;
36043694 // call ParseToken from matchid
3605- stack[base + 5LLU] = 248LLU/*throw to this address*/;
3695+ stack[base + 5LLU] = 258LLU/*throw to this address*/;
36063696 stack[base + 6LLU] = base;
3607- stack[base + 7LLU] = 249LLU;
3697+ stack[base + 7LLU] = 259LLU;
36083698 // arguments for call to ParseToken
36093699 stack[base + 10LLU] = stack[base + 2]/*lookahead*/;
36103700 // set stack-base & callee-address
@@ -3612,15 +3702,15 @@
36123702 label = 3LLU; // ParseToken
36133703 break;
36143704 }
3615- case 248LLU: // copy-back deleter (ParseToken to matchid)
3705+ case 258LLU: // copy-back deleter (ParseToken to matchid)
36163706 {
36173707 fprintf(stderr, "in function matchid: unrolling stack, copy-back (ParseToken to matchid)\n");
36183708 // copy mutable arguments back from call to ParseToken
36193709 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
3620- label = 246LLU; // continue to roll stack
3710+ label = 256LLU; // continue to roll stack
36213711 break;
36223712 }
3623- case 249LLU: // return from ParseToken to matchid
3713+ case 259LLU: // return from ParseToken to matchid
36243714 {
36253715 // copy mutable arguments back from call to ParseToken
36263716 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
@@ -3627,29 +3717,29 @@
36273717 // copy back results provided by call to ParseToken
36283718 stack[base + 3] = stack[base + 8LLU];
36293719 stack[base + 4] = stack[base + 9LLU];
3630- label = 251LLU; // skip deleter
3720+ label = 261LLU; // skip deleter
36313721 break;
36323722 }
3633- case 250LLU: // deleter
3723+ case 260LLU: // deleter
36343724 {
36353725 // throw from matchid
36363726 if(!stack[base + 5])
36373727 {
36383728 fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 isqual\n");
3639- label = 246LLU; // skip, variable already deleted/unscoped
3729+ label = 256LLU; // skip, variable already deleted/unscoped
36403730 break;
36413731 }
36423732 fprintf(stderr, "in function matchid: unrolling stack, variable u64 isqual\n");
3643- label = 246LLU; // continue unrolling stack, delete next variable
3733+ label = 256LLU; // continue unrolling stack, delete next variable
36443734 break;
36453735 }
3646- case 251LLU: // skipped deleter
3736+ case 261LLU: // skipped deleter
36473737 {
36483738 stack[base + 5] = 0;
36493739 // call equ from matchid
3650- stack[base + 6LLU] = 252LLU/*throw to this address*/;
3740+ stack[base + 6LLU] = 262LLU/*throw to this address*/;
36513741 stack[base + 7LLU] = base;
3652- stack[base + 8LLU] = 253LLU;
3742+ stack[base + 8LLU] = 263LLU;
36533743 // arguments for call to equ
36543744 stack[base + 10LLU] = stack[base + 3]/*variant*/;
36553745 stack[base + 11LLU] = 4LLU;
@@ -3658,14 +3748,14 @@
36583748 label = 18446744073709551600LLU; // equ
36593749 break;
36603750 }
3661- case 252LLU: // copy-back deleter (equ to matchid)
3751+ case 262LLU: // copy-back deleter (equ to matchid)
36623752 {
36633753 fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
36643754 // copy mutable arguments back from call to equ
3665- label = 250LLU; // continue to roll stack
3755+ label = 260LLU; // continue to roll stack
36663756 break;
36673757 }
3668- case 253LLU: // return from equ to matchid
3758+ case 263LLU: // return from equ to matchid
36693759 {
36703760 // copy mutable arguments back from call to equ
36713761 // copy back results provided by call to equ
@@ -3672,15 +3762,15 @@
36723762 stack[base + 5] = stack[base + 9LLU];
36733763 if(!stack[base + 5]/*isqual*/)
36743764 {
3675- label = 254LLU; // jump to alternative
3765+ label = 264LLU; // jump to alternative
36763766 break;
36773767 }
36783768
36793769 // consequent
36803770 // call equ from matchid
3681- stack[base + 6LLU] = 256LLU/*throw to this address*/;
3771+ stack[base + 6LLU] = 266LLU/*throw to this address*/;
36823772 stack[base + 7LLU] = base;
3683- stack[base + 8LLU] = 257LLU;
3773+ stack[base + 8LLU] = 267LLU;
36843774 // arguments for call to equ
36853775 stack[base + 10LLU] = stack[base + 1]/*id*/;
36863776 stack[base + 11LLU] = stack[base + 4]/*content*/;
@@ -3689,14 +3779,14 @@
36893779 label = 18446744073709551600LLU; // equ
36903780 break;
36913781 }
3692- case 256LLU: // copy-back deleter (equ to matchid)
3782+ case 266LLU: // copy-back deleter (equ to matchid)
36933783 {
36943784 fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
36953785 // copy mutable arguments back from call to equ
3696- label = 250LLU; // continue to roll stack
3786+ label = 260LLU; // continue to roll stack
36973787 break;
36983788 }
3699- case 257LLU: // return from equ to matchid
3789+ case 267LLU: // return from equ to matchid
37003790 {
37013791 // copy mutable arguments back from call to equ
37023792 // copy back results provided by call to equ
@@ -3703,21 +3793,21 @@
37033793 stack[base + 5] = stack[base + 9LLU];
37043794 if(!stack[base + 5]/*isqual*/)
37053795 {
3706- label = 258LLU; // jump to alternative
3796+ label = 268LLU; // jump to alternative
37073797 break;
37083798 }
37093799
37103800 // consequent
3711- label = 259LLU; // consequent complete
3801+ label = 269LLU; // consequent complete
37123802 break;
37133803 }
3714- case 258LLU: // alternative
3804+ case 268LLU: // alternative
37153805 {
37163806 fprintf(stderr, "%s", "in function ");
37173807 // call reportid from matchid
3718- stack[base + 6LLU] = 260LLU/*throw to this address*/;
3808+ stack[base + 6LLU] = 270LLU/*throw to this address*/;
37193809 stack[base + 7LLU] = base;
3720- stack[base + 8LLU] = 261LLU;
3810+ stack[base + 8LLU] = 271LLU;
37213811 // arguments for call to reportid
37223812 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
37233813 // set stack-base & callee-address
@@ -3725,22 +3815,22 @@
37253815 label = 18446744073709551586LLU; // reportid
37263816 break;
37273817 }
3728- case 260LLU: // copy-back deleter (reportid to matchid)
3818+ case 270LLU: // copy-back deleter (reportid to matchid)
37293819 {
37303820 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
37313821 // copy mutable arguments back from call to reportid
3732- label = 250LLU; // continue to roll stack
3822+ label = 260LLU; // continue to roll stack
37333823 break;
37343824 }
3735- case 261LLU: // return from reportid to matchid
3825+ case 271LLU: // return from reportid to matchid
37363826 {
37373827 // copy mutable arguments back from call to reportid
37383828 fprintf(stderr, "%s", ": ");
37393829 fprintf(stderr, "%s", "expected ");
37403830 // call reportid from matchid
3741- stack[base + 6LLU] = 262LLU/*throw to this address*/;
3831+ stack[base + 6LLU] = 272LLU/*throw to this address*/;
37423832 stack[base + 7LLU] = base;
3743- stack[base + 8LLU] = 263LLU;
3833+ stack[base + 8LLU] = 273LLU;
37443834 // arguments for call to reportid
37453835 stack[base + 9LLU] = stack[base + 1]/*id*/;
37463836 // set stack-base & callee-address
@@ -3748,21 +3838,21 @@
37483838 label = 18446744073709551586LLU; // reportid
37493839 break;
37503840 }
3751- case 262LLU: // copy-back deleter (reportid to matchid)
3841+ case 272LLU: // copy-back deleter (reportid to matchid)
37523842 {
37533843 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
37543844 // copy mutable arguments back from call to reportid
3755- label = 250LLU; // continue to roll stack
3845+ label = 260LLU; // continue to roll stack
37563846 break;
37573847 }
3758- case 263LLU: // return from reportid to matchid
3848+ case 273LLU: // return from reportid to matchid
37593849 {
37603850 // copy mutable arguments back from call to reportid
37613851 fprintf(stderr, "%s", " but found token ");
37623852 // call reporttok from matchid
3763- stack[base + 6LLU] = 264LLU/*throw to this address*/;
3853+ stack[base + 6LLU] = 274LLU/*throw to this address*/;
37643854 stack[base + 7LLU] = base;
3765- stack[base + 8LLU] = 265LLU;
3855+ stack[base + 8LLU] = 275LLU;
37663856 // arguments for call to reporttok
37673857 stack[base + 9LLU] = stack[base + 3]/*variant*/;
37683858 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3771,33 +3861,33 @@
37713861 label = 18446744073709551582LLU; // reporttok
37723862 break;
37733863 }
3774- case 264LLU: // copy-back deleter (reporttok to matchid)
3864+ case 274LLU: // copy-back deleter (reporttok to matchid)
37753865 {
37763866 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
37773867 // copy mutable arguments back from call to reporttok
3778- label = 250LLU; // continue to roll stack
3868+ label = 260LLU; // continue to roll stack
37793869 break;
37803870 }
3781- case 265LLU: // return from reporttok to matchid
3871+ case 275LLU: // return from reporttok to matchid
37823872 {
37833873 // copy mutable arguments back from call to reporttok
37843874 fprintf(stderr, "%s", "\n");
37853875 exit(-1);
3786- label = 259LLU; // alternative complete
3876+ label = 269LLU; // alternative complete
37873877 break;
37883878 }
3789- case 259LLU: // completed if-then-else
3879+ case 269LLU: // completed if-then-else
37903880 {
3791- label = 255LLU; // consequent complete
3881+ label = 265LLU; // consequent complete
37923882 break;
37933883 }
3794- case 254LLU: // alternative
3884+ case 264LLU: // alternative
37953885 {
37963886 fprintf(stderr, "%s", "in function ");
37973887 // call reportid from matchid
3798- stack[base + 6LLU] = 266LLU/*throw to this address*/;
3888+ stack[base + 6LLU] = 276LLU/*throw to this address*/;
37993889 stack[base + 7LLU] = base;
3800- stack[base + 8LLU] = 267LLU;
3890+ stack[base + 8LLU] = 277LLU;
38013891 // arguments for call to reportid
38023892 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
38033893 // set stack-base & callee-address
@@ -3805,22 +3895,22 @@
38053895 label = 18446744073709551586LLU; // reportid
38063896 break;
38073897 }
3808- case 266LLU: // copy-back deleter (reportid to matchid)
3898+ case 276LLU: // copy-back deleter (reportid to matchid)
38093899 {
38103900 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
38113901 // copy mutable arguments back from call to reportid
3812- label = 250LLU; // continue to roll stack
3902+ label = 260LLU; // continue to roll stack
38133903 break;
38143904 }
3815- case 267LLU: // return from reportid to matchid
3905+ case 277LLU: // return from reportid to matchid
38163906 {
38173907 // copy mutable arguments back from call to reportid
38183908 fprintf(stderr, "%s", ": ");
38193909 fprintf(stderr, "%s", "expected ");
38203910 // call reportid from matchid
3821- stack[base + 6LLU] = 268LLU/*throw to this address*/;
3911+ stack[base + 6LLU] = 278LLU/*throw to this address*/;
38223912 stack[base + 7LLU] = base;
3823- stack[base + 8LLU] = 269LLU;
3913+ stack[base + 8LLU] = 279LLU;
38243914 // arguments for call to reportid
38253915 stack[base + 9LLU] = stack[base + 1]/*id*/;
38263916 // set stack-base & callee-address
@@ -3828,21 +3918,21 @@
38283918 label = 18446744073709551586LLU; // reportid
38293919 break;
38303920 }
3831- case 268LLU: // copy-back deleter (reportid to matchid)
3921+ case 278LLU: // copy-back deleter (reportid to matchid)
38323922 {
38333923 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
38343924 // copy mutable arguments back from call to reportid
3835- label = 250LLU; // continue to roll stack
3925+ label = 260LLU; // continue to roll stack
38363926 break;
38373927 }
3838- case 269LLU: // return from reportid to matchid
3928+ case 279LLU: // return from reportid to matchid
38393929 {
38403930 // copy mutable arguments back from call to reportid
38413931 fprintf(stderr, "%s", " but found token ");
38423932 // call reporttok from matchid
3843- stack[base + 6LLU] = 270LLU/*throw to this address*/;
3933+ stack[base + 6LLU] = 280LLU/*throw to this address*/;
38443934 stack[base + 7LLU] = base;
3845- stack[base + 8LLU] = 271LLU;
3935+ stack[base + 8LLU] = 281LLU;
38463936 // arguments for call to reporttok
38473937 stack[base + 9LLU] = stack[base + 3]/*variant*/;
38483938 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3851,22 +3941,22 @@
38513941 label = 18446744073709551582LLU; // reporttok
38523942 break;
38533943 }
3854- case 270LLU: // copy-back deleter (reporttok to matchid)
3944+ case 280LLU: // copy-back deleter (reporttok to matchid)
38553945 {
38563946 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
38573947 // copy mutable arguments back from call to reporttok
3858- label = 250LLU; // continue to roll stack
3948+ label = 260LLU; // continue to roll stack
38593949 break;
38603950 }
3861- case 271LLU: // return from reporttok to matchid
3951+ case 281LLU: // return from reporttok to matchid
38623952 {
38633953 // copy mutable arguments back from call to reporttok
38643954 fprintf(stderr, "%s", "\n");
38653955 exit(-1);
3866- label = 255LLU; // alternative complete
3956+ label = 265LLU; // alternative complete
38673957 break;
38683958 }
3869- case 255LLU: // completed if-then-else
3959+ case 265LLU: // completed if-then-else
38703960 {
38713961 // return from matchid
38723962 label = stack[base - 1];
@@ -3873,7 +3963,7 @@
38733963 base = stack[base - 2];
38743964 break;
38753965 }
3876- case 273LLU: // function isncs failed
3966+ case 283LLU: // function isncs failed
38773967 {
38783968 fprintf(stderr, "function isncs failed\n");
38793969 label = stack[base - 3];
@@ -3880,33 +3970,33 @@
38803970 base = stack[base - 2];
38813971 break;
38823972 }
3883- case 272LLU: // isncs
3973+ case 282LLU: // isncs
38843974 {
38853975 //#define res0 0
38863976 //#define arg0 1
3887- label = 275LLU; // skip deleter
3977+ label = 285LLU; // skip deleter
38883978 break;
38893979 }
3890- case 274LLU: // deleter
3980+ case 284LLU: // deleter
38913981 {
38923982 // throw from isncs
38933983 if(!stack[base + 2])
38943984 {
38953985 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
3896- label = 273LLU; // skip, variable already deleted/unscoped
3986+ label = 283LLU; // skip, variable already deleted/unscoped
38973987 break;
38983988 }
38993989 fprintf(stderr, "in function isncs: unrolling stack, variable u64 isequal\n");
3900- label = 273LLU; // continue unrolling stack, delete next variable
3990+ label = 283LLU; // continue unrolling stack, delete next variable
39013991 break;
39023992 }
3903- case 275LLU: // skipped deleter
3993+ case 285LLU: // skipped deleter
39043994 {
39053995 stack[base + 2] = 0;
39063996 // call equ from isncs
3907- stack[base + 3LLU] = 276LLU/*throw to this address*/;
3997+ stack[base + 3LLU] = 286LLU/*throw to this address*/;
39083998 stack[base + 4LLU] = base;
3909- stack[base + 5LLU] = 277LLU;
3999+ stack[base + 5LLU] = 287LLU;
39104000 // arguments for call to equ
39114001 stack[base + 7LLU] = stack[base + 1]/*tokvar*/;
39124002 stack[base + 8LLU] = 1LLU;
@@ -3915,14 +4005,14 @@
39154005 label = 18446744073709551600LLU; // equ
39164006 break;
39174007 }
3918- case 276LLU: // copy-back deleter (equ to isncs)
4008+ case 286LLU: // copy-back deleter (equ to isncs)
39194009 {
39204010 fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
39214011 // copy mutable arguments back from call to equ
3922- label = 274LLU; // continue to roll stack
4012+ label = 284LLU; // continue to roll stack
39234013 break;
39244014 }
3925- case 277LLU: // return from equ to isncs
4015+ case 287LLU: // return from equ to isncs
39264016 {
39274017 // copy mutable arguments back from call to equ
39284018 // copy back results provided by call to equ
@@ -3929,39 +4019,39 @@
39294019 stack[base + 2] = stack[base + 6LLU];
39304020 if(!stack[base + 2]/*isequal*/)
39314021 {
3932- label = 278LLU; // jump to alternative
4022+ label = 288LLU; // jump to alternative
39334023 break;
39344024 }
39354025
39364026 // consequent
3937- label = 281LLU; // skip deleter
4027+ label = 291LLU; // skip deleter
39384028 break;
39394029 }
3940- case 280LLU: // deleter
4030+ case 290LLU: // deleter
39414031 {
39424032 // throw from isncs
39434033 if(!stack[base + 0])
39444034 {
39454035 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3946- label = 274LLU; // skip, variable already deleted/unscoped
4036+ label = 284LLU; // skip, variable already deleted/unscoped
39474037 break;
39484038 }
39494039 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
3950- label = 274LLU; // continue unrolling stack, delete next variable
4040+ label = 284LLU; // continue unrolling stack, delete next variable
39514041 break;
39524042 }
3953- case 281LLU: // skipped deleter
4043+ case 291LLU: // skipped deleter
39544044 {
39554045 stack[base + 0] = 1;
3956- label = 279LLU; // consequent complete
4046+ label = 289LLU; // consequent complete
39574047 break;
39584048 }
3959- case 278LLU: // alternative
4049+ case 288LLU: // alternative
39604050 {
39614051 // call equ from isncs
3962- stack[base + 3LLU] = 282LLU/*throw to this address*/;
4052+ stack[base + 3LLU] = 292LLU/*throw to this address*/;
39634053 stack[base + 4LLU] = base;
3964- stack[base + 5LLU] = 283LLU;
4054+ stack[base + 5LLU] = 293LLU;
39654055 // arguments for call to equ
39664056 stack[base + 7LLU] = stack[base + 1]/*tokvar*/;
39674057 stack[base + 8LLU] = 2LLU;
@@ -3970,14 +4060,14 @@
39704060 label = 18446744073709551600LLU; // equ
39714061 break;
39724062 }
3973- case 282LLU: // copy-back deleter (equ to isncs)
4063+ case 292LLU: // copy-back deleter (equ to isncs)
39744064 {
39754065 fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
39764066 // copy mutable arguments back from call to equ
3977- label = 274LLU; // continue to roll stack
4067+ label = 284LLU; // continue to roll stack
39784068 break;
39794069 }
3980- case 283LLU: // return from equ to isncs
4070+ case 293LLU: // return from equ to isncs
39814071 {
39824072 // copy mutable arguments back from call to equ
39834073 // copy back results provided by call to equ
@@ -3984,39 +4074,39 @@
39844074 stack[base + 2] = stack[base + 6LLU];
39854075 if(!stack[base + 2]/*isequal*/)
39864076 {
3987- label = 284LLU; // jump to alternative
4077+ label = 294LLU; // jump to alternative
39884078 break;
39894079 }
39904080
39914081 // consequent
3992- label = 287LLU; // skip deleter
4082+ label = 297LLU; // skip deleter
39934083 break;
39944084 }
3995- case 286LLU: // deleter
4085+ case 296LLU: // deleter
39964086 {
39974087 // throw from isncs
39984088 if(!stack[base + 0])
39994089 {
40004090 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4001- label = 274LLU; // skip, variable already deleted/unscoped
4091+ label = 284LLU; // skip, variable already deleted/unscoped
40024092 break;
40034093 }
40044094 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
4005- label = 274LLU; // continue unrolling stack, delete next variable
4095+ label = 284LLU; // continue unrolling stack, delete next variable
40064096 break;
40074097 }
4008- case 287LLU: // skipped deleter
4098+ case 297LLU: // skipped deleter
40094099 {
40104100 stack[base + 0] = 1;
4011- label = 285LLU; // consequent complete
4101+ label = 295LLU; // consequent complete
40124102 break;
40134103 }
4014- case 284LLU: // alternative
4104+ case 294LLU: // alternative
40154105 {
40164106 // call equ from isncs
4017- stack[base + 3LLU] = 288LLU/*throw to this address*/;
4107+ stack[base + 3LLU] = 298LLU/*throw to this address*/;
40184108 stack[base + 4LLU] = base;
4019- stack[base + 5LLU] = 289LLU;
4109+ stack[base + 5LLU] = 299LLU;
40204110 // arguments for call to equ
40214111 stack[base + 7LLU] = stack[base + 1]/*tokvar*/;
40224112 stack[base + 8LLU] = 3LLU;
@@ -4025,14 +4115,14 @@
40254115 label = 18446744073709551600LLU; // equ
40264116 break;
40274117 }
4028- case 288LLU: // copy-back deleter (equ to isncs)
4118+ case 298LLU: // copy-back deleter (equ to isncs)
40294119 {
40304120 fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
40314121 // copy mutable arguments back from call to equ
4032- label = 274LLU; // continue to roll stack
4122+ label = 284LLU; // continue to roll stack
40334123 break;
40344124 }
4035- case 289LLU: // return from equ to isncs
4125+ case 299LLU: // return from equ to isncs
40364126 {
40374127 // copy mutable arguments back from call to equ
40384128 // copy back results provided by call to equ
@@ -4039,68 +4129,68 @@
40394129 stack[base + 2] = stack[base + 6LLU];
40404130 if(!stack[base + 2]/*isequal*/)
40414131 {
4042- label = 290LLU; // jump to alternative
4132+ label = 300LLU; // jump to alternative
40434133 break;
40444134 }
40454135
40464136 // consequent
4047- label = 293LLU; // skip deleter
4137+ label = 303LLU; // skip deleter
40484138 break;
40494139 }
4050- case 292LLU: // deleter
4140+ case 302LLU: // deleter
40514141 {
40524142 // throw from isncs
40534143 if(!stack[base + 0])
40544144 {
40554145 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4056- label = 274LLU; // skip, variable already deleted/unscoped
4146+ label = 284LLU; // skip, variable already deleted/unscoped
40574147 break;
40584148 }
40594149 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
4060- label = 274LLU; // continue unrolling stack, delete next variable
4150+ label = 284LLU; // continue unrolling stack, delete next variable
40614151 break;
40624152 }
4063- case 293LLU: // skipped deleter
4153+ case 303LLU: // skipped deleter
40644154 {
40654155 stack[base + 0] = 1;
4066- label = 291LLU; // consequent complete
4156+ label = 301LLU; // consequent complete
40674157 break;
40684158 }
4069- case 290LLU: // alternative
4159+ case 300LLU: // alternative
40704160 {
4071- label = 295LLU; // skip deleter
4161+ label = 305LLU; // skip deleter
40724162 break;
40734163 }
4074- case 294LLU: // deleter
4164+ case 304LLU: // deleter
40754165 {
40764166 // throw from isncs
40774167 if(!stack[base + 0])
40784168 {
40794169 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4080- label = 274LLU; // skip, variable already deleted/unscoped
4170+ label = 284LLU; // skip, variable already deleted/unscoped
40814171 break;
40824172 }
40834173 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
4084- label = 274LLU; // continue unrolling stack, delete next variable
4174+ label = 284LLU; // continue unrolling stack, delete next variable
40854175 break;
40864176 }
4087- case 295LLU: // skipped deleter
4177+ case 305LLU: // skipped deleter
40884178 {
40894179 stack[base + 0] = 0;
4090- label = 291LLU; // alternative complete
4180+ label = 301LLU; // alternative complete
40914181 break;
40924182 }
4093- case 291LLU: // completed if-then-else
4183+ case 301LLU: // completed if-then-else
40944184 {
4095- label = 285LLU; // alternative complete
4185+ label = 295LLU; // alternative complete
40964186 break;
40974187 }
4098- case 285LLU: // completed if-then-else
4188+ case 295LLU: // completed if-then-else
40994189 {
4100- label = 279LLU; // alternative complete
4190+ label = 289LLU; // alternative complete
41014191 break;
41024192 }
4103- case 279LLU: // completed if-then-else
4193+ case 289LLU: // completed if-then-else
41044194 {
41054195 // return from isncs
41064196 label = stack[base - 1];
@@ -4107,7 +4197,7 @@
41074197 base = stack[base - 2];
41084198 break;
41094199 }
4110- case 296LLU: // ~type
4200+ case 306LLU: // ~type
41114201 {
41124202 if(stack[base + 0]/*variant-nr*/ >= 2)
41134203 {
@@ -4114,10 +4204,10 @@
41144204 fprintf(stderr, "in ~type: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
41154205 exit(-1);
41164206 }
4117- label = 296LLU + 1LLU + stack[base + 0]/*variant-nr*/;
4207+ label = 306LLU + 1LLU + stack[base + 0]/*variant-nr*/;
41184208 break;
41194209 }
4120- case 296LLU + 1LLU + 0LLU: // ~type.typename
4210+ case 306LLU + 1LLU + 0LLU: // ~type.typename
41214211 {
41224212 // release element name
41234213 // release variant container
@@ -4126,7 +4216,7 @@
41264216 base = stack[base - 2];
41274217 break;
41284218 }
4129- case 296LLU + 1LLU + 1LLU: // ~type.typelist
4219+ case 306LLU + 1LLU + 1LLU: // ~type.typelist
41304220 {
41314221 // release element subtype
41324222 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -4136,14 +4226,14 @@
41364226 newstack[0] = (uint64_t)stack; // backup stack location
41374227 newstack[1] = 1234567890;
41384228 newstack[2] = base;
4139- newstack[3] = 299LLU;
4229+ newstack[3] = 309LLU;
41404230 stack = newstack;
41414231 // set stack-base & callee-address
41424232 base = 4/*deloffset*/;
4143- label = 296LLU; // ~type
4233+ label = 306LLU; // ~type
41444234 break;
41454235 }
4146- case 299LLU: // return from ~type to type
4236+ case 309LLU: // return from ~type to type
41474237 {
41484238 stack = (uint64_t *)stack[0];
41494239 // releasing toplevel container
@@ -4155,7 +4245,7 @@
41554245 base = stack[base - 2];
41564246 break;
41574247 }
4158- case 301LLU: // function mktypename failed
4248+ case 311LLU: // function mktypename failed
41594249 {
41604250 fprintf(stderr, "function mktypename failed\n");
41614251 label = stack[base - 3];
@@ -4162,20 +4252,20 @@
41624252 base = stack[base - 2];
41634253 break;
41644254 }
4165- case 300LLU: // mktypename
4255+ case 310LLU: // mktypename
41664256 {
41674257 //#define res0 0
41684258 //#define arg0 1
4169- label = 303LLU; // skip deleter
4259+ label = 313LLU; // skip deleter
41704260 break;
41714261 }
4172- case 302LLU: // deleter
4262+ case 312LLU: // deleter
41734263 {
41744264 // throw from mktypename
41754265 if(!stack[base + 0])
41764266 {
41774267 fprintf(stderr, "in function mktypename: unrolling stack, skipping already deleted/unscoped variable type \n");
4178- label = 301LLU; // skip, variable already deleted/unscoped
4268+ label = 311LLU; // skip, variable already deleted/unscoped
41794269 break;
41804270 }
41814271 fprintf(stderr, "in function mktypename: unrolling stack, variable type \n");
@@ -4185,28 +4275,28 @@
41854275 newstack[0] = (uint64_t)stack; // backup stack location
41864276 newstack[1] = 1234567890;
41874277 newstack[2] = base;
4188- newstack[3] = 304LLU;
4278+ newstack[3] = 314LLU;
41894279 stack = newstack;
41904280 // set stack-base & callee-address
41914281 base = 4/*deloffset*/;
4192- label = 296LLU; // ~type
4282+ label = 306LLU; // ~type
41934283 break;
41944284 }
4195- case 304LLU: // return from ~type to mktypename
4285+ case 314LLU: // return from ~type to mktypename
41964286 {
41974287 stack = (uint64_t *)stack[0];
41984288 // releasing toplevel container
41994289 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
42004290
4201- label = 301LLU; // continue unrolling stack, delete next variable
4291+ label = 311LLU; // continue unrolling stack, delete next variable
42024292 break;
42034293 }
4204- case 303LLU: // skipped deleter
4294+ case 313LLU: // skipped deleter
42054295 {
42064296 // construct type.typename
42074297 if(!(stack[base + 0] = construct(1)))
42084298 {
4209- label = 301LLU; // throw: begin to unroll stack
4299+ label = 311LLU; // throw: begin to unroll stack
42104300 break;
42114301 }
42124302
@@ -4218,7 +4308,7 @@
42184308 base = stack[base - 2];
42194309 break;
42204310 }
4221- case 306LLU: // function printtype failed
4311+ case 316LLU: // function printtype failed
42224312 {
42234313 fprintf(stderr, "function printtype failed\n");
42244314 label = stack[base - 3];
@@ -4225,12 +4315,12 @@
42254315 base = stack[base - 2];
42264316 break;
42274317 }
4228- case 305LLU: // printtype
4318+ case 315LLU: // printtype
42294319 {
42304320 //#define arg0 0
42314321 if(/*typename*/0 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
42324322 {
4233- label = 308LLU; // jump to alternative
4323+ label = 318LLU; // jump to alternative
42344324 break;
42354325 }
42364326
@@ -4238,9 +4328,9 @@
42384328
42394329 // case
42404330 // call printid from printtype
4241- stack[base + 2LLU] = 310LLU/*throw to this address*/;
4331+ stack[base + 2LLU] = 320LLU/*throw to this address*/;
42424332 stack[base + 3LLU] = base;
4243- stack[base + 4LLU] = 311LLU;
4333+ stack[base + 4LLU] = 321LLU;
42444334 // arguments for call to printid
42454335 stack[base + 5LLU] = stack[base + 1]/*name*/;
42464336 // set stack-base & callee-address
@@ -4248,31 +4338,31 @@
42484338 label = 18446744073709551587LLU; // printid
42494339 break;
42504340 }
4251- case 310LLU: // copy-back deleter (printid to printtype)
4341+ case 320LLU: // copy-back deleter (printid to printtype)
42524342 {
42534343 fprintf(stderr, "in function printtype: unrolling stack, copy-back (printid to printtype)\n");
42544344 // copy mutable arguments back from call to printid
4255- label = 309LLU; // continue to roll stack
4345+ label = 319LLU; // continue to roll stack
42564346 break;
42574347 }
4258- case 311LLU: // return from printid to printtype
4348+ case 321LLU: // return from printid to printtype
42594349 {
42604350 // copy mutable arguments back from call to printid
42614351 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4262- label = 307LLU; // case complete
4352+ label = 317LLU; // case complete
42634353 break;
42644354 }
4265- case 309LLU: // copy-back deleter (switch)
4355+ case 319LLU: // copy-back deleter (switch)
42664356 {
42674357 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4268- label = 306LLU; // continue to unroll stack
4358+ label = 316LLU; // continue to unroll stack
42694359 break;
42704360 }
4271- case 308LLU: // try next case
4361+ case 318LLU: // try next case
42724362 {
42734363 if(/*typelist*/1 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
42744364 {
4275- label = 312LLU; // jump to alternative
4365+ label = 322LLU; // jump to alternative
42764366 break;
42774367 }
42784368
@@ -4283,7 +4373,7 @@
42834373 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
42844374 if(!newstack)
42854375 {
4286- label = 313LLU; // throw: begin to unroll stack
4376+ label = 323LLU; // throw: begin to unroll stack
42874377 break;
42884378 }
42894379
@@ -4290,18 +4380,18 @@
42904380 newstack[10LLU] = 9876543210LLU; // overflow-marker
42914381 // call printtype from printtype
42924382 newstack[0] = (uint64_t)stack; // backup stack location
4293- newstack[1] = 314LLU;
4383+ newstack[1] = 324LLU;
42944384 newstack[2] = base;
4295- newstack[3] = 315LLU;
4385+ newstack[3] = 325LLU;
42964386 // arguments for call to printtype
42974387 newstack[4LLU] = stack[base + 1]/*subtype*/;
42984388 stack = newstack;
42994389 // set stack-base & callee-address
43004390 base = 4/*deloffset*/;
4301- label = 305LLU; // printtype
4391+ label = 315LLU; // printtype
43024392 break;
43034393 }
4304- case 314LLU: // copy-back deleter (printtype to printtype)
4394+ case 324LLU: // copy-back deleter (printtype to printtype)
43054395 {
43064396 fprintf(stderr, "in function printtype: unrolling stack, copy-back (printtype to printtype)\n");
43074397 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4313,10 +4403,10 @@
43134403 }
43144404 Free(10LLU + 1, sizeof(uint64_t), stack);
43154405 stack = oldstack;
4316- label = 313LLU; // continue to unroll stack
4406+ label = 323LLU; // continue to unroll stack
43174407 break;
43184408 }
4319- case 315LLU: // return from printtype to printtype
4409+ case 325LLU: // return from printtype to printtype
43204410 {
43214411 uint64_t *oldstack = (uint64_t *)stack[0];
43224412 // copy mutable arguments back from call to printtype
@@ -4329,21 +4419,21 @@
43294419 stack = oldstack;
43304420 printf("%s", "]");
43314421 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4332- label = 307LLU; // case complete
4422+ label = 317LLU; // case complete
43334423 break;
43344424 }
4335- case 313LLU: // copy-back deleter (switch)
4425+ case 323LLU: // copy-back deleter (switch)
43364426 {
43374427 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4338- label = 306LLU; // continue to unroll stack
4428+ label = 316LLU; // continue to unroll stack
43394429 break;
43404430 }
4341- case 312LLU: // try next case
4431+ case 322LLU: // try next case
43424432 {
43434433 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
43444434 exit(-1);
43454435 }
4346- case 307LLU: // completed switch
4436+ case 317LLU: // completed switch
43474437 {
43484438 // return from printtype
43494439 label = stack[base - 1];
@@ -4350,7 +4440,7 @@
43504440 base = stack[base - 2];
43514441 break;
43524442 }
4353- case 317LLU: // function reporttype failed
4443+ case 327LLU: // function reporttype failed
43544444 {
43554445 fprintf(stderr, "function reporttype failed\n");
43564446 label = stack[base - 3];
@@ -4357,12 +4447,12 @@
43574447 base = stack[base - 2];
43584448 break;
43594449 }
4360- case 316LLU: // reporttype
4450+ case 326LLU: // reporttype
43614451 {
43624452 //#define arg0 0
43634453 if(/*typename*/0 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
43644454 {
4365- label = 319LLU; // jump to alternative
4455+ label = 329LLU; // jump to alternative
43664456 break;
43674457 }
43684458
@@ -4370,9 +4460,9 @@
43704460
43714461 // case
43724462 // call reportid from reporttype
4373- stack[base + 2LLU] = 321LLU/*throw to this address*/;
4463+ stack[base + 2LLU] = 331LLU/*throw to this address*/;
43744464 stack[base + 3LLU] = base;
4375- stack[base + 4LLU] = 322LLU;
4465+ stack[base + 4LLU] = 332LLU;
43764466 // arguments for call to reportid
43774467 stack[base + 5LLU] = stack[base + 1]/*name*/;
43784468 // set stack-base & callee-address
@@ -4380,31 +4470,31 @@
43804470 label = 18446744073709551586LLU; // reportid
43814471 break;
43824472 }
4383- case 321LLU: // copy-back deleter (reportid to reporttype)
4473+ case 331LLU: // copy-back deleter (reportid to reporttype)
43844474 {
43854475 fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reportid to reporttype)\n");
43864476 // copy mutable arguments back from call to reportid
4387- label = 320LLU; // continue to roll stack
4477+ label = 330LLU; // continue to roll stack
43884478 break;
43894479 }
4390- case 322LLU: // return from reportid to reporttype
4480+ case 332LLU: // return from reportid to reporttype
43914481 {
43924482 // copy mutable arguments back from call to reportid
43934483 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4394- label = 318LLU; // case complete
4484+ label = 328LLU; // case complete
43954485 break;
43964486 }
4397- case 320LLU: // copy-back deleter (switch)
4487+ case 330LLU: // copy-back deleter (switch)
43984488 {
43994489 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4400- label = 317LLU; // continue to unroll stack
4490+ label = 327LLU; // continue to unroll stack
44014491 break;
44024492 }
4403- case 319LLU: // try next case
4493+ case 329LLU: // try next case
44044494 {
44054495 if(/*typelist*/1 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
44064496 {
4407- label = 323LLU; // jump to alternative
4497+ label = 333LLU; // jump to alternative
44084498 break;
44094499 }
44104500
@@ -4415,7 +4505,7 @@
44154505 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
44164506 if(!newstack)
44174507 {
4418- label = 324LLU; // throw: begin to unroll stack
4508+ label = 334LLU; // throw: begin to unroll stack
44194509 break;
44204510 }
44214511
@@ -4422,18 +4512,18 @@
44224512 newstack[10LLU] = 9876543210LLU; // overflow-marker
44234513 // call reporttype from reporttype
44244514 newstack[0] = (uint64_t)stack; // backup stack location
4425- newstack[1] = 325LLU;
4515+ newstack[1] = 335LLU;
44264516 newstack[2] = base;
4427- newstack[3] = 326LLU;
4517+ newstack[3] = 336LLU;
44284518 // arguments for call to reporttype
44294519 newstack[4LLU] = stack[base + 1]/*subtype*/;
44304520 stack = newstack;
44314521 // set stack-base & callee-address
44324522 base = 4/*deloffset*/;
4433- label = 316LLU; // reporttype
4523+ label = 326LLU; // reporttype
44344524 break;
44354525 }
4436- case 325LLU: // copy-back deleter (reporttype to reporttype)
4526+ case 335LLU: // copy-back deleter (reporttype to reporttype)
44374527 {
44384528 fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reporttype to reporttype)\n");
44394529 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4445,10 +4535,10 @@
44454535 }
44464536 Free(10LLU + 1, sizeof(uint64_t), stack);
44474537 stack = oldstack;
4448- label = 324LLU; // continue to unroll stack
4538+ label = 334LLU; // continue to unroll stack
44494539 break;
44504540 }
4451- case 326LLU: // return from reporttype to reporttype
4541+ case 336LLU: // return from reporttype to reporttype
44524542 {
44534543 uint64_t *oldstack = (uint64_t *)stack[0];
44544544 // copy mutable arguments back from call to reporttype
@@ -4461,21 +4551,21 @@
44614551 stack = oldstack;
44624552 fprintf(stderr, "%s", "]");
44634553 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4464- label = 318LLU; // case complete
4554+ label = 328LLU; // case complete
44654555 break;
44664556 }
4467- case 324LLU: // copy-back deleter (switch)
4557+ case 334LLU: // copy-back deleter (switch)
44684558 {
44694559 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4470- label = 317LLU; // continue to unroll stack
4560+ label = 327LLU; // continue to unroll stack
44714561 break;
44724562 }
4473- case 323LLU: // try next case
4563+ case 333LLU: // try next case
44744564 {
44754565 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
44764566 exit(-1);
44774567 }
4478- case 318LLU: // completed switch
4568+ case 328LLU: // completed switch
44794569 {
44804570 // return from reporttype
44814571 label = stack[base - 1];
@@ -4482,7 +4572,7 @@
44824572 base = stack[base - 2];
44834573 break;
44844574 }
4485- case 328LLU: // function copytype failed
4575+ case 338LLU: // function copytype failed
44864576 {
44874577 fprintf(stderr, "function copytype failed\n");
44884578 label = stack[base - 3];
@@ -4489,13 +4579,13 @@
44894579 base = stack[base - 2];
44904580 break;
44914581 }
4492- case 327LLU: // copytype
4582+ case 337LLU: // copytype
44934583 {
44944584 //#define res0 0
44954585 //#define arg0 1
44964586 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
44974587 {
4498- label = 330LLU; // jump to alternative
4588+ label = 340LLU; // jump to alternative
44994589 break;
45004590 }
45014591
@@ -4502,16 +4592,16 @@
45024592 /*name*/stack[base + 2] = ((uint64_t **)(stack[base + 1]/*type*/))[1][0]/*name*/;
45034593
45044594 // case
4505- label = 333LLU; // skip deleter
4595+ label = 343LLU; // skip deleter
45064596 break;
45074597 }
4508- case 332LLU: // deleter
4598+ case 342LLU: // deleter
45094599 {
45104600 // throw from copytype
45114601 if(!stack[base + 0])
45124602 {
45134603 fprintf(stderr, "in function copytype: unrolling stack, skipping already deleted/unscoped variable type \n");
4514- label = 331LLU; // skip, variable already deleted/unscoped
4604+ label = 341LLU; // skip, variable already deleted/unscoped
45154605 break;
45164606 }
45174607 fprintf(stderr, "in function copytype: unrolling stack, variable type \n");
@@ -4521,28 +4611,28 @@
45214611 newstack[0] = (uint64_t)stack; // backup stack location
45224612 newstack[1] = 1234567890;
45234613 newstack[2] = base;
4524- newstack[3] = 334LLU;
4614+ newstack[3] = 344LLU;
45254615 stack = newstack;
45264616 // set stack-base & callee-address
45274617 base = 4/*deloffset*/;
4528- label = 296LLU; // ~type
4618+ label = 306LLU; // ~type
45294619 break;
45304620 }
4531- case 334LLU: // return from ~type to copytype
4621+ case 344LLU: // return from ~type to copytype
45324622 {
45334623 stack = (uint64_t *)stack[0];
45344624 // releasing toplevel container
45354625 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
45364626
4537- label = 331LLU; // continue unrolling stack, delete next variable
4627+ label = 341LLU; // continue unrolling stack, delete next variable
45384628 break;
45394629 }
4540- case 333LLU: // skipped deleter
4630+ case 343LLU: // skipped deleter
45414631 {
45424632 // construct type.typename
45434633 if(!(stack[base + 0] = construct(1)))
45444634 {
4545- label = 331LLU; // throw: begin to unroll stack
4635+ label = 341LLU; // throw: begin to unroll stack
45464636 break;
45474637 }
45484638
@@ -4550,20 +4640,20 @@
45504640 ((uint64_t *)stack[base + 0])[0] = 0;
45514641 (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 2]/*name*/;
45524642 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4553- label = 329LLU; // case complete
4643+ label = 339LLU; // case complete
45544644 break;
45554645 }
4556- case 331LLU: // copy-back deleter (switch)
4646+ case 341LLU: // copy-back deleter (switch)
45574647 {
45584648 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4559- label = 328LLU; // continue to unroll stack
4649+ label = 338LLU; // continue to unroll stack
45604650 break;
45614651 }
4562- case 330LLU: // try next case
4652+ case 340LLU: // try next case
45634653 {
45644654 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
45654655 {
4566- label = 335LLU; // jump to alternative
4656+ label = 345LLU; // jump to alternative
45674657 break;
45684658 }
45694659
@@ -4570,10 +4660,47 @@
45704660 /*original*/stack[base + 2] = ((uint64_t **)(stack[base + 1]/*type*/))[1][0]/*subtype*/;
45714661
45724662 // case
4663+ label = 348LLU; // skip deleter
4664+ break;
4665+ }
4666+ case 347LLU: // deleter
4667+ {
4668+ // throw from copytype
4669+ if(!stack[base + 3])
4670+ {
4671+ fprintf(stderr, "in function copytype: unrolling stack, skipping already deleted/unscoped variable type copy\n");
4672+ label = 346LLU; // skip, variable already deleted/unscoped
4673+ break;
4674+ }
4675+ fprintf(stderr, "in function copytype: unrolling stack, variable type copy\n");
4676+
4677+ uint64_t *newstack = (uint64_t *)(stack[base + 3] - sizeof(uint64_t) * 4);
4678+ // call ~type from copytype
4679+ newstack[0] = (uint64_t)stack; // backup stack location
4680+ newstack[1] = 1234567890;
4681+ newstack[2] = base;
4682+ newstack[3] = 349LLU;
4683+ stack = newstack;
4684+ // set stack-base & callee-address
4685+ base = 4/*deloffset*/;
4686+ label = 306LLU; // ~type
4687+ break;
4688+ }
4689+ case 349LLU: // return from ~type to copytype
4690+ {
4691+ stack = (uint64_t *)stack[0];
4692+ // releasing toplevel container
4693+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 3] - sizeof(uint64_t) * 4));
4694+
4695+ label = 346LLU; // continue unrolling stack, delete next variable
4696+ break;
4697+ }
4698+ case 348LLU: // skipped deleter
4699+ {
45734700 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
45744701 if(!newstack)
45754702 {
4576- label = 336LLU; // throw: begin to unroll stack
4703+ label = 346LLU; // throw: begin to unroll stack
45774704 break;
45784705 }
45794706
@@ -4580,18 +4707,18 @@
45804707 newstack[15LLU] = 9876543210LLU; // overflow-marker
45814708 // call copytype from copytype
45824709 newstack[0] = (uint64_t)stack; // backup stack location
4583- newstack[1] = 337LLU;
4710+ newstack[1] = 350LLU;
45844711 newstack[2] = base;
4585- newstack[3] = 338LLU;
4712+ newstack[3] = 351LLU;
45864713 // arguments for call to copytype
45874714 newstack[5LLU] = stack[base + 2]/*original*/;
45884715 stack = newstack;
45894716 // set stack-base & callee-address
45904717 base = 4/*deloffset*/;
4591- label = 327LLU; // copytype
4718+ label = 337LLU; // copytype
45924719 break;
45934720 }
4594- case 337LLU: // copy-back deleter (copytype to copytype)
4721+ case 350LLU: // copy-back deleter (copytype to copytype)
45954722 {
45964723 fprintf(stderr, "in function copytype: unrolling stack, copy-back (copytype to copytype)\n");
45974724 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4603,10 +4730,10 @@
46034730 }
46044731 Free(15LLU + 1, sizeof(uint64_t), stack);
46054732 stack = oldstack;
4606- label = 336LLU; // continue to unroll stack
4733+ label = 346LLU; // continue to unroll stack
46074734 break;
46084735 }
4609- case 338LLU: // return from copytype to copytype
4736+ case 351LLU: // return from copytype to copytype
46104737 {
46114738 uint64_t *oldstack = (uint64_t *)stack[0];
46124739 // copy mutable arguments back from call to copytype
@@ -4619,16 +4746,16 @@
46194746 }
46204747 Free(15LLU + 1, sizeof(uint64_t), stack);
46214748 stack = oldstack;
4622- label = 340LLU; // skip deleter
4749+ label = 353LLU; // skip deleter
46234750 break;
46244751 }
4625- case 339LLU: // deleter
4752+ case 352LLU: // deleter
46264753 {
46274754 // throw from copytype
46284755 if(!stack[base + 0])
46294756 {
46304757 fprintf(stderr, "in function copytype: unrolling stack, skipping already deleted/unscoped variable type \n");
4631- label = 336LLU; // skip, variable already deleted/unscoped
4758+ label = 347LLU; // skip, variable already deleted/unscoped
46324759 break;
46334760 }
46344761 fprintf(stderr, "in function copytype: unrolling stack, variable type \n");
@@ -4638,28 +4765,28 @@
46384765 newstack[0] = (uint64_t)stack; // backup stack location
46394766 newstack[1] = 1234567890;
46404767 newstack[2] = base;
4641- newstack[3] = 341LLU;
4768+ newstack[3] = 354LLU;
46424769 stack = newstack;
46434770 // set stack-base & callee-address
46444771 base = 4/*deloffset*/;
4645- label = 296LLU; // ~type
4772+ label = 306LLU; // ~type
46464773 break;
46474774 }
4648- case 341LLU: // return from ~type to copytype
4775+ case 354LLU: // return from ~type to copytype
46494776 {
46504777 stack = (uint64_t *)stack[0];
46514778 // releasing toplevel container
46524779 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
46534780
4654- label = 336LLU; // continue unrolling stack, delete next variable
4781+ label = 347LLU; // continue unrolling stack, delete next variable
46554782 break;
46564783 }
4657- case 340LLU: // skipped deleter
4784+ case 353LLU: // skipped deleter
46584785 {
46594786 // construct type.typelist
46604787 if(!(stack[base + 0] = construct(1)))
46614788 {
4662- label = 336LLU; // throw: begin to unroll stack
4789+ label = 347LLU; // throw: begin to unroll stack
46634790 break;
46644791 }
46654792
@@ -4667,21 +4794,21 @@
46674794 ((uint64_t *)stack[base + 0])[0] = 1;
46684795 INIT(&(((uint64_t **)(stack[base + 0]))[1][0]), &stack[base + 3]/*copy*/);
46694796 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4670- label = 329LLU; // case complete
4797+ label = 339LLU; // case complete
46714798 break;
46724799 }
4673- case 336LLU: // copy-back deleter (switch)
4800+ case 346LLU: // copy-back deleter (switch)
46744801 {
46754802 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4676- label = 328LLU; // continue to unroll stack
4803+ label = 338LLU; // continue to unroll stack
46774804 break;
46784805 }
4679- case 335LLU: // try next case
4806+ case 345LLU: // try next case
46804807 {
46814808 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
46824809 exit(-1);
46834810 }
4684- case 329LLU: // completed switch
4811+ case 339LLU: // completed switch
46854812 {
46864813 // return from copytype
46874814 label = stack[base - 1];
@@ -4688,7 +4815,7 @@
46884815 base = stack[base - 2];
46894816 break;
46904817 }
4691- case 343LLU: // function equtype failed
4818+ case 356LLU: // function equtype failed
46924819 {
46934820 fprintf(stderr, "function equtype failed\n");
46944821 label = stack[base - 3];
@@ -4695,7 +4822,7 @@
46954822 base = stack[base - 2];
46964823 break;
46974824 }
4698- case 342LLU: // equtype
4825+ case 355LLU: // equtype
46994826 {
47004827 //#define res0 0
47014828 //#define arg0 1
@@ -4702,7 +4829,7 @@
47024829 //#define arg1 2
47034830 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
47044831 {
4705- label = 345LLU; // jump to alternative
4832+ label = 358LLU; // jump to alternative
47064833 break;
47074834 }
47084835
@@ -4710,7 +4837,7 @@
47104837
47114838 if(/*typename*/0 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
47124839 {
4713- label = 345LLU; // jump to alternative
4840+ label = 358LLU; // jump to alternative
47144841 break;
47154842 }
47164843
@@ -4718,9 +4845,9 @@
47184845
47194846 // case
47204847 // call equ from equtype
4721- stack[base + 5LLU] = 347LLU/*throw to this address*/;
4848+ stack[base + 5LLU] = 360LLU/*throw to this address*/;
47224849 stack[base + 6LLU] = base;
4723- stack[base + 7LLU] = 348LLU;
4850+ stack[base + 7LLU] = 361LLU;
47244851 // arguments for call to equ
47254852 stack[base + 9LLU] = stack[base + 3]/*xname*/;
47264853 stack[base + 10LLU] = stack[base + 4]/*yname*/;
@@ -4729,14 +4856,14 @@
47294856 label = 18446744073709551600LLU; // equ
47304857 break;
47314858 }
4732- case 347LLU: // copy-back deleter (equ to equtype)
4859+ case 360LLU: // copy-back deleter (equ to equtype)
47334860 {
47344861 fprintf(stderr, "in function equtype: unrolling stack, copy-back (equ to equtype)\n");
47354862 // copy mutable arguments back from call to equ
4736- label = 346LLU; // continue to roll stack
4863+ label = 359LLU; // continue to roll stack
47374864 break;
47384865 }
4739- case 348LLU: // return from equ to equtype
4866+ case 361LLU: // return from equ to equtype
47404867 {
47414868 // copy mutable arguments back from call to equ
47424869 // copy back results provided by call to equ
@@ -4743,21 +4870,21 @@
47434870 stack[base + 0] = stack[base + 8LLU];
47444871 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
47454872 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4746- label = 344LLU; // case complete
4873+ label = 357LLU; // case complete
47474874 break;
47484875 }
4749- case 346LLU: // copy-back deleter (switch)
4876+ case 359LLU: // copy-back deleter (switch)
47504877 {
47514878 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
47524879 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4753- label = 343LLU; // continue to unroll stack
4880+ label = 356LLU; // continue to unroll stack
47544881 break;
47554882 }
4756- case 345LLU: // try next case
4883+ case 358LLU: // try next case
47574884 {
47584885 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
47594886 {
4760- label = 349LLU; // jump to alternative
4887+ label = 362LLU; // jump to alternative
47614888 break;
47624889 }
47634890
@@ -4765,7 +4892,7 @@
47654892
47664893 if(/*typelist*/1 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
47674894 {
4768- label = 349LLU; // jump to alternative
4895+ label = 362LLU; // jump to alternative
47694896 break;
47704897 }
47714898
@@ -4775,7 +4902,7 @@
47754902 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
47764903 if(!newstack)
47774904 {
4778- label = 350LLU; // throw: begin to unroll stack
4905+ label = 363LLU; // throw: begin to unroll stack
47794906 break;
47804907 }
47814908
@@ -4782,9 +4909,9 @@
47824909 newstack[15LLU] = 9876543210LLU; // overflow-marker
47834910 // call equtype from equtype
47844911 newstack[0] = (uint64_t)stack; // backup stack location
4785- newstack[1] = 351LLU;
4912+ newstack[1] = 364LLU;
47864913 newstack[2] = base;
4787- newstack[3] = 352LLU;
4914+ newstack[3] = 365LLU;
47884915 // arguments for call to equtype
47894916 newstack[5LLU] = stack[base + 3]/*xsubtype*/;
47904917 newstack[6LLU] = stack[base + 4]/*ysubtype*/;
@@ -4791,10 +4918,10 @@
47914918 stack = newstack;
47924919 // set stack-base & callee-address
47934920 base = 4/*deloffset*/;
4794- label = 342LLU; // equtype
4921+ label = 355LLU; // equtype
47954922 break;
47964923 }
4797- case 351LLU: // copy-back deleter (equtype to equtype)
4924+ case 364LLU: // copy-back deleter (equtype to equtype)
47984925 {
47994926 fprintf(stderr, "in function equtype: unrolling stack, copy-back (equtype to equtype)\n");
48004927 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4806,10 +4933,10 @@
48064933 }
48074934 Free(15LLU + 1, sizeof(uint64_t), stack);
48084935 stack = oldstack;
4809- label = 350LLU; // continue to unroll stack
4936+ label = 363LLU; // continue to unroll stack
48104937 break;
48114938 }
4812- case 352LLU: // return from equtype to equtype
4939+ case 365LLU: // return from equtype to equtype
48134940 {
48144941 uint64_t *oldstack = (uint64_t *)stack[0];
48154942 // copy mutable arguments back from call to equtype
@@ -4824,42 +4951,42 @@
48244951 stack = oldstack;
48254952 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
48264953 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4827- label = 344LLU; // case complete
4954+ label = 357LLU; // case complete
48284955 break;
48294956 }
4830- case 350LLU: // copy-back deleter (switch)
4957+ case 363LLU: // copy-back deleter (switch)
48314958 {
48324959 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
48334960 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4834- label = 343LLU; // continue to unroll stack
4961+ label = 356LLU; // continue to unroll stack
48354962 break;
48364963 }
4837- case 349LLU: // try next case
4964+ case 362LLU: // try next case
48384965 {
48394966 // default
4840- label = 354LLU; // skip deleter
4967+ label = 367LLU; // skip deleter
48414968 break;
48424969 }
4843- case 353LLU: // deleter
4970+ case 366LLU: // deleter
48444971 {
48454972 // throw from equtype
48464973 if(!stack[base + 0])
48474974 {
48484975 fprintf(stderr, "in function equtype: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4849- label = 343LLU; // skip, variable already deleted/unscoped
4976+ label = 356LLU; // skip, variable already deleted/unscoped
48504977 break;
48514978 }
48524979 fprintf(stderr, "in function equtype: unrolling stack, variable u64 \n");
4853- label = 343LLU; // continue unrolling stack, delete next variable
4980+ label = 356LLU; // continue unrolling stack, delete next variable
48544981 break;
48554982 }
4856- case 354LLU: // skipped deleter
4983+ case 367LLU: // skipped deleter
48574984 {
48584985 stack[base + 0] = 0;
4859- label = 344LLU; // default complete
4986+ label = 357LLU; // default complete
48604987 break;
48614988 }
4862- case 344LLU: // completed switch
4989+ case 357LLU: // completed switch
48634990 {
48644991 // return from equtype
48654992 label = stack[base - 1];
@@ -4866,7 +4993,7 @@
48664993 base = stack[base - 2];
48674994 break;
48684995 }
4869- case 355LLU: // ~typeid
4996+ case 368LLU: // ~typeid
48704997 {
48714998 if(stack[base + 0]/*variant-nr*/ >= 1)
48724999 {
@@ -4873,10 +5000,10 @@
48735000 fprintf(stderr, "in ~typeid: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
48745001 exit(-1);
48755002 }
4876- label = 355LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5003+ label = 368LLU + 1LLU + stack[base + 0]/*variant-nr*/;
48775004 break;
48785005 }
4879- case 355LLU + 1LLU + 0LLU: // ~typeid.typeid
5006+ case 368LLU + 1LLU + 0LLU: // ~typeid.typeid
48805007 {
48815008 // release element type
48825009 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -4886,14 +5013,14 @@
48865013 newstack[0] = (uint64_t)stack; // backup stack location
48875014 newstack[1] = 1234567890;
48885015 newstack[2] = base;
4889- newstack[3] = 357LLU;
5016+ newstack[3] = 370LLU;
48905017 stack = newstack;
48915018 // set stack-base & callee-address
48925019 base = 4/*deloffset*/;
4893- label = 296LLU; // ~type
5020+ label = 306LLU; // ~type
48945021 break;
48955022 }
4896- case 357LLU: // return from ~type to typeid
5023+ case 370LLU: // return from ~type to typeid
48975024 {
48985025 stack = (uint64_t *)stack[0];
48995026 // releasing toplevel container
@@ -4906,7 +5033,7 @@
49065033 base = stack[base - 2];
49075034 break;
49085035 }
4909- case 359LLU: // function copytypeid failed
5036+ case 372LLU: // function copytypeid failed
49105037 {
49115038 fprintf(stderr, "function copytypeid failed\n");
49125039 label = stack[base - 3];
@@ -4913,13 +5040,13 @@
49135040 base = stack[base - 2];
49145041 break;
49155042 }
4916- case 358LLU: // copytypeid
5043+ case 371LLU: // copytypeid
49175044 {
49185045 //#define res0 0
49195046 //#define arg0 1
49205047 if(/*typeid*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
49215048 {
4922- label = 361LLU; // jump to alternative
5049+ label = 374LLU; // jump to alternative
49235050 break;
49245051 }
49255052
@@ -4927,10 +5054,47 @@
49275054 /*origid*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*original*/))[1][1]/*id*/;
49285055
49295056 // case
5057+ label = 377LLU; // skip deleter
5058+ break;
5059+ }
5060+ case 376LLU: // deleter
5061+ {
5062+ // throw from copytypeid
5063+ if(!stack[base + 4])
5064+ {
5065+ fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable type copytype\n");
5066+ label = 375LLU; // skip, variable already deleted/unscoped
5067+ break;
5068+ }
5069+ fprintf(stderr, "in function copytypeid: unrolling stack, variable type copytype\n");
5070+
5071+ uint64_t *newstack = (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4);
5072+ // call ~type from copytypeid
5073+ newstack[0] = (uint64_t)stack; // backup stack location
5074+ newstack[1] = 1234567890;
5075+ newstack[2] = base;
5076+ newstack[3] = 378LLU;
5077+ stack = newstack;
5078+ // set stack-base & callee-address
5079+ base = 4/*deloffset*/;
5080+ label = 306LLU; // ~type
5081+ break;
5082+ }
5083+ case 378LLU: // return from ~type to copytypeid
5084+ {
5085+ stack = (uint64_t *)stack[0];
5086+ // releasing toplevel container
5087+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4));
5088+
5089+ label = 375LLU; // continue unrolling stack, delete next variable
5090+ break;
5091+ }
5092+ case 377LLU: // skipped deleter
5093+ {
49305094 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
49315095 if(!newstack)
49325096 {
4933- label = 362LLU; // throw: begin to unroll stack
5097+ label = 375LLU; // throw: begin to unroll stack
49345098 break;
49355099 }
49365100
@@ -4937,18 +5101,18 @@
49375101 newstack[15LLU] = 9876543210LLU; // overflow-marker
49385102 // call copytype from copytypeid
49395103 newstack[0] = (uint64_t)stack; // backup stack location
4940- newstack[1] = 363LLU;
5104+ newstack[1] = 379LLU;
49415105 newstack[2] = base;
4942- newstack[3] = 364LLU;
5106+ newstack[3] = 380LLU;
49435107 // arguments for call to copytype
49445108 newstack[5LLU] = stack[base + 2]/*origtype*/;
49455109 stack = newstack;
49465110 // set stack-base & callee-address
49475111 base = 4/*deloffset*/;
4948- label = 327LLU; // copytype
5112+ label = 337LLU; // copytype
49495113 break;
49505114 }
4951- case 363LLU: // copy-back deleter (copytype to copytypeid)
5115+ case 379LLU: // copy-back deleter (copytype to copytypeid)
49525116 {
49535117 fprintf(stderr, "in function copytypeid: unrolling stack, copy-back (copytype to copytypeid)\n");
49545118 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4960,10 +5124,10 @@
49605124 }
49615125 Free(15LLU + 1, sizeof(uint64_t), stack);
49625126 stack = oldstack;
4963- label = 362LLU; // continue to unroll stack
5127+ label = 375LLU; // continue to unroll stack
49645128 break;
49655129 }
4966- case 364LLU: // return from copytype to copytypeid
5130+ case 380LLU: // return from copytype to copytypeid
49675131 {
49685132 uint64_t *oldstack = (uint64_t *)stack[0];
49695133 // copy mutable arguments back from call to copytype
@@ -4976,35 +5140,35 @@
49765140 }
49775141 Free(15LLU + 1, sizeof(uint64_t), stack);
49785142 stack = oldstack;
4979- label = 366LLU; // skip deleter
5143+ label = 382LLU; // skip deleter
49805144 break;
49815145 }
4982- case 365LLU: // deleter
5146+ case 381LLU: // deleter
49835147 {
49845148 // throw from copytypeid
49855149 if(!stack[base + 5])
49865150 {
49875151 fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable u64 copyid\n");
4988- label = 362LLU; // skip, variable already deleted/unscoped
5152+ label = 376LLU; // skip, variable already deleted/unscoped
49895153 break;
49905154 }
49915155 fprintf(stderr, "in function copytypeid: unrolling stack, variable u64 copyid\n");
4992- label = 362LLU; // continue unrolling stack, delete next variable
5156+ label = 376LLU; // continue unrolling stack, delete next variable
49935157 break;
49945158 }
4995- case 366LLU: // skipped deleter
5159+ case 382LLU: // skipped deleter
49965160 {
49975161 stack[base + 5] = stack[base + 3]/*origid*/;
4998- label = 368LLU; // skip deleter
5162+ label = 384LLU; // skip deleter
49995163 break;
50005164 }
5001- case 367LLU: // deleter
5165+ case 383LLU: // deleter
50025166 {
50035167 // throw from copytypeid
50045168 if(!stack[base + 0])
50055169 {
50065170 fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable typeid \n");
5007- label = 365LLU; // skip, variable already deleted/unscoped
5171+ label = 381LLU; // skip, variable already deleted/unscoped
50085172 break;
50095173 }
50105174 fprintf(stderr, "in function copytypeid: unrolling stack, variable typeid \n");
@@ -5014,28 +5178,28 @@
50145178 newstack[0] = (uint64_t)stack; // backup stack location
50155179 newstack[1] = 1234567890;
50165180 newstack[2] = base;
5017- newstack[3] = 369LLU;
5181+ newstack[3] = 385LLU;
50185182 stack = newstack;
50195183 // set stack-base & callee-address
50205184 base = 4/*deloffset*/;
5021- label = 355LLU; // ~typeid
5185+ label = 368LLU; // ~typeid
50225186 break;
50235187 }
5024- case 369LLU: // return from ~typeid to copytypeid
5188+ case 385LLU: // return from ~typeid to copytypeid
50255189 {
50265190 stack = (uint64_t *)stack[0];
50275191 // releasing toplevel container
50285192 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
50295193
5030- label = 365LLU; // continue unrolling stack, delete next variable
5194+ label = 381LLU; // continue unrolling stack, delete next variable
50315195 break;
50325196 }
5033- case 368LLU: // skipped deleter
5197+ case 384LLU: // skipped deleter
50345198 {
50355199 // construct typeid.typeid
50365200 if(!(stack[base + 0] = construct(2)))
50375201 {
5038- label = 365LLU; // throw: begin to unroll stack
5202+ label = 381LLU; // throw: begin to unroll stack
50395203 break;
50405204 }
50415205
@@ -5045,22 +5209,22 @@
50455209 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*copyid*/;
50465210 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
50475211 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5048- label = 360LLU; // case complete
5212+ label = 373LLU; // case complete
50495213 break;
50505214 }
5051- case 362LLU: // copy-back deleter (switch)
5215+ case 375LLU: // copy-back deleter (switch)
50525216 {
50535217 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
50545218 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5055- label = 359LLU; // continue to unroll stack
5219+ label = 372LLU; // continue to unroll stack
50565220 break;
50575221 }
5058- case 361LLU: // try next case
5222+ case 374LLU: // try next case
50595223 {
50605224 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
50615225 exit(-1);
50625226 }
5063- case 360LLU: // completed switch
5227+ case 373LLU: // completed switch
50645228 {
50655229 // return from copytypeid
50665230 label = stack[base - 1];
@@ -5067,7 +5231,7 @@
50675231 base = stack[base - 2];
50685232 break;
50695233 }
5070- case 371LLU: // function reportti failed
5234+ case 387LLU: // function reportti failed
50715235 {
50725236 fprintf(stderr, "function reportti failed\n");
50735237 label = stack[base - 3];
@@ -5074,12 +5238,12 @@
50745238 base = stack[base - 2];
50755239 break;
50765240 }
5077- case 370LLU: // reportti
5241+ case 386LLU: // reportti
50785242 {
50795243 //#define arg0 0
50805244 if(/*typeid*/0 != ((uint64_t *)(stack[base + 0]/*typeid*/))[0])
50815245 {
5082- label = 373LLU; // jump to alternative
5246+ label = 389LLU; // jump to alternative
50835247 break;
50845248 }
50855249
@@ -5090,7 +5254,7 @@
50905254 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
50915255 if(!newstack)
50925256 {
5093- label = 374LLU; // throw: begin to unroll stack
5257+ label = 390LLU; // throw: begin to unroll stack
50945258 break;
50955259 }
50965260
@@ -5097,18 +5261,18 @@
50975261 newstack[10LLU] = 9876543210LLU; // overflow-marker
50985262 // call reporttype from reportti
50995263 newstack[0] = (uint64_t)stack; // backup stack location
5100- newstack[1] = 375LLU;
5264+ newstack[1] = 391LLU;
51015265 newstack[2] = base;
5102- newstack[3] = 376LLU;
5266+ newstack[3] = 392LLU;
51035267 // arguments for call to reporttype
51045268 newstack[4LLU] = stack[base + 1]/*type*/;
51055269 stack = newstack;
51065270 // set stack-base & callee-address
51075271 base = 4/*deloffset*/;
5108- label = 316LLU; // reporttype
5272+ label = 326LLU; // reporttype
51095273 break;
51105274 }
5111- case 375LLU: // copy-back deleter (reporttype to reportti)
5275+ case 391LLU: // copy-back deleter (reporttype to reportti)
51125276 {
51135277 fprintf(stderr, "in function reportti: unrolling stack, copy-back (reporttype to reportti)\n");
51145278 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5120,10 +5284,10 @@
51205284 }
51215285 Free(10LLU + 1, sizeof(uint64_t), stack);
51225286 stack = oldstack;
5123- label = 374LLU; // continue to unroll stack
5287+ label = 390LLU; // continue to unroll stack
51245288 break;
51255289 }
5126- case 376LLU: // return from reporttype to reportti
5290+ case 392LLU: // return from reporttype to reportti
51275291 {
51285292 uint64_t *oldstack = (uint64_t *)stack[0];
51295293 // copy mutable arguments back from call to reporttype
@@ -5136,9 +5300,9 @@
51365300 stack = oldstack;
51375301 fprintf(stderr, "%s", " ");
51385302 // call reportid from reportti
5139- stack[base + 3LLU] = 377LLU/*throw to this address*/;
5303+ stack[base + 3LLU] = 393LLU/*throw to this address*/;
51405304 stack[base + 4LLU] = base;
5141- stack[base + 5LLU] = 378LLU;
5305+ stack[base + 5LLU] = 394LLU;
51425306 // arguments for call to reportid
51435307 stack[base + 6LLU] = stack[base + 2]/*id*/;
51445308 // set stack-base & callee-address
@@ -5146,34 +5310,34 @@
51465310 label = 18446744073709551586LLU; // reportid
51475311 break;
51485312 }
5149- case 377LLU: // copy-back deleter (reportid to reportti)
5313+ case 393LLU: // copy-back deleter (reportid to reportti)
51505314 {
51515315 fprintf(stderr, "in function reportti: unrolling stack, copy-back (reportid to reportti)\n");
51525316 // copy mutable arguments back from call to reportid
5153- label = 374LLU; // continue to roll stack
5317+ label = 390LLU; // continue to roll stack
51545318 break;
51555319 }
5156- case 378LLU: // return from reportid to reportti
5320+ case 394LLU: // return from reportid to reportti
51575321 {
51585322 // copy mutable arguments back from call to reportid
51595323 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
51605324 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5161- label = 372LLU; // case complete
5325+ label = 388LLU; // case complete
51625326 break;
51635327 }
5164- case 374LLU: // copy-back deleter (switch)
5328+ case 390LLU: // copy-back deleter (switch)
51655329 {
51665330 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
51675331 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5168- label = 371LLU; // continue to unroll stack
5332+ label = 387LLU; // continue to unroll stack
51695333 break;
51705334 }
5171- case 373LLU: // try next case
5335+ case 389LLU: // try next case
51725336 {
51735337 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
51745338 exit(-1);
51755339 }
5176- case 372LLU: // completed switch
5340+ case 388LLU: // completed switch
51775341 {
51785342 // return from reportti
51795343 label = stack[base - 1];
@@ -5180,7 +5344,7 @@
51805344 base = stack[base - 2];
51815345 break;
51825346 }
5183- case 379LLU: // ~typeidx
5347+ case 395LLU: // ~typeidx
51845348 {
51855349 if(stack[base + 0]/*variant-nr*/ >= 1)
51865350 {
@@ -5187,10 +5351,10 @@
51875351 fprintf(stderr, "in ~typeidx: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
51885352 exit(-1);
51895353 }
5190- label = 379LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5354+ label = 395LLU + 1LLU + stack[base + 0]/*variant-nr*/;
51915355 break;
51925356 }
5193- case 379LLU + 1LLU + 0LLU: // ~typeidx.typeidx
5357+ case 395LLU + 1LLU + 0LLU: // ~typeidx.typeidx
51945358 {
51955359 // release element type
51965360 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5200,14 +5364,14 @@
52005364 newstack[0] = (uint64_t)stack; // backup stack location
52015365 newstack[1] = 1234567890;
52025366 newstack[2] = base;
5203- newstack[3] = 381LLU;
5367+ newstack[3] = 397LLU;
52045368 stack = newstack;
52055369 // set stack-base & callee-address
52065370 base = 4/*deloffset*/;
5207- label = 296LLU; // ~type
5371+ label = 306LLU; // ~type
52085372 break;
52095373 }
5210- case 381LLU: // return from ~type to typeidx
5374+ case 397LLU: // return from ~type to typeidx
52115375 {
52125376 stack = (uint64_t *)stack[0];
52135377 // releasing toplevel container
@@ -5220,7 +5384,7 @@
52205384 base = stack[base - 2];
52215385 break;
52225386 }
5223- case 383LLU: // function cptypeidx failed
5387+ case 399LLU: // function cptypeidx failed
52245388 {
52255389 fprintf(stderr, "function cptypeidx failed\n");
52265390 label = stack[base - 3];
@@ -5227,13 +5391,13 @@
52275391 base = stack[base - 2];
52285392 break;
52295393 }
5230- case 382LLU: // cptypeidx
5394+ case 398LLU: // cptypeidx
52315395 {
52325396 //#define res0 0
52335397 //#define arg0 1
52345398 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 1]/*orig*/))[0])
52355399 {
5236- label = 385LLU; // jump to alternative
5400+ label = 401LLU; // jump to alternative
52375401 break;
52385402 }
52395403
@@ -5241,10 +5405,47 @@
52415405 /*oidx*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*orig*/))[1][1]/*idx*/;
52425406
52435407 // case
5408+ label = 404LLU; // skip deleter
5409+ break;
5410+ }
5411+ case 403LLU: // deleter
5412+ {
5413+ // throw from cptypeidx
5414+ if(!stack[base + 4])
5415+ {
5416+ fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable type ctype\n");
5417+ label = 402LLU; // skip, variable already deleted/unscoped
5418+ break;
5419+ }
5420+ fprintf(stderr, "in function cptypeidx: unrolling stack, variable type ctype\n");
5421+
5422+ uint64_t *newstack = (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4);
5423+ // call ~type from cptypeidx
5424+ newstack[0] = (uint64_t)stack; // backup stack location
5425+ newstack[1] = 1234567890;
5426+ newstack[2] = base;
5427+ newstack[3] = 405LLU;
5428+ stack = newstack;
5429+ // set stack-base & callee-address
5430+ base = 4/*deloffset*/;
5431+ label = 306LLU; // ~type
5432+ break;
5433+ }
5434+ case 405LLU: // return from ~type to cptypeidx
5435+ {
5436+ stack = (uint64_t *)stack[0];
5437+ // releasing toplevel container
5438+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4));
5439+
5440+ label = 402LLU; // continue unrolling stack, delete next variable
5441+ break;
5442+ }
5443+ case 404LLU: // skipped deleter
5444+ {
52445445 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
52455446 if(!newstack)
52465447 {
5247- label = 386LLU; // throw: begin to unroll stack
5448+ label = 402LLU; // throw: begin to unroll stack
52485449 break;
52495450 }
52505451
@@ -5251,18 +5452,18 @@
52515452 newstack[15LLU] = 9876543210LLU; // overflow-marker
52525453 // call copytype from cptypeidx
52535454 newstack[0] = (uint64_t)stack; // backup stack location
5254- newstack[1] = 387LLU;
5455+ newstack[1] = 406LLU;
52555456 newstack[2] = base;
5256- newstack[3] = 388LLU;
5457+ newstack[3] = 407LLU;
52575458 // arguments for call to copytype
52585459 newstack[5LLU] = stack[base + 2]/*otype*/;
52595460 stack = newstack;
52605461 // set stack-base & callee-address
52615462 base = 4/*deloffset*/;
5262- label = 327LLU; // copytype
5463+ label = 337LLU; // copytype
52635464 break;
52645465 }
5265- case 387LLU: // copy-back deleter (copytype to cptypeidx)
5466+ case 406LLU: // copy-back deleter (copytype to cptypeidx)
52665467 {
52675468 fprintf(stderr, "in function cptypeidx: unrolling stack, copy-back (copytype to cptypeidx)\n");
52685469 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5274,10 +5475,10 @@
52745475 }
52755476 Free(15LLU + 1, sizeof(uint64_t), stack);
52765477 stack = oldstack;
5277- label = 386LLU; // continue to unroll stack
5478+ label = 402LLU; // continue to unroll stack
52785479 break;
52795480 }
5280- case 388LLU: // return from copytype to cptypeidx
5481+ case 407LLU: // return from copytype to cptypeidx
52815482 {
52825483 uint64_t *oldstack = (uint64_t *)stack[0];
52835484 // copy mutable arguments back from call to copytype
@@ -5290,35 +5491,35 @@
52905491 }
52915492 Free(15LLU + 1, sizeof(uint64_t), stack);
52925493 stack = oldstack;
5293- label = 390LLU; // skip deleter
5494+ label = 409LLU; // skip deleter
52945495 break;
52955496 }
5296- case 389LLU: // deleter
5497+ case 408LLU: // deleter
52975498 {
52985499 // throw from cptypeidx
52995500 if(!stack[base + 5])
53005501 {
53015502 fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable u64 cidx\n");
5302- label = 386LLU; // skip, variable already deleted/unscoped
5503+ label = 403LLU; // skip, variable already deleted/unscoped
53035504 break;
53045505 }
53055506 fprintf(stderr, "in function cptypeidx: unrolling stack, variable u64 cidx\n");
5306- label = 386LLU; // continue unrolling stack, delete next variable
5507+ label = 403LLU; // continue unrolling stack, delete next variable
53075508 break;
53085509 }
5309- case 390LLU: // skipped deleter
5510+ case 409LLU: // skipped deleter
53105511 {
53115512 stack[base + 5] = stack[base + 3]/*oidx*/;
5312- label = 392LLU; // skip deleter
5513+ label = 411LLU; // skip deleter
53135514 break;
53145515 }
5315- case 391LLU: // deleter
5516+ case 410LLU: // deleter
53165517 {
53175518 // throw from cptypeidx
53185519 if(!stack[base + 0])
53195520 {
53205521 fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable typeidx \n");
5321- label = 389LLU; // skip, variable already deleted/unscoped
5522+ label = 408LLU; // skip, variable already deleted/unscoped
53225523 break;
53235524 }
53245525 fprintf(stderr, "in function cptypeidx: unrolling stack, variable typeidx \n");
@@ -5328,28 +5529,28 @@
53285529 newstack[0] = (uint64_t)stack; // backup stack location
53295530 newstack[1] = 1234567890;
53305531 newstack[2] = base;
5331- newstack[3] = 393LLU;
5532+ newstack[3] = 412LLU;
53325533 stack = newstack;
53335534 // set stack-base & callee-address
53345535 base = 4/*deloffset*/;
5335- label = 379LLU; // ~typeidx
5536+ label = 395LLU; // ~typeidx
53365537 break;
53375538 }
5338- case 393LLU: // return from ~typeidx to cptypeidx
5539+ case 412LLU: // return from ~typeidx to cptypeidx
53395540 {
53405541 stack = (uint64_t *)stack[0];
53415542 // releasing toplevel container
53425543 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
53435544
5344- label = 389LLU; // continue unrolling stack, delete next variable
5545+ label = 408LLU; // continue unrolling stack, delete next variable
53455546 break;
53465547 }
5347- case 392LLU: // skipped deleter
5548+ case 411LLU: // skipped deleter
53485549 {
53495550 // construct typeidx.typeidx
53505551 if(!(stack[base + 0] = construct(2)))
53515552 {
5352- label = 389LLU; // throw: begin to unroll stack
5553+ label = 408LLU; // throw: begin to unroll stack
53535554 break;
53545555 }
53555556
@@ -5359,22 +5560,22 @@
53595560 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*cidx*/;
53605561 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
53615562 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5362- label = 384LLU; // case complete
5563+ label = 400LLU; // case complete
53635564 break;
53645565 }
5365- case 386LLU: // copy-back deleter (switch)
5566+ case 402LLU: // copy-back deleter (switch)
53665567 {
53675568 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
53685569 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5369- label = 383LLU; // continue to unroll stack
5570+ label = 399LLU; // continue to unroll stack
53705571 break;
53715572 }
5372- case 385LLU: // try next case
5573+ case 401LLU: // try next case
53735574 {
53745575 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
53755576 exit(-1);
53765577 }
5377- case 384LLU: // completed switch
5578+ case 400LLU: // completed switch
53785579 {
53795580 // return from cptypeidx
53805581 label = stack[base - 1];
@@ -5381,7 +5582,7 @@
53815582 base = stack[base - 2];
53825583 break;
53835584 }
5384- case 394LLU: // ~result
5585+ case 413LLU: // ~result
53855586 {
53865587 if(stack[base + 0]/*variant-nr*/ >= 1)
53875588 {
@@ -5388,10 +5589,10 @@
53885589 fprintf(stderr, "in ~result: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
53895590 exit(-1);
53905591 }
5391- label = 394LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5592+ label = 413LLU + 1LLU + stack[base + 0]/*variant-nr*/;
53925593 break;
53935594 }
5394- case 394LLU + 1LLU + 0LLU: // ~result.result
5595+ case 413LLU + 1LLU + 0LLU: // ~result.result
53955596 {
53965597 // release element type
53975598 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5401,14 +5602,14 @@
54015602 newstack[0] = (uint64_t)stack; // backup stack location
54025603 newstack[1] = 1234567890;
54035604 newstack[2] = base;
5404- newstack[3] = 396LLU;
5605+ newstack[3] = 415LLU;
54055606 stack = newstack;
54065607 // set stack-base & callee-address
54075608 base = 4/*deloffset*/;
5408- label = 296LLU; // ~type
5609+ label = 306LLU; // ~type
54095610 break;
54105611 }
5411- case 396LLU: // return from ~type to result
5612+ case 415LLU: // return from ~type to result
54125613 {
54135614 stack = (uint64_t *)stack[0];
54145615 // releasing toplevel container
@@ -5421,7 +5622,7 @@
54215622 base = stack[base - 2];
54225623 break;
54235624 }
5424- case 398LLU: // function copyresult failed
5625+ case 417LLU: // function copyresult failed
54255626 {
54265627 fprintf(stderr, "function copyresult failed\n");
54275628 label = stack[base - 3];
@@ -5428,13 +5629,13 @@
54285629 base = stack[base - 2];
54295630 break;
54305631 }
5431- case 397LLU: // copyresult
5632+ case 416LLU: // copyresult
54325633 {
54335634 //#define res0 0
54345635 //#define arg0 1
54355636 if(/*result*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
54365637 {
5437- label = 400LLU; // jump to alternative
5638+ label = 419LLU; // jump to alternative
54385639 break;
54395640 }
54405641
@@ -5442,10 +5643,47 @@
54425643 /*RESERVED*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*original*/))[1][1]/*RESERVED*/;
54435644
54445645 // case
5646+ label = 422LLU; // skip deleter
5647+ break;
5648+ }
5649+ case 421LLU: // deleter
5650+ {
5651+ // throw from copyresult
5652+ if(!stack[base + 4])
5653+ {
5654+ fprintf(stderr, "in function copyresult: unrolling stack, skipping already deleted/unscoped variable type copytype\n");
5655+ label = 420LLU; // skip, variable already deleted/unscoped
5656+ break;
5657+ }
5658+ fprintf(stderr, "in function copyresult: unrolling stack, variable type copytype\n");
5659+
5660+ uint64_t *newstack = (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4);
5661+ // call ~type from copyresult
5662+ newstack[0] = (uint64_t)stack; // backup stack location
5663+ newstack[1] = 1234567890;
5664+ newstack[2] = base;
5665+ newstack[3] = 423LLU;
5666+ stack = newstack;
5667+ // set stack-base & callee-address
5668+ base = 4/*deloffset*/;
5669+ label = 306LLU; // ~type
5670+ break;
5671+ }
5672+ case 423LLU: // return from ~type to copyresult
5673+ {
5674+ stack = (uint64_t *)stack[0];
5675+ // releasing toplevel container
5676+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4));
5677+
5678+ label = 420LLU; // continue unrolling stack, delete next variable
5679+ break;
5680+ }
5681+ case 422LLU: // skipped deleter
5682+ {
54455683 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
54465684 if(!newstack)
54475685 {
5448- label = 401LLU; // throw: begin to unroll stack
5686+ label = 420LLU; // throw: begin to unroll stack
54495687 break;
54505688 }
54515689
@@ -5452,18 +5690,18 @@
54525690 newstack[15LLU] = 9876543210LLU; // overflow-marker
54535691 // call copytype from copyresult
54545692 newstack[0] = (uint64_t)stack; // backup stack location
5455- newstack[1] = 402LLU;
5693+ newstack[1] = 424LLU;
54565694 newstack[2] = base;
5457- newstack[3] = 403LLU;
5695+ newstack[3] = 425LLU;
54585696 // arguments for call to copytype
54595697 newstack[5LLU] = stack[base + 2]/*origtype*/;
54605698 stack = newstack;
54615699 // set stack-base & callee-address
54625700 base = 4/*deloffset*/;
5463- label = 327LLU; // copytype
5701+ label = 337LLU; // copytype
54645702 break;
54655703 }
5466- case 402LLU: // copy-back deleter (copytype to copyresult)
5704+ case 424LLU: // copy-back deleter (copytype to copyresult)
54675705 {
54685706 fprintf(stderr, "in function copyresult: unrolling stack, copy-back (copytype to copyresult)\n");
54695707 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5475,10 +5713,10 @@
54755713 }
54765714 Free(15LLU + 1, sizeof(uint64_t), stack);
54775715 stack = oldstack;
5478- label = 401LLU; // continue to unroll stack
5716+ label = 420LLU; // continue to unroll stack
54795717 break;
54805718 }
5481- case 403LLU: // return from copytype to copyresult
5719+ case 425LLU: // return from copytype to copyresult
54825720 {
54835721 uint64_t *oldstack = (uint64_t *)stack[0];
54845722 // copy mutable arguments back from call to copytype
@@ -5491,16 +5729,16 @@
54915729 }
54925730 Free(15LLU + 1, sizeof(uint64_t), stack);
54935731 stack = oldstack;
5494- label = 405LLU; // skip deleter
5732+ label = 427LLU; // skip deleter
54955733 break;
54965734 }
5497- case 404LLU: // deleter
5735+ case 426LLU: // deleter
54985736 {
54995737 // throw from copyresult
55005738 if(!stack[base + 0])
55015739 {
55025740 fprintf(stderr, "in function copyresult: unrolling stack, skipping already deleted/unscoped variable result \n");
5503- label = 401LLU; // skip, variable already deleted/unscoped
5741+ label = 421LLU; // skip, variable already deleted/unscoped
55045742 break;
55055743 }
55065744 fprintf(stderr, "in function copyresult: unrolling stack, variable result \n");
@@ -5510,28 +5748,28 @@
55105748 newstack[0] = (uint64_t)stack; // backup stack location
55115749 newstack[1] = 1234567890;
55125750 newstack[2] = base;
5513- newstack[3] = 406LLU;
5751+ newstack[3] = 428LLU;
55145752 stack = newstack;
55155753 // set stack-base & callee-address
55165754 base = 4/*deloffset*/;
5517- label = 394LLU; // ~result
5755+ label = 413LLU; // ~result
55185756 break;
55195757 }
5520- case 406LLU: // return from ~result to copyresult
5758+ case 428LLU: // return from ~result to copyresult
55215759 {
55225760 stack = (uint64_t *)stack[0];
55235761 // releasing toplevel container
55245762 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
55255763
5526- label = 401LLU; // continue unrolling stack, delete next variable
5764+ label = 421LLU; // continue unrolling stack, delete next variable
55275765 break;
55285766 }
5529- case 405LLU: // skipped deleter
5767+ case 427LLU: // skipped deleter
55305768 {
55315769 // construct result.result
55325770 if(!(stack[base + 0] = construct(2)))
55335771 {
5534- label = 401LLU; // throw: begin to unroll stack
5772+ label = 421LLU; // throw: begin to unroll stack
55355773 break;
55365774 }
55375775
@@ -5541,22 +5779,22 @@
55415779 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 3]/*RESERVED*/;
55425780 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
55435781 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5544- label = 399LLU; // case complete
5782+ label = 418LLU; // case complete
55455783 break;
55465784 }
5547- case 401LLU: // copy-back deleter (switch)
5785+ case 420LLU: // copy-back deleter (switch)
55485786 {
55495787 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
55505788 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5551- label = 398LLU; // continue to unroll stack
5789+ label = 417LLU; // continue to unroll stack
55525790 break;
55535791 }
5554- case 400LLU: // try next case
5792+ case 419LLU: // try next case
55555793 {
55565794 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
55575795 exit(-1);
55585796 }
5559- case 399LLU: // completed switch
5797+ case 418LLU: // completed switch
55605798 {
55615799 // return from copyresult
55625800 label = stack[base - 1];
@@ -5563,7 +5801,7 @@
55635801 base = stack[base - 2];
55645802 break;
55655803 }
5566- case 408LLU: // function represult failed
5804+ case 430LLU: // function represult failed
55675805 {
55685806 fprintf(stderr, "function represult failed\n");
55695807 label = stack[base - 3];
@@ -5570,12 +5808,12 @@
55705808 base = stack[base - 2];
55715809 break;
55725810 }
5573- case 407LLU: // represult
5811+ case 429LLU: // represult
55745812 {
55755813 //#define arg0 0
55765814 if(/*result*/0 != ((uint64_t *)(stack[base + 0]/*result*/))[0])
55775815 {
5578- label = 410LLU; // jump to alternative
5816+ label = 432LLU; // jump to alternative
55795817 break;
55805818 }
55815819
@@ -5586,7 +5824,7 @@
55865824 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
55875825 if(!newstack)
55885826 {
5589- label = 411LLU; // throw: begin to unroll stack
5827+ label = 433LLU; // throw: begin to unroll stack
55905828 break;
55915829 }
55925830
@@ -5593,18 +5831,18 @@
55935831 newstack[10LLU] = 9876543210LLU; // overflow-marker
55945832 // call reporttype from represult
55955833 newstack[0] = (uint64_t)stack; // backup stack location
5596- newstack[1] = 412LLU;
5834+ newstack[1] = 434LLU;
55975835 newstack[2] = base;
5598- newstack[3] = 413LLU;
5836+ newstack[3] = 435LLU;
55995837 // arguments for call to reporttype
56005838 newstack[4LLU] = stack[base + 1]/*type*/;
56015839 stack = newstack;
56025840 // set stack-base & callee-address
56035841 base = 4/*deloffset*/;
5604- label = 316LLU; // reporttype
5842+ label = 326LLU; // reporttype
56055843 break;
56065844 }
5607- case 412LLU: // copy-back deleter (reporttype to represult)
5845+ case 434LLU: // copy-back deleter (reporttype to represult)
56085846 {
56095847 fprintf(stderr, "in function represult: unrolling stack, copy-back (reporttype to represult)\n");
56105848 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5616,10 +5854,10 @@
56165854 }
56175855 Free(10LLU + 1, sizeof(uint64_t), stack);
56185856 stack = oldstack;
5619- label = 411LLU; // continue to unroll stack
5857+ label = 433LLU; // continue to unroll stack
56205858 break;
56215859 }
5622- case 413LLU: // return from reporttype to represult
5860+ case 435LLU: // return from reporttype to represult
56235861 {
56245862 uint64_t *oldstack = (uint64_t *)stack[0];
56255863 // copy mutable arguments back from call to reporttype
@@ -5632,22 +5870,22 @@
56325870 stack = oldstack;
56335871 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
56345872 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5635- label = 409LLU; // case complete
5873+ label = 431LLU; // case complete
56365874 break;
56375875 }
5638- case 411LLU: // copy-back deleter (switch)
5876+ case 433LLU: // copy-back deleter (switch)
56395877 {
56405878 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
56415879 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5642- label = 408LLU; // continue to unroll stack
5880+ label = 430LLU; // continue to unroll stack
56435881 break;
56445882 }
5645- case 410LLU: // try next case
5883+ case 432LLU: // try next case
56465884 {
56475885 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
56485886 exit(-1);
56495887 }
5650- case 409LLU: // completed switch
5888+ case 431LLU: // completed switch
56515889 {
56525890 // return from represult
56535891 label = stack[base - 1];
@@ -5654,7 +5892,7 @@
56545892 base = stack[base - 2];
56555893 break;
56565894 }
5657- case 414LLU: // ~param
5895+ case 436LLU: // ~param
56585896 {
56595897 if(stack[base + 0]/*variant-nr*/ >= 1)
56605898 {
@@ -5661,10 +5899,10 @@
56615899 fprintf(stderr, "in ~param: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
56625900 exit(-1);
56635901 }
5664- label = 414LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5902+ label = 436LLU + 1LLU + stack[base + 0]/*variant-nr*/;
56655903 break;
56665904 }
5667- case 414LLU + 1LLU + 0LLU: // ~param.param
5905+ case 436LLU + 1LLU + 0LLU: // ~param.param
56685906 {
56695907 // release element typeid
56705908 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5674,14 +5912,14 @@
56745912 newstack[0] = (uint64_t)stack; // backup stack location
56755913 newstack[1] = 1234567890;
56765914 newstack[2] = base;
5677- newstack[3] = 416LLU;
5915+ newstack[3] = 438LLU;
56785916 stack = newstack;
56795917 // set stack-base & callee-address
56805918 base = 4/*deloffset*/;
5681- label = 355LLU; // ~typeid
5919+ label = 368LLU; // ~typeid
56825920 break;
56835921 }
5684- case 416LLU: // return from ~typeid to param
5922+ case 438LLU: // return from ~typeid to param
56855923 {
56865924 stack = (uint64_t *)stack[0];
56875925 // releasing toplevel container
@@ -5694,7 +5932,7 @@
56945932 base = stack[base - 2];
56955933 break;
56965934 }
5697- case 418LLU: // function copyparam failed
5935+ case 440LLU: // function copyparam failed
56985936 {
56995937 fprintf(stderr, "function copyparam failed\n");
57005938 label = stack[base - 3];
@@ -5701,13 +5939,13 @@
57015939 base = stack[base - 2];
57025940 break;
57035941 }
5704- case 417LLU: // copyparam
5942+ case 439LLU: // copyparam
57055943 {
57065944 //#define res0 0
57075945 //#define arg0 1
57085946 if(/*param*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
57095947 {
5710- label = 420LLU; // jump to alternative
5948+ label = 442LLU; // jump to alternative
57115949 break;
57125950 }
57135951
@@ -5715,58 +5953,95 @@
57155953 /*origmut*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*original*/))[1][1]/*mutable*/;
57165954
57175955 // case
5956+ label = 445LLU; // skip deleter
5957+ break;
5958+ }
5959+ case 444LLU: // deleter
5960+ {
5961+ // throw from copyparam
5962+ if(!stack[base + 4])
5963+ {
5964+ fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable typeid copytypeid\n");
5965+ label = 443LLU; // skip, variable already deleted/unscoped
5966+ break;
5967+ }
5968+ fprintf(stderr, "in function copyparam: unrolling stack, variable typeid copytypeid\n");
5969+
5970+ uint64_t *newstack = (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4);
5971+ // call ~typeid from copyparam
5972+ newstack[0] = (uint64_t)stack; // backup stack location
5973+ newstack[1] = 1234567890;
5974+ newstack[2] = base;
5975+ newstack[3] = 446LLU;
5976+ stack = newstack;
5977+ // set stack-base & callee-address
5978+ base = 4/*deloffset*/;
5979+ label = 368LLU; // ~typeid
5980+ break;
5981+ }
5982+ case 446LLU: // return from ~typeid to copyparam
5983+ {
5984+ stack = (uint64_t *)stack[0];
5985+ // releasing toplevel container
5986+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 4));
5987+
5988+ label = 443LLU; // continue unrolling stack, delete next variable
5989+ break;
5990+ }
5991+ case 445LLU: // skipped deleter
5992+ {
57185993 // call copytypeid from copyparam
5719- stack[base + 5LLU] = 422LLU/*throw to this address*/;
5994+ stack[base + 5LLU] = 447LLU/*throw to this address*/;
57205995 stack[base + 6LLU] = base;
5721- stack[base + 7LLU] = 423LLU;
5996+ stack[base + 7LLU] = 448LLU;
57225997 // arguments for call to copytypeid
57235998 stack[base + 9LLU] = stack[base + 2]/*origtypeid*/;
57245999 // set stack-base & callee-address
57256000 base += 8LLU;
5726- label = 358LLU; // copytypeid
6001+ label = 371LLU; // copytypeid
57276002 break;
57286003 }
5729- case 422LLU: // copy-back deleter (copytypeid to copyparam)
6004+ case 447LLU: // copy-back deleter (copytypeid to copyparam)
57306005 {
57316006 fprintf(stderr, "in function copyparam: unrolling stack, copy-back (copytypeid to copyparam)\n");
57326007 // copy mutable arguments back from call to copytypeid
5733- label = 421LLU; // continue to roll stack
6008+ label = 443LLU; // continue to roll stack
57346009 break;
57356010 }
5736- case 423LLU: // return from copytypeid to copyparam
6011+ case 448LLU: // return from copytypeid to copyparam
57376012 {
57386013 // copy mutable arguments back from call to copytypeid
57396014 // copy back results provided by call to copytypeid
57406015 stack[base + 4] = stack[base + 8LLU];
5741- label = 425LLU; // skip deleter
6016+ label = 450LLU; // skip deleter
57426017 break;
57436018 }
5744- case 424LLU: // deleter
6019+ case 449LLU: // deleter
57456020 {
57466021 // throw from copyparam
57476022 if(!stack[base + 5])
57486023 {
57496024 fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable u64 copymut\n");
5750- label = 421LLU; // skip, variable already deleted/unscoped
6025+ label = 444LLU; // skip, variable already deleted/unscoped
57516026 break;
57526027 }
57536028 fprintf(stderr, "in function copyparam: unrolling stack, variable u64 copymut\n");
5754- label = 421LLU; // continue unrolling stack, delete next variable
6029+ label = 444LLU; // continue unrolling stack, delete next variable
57556030 break;
57566031 }
5757- case 425LLU: // skipped deleter
6032+ case 450LLU: // skipped deleter
57586033 {
57596034 stack[base + 5] = stack[base + 3]/*origmut*/;
5760- label = 427LLU; // skip deleter
6035+ label = 452LLU; // skip deleter
57616036 break;
57626037 }
5763- case 426LLU: // deleter
6038+ case 451LLU: // deleter
57646039 {
57656040 // throw from copyparam
57666041 if(!stack[base + 0])
57676042 {
57686043 fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable param \n");
5769- label = 424LLU; // skip, variable already deleted/unscoped
6044+ label = 449LLU; // skip, variable already deleted/unscoped
57706045 break;
57716046 }
57726047 fprintf(stderr, "in function copyparam: unrolling stack, variable param \n");
@@ -5776,28 +6051,28 @@
57766051 newstack[0] = (uint64_t)stack; // backup stack location
57776052 newstack[1] = 1234567890;
57786053 newstack[2] = base;
5779- newstack[3] = 428LLU;
6054+ newstack[3] = 453LLU;
57806055 stack = newstack;
57816056 // set stack-base & callee-address
57826057 base = 4/*deloffset*/;
5783- label = 414LLU; // ~param
6058+ label = 436LLU; // ~param
57846059 break;
57856060 }
5786- case 428LLU: // return from ~param to copyparam
6061+ case 453LLU: // return from ~param to copyparam
57876062 {
57886063 stack = (uint64_t *)stack[0];
57896064 // releasing toplevel container
57906065 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
57916066
5792- label = 424LLU; // continue unrolling stack, delete next variable
6067+ label = 449LLU; // continue unrolling stack, delete next variable
57936068 break;
57946069 }
5795- case 427LLU: // skipped deleter
6070+ case 452LLU: // skipped deleter
57966071 {
57976072 // construct param.param
57986073 if(!(stack[base + 0] = construct(2)))
57996074 {
5800- label = 424LLU; // throw: begin to unroll stack
6075+ label = 449LLU; // throw: begin to unroll stack
58016076 break;
58026077 }
58036078
@@ -5807,22 +6082,22 @@
58076082 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*copymut*/;
58086083 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
58096084 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5810- label = 419LLU; // case complete
6085+ label = 441LLU; // case complete
58116086 break;
58126087 }
5813- case 421LLU: // copy-back deleter (switch)
6088+ case 443LLU: // copy-back deleter (switch)
58146089 {
58156090 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
58166091 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5817- label = 418LLU; // continue to unroll stack
6092+ label = 440LLU; // continue to unroll stack
58186093 break;
58196094 }
5820- case 420LLU: // try next case
6095+ case 442LLU: // try next case
58216096 {
58226097 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
58236098 exit(-1);
58246099 }
5825- case 419LLU: // completed switch
6100+ case 441LLU: // completed switch
58266101 {
58276102 // return from copyparam
58286103 label = stack[base - 1];
@@ -5829,7 +6104,7 @@
58296104 base = stack[base - 2];
58306105 break;
58316106 }
5832- case 430LLU: // function repparam failed
6107+ case 455LLU: // function repparam failed
58336108 {
58346109 fprintf(stderr, "function repparam failed\n");
58356110 label = stack[base - 3];
@@ -5836,12 +6111,12 @@
58366111 base = stack[base - 2];
58376112 break;
58386113 }
5839- case 429LLU: // repparam
6114+ case 454LLU: // repparam
58406115 {
58416116 //#define arg0 0
58426117 if(/*param*/0 != ((uint64_t *)(stack[base + 0]/*param*/))[0])
58436118 {
5844- label = 432LLU; // jump to alternative
6119+ label = 457LLU; // jump to alternative
58456120 break;
58466121 }
58476122
@@ -5851,61 +6126,61 @@
58516126 // case
58526127 if(!stack[base + 2]/*mutable*/)
58536128 {
5854- label = 434LLU; // jump to alternative
6129+ label = 459LLU; // jump to alternative
58556130 break;
58566131 }
58576132
58586133 // consequent
58596134 fprintf(stderr, "%s", "mut ");
5860- label = 435LLU; // consequent complete
6135+ label = 460LLU; // consequent complete
58616136 break;
58626137 }
5863- case 434LLU: // alternative
6138+ case 459LLU: // alternative
58646139 {
5865- label = 435LLU; // alternative complete
6140+ label = 460LLU; // alternative complete
58666141 break;
58676142 }
5868- case 435LLU: // completed if-then-else
6143+ case 460LLU: // completed if-then-else
58696144 {
58706145 // call reportti from repparam
5871- stack[base + 3LLU] = 436LLU/*throw to this address*/;
6146+ stack[base + 3LLU] = 461LLU/*throw to this address*/;
58726147 stack[base + 4LLU] = base;
5873- stack[base + 5LLU] = 437LLU;
6148+ stack[base + 5LLU] = 462LLU;
58746149 // arguments for call to reportti
58756150 stack[base + 6LLU] = stack[base + 1]/*typeid*/;
58766151 // set stack-base & callee-address
58776152 base += 6LLU;
5878- label = 370LLU; // reportti
6153+ label = 386LLU; // reportti
58796154 break;
58806155 }
5881- case 436LLU: // copy-back deleter (reportti to repparam)
6156+ case 461LLU: // copy-back deleter (reportti to repparam)
58826157 {
58836158 fprintf(stderr, "in function repparam: unrolling stack, copy-back (reportti to repparam)\n");
58846159 // copy mutable arguments back from call to reportti
5885- label = 433LLU; // continue to roll stack
6160+ label = 458LLU; // continue to roll stack
58866161 break;
58876162 }
5888- case 437LLU: // return from reportti to repparam
6163+ case 462LLU: // return from reportti to repparam
58896164 {
58906165 // copy mutable arguments back from call to reportti
58916166 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
58926167 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5893- label = 431LLU; // case complete
6168+ label = 456LLU; // case complete
58946169 break;
58956170 }
5896- case 433LLU: // copy-back deleter (switch)
6171+ case 458LLU: // copy-back deleter (switch)
58976172 {
58986173 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
58996174 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5900- label = 430LLU; // continue to unroll stack
6175+ label = 455LLU; // continue to unroll stack
59016176 break;
59026177 }
5903- case 432LLU: // try next case
6178+ case 457LLU: // try next case
59046179 {
59056180 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
59066181 exit(-1);
59076182 }
5908- case 431LLU: // completed switch
6183+ case 456LLU: // completed switch
59096184 {
59106185 // return from repparam
59116186 label = stack[base - 1];
@@ -5912,7 +6187,7 @@
59126187 base = stack[base - 2];
59136188 break;
59146189 }
5915- case 439LLU: // function lookparam failed
6190+ case 464LLU: // function lookparam failed
59166191 {
59176192 fprintf(stderr, "function lookparam failed\n");
59186193 label = stack[base - 3];
@@ -5919,39 +6194,39 @@
59196194 base = stack[base - 2];
59206195 break;
59216196 }
5922- case 438LLU: // lookparam
6197+ case 463LLU: // lookparam
59236198 {
59246199 //#define res0 0
59256200 //#define arg0 1
59266201 //#define arg1 2
5927- label = 441LLU; // skip deleter
6202+ label = 466LLU; // skip deleter
59286203 break;
59296204 }
5930- case 440LLU: // deleter
6205+ case 465LLU: // deleter
59316206 {
59326207 // throw from lookparam
59336208 if(!stack[base + 3])
59346209 {
59356210 fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
5936- label = 439LLU; // skip, variable already deleted/unscoped
6211+ label = 464LLU; // skip, variable already deleted/unscoped
59376212 break;
59386213 }
59396214 fprintf(stderr, "in function lookparam: unrolling stack, variable u64 found\n");
5940- label = 439LLU; // continue unrolling stack, delete next variable
6215+ label = 464LLU; // continue unrolling stack, delete next variable
59416216 break;
59426217 }
5943- case 441LLU: // skipped deleter
6218+ case 466LLU: // skipped deleter
59446219 {
59456220 stack[base + 3] = 0;
59466221 flippedassign(stack[base + 1]/*params*/, &stack[base + 4]);
5947- label = 442LLU; // start to repeat
6222+ label = 467LLU; // start to repeat
59486223 break;
59496224 }
5950- case 442LLU: // repeat from here
6225+ case 467LLU: // repeat from here
59516226 {
59526227 if(!stack[base + 4])
59536228 {
5954- label = 443LLU; // break loop
6229+ label = 468LLU; // break loop
59556230 break;
59566231 }
59576232
@@ -5961,19 +6236,19 @@
59616236 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
59626237 if(!stack[base + 3]/*found*/)
59636238 {
5964- label = 445LLU; // jump to alternative
6239+ label = 470LLU; // jump to alternative
59656240 break;
59666241 }
59676242
59686243 // consequent
5969- label = 446LLU; // consequent complete
6244+ label = 471LLU; // consequent complete
59706245 break;
59716246 }
5972- case 445LLU: // alternative
6247+ case 470LLU: // alternative
59736248 {
59746249 if(/*param*/0 != ((uint64_t *)(stack[base + 5]/*param*/))[0])
59756250 {
5976- label = 448LLU; // jump to alternative
6251+ label = 473LLU; // jump to alternative
59776252 break;
59786253 }
59796254
@@ -5983,7 +6258,7 @@
59836258 // case
59846259 if(/*typeid*/0 != ((uint64_t *)(stack[base + 7]/*typeid*/))[0])
59856260 {
5986- label = 451LLU; // jump to alternative
6261+ label = 476LLU; // jump to alternative
59876262 break;
59886263 }
59896264
@@ -5992,9 +6267,9 @@
59926267
59936268 // case
59946269 // call equ from lookparam
5995- stack[base + 11LLU] = 453LLU/*throw to this address*/;
6270+ stack[base + 11LLU] = 478LLU/*throw to this address*/;
59966271 stack[base + 12LLU] = base;
5997- stack[base + 13LLU] = 454LLU;
6272+ stack[base + 13LLU] = 479LLU;
59986273 // arguments for call to equ
59996274 stack[base + 15LLU] = stack[base + 10]/*id*/;
60006275 stack[base + 16LLU] = stack[base + 2]/*wanted*/;
@@ -6003,14 +6278,14 @@
60036278 label = 18446744073709551600LLU; // equ
60046279 break;
60056280 }
6006- case 453LLU: // copy-back deleter (equ to lookparam)
6281+ case 478LLU: // copy-back deleter (equ to lookparam)
60076282 {
60086283 fprintf(stderr, "in function lookparam: unrolling stack, copy-back (equ to lookparam)\n");
60096284 // copy mutable arguments back from call to equ
6010- label = 452LLU; // continue to roll stack
6285+ label = 477LLU; // continue to roll stack
60116286 break;
60126287 }
6013- case 454LLU: // return from equ to lookparam
6288+ case 479LLU: // return from equ to lookparam
60146289 {
60156290 // copy mutable arguments back from call to equ
60166291 // copy back results provided by call to equ
@@ -6017,76 +6292,76 @@
60176292 stack[base + 3] = stack[base + 14LLU];
60186293 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
60196294 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6020- label = 450LLU; // case complete
6295+ label = 475LLU; // case complete
60216296 break;
60226297 }
6023- case 452LLU: // copy-back deleter (switch)
6298+ case 477LLU: // copy-back deleter (switch)
60246299 {
60256300 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
60266301 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6027- label = 449LLU; // continue to unroll stack
6302+ label = 474LLU; // continue to unroll stack
60286303 break;
60296304 }
6030- case 451LLU: // try next case
6305+ case 476LLU: // try next case
60316306 {
60326307 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
60336308 exit(-1);
60346309 }
6035- case 450LLU: // completed switch
6310+ case 475LLU: // completed switch
60366311 {
60376312 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
60386313 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6039- label = 447LLU; // case complete
6314+ label = 472LLU; // case complete
60406315 break;
60416316 }
6042- case 449LLU: // copy-back deleter (switch)
6317+ case 474LLU: // copy-back deleter (switch)
60436318 {
60446319 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
60456320 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6046- label = 444LLU; // continue to unroll stack
6321+ label = 469LLU; // continue to unroll stack
60476322 break;
60486323 }
6049- case 448LLU: // try next case
6324+ case 473LLU: // try next case
60506325 {
60516326 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
60526327 exit(-1);
60536328 }
6054- case 447LLU: // completed switch
6329+ case 472LLU: // completed switch
60556330 {
6056- label = 446LLU; // alternative complete
6331+ label = 471LLU; // alternative complete
60576332 break;
60586333 }
6059- case 446LLU: // completed if-then-else
6334+ case 471LLU: // completed if-then-else
60606335 {
60616336 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
6062- label = 442LLU; // repeat
6337+ label = 467LLU; // repeat
60636338 break;
60646339 }
6065- case 444LLU: // copy-back deleter for while next
6340+ case 469LLU: // copy-back deleter for while next
60666341 {
60676342 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
6068- label = 440LLU; // continue to unroll stack
6343+ label = 465LLU; // continue to unroll stack
60696344 break;
60706345 }
6071- case 443LLU: // loop finished
6346+ case 468LLU: // loop finished
60726347 {
6073- label = 456LLU; // skip deleter
6348+ label = 481LLU; // skip deleter
60746349 break;
60756350 }
6076- case 455LLU: // deleter
6351+ case 480LLU: // deleter
60776352 {
60786353 // throw from lookparam
60796354 if(!stack[base + 0])
60806355 {
60816356 fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6082- label = 440LLU; // skip, variable already deleted/unscoped
6357+ label = 465LLU; // skip, variable already deleted/unscoped
60836358 break;
60846359 }
60856360 fprintf(stderr, "in function lookparam: unrolling stack, variable u64 \n");
6086- label = 440LLU; // continue unrolling stack, delete next variable
6361+ label = 465LLU; // continue unrolling stack, delete next variable
60876362 break;
60886363 }
6089- case 456LLU: // skipped deleter
6364+ case 481LLU: // skipped deleter
60906365 {
60916366 stack[base + 0] = stack[base + 3]/*found*/;
60926367 // return from lookparam
@@ -6094,7 +6369,7 @@
60946369 base = stack[base - 2];
60956370 break;
60966371 }
6097- case 457LLU: // ~letdef
6372+ case 482LLU: // ~letdef
60986373 {
60996374 if(stack[base + 0]/*variant-nr*/ >= 1)
61006375 {
@@ -6101,10 +6376,10 @@
61016376 fprintf(stderr, "in ~letdef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
61026377 exit(-1);
61036378 }
6104- label = 457LLU + 1LLU + stack[base + 0]/*variant-nr*/;
6379+ label = 482LLU + 1LLU + stack[base + 0]/*variant-nr*/;
61056380 break;
61066381 }
6107- case 457LLU + 1LLU + 0LLU: // ~letdef.letdef
6382+ case 482LLU + 1LLU + 0LLU: // ~letdef.letdef
61086383 {
61096384 // release element type
61106385 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -6114,14 +6389,14 @@
61146389 newstack[0] = (uint64_t)stack; // backup stack location
61156390 newstack[1] = 1234567890;
61166391 newstack[2] = base;
6117- newstack[3] = 459LLU;
6392+ newstack[3] = 484LLU;
61186393 stack = newstack;
61196394 // set stack-base & callee-address
61206395 base = 4/*deloffset*/;
6121- label = 296LLU; // ~type
6396+ label = 306LLU; // ~type
61226397 break;
61236398 }
6124- case 459LLU: // return from ~type to letdef
6399+ case 484LLU: // return from ~type to letdef
61256400 {
61266401 stack = (uint64_t *)stack[0];
61276402 // releasing toplevel container
@@ -6137,7 +6412,7 @@
61376412 base = stack[base - 2];
61386413 break;
61396414 }
6140- case 461LLU: // function mkletdummy failed
6415+ case 486LLU: // function mkletdummy failed
61416416 {
61426417 fprintf(stderr, "function mkletdummy failed\n");
61436418 label = stack[base - 3];
@@ -6144,38 +6419,38 @@
61446419 base = stack[base - 2];
61456420 break;
61466421 }
6147- case 460LLU: // mkletdummy
6422+ case 485LLU: // mkletdummy
61486423 {
61496424 //#define res0 0
6150- label = 463LLU; // skip deleter
6425+ label = 488LLU; // skip deleter
61516426 break;
61526427 }
6153- case 462LLU: // deleter
6428+ case 487LLU: // deleter
61546429 {
61556430 // throw from mkletdummy
61566431 if(!stack[base + 1])
61576432 {
61586433 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 newid\n");
6159- label = 461LLU; // skip, variable already deleted/unscoped
6434+ label = 486LLU; // skip, variable already deleted/unscoped
61606435 break;
61616436 }
61626437 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 newid\n");
6163- label = 461LLU; // continue unrolling stack, delete next variable
6438+ label = 486LLU; // continue unrolling stack, delete next variable
61646439 break;
61656440 }
6166- case 463LLU: // skipped deleter
6441+ case 488LLU: // skipped deleter
61676442 {
61686443 stack[base + 1] = 78026663350239232;
6169- label = 465LLU; // skip deleter
6444+ label = 490LLU; // skip deleter
61706445 break;
61716446 }
6172- case 464LLU: // deleter
6447+ case 489LLU: // deleter
61736448 {
61746449 // throw from mkletdummy
61756450 if(!stack[base + 2])
61766451 {
61776452 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable type newtype\n");
6178- label = 462LLU; // skip, variable already deleted/unscoped
6453+ label = 487LLU; // skip, variable already deleted/unscoped
61796454 break;
61806455 }
61816456 fprintf(stderr, "in function mkletdummy: unrolling stack, variable type newtype\n");
@@ -6185,28 +6460,28 @@
61856460 newstack[0] = (uint64_t)stack; // backup stack location
61866461 newstack[1] = 1234567890;
61876462 newstack[2] = base;
6188- newstack[3] = 466LLU;
6463+ newstack[3] = 491LLU;
61896464 stack = newstack;
61906465 // set stack-base & callee-address
61916466 base = 4/*deloffset*/;
6192- label = 296LLU; // ~type
6467+ label = 306LLU; // ~type
61936468 break;
61946469 }
6195- case 466LLU: // return from ~type to mkletdummy
6470+ case 491LLU: // return from ~type to mkletdummy
61966471 {
61976472 stack = (uint64_t *)stack[0];
61986473 // releasing toplevel container
61996474 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 2] - sizeof(uint64_t) * 4));
62006475
6201- label = 462LLU; // continue unrolling stack, delete next variable
6476+ label = 487LLU; // continue unrolling stack, delete next variable
62026477 break;
62036478 }
6204- case 465LLU: // skipped deleter
6479+ case 490LLU: // skipped deleter
62056480 {
62066481 // construct type.typename
62076482 if(!(stack[base + 2] = construct(1)))
62086483 {
6209- label = 462LLU; // throw: begin to unroll stack
6484+ label = 487LLU; // throw: begin to unroll stack
62106485 break;
62116486 }
62126487
@@ -6213,73 +6488,73 @@
62136488 // consequent
62146489 ((uint64_t *)stack[base + 2])[0] = 0;
62156490 (((uint64_t **)(stack[base + 2]))[1][0]) = stack[base + 1]/*newid*/;
6216- label = 468LLU; // skip deleter
6491+ label = 493LLU; // skip deleter
62176492 break;
62186493 }
6219- case 467LLU: // deleter
6494+ case 492LLU: // deleter
62206495 {
62216496 // throw from mkletdummy
62226497 if(!stack[base + 3])
62236498 {
62246499 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 newindex\n");
6225- label = 464LLU; // skip, variable already deleted/unscoped
6500+ label = 489LLU; // skip, variable already deleted/unscoped
62266501 break;
62276502 }
62286503 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 newindex\n");
6229- label = 464LLU; // continue unrolling stack, delete next variable
6504+ label = 489LLU; // continue unrolling stack, delete next variable
62306505 break;
62316506 }
6232- case 468LLU: // skipped deleter
6507+ case 493LLU: // skipped deleter
62336508 {
62346509 stack[base + 3] = 0;
6235- label = 470LLU; // skip deleter
6510+ label = 495LLU; // skip deleter
62366511 break;
62376512 }
6238- case 469LLU: // deleter
6513+ case 494LLU: // deleter
62396514 {
62406515 // throw from mkletdummy
62416516 if(!stack[base + 4])
62426517 {
62436518 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 newmutable\n");
6244- label = 467LLU; // skip, variable already deleted/unscoped
6519+ label = 492LLU; // skip, variable already deleted/unscoped
62456520 break;
62466521 }
62476522 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 newmutable\n");
6248- label = 467LLU; // continue unrolling stack, delete next variable
6523+ label = 492LLU; // continue unrolling stack, delete next variable
62496524 break;
62506525 }
6251- case 470LLU: // skipped deleter
6526+ case 495LLU: // skipped deleter
62526527 {
62536528 stack[base + 4] = 0;
6254- label = 472LLU; // skip deleter
6529+ label = 497LLU; // skip deleter
62556530 break;
62566531 }
6257- case 471LLU: // deleter
6532+ case 496LLU: // deleter
62586533 {
62596534 // throw from mkletdummy
62606535 if(!stack[base + 5])
62616536 {
62626537 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 substruct\n");
6263- label = 469LLU; // skip, variable already deleted/unscoped
6538+ label = 494LLU; // skip, variable already deleted/unscoped
62646539 break;
62656540 }
62666541 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 substruct\n");
6267- label = 469LLU; // continue unrolling stack, delete next variable
6542+ label = 494LLU; // continue unrolling stack, delete next variable
62686543 break;
62696544 }
6270- case 472LLU: // skipped deleter
6545+ case 497LLU: // skipped deleter
62716546 {
62726547 stack[base + 5] = 0;
6273- label = 474LLU; // skip deleter
6548+ label = 499LLU; // skip deleter
62746549 break;
62756550 }
6276- case 473LLU: // deleter
6551+ case 498LLU: // deleter
62776552 {
62786553 // throw from mkletdummy
62796554 if(!stack[base + 0])
62806555 {
62816556 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable letdef \n");
6282- label = 471LLU; // skip, variable already deleted/unscoped
6557+ label = 496LLU; // skip, variable already deleted/unscoped
62836558 break;
62846559 }
62856560 fprintf(stderr, "in function mkletdummy: unrolling stack, variable letdef \n");
@@ -6289,28 +6564,28 @@
62896564 newstack[0] = (uint64_t)stack; // backup stack location
62906565 newstack[1] = 1234567890;
62916566 newstack[2] = base;
6292- newstack[3] = 475LLU;
6567+ newstack[3] = 500LLU;
62936568 stack = newstack;
62946569 // set stack-base & callee-address
62956570 base = 4/*deloffset*/;
6296- label = 457LLU; // ~letdef
6571+ label = 482LLU; // ~letdef
62976572 break;
62986573 }
6299- case 475LLU: // return from ~letdef to mkletdummy
6574+ case 500LLU: // return from ~letdef to mkletdummy
63006575 {
63016576 stack = (uint64_t *)stack[0];
63026577 // releasing toplevel container
63036578 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
63046579
6305- label = 471LLU; // continue unrolling stack, delete next variable
6580+ label = 496LLU; // continue unrolling stack, delete next variable
63066581 break;
63076582 }
6308- case 474LLU: // skipped deleter
6583+ case 499LLU: // skipped deleter
63096584 {
63106585 // construct letdef.letdef
63116586 if(!(stack[base + 0] = construct(5)))
63126587 {
6313- label = 471LLU; // throw: begin to unroll stack
6588+ label = 496LLU; // throw: begin to unroll stack
63146589 break;
63156590 }
63166591
@@ -6326,7 +6601,7 @@
63266601 base = stack[base - 2];
63276602 break;
63286603 }
6329- case 477LLU: // function reportlet failed
6604+ case 502LLU: // function reportlet failed
63306605 {
63316606 fprintf(stderr, "function reportlet failed\n");
63326607 label = stack[base - 3];
@@ -6333,12 +6608,12 @@
63336608 base = stack[base - 2];
63346609 break;
63356610 }
6336- case 476LLU: // reportlet
6611+ case 501LLU: // reportlet
63376612 {
63386613 //#define arg0 0
63396614 if(/*letdef*/0 != ((uint64_t *)(stack[base + 0]/*letdef*/))[0])
63406615 {
6341- label = 479LLU; // jump to alternative
6616+ label = 504LLU; // jump to alternative
63426617 break;
63436618 }
63446619
@@ -6351,26 +6626,26 @@
63516626 // case
63526627 if(!stack[base + 4]/*mutable*/)
63536628 {
6354- label = 481LLU; // jump to alternative
6629+ label = 506LLU; // jump to alternative
63556630 break;
63566631 }
63576632
63586633 // consequent
63596634 fprintf(stderr, "%s", "mut ");
6360- label = 482LLU; // consequent complete
6635+ label = 507LLU; // consequent complete
63616636 break;
63626637 }
6363- case 481LLU: // alternative
6638+ case 506LLU: // alternative
63646639 {
6365- label = 482LLU; // alternative complete
6640+ label = 507LLU; // alternative complete
63666641 break;
63676642 }
6368- case 482LLU: // completed if-then-else
6643+ case 507LLU: // completed if-then-else
63696644 {
63706645 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
63716646 if(!newstack)
63726647 {
6373- label = 480LLU; // throw: begin to unroll stack
6648+ label = 505LLU; // throw: begin to unroll stack
63746649 break;
63756650 }
63766651
@@ -6377,18 +6652,18 @@
63776652 newstack[10LLU] = 9876543210LLU; // overflow-marker
63786653 // call reporttype from reportlet
63796654 newstack[0] = (uint64_t)stack; // backup stack location
6380- newstack[1] = 483LLU;
6655+ newstack[1] = 508LLU;
63816656 newstack[2] = base;
6382- newstack[3] = 484LLU;
6657+ newstack[3] = 509LLU;
63836658 // arguments for call to reporttype
63846659 newstack[4LLU] = stack[base + 1]/*type*/;
63856660 stack = newstack;
63866661 // set stack-base & callee-address
63876662 base = 4/*deloffset*/;
6388- label = 316LLU; // reporttype
6663+ label = 326LLU; // reporttype
63896664 break;
63906665 }
6391- case 483LLU: // copy-back deleter (reporttype to reportlet)
6666+ case 508LLU: // copy-back deleter (reporttype to reportlet)
63926667 {
63936668 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reporttype to reportlet)\n");
63946669 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6400,10 +6675,10 @@
64006675 }
64016676 Free(10LLU + 1, sizeof(uint64_t), stack);
64026677 stack = oldstack;
6403- label = 480LLU; // continue to unroll stack
6678+ label = 505LLU; // continue to unroll stack
64046679 break;
64056680 }
6406- case 484LLU: // return from reporttype to reportlet
6681+ case 509LLU: // return from reporttype to reportlet
64076682 {
64086683 uint64_t *oldstack = (uint64_t *)stack[0];
64096684 // copy mutable arguments back from call to reporttype
@@ -6416,9 +6691,9 @@
64166691 stack = oldstack;
64176692 fprintf(stderr, "%s", " ");
64186693 // call reportid from reportlet
6419- stack[base + 6LLU] = 485LLU/*throw to this address*/;
6694+ stack[base + 6LLU] = 510LLU/*throw to this address*/;
64206695 stack[base + 7LLU] = base;
6421- stack[base + 8LLU] = 486LLU;
6696+ stack[base + 8LLU] = 511LLU;
64226697 // arguments for call to reportid
64236698 stack[base + 9LLU] = stack[base + 2]/*id*/;
64246699 // set stack-base & callee-address
@@ -6426,21 +6701,21 @@
64266701 label = 18446744073709551586LLU; // reportid
64276702 break;
64286703 }
6429- case 485LLU: // copy-back deleter (reportid to reportlet)
6704+ case 510LLU: // copy-back deleter (reportid to reportlet)
64306705 {
64316706 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportid to reportlet)\n");
64326707 // copy mutable arguments back from call to reportid
6433- label = 480LLU; // continue to roll stack
6708+ label = 505LLU; // continue to roll stack
64346709 break;
64356710 }
6436- case 486LLU: // return from reportid to reportlet
6711+ case 511LLU: // return from reportid to reportlet
64376712 {
64386713 // copy mutable arguments back from call to reportid
64396714 fprintf(stderr, "%s", " ");
64406715 // call reportnr from reportlet
6441- stack[base + 6LLU] = 487LLU/*throw to this address*/;
6716+ stack[base + 6LLU] = 512LLU/*throw to this address*/;
64426717 stack[base + 7LLU] = base;
6443- stack[base + 8LLU] = 488LLU;
6718+ stack[base + 8LLU] = 513LLU;
64446719 // arguments for call to reportnr
64456720 stack[base + 9LLU] = stack[base + 3]/*index*/;
64466721 // set stack-base & callee-address
@@ -6448,14 +6723,14 @@
64486723 label = 18446744073709551589LLU; // reportnr
64496724 break;
64506725 }
6451- case 487LLU: // copy-back deleter (reportnr to reportlet)
6726+ case 512LLU: // copy-back deleter (reportnr to reportlet)
64526727 {
64536728 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportnr to reportlet)\n");
64546729 // copy mutable arguments back from call to reportnr
6455- label = 480LLU; // continue to roll stack
6730+ label = 505LLU; // continue to roll stack
64566731 break;
64576732 }
6458- case 488LLU: // return from reportnr to reportlet
6733+ case 513LLU: // return from reportnr to reportlet
64596734 {
64606735 // copy mutable arguments back from call to reportnr
64616736 ((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
@@ -6463,10 +6738,10 @@
64636738 ((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
64646739 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
64656740 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6466- label = 478LLU; // case complete
6741+ label = 503LLU; // case complete
64676742 break;
64686743 }
6469- case 480LLU: // copy-back deleter (switch)
6744+ case 505LLU: // copy-back deleter (switch)
64706745 {
64716746 ((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
64726747 ((uint64_t **)(stack[base + 0]))[1][3] = stack[base + 4];
@@ -6473,15 +6748,15 @@
64736748 ((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
64746749 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
64756750 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6476- label = 477LLU; // continue to unroll stack
6751+ label = 502LLU; // continue to unroll stack
64776752 break;
64786753 }
6479- case 479LLU: // try next case
6754+ case 504LLU: // try next case
64806755 {
64816756 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
64826757 exit(-1);
64836758 }
6484- case 478LLU: // completed switch
6759+ case 503LLU: // completed switch
64856760 {
64866761 // return from reportlet
64876762 label = stack[base - 1];
@@ -6488,7 +6763,7 @@
64886763 base = stack[base - 2];
64896764 break;
64906765 }
6491- case 490LLU: // function equletdef failed
6766+ case 515LLU: // function equletdef failed
64926767 {
64936768 fprintf(stderr, "function equletdef failed\n");
64946769 label = stack[base - 3];
@@ -6495,7 +6770,7 @@
64956770 base = stack[base - 2];
64966771 break;
64976772 }
6498- case 489LLU: // equletdef
6773+ case 514LLU: // equletdef
64996774 {
65006775 //#define res0 0
65016776 //#define arg0 1
@@ -6502,7 +6777,7 @@
65026777 //#define arg1 2
65036778 if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
65046779 {
6505- label = 492LLU; // jump to alternative
6780+ label = 517LLU; // jump to alternative
65066781 break;
65076782 }
65086783
@@ -6514,7 +6789,7 @@
65146789
65156790 if(/*letdef*/0 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
65166791 {
6517- label = 492LLU; // jump to alternative
6792+ label = 517LLU; // jump to alternative
65186793 break;
65196794 }
65206795
@@ -6525,48 +6800,48 @@
65256800 /*ysubstruct*/stack[base + 12] = ((uint64_t **)(stack[base + 2]/*y*/))[1][4]/*substruct*/;
65266801
65276802 // case
6528- label = 495LLU; // skip deleter
6803+ label = 520LLU; // skip deleter
65296804 break;
65306805 }
6531- case 494LLU: // deleter
6806+ case 519LLU: // deleter
65326807 {
65336808 // throw from equletdef
65346809 if(!stack[base + 13])
65356810 {
65366811 fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 result\n");
6537- label = 493LLU; // skip, variable already deleted/unscoped
6812+ label = 518LLU; // skip, variable already deleted/unscoped
65386813 break;
65396814 }
65406815 fprintf(stderr, "in function equletdef: unrolling stack, variable u64 result\n");
6541- label = 493LLU; // continue unrolling stack, delete next variable
6816+ label = 518LLU; // continue unrolling stack, delete next variable
65426817 break;
65436818 }
6544- case 495LLU: // skipped deleter
6819+ case 520LLU: // skipped deleter
65456820 {
65466821 stack[base + 13] = 1;
6547- label = 497LLU; // skip deleter
6822+ label = 522LLU; // skip deleter
65486823 break;
65496824 }
6550- case 496LLU: // deleter
6825+ case 521LLU: // deleter
65516826 {
65526827 // throw from equletdef
65536828 if(!stack[base + 14])
65546829 {
65556830 fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
6556- label = 494LLU; // skip, variable already deleted/unscoped
6831+ label = 519LLU; // skip, variable already deleted/unscoped
65576832 break;
65586833 }
65596834 fprintf(stderr, "in function equletdef: unrolling stack, variable u64 isequal\n");
6560- label = 494LLU; // continue unrolling stack, delete next variable
6835+ label = 519LLU; // continue unrolling stack, delete next variable
65616836 break;
65626837 }
6563- case 497LLU: // skipped deleter
6838+ case 522LLU: // skipped deleter
65646839 {
65656840 stack[base + 14] = 0;
65666841 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
65676842 if(!newstack)
65686843 {
6569- label = 496LLU; // throw: begin to unroll stack
6844+ label = 521LLU; // throw: begin to unroll stack
65706845 break;
65716846 }
65726847
@@ -6573,9 +6848,9 @@
65736848 newstack[15LLU] = 9876543210LLU; // overflow-marker
65746849 // call equtype from equletdef
65756850 newstack[0] = (uint64_t)stack; // backup stack location
6576- newstack[1] = 498LLU;
6851+ newstack[1] = 523LLU;
65776852 newstack[2] = base;
6578- newstack[3] = 499LLU;
6853+ newstack[3] = 524LLU;
65796854 // arguments for call to equtype
65806855 newstack[5LLU] = stack[base + 3]/*xtype*/;
65816856 newstack[6LLU] = stack[base + 8]/*ytype*/;
@@ -6582,10 +6857,10 @@
65826857 stack = newstack;
65836858 // set stack-base & callee-address
65846859 base = 4/*deloffset*/;
6585- label = 342LLU; // equtype
6860+ label = 355LLU; // equtype
65866861 break;
65876862 }
6588- case 498LLU: // copy-back deleter (equtype to equletdef)
6863+ case 523LLU: // copy-back deleter (equtype to equletdef)
65896864 {
65906865 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equtype to equletdef)\n");
65916866 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6597,10 +6872,10 @@
65976872 }
65986873 Free(15LLU + 1, sizeof(uint64_t), stack);
65996874 stack = oldstack;
6600- label = 496LLU; // continue to unroll stack
6875+ label = 521LLU; // continue to unroll stack
66016876 break;
66026877 }
6603- case 499LLU: // return from equtype to equletdef
6878+ case 524LLU: // return from equtype to equletdef
66046879 {
66056880 uint64_t *oldstack = (uint64_t *)stack[0];
66066881 // copy mutable arguments back from call to equtype
@@ -6614,9 +6889,9 @@
66146889 Free(15LLU + 1, sizeof(uint64_t), stack);
66156890 stack = oldstack;
66166891 // call and from equletdef
6617- stack[base + 15LLU] = 500LLU/*throw to this address*/;
6892+ stack[base + 15LLU] = 525LLU/*throw to this address*/;
66186893 stack[base + 16LLU] = base;
6619- stack[base + 17LLU] = 501LLU;
6894+ stack[base + 17LLU] = 526LLU;
66206895 // arguments for call to and
66216896 stack[base + 19LLU] = stack[base + 13]/*result*/;
66226897 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6625,22 +6900,22 @@
66256900 label = 18446744073709551613LLU; // and
66266901 break;
66276902 }
6628- case 500LLU: // copy-back deleter (and to equletdef)
6903+ case 525LLU: // copy-back deleter (and to equletdef)
66296904 {
66306905 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
66316906 // copy mutable arguments back from call to and
6632- label = 496LLU; // continue to roll stack
6907+ label = 521LLU; // continue to roll stack
66336908 break;
66346909 }
6635- case 501LLU: // return from and to equletdef
6910+ case 526LLU: // return from and to equletdef
66366911 {
66376912 // copy mutable arguments back from call to and
66386913 // copy back results provided by call to and
66396914 stack[base + 13] = stack[base + 18LLU];
66406915 // call equ from equletdef
6641- stack[base + 15LLU] = 502LLU/*throw to this address*/;
6916+ stack[base + 15LLU] = 527LLU/*throw to this address*/;
66426917 stack[base + 16LLU] = base;
6643- stack[base + 17LLU] = 503LLU;
6918+ stack[base + 17LLU] = 528LLU;
66446919 // arguments for call to equ
66456920 stack[base + 19LLU] = stack[base + 4]/*xid*/;
66466921 stack[base + 20LLU] = stack[base + 9]/*yid*/;
@@ -6649,22 +6924,22 @@
66496924 label = 18446744073709551600LLU; // equ
66506925 break;
66516926 }
6652- case 502LLU: // copy-back deleter (equ to equletdef)
6927+ case 527LLU: // copy-back deleter (equ to equletdef)
66536928 {
66546929 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
66556930 // copy mutable arguments back from call to equ
6656- label = 496LLU; // continue to roll stack
6931+ label = 521LLU; // continue to roll stack
66576932 break;
66586933 }
6659- case 503LLU: // return from equ to equletdef
6934+ case 528LLU: // return from equ to equletdef
66606935 {
66616936 // copy mutable arguments back from call to equ
66626937 // copy back results provided by call to equ
66636938 stack[base + 14] = stack[base + 18LLU];
66646939 // call and from equletdef
6665- stack[base + 15LLU] = 504LLU/*throw to this address*/;
6940+ stack[base + 15LLU] = 529LLU/*throw to this address*/;
66666941 stack[base + 16LLU] = base;
6667- stack[base + 17LLU] = 505LLU;
6942+ stack[base + 17LLU] = 530LLU;
66686943 // arguments for call to and
66696944 stack[base + 19LLU] = stack[base + 13]/*result*/;
66706945 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6673,22 +6948,22 @@
66736948 label = 18446744073709551613LLU; // and
66746949 break;
66756950 }
6676- case 504LLU: // copy-back deleter (and to equletdef)
6951+ case 529LLU: // copy-back deleter (and to equletdef)
66776952 {
66786953 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
66796954 // copy mutable arguments back from call to and
6680- label = 496LLU; // continue to roll stack
6955+ label = 521LLU; // continue to roll stack
66816956 break;
66826957 }
6683- case 505LLU: // return from and to equletdef
6958+ case 530LLU: // return from and to equletdef
66846959 {
66856960 // copy mutable arguments back from call to and
66866961 // copy back results provided by call to and
66876962 stack[base + 13] = stack[base + 18LLU];
66886963 // call equ from equletdef
6689- stack[base + 15LLU] = 506LLU/*throw to this address*/;
6964+ stack[base + 15LLU] = 531LLU/*throw to this address*/;
66906965 stack[base + 16LLU] = base;
6691- stack[base + 17LLU] = 507LLU;
6966+ stack[base + 17LLU] = 532LLU;
66926967 // arguments for call to equ
66936968 stack[base + 19LLU] = stack[base + 5]/*xindex*/;
66946969 stack[base + 20LLU] = stack[base + 10]/*yindex*/;
@@ -6697,22 +6972,22 @@
66976972 label = 18446744073709551600LLU; // equ
66986973 break;
66996974 }
6700- case 506LLU: // copy-back deleter (equ to equletdef)
6975+ case 531LLU: // copy-back deleter (equ to equletdef)
67016976 {
67026977 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
67036978 // copy mutable arguments back from call to equ
6704- label = 496LLU; // continue to roll stack
6979+ label = 521LLU; // continue to roll stack
67056980 break;
67066981 }
6707- case 507LLU: // return from equ to equletdef
6982+ case 532LLU: // return from equ to equletdef
67086983 {
67096984 // copy mutable arguments back from call to equ
67106985 // copy back results provided by call to equ
67116986 stack[base + 14] = stack[base + 18LLU];
67126987 // call and from equletdef
6713- stack[base + 15LLU] = 508LLU/*throw to this address*/;
6988+ stack[base + 15LLU] = 533LLU/*throw to this address*/;
67146989 stack[base + 16LLU] = base;
6715- stack[base + 17LLU] = 509LLU;
6990+ stack[base + 17LLU] = 534LLU;
67166991 // arguments for call to and
67176992 stack[base + 19LLU] = stack[base + 13]/*result*/;
67186993 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6721,22 +6996,22 @@
67216996 label = 18446744073709551613LLU; // and
67226997 break;
67236998 }
6724- case 508LLU: // copy-back deleter (and to equletdef)
6999+ case 533LLU: // copy-back deleter (and to equletdef)
67257000 {
67267001 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
67277002 // copy mutable arguments back from call to and
6728- label = 496LLU; // continue to roll stack
7003+ label = 521LLU; // continue to roll stack
67297004 break;
67307005 }
6731- case 509LLU: // return from and to equletdef
7006+ case 534LLU: // return from and to equletdef
67327007 {
67337008 // copy mutable arguments back from call to and
67347009 // copy back results provided by call to and
67357010 stack[base + 13] = stack[base + 18LLU];
67367011 // call equ from equletdef
6737- stack[base + 15LLU] = 510LLU/*throw to this address*/;
7012+ stack[base + 15LLU] = 535LLU/*throw to this address*/;
67387013 stack[base + 16LLU] = base;
6739- stack[base + 17LLU] = 511LLU;
7014+ stack[base + 17LLU] = 536LLU;
67407015 // arguments for call to equ
67417016 stack[base + 19LLU] = stack[base + 6]/*xmutable*/;
67427017 stack[base + 20LLU] = stack[base + 11]/*ymutable*/;
@@ -6745,22 +7020,22 @@
67457020 label = 18446744073709551600LLU; // equ
67467021 break;
67477022 }
6748- case 510LLU: // copy-back deleter (equ to equletdef)
7023+ case 535LLU: // copy-back deleter (equ to equletdef)
67497024 {
67507025 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
67517026 // copy mutable arguments back from call to equ
6752- label = 496LLU; // continue to roll stack
7027+ label = 521LLU; // continue to roll stack
67537028 break;
67547029 }
6755- case 511LLU: // return from equ to equletdef
7030+ case 536LLU: // return from equ to equletdef
67567031 {
67577032 // copy mutable arguments back from call to equ
67587033 // copy back results provided by call to equ
67597034 stack[base + 14] = stack[base + 18LLU];
67607035 // call and from equletdef
6761- stack[base + 15LLU] = 512LLU/*throw to this address*/;
7036+ stack[base + 15LLU] = 537LLU/*throw to this address*/;
67627037 stack[base + 16LLU] = base;
6763- stack[base + 17LLU] = 513LLU;
7038+ stack[base + 17LLU] = 538LLU;
67647039 // arguments for call to and
67657040 stack[base + 19LLU] = stack[base + 13]/*result*/;
67667041 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6769,22 +7044,22 @@
67697044 label = 18446744073709551613LLU; // and
67707045 break;
67717046 }
6772- case 512LLU: // copy-back deleter (and to equletdef)
7047+ case 537LLU: // copy-back deleter (and to equletdef)
67737048 {
67747049 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
67757050 // copy mutable arguments back from call to and
6776- label = 496LLU; // continue to roll stack
7051+ label = 521LLU; // continue to roll stack
67777052 break;
67787053 }
6779- case 513LLU: // return from and to equletdef
7054+ case 538LLU: // return from and to equletdef
67807055 {
67817056 // copy mutable arguments back from call to and
67827057 // copy back results provided by call to and
67837058 stack[base + 13] = stack[base + 18LLU];
67847059 // call equ from equletdef
6785- stack[base + 15LLU] = 514LLU/*throw to this address*/;
7060+ stack[base + 15LLU] = 539LLU/*throw to this address*/;
67867061 stack[base + 16LLU] = base;
6787- stack[base + 17LLU] = 515LLU;
7062+ stack[base + 17LLU] = 540LLU;
67887063 // arguments for call to equ
67897064 stack[base + 19LLU] = stack[base + 7]/*xsubstruct*/;
67907065 stack[base + 20LLU] = stack[base + 12]/*ysubstruct*/;
@@ -6793,22 +7068,22 @@
67937068 label = 18446744073709551600LLU; // equ
67947069 break;
67957070 }
6796- case 514LLU: // copy-back deleter (equ to equletdef)
7071+ case 539LLU: // copy-back deleter (equ to equletdef)
67977072 {
67987073 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
67997074 // copy mutable arguments back from call to equ
6800- label = 496LLU; // continue to roll stack
7075+ label = 521LLU; // continue to roll stack
68017076 break;
68027077 }
6803- case 515LLU: // return from equ to equletdef
7078+ case 540LLU: // return from equ to equletdef
68047079 {
68057080 // copy mutable arguments back from call to equ
68067081 // copy back results provided by call to equ
68077082 stack[base + 14] = stack[base + 18LLU];
68087083 // call and from equletdef
6809- stack[base + 15LLU] = 516LLU/*throw to this address*/;
7084+ stack[base + 15LLU] = 541LLU/*throw to this address*/;
68107085 stack[base + 16LLU] = base;
6811- stack[base + 17LLU] = 517LLU;
7086+ stack[base + 17LLU] = 542LLU;
68127087 // arguments for call to and
68137088 stack[base + 19LLU] = stack[base + 13]/*result*/;
68147089 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6817,35 +7092,35 @@
68177092 label = 18446744073709551613LLU; // and
68187093 break;
68197094 }
6820- case 516LLU: // copy-back deleter (and to equletdef)
7095+ case 541LLU: // copy-back deleter (and to equletdef)
68217096 {
68227097 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
68237098 // copy mutable arguments back from call to and
6824- label = 496LLU; // continue to roll stack
7099+ label = 521LLU; // continue to roll stack
68257100 break;
68267101 }
6827- case 517LLU: // return from and to equletdef
7102+ case 542LLU: // return from and to equletdef
68287103 {
68297104 // copy mutable arguments back from call to and
68307105 // copy back results provided by call to and
68317106 stack[base + 13] = stack[base + 18LLU];
6832- label = 519LLU; // skip deleter
7107+ label = 544LLU; // skip deleter
68337108 break;
68347109 }
6835- case 518LLU: // deleter
7110+ case 543LLU: // deleter
68367111 {
68377112 // throw from equletdef
68387113 if(!stack[base + 0])
68397114 {
68407115 fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6841- label = 496LLU; // skip, variable already deleted/unscoped
7116+ label = 521LLU; // skip, variable already deleted/unscoped
68427117 break;
68437118 }
68447119 fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6845- label = 496LLU; // continue unrolling stack, delete next variable
7120+ label = 521LLU; // continue unrolling stack, delete next variable
68467121 break;
68477122 }
6848- case 519LLU: // skipped deleter
7123+ case 544LLU: // skipped deleter
68497124 {
68507125 stack[base + 0] = stack[base + 13]/*result*/;
68517126 ((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
@@ -6858,10 +7133,10 @@
68587133 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
68597134 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
68607135 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6861- label = 491LLU; // case complete
7136+ label = 516LLU; // case complete
68627137 break;
68637138 }
6864- case 493LLU: // copy-back deleter (switch)
7139+ case 518LLU: // copy-back deleter (switch)
68657140 {
68667141 ((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
68677142 ((uint64_t **)(stack[base + 2]))[1][3] = stack[base + 11];
@@ -6873,15 +7148,15 @@
68737148 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
68747149 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
68757150 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6876- label = 490LLU; // continue to unroll stack
7151+ label = 515LLU; // continue to unroll stack
68777152 break;
68787153 }
6879- case 492LLU: // try next case
7154+ case 517LLU: // try next case
68807155 {
68817156 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
68827157 exit(-1);
68837158 }
6884- case 491LLU: // completed switch
7159+ case 516LLU: // completed switch
68857160 {
68867161 // return from equletdef
68877162 label = stack[base - 1];
@@ -6888,7 +7163,7 @@
68887163 base = stack[base - 2];
68897164 break;
68907165 }
6891- case 521LLU: // function copyletdef failed
7166+ case 546LLU: // function copyletdef failed
68927167 {
68937168 fprintf(stderr, "function copyletdef failed\n");
68947169 label = stack[base - 3];
@@ -6895,13 +7170,13 @@
68957170 base = stack[base - 2];
68967171 break;
68977172 }
6898- case 520LLU: // copyletdef
7173+ case 545LLU: // copyletdef
68997174 {
69007175 //#define res0 0
69017176 //#define arg0 1
69027177 if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
69037178 {
6904- label = 523LLU; // jump to alternative
7179+ label = 548LLU; // jump to alternative
69057180 break;
69067181 }
69077182
@@ -6912,10 +7187,47 @@
69127187 /*substruct*/stack[base + 6] = ((uint64_t **)(stack[base + 1]/*original*/))[1][4]/*substruct*/;
69137188
69147189 // case
7190+ label = 551LLU; // skip deleter
7191+ break;
7192+ }
7193+ case 550LLU: // deleter
7194+ {
7195+ // throw from copyletdef
7196+ if(!stack[base + 7])
7197+ {
7198+ fprintf(stderr, "in function copyletdef: unrolling stack, skipping already deleted/unscoped variable type cptype\n");
7199+ label = 549LLU; // skip, variable already deleted/unscoped
7200+ break;
7201+ }
7202+ fprintf(stderr, "in function copyletdef: unrolling stack, variable type cptype\n");
7203+
7204+ uint64_t *newstack = (uint64_t *)(stack[base + 7] - sizeof(uint64_t) * 4);
7205+ // call ~type from copyletdef
7206+ newstack[0] = (uint64_t)stack; // backup stack location
7207+ newstack[1] = 1234567890;
7208+ newstack[2] = base;
7209+ newstack[3] = 552LLU;
7210+ stack = newstack;
7211+ // set stack-base & callee-address
7212+ base = 4/*deloffset*/;
7213+ label = 306LLU; // ~type
7214+ break;
7215+ }
7216+ case 552LLU: // return from ~type to copyletdef
7217+ {
7218+ stack = (uint64_t *)stack[0];
7219+ // releasing toplevel container
7220+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 7] - sizeof(uint64_t) * 4));
7221+
7222+ label = 549LLU; // continue unrolling stack, delete next variable
7223+ break;
7224+ }
7225+ case 551LLU: // skipped deleter
7226+ {
69157227 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
69167228 if(!newstack)
69177229 {
6918- label = 524LLU; // throw: begin to unroll stack
7230+ label = 549LLU; // throw: begin to unroll stack
69197231 break;
69207232 }
69217233
@@ -6922,18 +7234,18 @@
69227234 newstack[15LLU] = 9876543210LLU; // overflow-marker
69237235 // call copytype from copyletdef
69247236 newstack[0] = (uint64_t)stack; // backup stack location
6925- newstack[1] = 525LLU;
7237+ newstack[1] = 553LLU;
69267238 newstack[2] = base;
6927- newstack[3] = 526LLU;
7239+ newstack[3] = 554LLU;
69287240 // arguments for call to copytype
69297241 newstack[5LLU] = stack[base + 2]/*type*/;
69307242 stack = newstack;
69317243 // set stack-base & callee-address
69327244 base = 4/*deloffset*/;
6933- label = 327LLU; // copytype
7245+ label = 337LLU; // copytype
69347246 break;
69357247 }
6936- case 525LLU: // copy-back deleter (copytype to copyletdef)
7248+ case 553LLU: // copy-back deleter (copytype to copyletdef)
69377249 {
69387250 fprintf(stderr, "in function copyletdef: unrolling stack, copy-back (copytype to copyletdef)\n");
69397251 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6945,10 +7257,10 @@
69457257 }
69467258 Free(15LLU + 1, sizeof(uint64_t), stack);
69477259 stack = oldstack;
6948- label = 524LLU; // continue to unroll stack
7260+ label = 549LLU; // continue to unroll stack
69497261 break;
69507262 }
6951- case 526LLU: // return from copytype to copyletdef
7263+ case 554LLU: // return from copytype to copyletdef
69527264 {
69537265 uint64_t *oldstack = (uint64_t *)stack[0];
69547266 // copy mutable arguments back from call to copytype
@@ -6961,16 +7273,16 @@
69617273 }
69627274 Free(15LLU + 1, sizeof(uint64_t), stack);
69637275 stack = oldstack;
6964- label = 528LLU; // skip deleter
7276+ label = 556LLU; // skip deleter
69657277 break;
69667278 }
6967- case 527LLU: // deleter
7279+ case 555LLU: // deleter
69687280 {
69697281 // throw from copyletdef
69707282 if(!stack[base + 0])
69717283 {
69727284 fprintf(stderr, "in function copyletdef: unrolling stack, skipping already deleted/unscoped variable letdef \n");
6973- label = 524LLU; // skip, variable already deleted/unscoped
7285+ label = 550LLU; // skip, variable already deleted/unscoped
69747286 break;
69757287 }
69767288 fprintf(stderr, "in function copyletdef: unrolling stack, variable letdef \n");
@@ -6980,28 +7292,28 @@
69807292 newstack[0] = (uint64_t)stack; // backup stack location
69817293 newstack[1] = 1234567890;
69827294 newstack[2] = base;
6983- newstack[3] = 529LLU;
7295+ newstack[3] = 557LLU;
69847296 stack = newstack;
69857297 // set stack-base & callee-address
69867298 base = 4/*deloffset*/;
6987- label = 457LLU; // ~letdef
7299+ label = 482LLU; // ~letdef
69887300 break;
69897301 }
6990- case 529LLU: // return from ~letdef to copyletdef
7302+ case 557LLU: // return from ~letdef to copyletdef
69917303 {
69927304 stack = (uint64_t *)stack[0];
69937305 // releasing toplevel container
69947306 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
69957307
6996- label = 524LLU; // continue unrolling stack, delete next variable
7308+ label = 550LLU; // continue unrolling stack, delete next variable
69977309 break;
69987310 }
6999- case 528LLU: // skipped deleter
7311+ case 556LLU: // skipped deleter
70007312 {
70017313 // construct letdef.letdef
70027314 if(!(stack[base + 0] = construct(5)))
70037315 {
7004- label = 524LLU; // throw: begin to unroll stack
7316+ label = 550LLU; // throw: begin to unroll stack
70057317 break;
70067318 }
70077319
@@ -7017,10 +7329,10 @@
70177329 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
70187330 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
70197331 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7020- label = 522LLU; // case complete
7332+ label = 547LLU; // case complete
70217333 break;
70227334 }
7023- case 524LLU: // copy-back deleter (switch)
7335+ case 549LLU: // copy-back deleter (switch)
70247336 {
70257337 ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 6];
70267338 ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 5];
@@ -7027,15 +7339,15 @@
70277339 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
70287340 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
70297341 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7030- label = 521LLU; // continue to unroll stack
7342+ label = 546LLU; // continue to unroll stack
70317343 break;
70327344 }
7033- case 523LLU: // try next case
7345+ case 548LLU: // try next case
70347346 {
70357347 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
70367348 exit(-1);
70377349 }
7038- case 522LLU: // completed switch
7350+ case 547LLU: // completed switch
70397351 {
70407352 // return from copyletdef
70417353 label = stack[base - 1];
@@ -7042,7 +7354,7 @@
70427354 base = stack[base - 2];
70437355 break;
70447356 }
7045- case 530LLU: // ~scope
7357+ case 558LLU: // ~scope
70467358 {
70477359 if(stack[base + 0]/*variant-nr*/ >= 1)
70487360 {
@@ -7049,23 +7361,23 @@
70497361 fprintf(stderr, "in ~scope: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
70507362 exit(-1);
70517363 }
7052- label = 530LLU + 1LLU + stack[base + 0]/*variant-nr*/;
7364+ label = 558LLU + 1LLU + stack[base + 0]/*variant-nr*/;
70537365 break;
70547366 }
7055- case 530LLU + 1LLU + 0LLU: // ~scope.scope
7367+ case 558LLU + 1LLU + 0LLU: // ~scope.scope
70567368 {
70577369 // release element deleteaddr
70587370 // release element letdefs
70597371 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[1/*element-nr*/];
70607372 // delete list
7061- label = 532LLU; // start to repeat
7373+ label = 560LLU; // start to repeat
70627374 break;
70637375 }
7064- case 532LLU: // repeat from here
7376+ case 560LLU: // repeat from here
70657377 {
70667378 if(!stack[base + 0])
70677379 {
7068- label = 533LLU; // break loop
7380+ label = 561LLU; // break loop
70697381 break;
70707382 }
70717383
@@ -7076,14 +7388,14 @@
70767388 newstack[0] = (uint64_t)stack; // backup stack location
70777389 newstack[1] = 1234567890;
70787390 newstack[2] = base;
7079- newstack[3] = 534LLU;
7391+ newstack[3] = 562LLU;
70807392 stack = newstack;
70817393 // set stack-base & callee-address
70827394 base = 4/*deloffset*/;
7083- label = 457LLU; // ~letdef
7395+ label = 482LLU; // ~letdef
70847396 break;
70857397 }
7086- case 534LLU: // return from ~letdef to scope
7398+ case 562LLU: // return from ~letdef to scope
70877399 {
70887400 stack = (uint64_t *)stack[0];
70897401 // releasing toplevel container
@@ -7094,10 +7406,10 @@
70947406 stack[base + 0] = (uint64_t)list->next;
70957407 Free(1, sizeof(struct listnode), list);
70967408 }
7097- label = 532LLU; // repeat
7409+ label = 560LLU; // repeat
70987410 break;
70997411 }
7100- case 533LLU: // loop finished
7412+ case 561LLU: // loop finished
71017413 {
71027414 // release variant container
71037415 Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/));
@@ -7105,7 +7417,7 @@
71057417 base = stack[base - 2];
71067418 break;
71077419 }
7108- case 536LLU: // function emptyscope failed
7420+ case 564LLU: // function emptyscope failed
71097421 {
71107422 fprintf(stderr, "function emptyscope failed\n");
71117423 label = stack[base - 3];
@@ -7112,50 +7424,50 @@
71127424 base = stack[base - 2];
71137425 break;
71147426 }
7115- case 535LLU: // emptyscope
7427+ case 563LLU: // emptyscope
71167428 {
71177429 //#define res0 0
7118- label = 538LLU; // skip deleter
7430+ label = 566LLU; // skip deleter
71197431 break;
71207432 }
7121- case 537LLU: // deleter
7433+ case 565LLU: // deleter
71227434 {
71237435 // throw from emptyscope
71247436 if(!stack[base + 1])
71257437 {
71267438 fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable u64 deleteaddr\n");
7127- label = 536LLU; // skip, variable already deleted/unscoped
7439+ label = 564LLU; // skip, variable already deleted/unscoped
71287440 break;
71297441 }
71307442 fprintf(stderr, "in function emptyscope: unrolling stack, variable u64 deleteaddr\n");
7131- label = 536LLU; // continue unrolling stack, delete next variable
7443+ label = 564LLU; // continue unrolling stack, delete next variable
71327444 break;
71337445 }
7134- case 538LLU: // skipped deleter
7446+ case 566LLU: // skipped deleter
71357447 {
71367448 stack[base + 1] = 1234567890;
7137- label = 540LLU; // skip deleter
7449+ label = 568LLU; // skip deleter
71387450 break;
71397451 }
7140- case 539LLU: // deleter
7452+ case 567LLU: // deleter
71417453 {
71427454 // throw from emptyscope
71437455 if(!stack[base + 2])
71447456 {
71457457 fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable [letdef] letdefs\n");
7146- label = 537LLU; // skip, variable already deleted/unscoped
7458+ label = 565LLU; // skip, variable already deleted/unscoped
71477459 break;
71487460 }
71497461 fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] letdefs\n");
71507462 // delete list
7151- label = 541LLU; // start to repeat
7463+ label = 569LLU; // start to repeat
71527464 break;
71537465 }
7154- case 541LLU: // repeat from here
7466+ case 569LLU: // repeat from here
71557467 {
71567468 if(!stack[base + 2])
71577469 {
7158- label = 542LLU; // break loop
7470+ label = 570LLU; // break loop
71597471 break;
71607472 }
71617473
@@ -7166,14 +7478,14 @@
71667478 newstack[0] = (uint64_t)stack; // backup stack location
71677479 newstack[1] = 1234567890;
71687480 newstack[2] = base;
7169- newstack[3] = 543LLU;
7481+ newstack[3] = 571LLU;
71707482 stack = newstack;
71717483 // set stack-base & callee-address
71727484 base = 4/*deloffset*/;
7173- label = 457LLU; // ~letdef
7485+ label = 482LLU; // ~letdef
71747486 break;
71757487 }
7176- case 543LLU: // return from ~letdef to emptyscope
7488+ case 571LLU: // return from ~letdef to emptyscope
71777489 {
71787490 stack = (uint64_t *)stack[0];
71797491 // releasing toplevel container
@@ -7184,27 +7496,27 @@
71847496 stack[base + 2] = (uint64_t)list->next;
71857497 Free(1, sizeof(struct listnode), list);
71867498 }
7187- label = 541LLU; // repeat
7499+ label = 569LLU; // repeat
71887500 break;
71897501 }
7190- case 542LLU: // loop finished
7502+ case 570LLU: // loop finished
71917503 {
7192- label = 537LLU; // continue unrolling stack, delete next variable
7504+ label = 565LLU; // continue unrolling stack, delete next variable
71937505 break;
71947506 }
7195- case 540LLU: // skipped deleter
7507+ case 568LLU: // skipped deleter
71967508 {
71977509 stack[base + 2] = 0;
7198- label = 545LLU; // skip deleter
7510+ label = 573LLU; // skip deleter
71997511 break;
72007512 }
7201- case 544LLU: // deleter
7513+ case 572LLU: // deleter
72027514 {
72037515 // throw from emptyscope
72047516 if(!stack[base + 0])
72057517 {
72067518 fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable scope \n");
7207- label = 539LLU; // skip, variable already deleted/unscoped
7519+ label = 567LLU; // skip, variable already deleted/unscoped
72087520 break;
72097521 }
72107522 fprintf(stderr, "in function emptyscope: unrolling stack, variable scope \n");
@@ -7214,28 +7526,28 @@
72147526 newstack[0] = (uint64_t)stack; // backup stack location
72157527 newstack[1] = 1234567890;
72167528 newstack[2] = base;
7217- newstack[3] = 546LLU;
7529+ newstack[3] = 574LLU;
72187530 stack = newstack;
72197531 // set stack-base & callee-address
72207532 base = 4/*deloffset*/;
7221- label = 530LLU; // ~scope
7533+ label = 558LLU; // ~scope
72227534 break;
72237535 }
7224- case 546LLU: // return from ~scope to emptyscope
7536+ case 574LLU: // return from ~scope to emptyscope
72257537 {
72267538 stack = (uint64_t *)stack[0];
72277539 // releasing toplevel container
72287540 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
72297541
7230- label = 539LLU; // continue unrolling stack, delete next variable
7542+ label = 567LLU; // continue unrolling stack, delete next variable
72317543 break;
72327544 }
7233- case 545LLU: // skipped deleter
7545+ case 573LLU: // skipped deleter
72347546 {
72357547 // construct scope.scope
72367548 if(!(stack[base + 0] = construct(2)))
72377549 {
7238- label = 539LLU; // throw: begin to unroll stack
7550+ label = 567LLU; // throw: begin to unroll stack
72397551 break;
72407552 }
72417553
@@ -7248,7 +7560,7 @@
72487560 base = stack[base - 2];
72497561 break;
72507562 }
7251- case 548LLU: // function chainscope failed
7563+ case 576LLU: // function chainscope failed
72527564 {
72537565 fprintf(stderr, "function chainscope failed\n");
72547566 label = stack[base - 3];
@@ -7255,32 +7567,32 @@
72557567 base = stack[base - 2];
72567568 break;
72577569 }
7258- case 547LLU: // chainscope
7570+ case 575LLU: // chainscope
72597571 {
72607572 //#define res0 0
72617573 //#define arg0 1
7262- label = 550LLU; // skip deleter
7574+ label = 578LLU; // skip deleter
72637575 break;
72647576 }
7265- case 549LLU: // deleter
7577+ case 577LLU: // deleter
72667578 {
72677579 // throw from chainscope
72687580 if(!stack[base + 2])
72697581 {
72707582 fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable [letdef] letdefs\n");
7271- label = 548LLU; // skip, variable already deleted/unscoped
7583+ label = 576LLU; // skip, variable already deleted/unscoped
72727584 break;
72737585 }
72747586 fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] letdefs\n");
72757587 // delete list
7276- label = 551LLU; // start to repeat
7588+ label = 579LLU; // start to repeat
72777589 break;
72787590 }
7279- case 551LLU: // repeat from here
7591+ case 579LLU: // repeat from here
72807592 {
72817593 if(!stack[base + 2])
72827594 {
7283- label = 552LLU; // break loop
7595+ label = 580LLU; // break loop
72847596 break;
72857597 }
72867598
@@ -7291,14 +7603,14 @@
72917603 newstack[0] = (uint64_t)stack; // backup stack location
72927604 newstack[1] = 1234567890;
72937605 newstack[2] = base;
7294- newstack[3] = 553LLU;
7606+ newstack[3] = 581LLU;
72957607 stack = newstack;
72967608 // set stack-base & callee-address
72977609 base = 4/*deloffset*/;
7298- label = 457LLU; // ~letdef
7610+ label = 482LLU; // ~letdef
72997611 break;
73007612 }
7301- case 553LLU: // return from ~letdef to chainscope
7613+ case 581LLU: // return from ~letdef to chainscope
73027614 {
73037615 stack = (uint64_t *)stack[0];
73047616 // releasing toplevel container
@@ -7309,27 +7621,27 @@
73097621 stack[base + 2] = (uint64_t)list->next;
73107622 Free(1, sizeof(struct listnode), list);
73117623 }
7312- label = 551LLU; // repeat
7624+ label = 579LLU; // repeat
73137625 break;
73147626 }
7315- case 552LLU: // loop finished
7627+ case 580LLU: // loop finished
73167628 {
7317- label = 548LLU; // continue unrolling stack, delete next variable
7629+ label = 576LLU; // continue unrolling stack, delete next variable
73187630 break;
73197631 }
7320- case 550LLU: // skipped deleter
7632+ case 578LLU: // skipped deleter
73217633 {
73227634 stack[base + 2] = 0;
7323- label = 555LLU; // skip deleter
7635+ label = 583LLU; // skip deleter
73247636 break;
73257637 }
7326- case 554LLU: // deleter
7638+ case 582LLU: // deleter
73277639 {
73287640 // throw from chainscope
73297641 if(!stack[base + 0])
73307642 {
73317643 fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable scope \n");
7332- label = 549LLU; // skip, variable already deleted/unscoped
7644+ label = 577LLU; // skip, variable already deleted/unscoped
73337645 break;
73347646 }
73357647 fprintf(stderr, "in function chainscope: unrolling stack, variable scope \n");
@@ -7339,28 +7651,28 @@
73397651 newstack[0] = (uint64_t)stack; // backup stack location
73407652 newstack[1] = 1234567890;
73417653 newstack[2] = base;
7342- newstack[3] = 556LLU;
7654+ newstack[3] = 584LLU;
73437655 stack = newstack;
73447656 // set stack-base & callee-address
73457657 base = 4/*deloffset*/;
7346- label = 530LLU; // ~scope
7658+ label = 558LLU; // ~scope
73477659 break;
73487660 }
7349- case 556LLU: // return from ~scope to chainscope
7661+ case 584LLU: // return from ~scope to chainscope
73507662 {
73517663 stack = (uint64_t *)stack[0];
73527664 // releasing toplevel container
73537665 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
73547666
7355- label = 549LLU; // continue unrolling stack, delete next variable
7667+ label = 577LLU; // continue unrolling stack, delete next variable
73567668 break;
73577669 }
7358- case 555LLU: // skipped deleter
7670+ case 583LLU: // skipped deleter
73597671 {
73607672 // construct scope.scope
73617673 if(!(stack[base + 0] = construct(2)))
73627674 {
7363- label = 549LLU; // throw: begin to unroll stack
7675+ label = 577LLU; // throw: begin to unroll stack
73647676 break;
73657677 }
73667678
@@ -7373,7 +7685,7 @@
73737685 base = stack[base - 2];
73747686 break;
73757687 }
7376- case 558LLU: // function linkscope failed
7688+ case 586LLU: // function linkscope failed
73777689 {
73787690 fprintf(stderr, "function linkscope failed\n");
73797691 label = stack[base - 3];
@@ -7380,13 +7692,13 @@
73807692 base = stack[base - 2];
73817693 break;
73827694 }
7383- case 557LLU: // linkscope
7695+ case 585LLU: // linkscope
73847696 {
73857697 //#define res0 0
73867698 //#define arg0 1
73877699 if(/*scope*/0 != ((uint64_t *)(stack[base + 1]/*scope*/))[0])
73887700 {
7389- label = 560LLU; // jump to alternative
7701+ label = 588LLU; // jump to alternative
73907702 break;
73917703 }
73927704
@@ -7395,24 +7707,24 @@
73957707
73967708 // case
73977709 // call chainscope from linkscope
7398- stack[base + 4LLU] = 562LLU/*throw to this address*/;
7710+ stack[base + 4LLU] = 590LLU/*throw to this address*/;
73997711 stack[base + 5LLU] = base;
7400- stack[base + 6LLU] = 563LLU;
7712+ stack[base + 6LLU] = 591LLU;
74017713 // arguments for call to chainscope
74027714 stack[base + 8LLU] = stack[base + 2]/*labelthrow*/;
74037715 // set stack-base & callee-address
74047716 base += 7LLU;
7405- label = 547LLU; // chainscope
7717+ label = 575LLU; // chainscope
74067718 break;
74077719 }
7408- case 562LLU: // copy-back deleter (chainscope to linkscope)
7720+ case 590LLU: // copy-back deleter (chainscope to linkscope)
74097721 {
74107722 fprintf(stderr, "in function linkscope: unrolling stack, copy-back (chainscope to linkscope)\n");
74117723 // copy mutable arguments back from call to chainscope
7412- label = 561LLU; // continue to roll stack
7724+ label = 589LLU; // continue to roll stack
74137725 break;
74147726 }
7415- case 563LLU: // return from chainscope to linkscope
7727+ case 591LLU: // return from chainscope to linkscope
74167728 {
74177729 // copy mutable arguments back from call to chainscope
74187730 // copy back results provided by call to chainscope
@@ -7419,22 +7731,22 @@
74197731 stack[base + 0] = stack[base + 7LLU];
74207732 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74217733 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7422- label = 559LLU; // case complete
7734+ label = 587LLU; // case complete
74237735 break;
74247736 }
7425- case 561LLU: // copy-back deleter (switch)
7737+ case 589LLU: // copy-back deleter (switch)
74267738 {
74277739 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74287740 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7429- label = 558LLU; // continue to unroll stack
7741+ label = 586LLU; // continue to unroll stack
74307742 break;
74317743 }
7432- case 560LLU: // try next case
7744+ case 588LLU: // try next case
74337745 {
74347746 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
74357747 exit(-1);
74367748 }
7437- case 559LLU: // completed switch
7749+ case 587LLU: // completed switch
74387750 {
74397751 // return from linkscope
74407752 label = stack[base - 1];
@@ -7441,7 +7753,7 @@
74417753 base = stack[base - 2];
74427754 break;
74437755 }
7444- case 565LLU: // function getdeladdr failed
7756+ case 593LLU: // function getdeladdr failed
74457757 {
74467758 fprintf(stderr, "function getdeladdr failed\n");
74477759 label = stack[base - 3];
@@ -7448,13 +7760,13 @@
74487760 base = stack[base - 2];
74497761 break;
74507762 }
7451- case 564LLU: // getdeladdr
7763+ case 592LLU: // getdeladdr
74527764 {
74537765 //#define res0 0
74547766 //#define arg0 1
74557767 if(/*scope*/0 != ((uint64_t *)(stack[base + 1]/*scope*/))[0])
74567768 {
7457- label = 567LLU; // jump to alternative
7769+ label = 595LLU; // jump to alternative
74587770 break;
74597771 }
74607772
@@ -7462,43 +7774,43 @@
74627774 /*letdefs*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*scope*/))[1][1]/*letdefs*/;
74637775
74647776 // case
7465- label = 570LLU; // skip deleter
7777+ label = 598LLU; // skip deleter
74667778 break;
74677779 }
7468- case 569LLU: // deleter
7780+ case 597LLU: // deleter
74697781 {
74707782 // throw from getdeladdr
74717783 if(!stack[base + 0])
74727784 {
74737785 fprintf(stderr, "in function getdeladdr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7474- label = 568LLU; // skip, variable already deleted/unscoped
7786+ label = 596LLU; // skip, variable already deleted/unscoped
74757787 break;
74767788 }
74777789 fprintf(stderr, "in function getdeladdr: unrolling stack, variable u64 \n");
7478- label = 568LLU; // continue unrolling stack, delete next variable
7790+ label = 596LLU; // continue unrolling stack, delete next variable
74797791 break;
74807792 }
7481- case 570LLU: // skipped deleter
7793+ case 598LLU: // skipped deleter
74827794 {
74837795 stack[base + 0] = stack[base + 2]/*labelthrow*/;
74847796 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74857797 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7486- label = 566LLU; // case complete
7798+ label = 594LLU; // case complete
74877799 break;
74887800 }
7489- case 568LLU: // copy-back deleter (switch)
7801+ case 596LLU: // copy-back deleter (switch)
74907802 {
74917803 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74927804 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7493- label = 565LLU; // continue to unroll stack
7805+ label = 593LLU; // continue to unroll stack
74947806 break;
74957807 }
7496- case 567LLU: // try next case
7808+ case 595LLU: // try next case
74977809 {
74987810 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
74997811 exit(-1);
75007812 }
7501- case 566LLU: // completed switch
7813+ case 594LLU: // completed switch
75027814 {
75037815 // return from getdeladdr
75047816 label = stack[base - 1];
@@ -7505,7 +7817,7 @@
75057817 base = stack[base - 2];
75067818 break;
75077819 }
7508- case 572LLU: // function existslet failed
7820+ case 600LLU: // function existslet failed
75097821 {
75107822 fprintf(stderr, "function existslet failed\n");
75117823 label = stack[base - 3];
@@ -7512,39 +7824,39 @@
75127824 base = stack[base - 2];
75137825 break;
75147826 }
7515- case 571LLU: // existslet
7827+ case 599LLU: // existslet
75167828 {
75177829 //#define res0 0
75187830 //#define arg0 1
75197831 //#define arg1 2
7520- label = 574LLU; // skip deleter
7832+ label = 602LLU; // skip deleter
75217833 break;
75227834 }
7523- case 573LLU: // deleter
7835+ case 601LLU: // deleter
75247836 {
75257837 // throw from existslet
75267838 if(!stack[base + 3])
75277839 {
75287840 fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
7529- label = 572LLU; // skip, variable already deleted/unscoped
7841+ label = 600LLU; // skip, variable already deleted/unscoped
75307842 break;
75317843 }
75327844 fprintf(stderr, "in function existslet: unrolling stack, variable u64 found\n");
7533- label = 572LLU; // continue unrolling stack, delete next variable
7845+ label = 600LLU; // continue unrolling stack, delete next variable
75347846 break;
75357847 }
7536- case 574LLU: // skipped deleter
7848+ case 602LLU: // skipped deleter
75377849 {
75387850 stack[base + 3] = 0;
75397851 flippedassign(stack[base + 1]/*letdefs*/, &stack[base + 4]);
7540- label = 575LLU; // start to repeat
7852+ label = 603LLU; // start to repeat
75417853 break;
75427854 }
7543- case 575LLU: // repeat from here
7855+ case 603LLU: // repeat from here
75447856 {
75457857 if(!stack[base + 4])
75467858 {
7547- label = 576LLU; // break loop
7859+ label = 604LLU; // break loop
75487860 break;
75497861 }
75507862
@@ -7554,19 +7866,19 @@
75547866 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
75557867 if(!stack[base + 3]/*found*/)
75567868 {
7557- label = 578LLU; // jump to alternative
7869+ label = 606LLU; // jump to alternative
75587870 break;
75597871 }
75607872
75617873 // consequent
7562- label = 579LLU; // consequent complete
7874+ label = 607LLU; // consequent complete
75637875 break;
75647876 }
7565- case 578LLU: // alternative
7877+ case 606LLU: // alternative
75667878 {
75677879 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
75687880 {
7569- label = 581LLU; // jump to alternative
7881+ label = 609LLU; // jump to alternative
75707882 break;
75717883 }
75727884
@@ -7578,9 +7890,9 @@
75787890
75797891 // case
75807892 // call equ from existslet
7581- stack[base + 12LLU] = 583LLU/*throw to this address*/;
7893+ stack[base + 12LLU] = 611LLU/*throw to this address*/;
75827894 stack[base + 13LLU] = base;
7583- stack[base + 14LLU] = 584LLU;
7895+ stack[base + 14LLU] = 612LLU;
75847896 // arguments for call to equ
75857897 stack[base + 16LLU] = stack[base + 8]/*curid*/;
75867898 stack[base + 17LLU] = stack[base + 2]/*id*/;
@@ -7589,14 +7901,14 @@
75897901 label = 18446744073709551600LLU; // equ
75907902 break;
75917903 }
7592- case 583LLU: // copy-back deleter (equ to existslet)
7904+ case 611LLU: // copy-back deleter (equ to existslet)
75937905 {
75947906 fprintf(stderr, "in function existslet: unrolling stack, copy-back (equ to existslet)\n");
75957907 // copy mutable arguments back from call to equ
7596- label = 582LLU; // continue to roll stack
7908+ label = 610LLU; // continue to roll stack
75977909 break;
75987910 }
7599- case 584LLU: // return from equ to existslet
7911+ case 612LLU: // return from equ to existslet
76007912 {
76017913 // copy mutable arguments back from call to equ
76027914 // copy back results provided by call to equ
@@ -7606,10 +7918,10 @@
76067918 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
76077919 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
76087920 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7609- label = 580LLU; // case complete
7921+ label = 608LLU; // case complete
76107922 break;
76117923 }
7612- case 582LLU: // copy-back deleter (switch)
7924+ case 610LLU: // copy-back deleter (switch)
76137925 {
76147926 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 11];
76157927 ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];
@@ -7616,50 +7928,50 @@
76167928 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
76177929 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
76187930 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7619- label = 577LLU; // continue to unroll stack
7931+ label = 605LLU; // continue to unroll stack
76207932 break;
76217933 }
7622- case 581LLU: // try next case
7934+ case 609LLU: // try next case
76237935 {
76247936 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
76257937 exit(-1);
76267938 }
7627- case 580LLU: // completed switch
7939+ case 608LLU: // completed switch
76287940 {
7629- label = 579LLU; // alternative complete
7941+ label = 607LLU; // alternative complete
76307942 break;
76317943 }
7632- case 579LLU: // completed if-then-else
7944+ case 607LLU: // completed if-then-else
76337945 {
76347946 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
7635- label = 575LLU; // repeat
7947+ label = 603LLU; // repeat
76367948 break;
76377949 }
7638- case 577LLU: // copy-back deleter for while next
7950+ case 605LLU: // copy-back deleter for while next
76397951 {
76407952 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
7641- label = 573LLU; // continue to unroll stack
7953+ label = 601LLU; // continue to unroll stack
76427954 break;
76437955 }
7644- case 576LLU: // loop finished
7956+ case 604LLU: // loop finished
76457957 {
7646- label = 586LLU; // skip deleter
7958+ label = 614LLU; // skip deleter
76477959 break;
76487960 }
7649- case 585LLU: // deleter
7961+ case 613LLU: // deleter
76507962 {
76517963 // throw from existslet
76527964 if(!stack[base + 0])
76537965 {
76547966 fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7655- label = 573LLU; // skip, variable already deleted/unscoped
7967+ label = 601LLU; // skip, variable already deleted/unscoped
76567968 break;
76577969 }
76587970 fprintf(stderr, "in function existslet: unrolling stack, variable u64 \n");
7659- label = 573LLU; // continue unrolling stack, delete next variable
7971+ label = 601LLU; // continue unrolling stack, delete next variable
76607972 break;
76617973 }
7662- case 586LLU: // skipped deleter
7974+ case 614LLU: // skipped deleter
76637975 {
76647976 stack[base + 0] = stack[base + 3]/*found*/;
76657977 // return from existslet
@@ -7667,7 +7979,7 @@
76677979 base = stack[base - 2];
76687980 break;
76697981 }
7670- case 588LLU: // function FindLetNew failed
7982+ case 616LLU: // function FindLetNew failed
76717983 {
76727984 fprintf(stderr, "function FindLetNew failed\n");
76737985 label = stack[base - 3];
@@ -7674,7 +7986,7 @@
76747986 base = stack[base - 2];
76757987 break;