OSDN > Pesquisar Software > Software Development > Compilers > JPL > SCM > SVN > Commit

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revisão	1172 (tree)
Hora	2021-02-24 08:03:28
Autor	jakobthomsen

Mensagem de Log

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

Mudança Sumário

modified: trunk/jpl_compiler_pragmatic/compiler.compiled.c (diff)
modified: trunk/jpl_compiler_pragmatic/compiler.source.c (diff)

Diff

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1171)

+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1172)

		@@ -863,10 +863,46 @@
863	863	//#define res0 0
864	864	//#define res1 1
865	865	//#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	+ {
866	902	// call PARSETOKEN from ParseToken
867		- stack[base + 5LLU] = 5LLU/throw to this address/;
	903	+ stack[base + 5LLU] = 9LLU/throw to this address/;
868	904	stack[base + 6LLU] = base;
869		- stack[base + 7LLU] = 6LLU;
	905	+ stack[base + 7LLU] = 10LLU;
870	906	// arguments for call to PARSETOKEN
871	907	stack[base + 10LLU] = stack[base + 2]/lookahead/;
872	908	// set stack-base & callee-address

		@@ -874,7 +910,7 @@
874	910	label = 18446744073709551584LLU; // PARSETOKEN
875	911	break;
876	912	}
877		- case 5LLU: // copy-back deleter (PARSETOKEN to ParseToken)
	913	+ case 9LLU: // copy-back deleter (PARSETOKEN to ParseToken)
878	914	{
879	915	fprintf(stderr, "in function ParseToken: unrolling stack, copy-back (PARSETOKEN to ParseToken)\n");
880	916	// copy mutable arguments back from call to PARSETOKEN

		@@ -881,7 +917,7 @@
881	917	label = 4LLU; // continue to roll stack
882	918	break;
883	919	}
884		- case 6LLU: // return from PARSETOKEN to ParseToken
	920	+ case 10LLU: // return from PARSETOKEN to ParseToken
885	921	{
886	922	// copy mutable arguments back from call to PARSETOKEN
887	923	// copy back results provided by call to PARSETOKEN

		@@ -888,9 +924,9 @@
888	924	stack[base + 3] = stack[base + 8LLU];
889	925	stack[base + 4] = stack[base + 9LLU];
890	926	// call getbyte from ParseToken
891		- stack[base + 5LLU] = 7LLU/throw to this address/;
	927	+ stack[base + 5LLU] = 11LLU/throw to this address/;
892	928	stack[base + 6LLU] = base;
893		- stack[base + 7LLU] = 8LLU;
	929	+ stack[base + 7LLU] = 12LLU;
894	930	// arguments for call to getbyte
895	931	// set stack-base & callee-address
896	932	base += 8LLU;

		@@ -897,54 +933,54 @@
897	933	label = 18446744073709551593LLU; // getbyte
898	934	break;
899	935	}
900		- case 7LLU: // copy-back deleter (getbyte to ParseToken)
	936	+ case 11LLU: // copy-back deleter (getbyte to ParseToken)
901	937	{
902	938	fprintf(stderr, "in function ParseToken: unrolling stack, copy-back (getbyte to ParseToken)\n");
903	939	// copy mutable arguments back from call to getbyte
904		- label = 4LLU; // continue to roll stack
	940	+ label = 7LLU; // continue to roll stack
905	941	break;
906	942	}
907		- case 8LLU: // return from getbyte to ParseToken
	943	+ case 12LLU: // return from getbyte to ParseToken
908	944	{
909	945	// copy mutable arguments back from call to getbyte
910	946	// copy back results provided by call to getbyte
911	947	stack[base + 2] = stack[base + 8LLU];
912		- label = 10LLU; // skip deleter
	948	+ label = 14LLU; // skip deleter
913	949	break;
914	950	}
915		- case 9LLU: // deleter
	951	+ case 13LLU: // deleter
916	952	{
917	953	// throw from ParseToken
918	954	if(!stack[base + 0])
919	955	{
920	956	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
922	958	break;
923	959	}
924	960	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
926	962	break;
927	963	}
928		- case 10LLU: // skipped deleter
	964	+ case 14LLU: // skipped deleter
929	965	{
930	966	stack[base + 0] = stack[base + 3]/variant/;
931		- label = 12LLU; // skip deleter
	967	+ label = 16LLU; // skip deleter
932	968	break;
933	969	}
934		- case 11LLU: // deleter
	970	+ case 15LLU: // deleter
935	971	{
936	972	// throw from ParseToken
937	973	if(!stack[base + 1])
938	974	{
939	975	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
941	977	break;
942	978	}
943	979	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
945	981	break;
946	982	}
947		- case 12LLU: // skipped deleter
	983	+ case 16LLU: // skipped deleter
948	984	{
949	985	stack[base + 1] = stack[base + 4]/content/;
950	986	// return from ParseToken

		@@ -952,7 +988,7 @@
952	988	base = stack[base - 2];
953	989	break;
954	990	}
955		- case 14LLU: // function DELIMITER failed
	991	+ case 18LLU: // function DELIMITER failed
956	992	{
957	993	fprintf(stderr, "function DELIMITER failed\n");
958	994	label = stack[base - 3];

		@@ -959,14 +995,14 @@
959	995	base = stack[base - 2];
960	996	break;
961	997	}
962		- case 13LLU: // DELIMITER
	998	+ case 17LLU: // DELIMITER
963	999	{
964	1000	//#define arg0 0
965	1001	//#define arg1 1
966	1002	// call skipwscmnt from DELIMITER
967		- stack[base + 2LLU] = 15LLU/throw to this address/;
	1003	+ stack[base + 2LLU] = 19LLU/throw to this address/;
968	1004	stack[base + 3LLU] = base;
969		- stack[base + 4LLU] = 16LLU;
	1005	+ stack[base + 4LLU] = 20LLU;
970	1006	// arguments for call to skipwscmnt
971	1007	stack[base + 6LLU] = stack[base + 1]/lookahead/;
972	1008	// set stack-base & callee-address

		@@ -974,22 +1010,40 @@
974	1010	label = 18446744073709551580LLU; // skipwscmnt
975	1011	break;
976	1012	}
977		- case 15LLU: // copy-back deleter (skipwscmnt to DELIMITER)
	1013	+ case 19LLU: // copy-back deleter (skipwscmnt to DELIMITER)
978	1014	{
979	1015	fprintf(stderr, "in function DELIMITER: unrolling stack, copy-back (skipwscmnt to DELIMITER)\n");
980	1016	// copy mutable arguments back from call to skipwscmnt
981		- label = 14LLU; // continue to roll stack
	1017	+ label = 18LLU; // continue to roll stack
982	1018	break;
983	1019	}
984		- case 16LLU: // return from skipwscmnt to DELIMITER
	1020	+ case 20LLU: // return from skipwscmnt to DELIMITER
985	1021	{
986	1022	// copy mutable arguments back from call to skipwscmnt
987	1023	// copy back results provided by call to skipwscmnt
988	1024	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	+ {
989	1043	// call equ from DELIMITER
990		- stack[base + 3LLU] = 17LLU/throw to this address/;
	1044	+ stack[base + 3LLU] = 23LLU/throw to this address/;
991	1045	stack[base + 4LLU] = base;
992		- stack[base + 5LLU] = 18LLU;
	1046	+ stack[base + 5LLU] = 24LLU;
993	1047	// arguments for call to equ
994	1048	stack[base + 7LLU] = 59LLU;
995	1049	stack[base + 8LLU] = stack[base + 1]/lookahead/;

		@@ -998,14 +1052,14 @@
998	1052	label = 18446744073709551600LLU; // equ
999	1053	break;
1000	1054	}
1001		- case 17LLU: // copy-back deleter (equ to DELIMITER)
	1055	+ case 23LLU: // copy-back deleter (equ to DELIMITER)
1002	1056	{
1003	1057	fprintf(stderr, "in function DELIMITER: unrolling stack, copy-back (equ to DELIMITER)\n");
1004	1058	// copy mutable arguments back from call to equ
1005		- label = 14LLU; // continue to roll stack
	1059	+ label = 18LLU; // continue to roll stack
1006	1060	break;
1007	1061	}
1008		- case 18LLU: // return from equ to DELIMITER
	1062	+ case 24LLU: // return from equ to DELIMITER
1009	1063	{
1010	1064	// copy mutable arguments back from call to equ
1011	1065	// copy back results provided by call to equ

		@@ -1012,21 +1066,21 @@
1012	1066	stack[base + 2] = stack[base + 6LLU];
1013	1067	if(!stack[base + 2]/isequal/)
1014	1068	{
1015		- label = 19LLU; // jump to alternative
	1069	+ label = 25LLU; // jump to alternative
1016	1070	break;
1017	1071	}
1018	1072
1019	1073	// consequent
1020		- label = 20LLU; // consequent complete
	1074	+ label = 26LLU; // consequent complete
1021	1075	break;
1022	1076	}
1023		- case 19LLU: // alternative
	1077	+ case 25LLU: // alternative
1024	1078	{
1025	1079	fprintf(stderr, "%s", "in function ");
1026	1080	// call reportid from DELIMITER
1027		- stack[base + 3LLU] = 21LLU/throw to this address/;
	1081	+ stack[base + 3LLU] = 27LLU/throw to this address/;
1028	1082	stack[base + 4LLU] = base;
1029		- stack[base + 5LLU] = 22LLU;
	1083	+ stack[base + 5LLU] = 28LLU;
1030	1084	// arguments for call to reportid
1031	1085	stack[base + 6LLU] = stack[base + 0]/fnid/;
1032	1086	// set stack-base & callee-address

		@@ -1034,22 +1088,22 @@
1034	1088	label = 18446744073709551586LLU; // reportid
1035	1089	break;
1036	1090	}
1037		- case 21LLU: // copy-back deleter (reportid to DELIMITER)
	1091	+ case 27LLU: // copy-back deleter (reportid to DELIMITER)
1038	1092	{
1039	1093	fprintf(stderr, "in function DELIMITER: unrolling stack, copy-back (reportid to DELIMITER)\n");
1040	1094	// copy mutable arguments back from call to reportid
1041		- label = 14LLU; // continue to roll stack
	1095	+ label = 21LLU; // continue to roll stack
1042	1096	break;
1043	1097	}
1044		- case 22LLU: // return from reportid to DELIMITER
	1098	+ case 28LLU: // return from reportid to DELIMITER
1045	1099	{
1046	1100	// copy mutable arguments back from call to reportid
1047	1101	fprintf(stderr, "%s", " missing ';'\n");
1048	1102	exit(-1);
1049		- label = 20LLU; // alternative complete
	1103	+ label = 26LLU; // alternative complete
1050	1104	break;
1051	1105	}
1052		- case 20LLU: // completed if-then-else
	1106	+ case 26LLU: // completed if-then-else
1053	1107	{
1054	1108	// return from DELIMITER
1055	1109	label = stack[base - 1];

		@@ -1056,7 +1110,7 @@
1056	1110	base = stack[base - 2];
1057	1111	break;
1058	1112	}
1059		- case 24LLU: // function delimiter failed
	1113	+ case 30LLU: // function delimiter failed
1060	1114	{
1061	1115	fprintf(stderr, "function delimiter failed\n");
1062	1116	label = stack[base - 3];

		@@ -1063,38 +1117,38 @@
1063	1117	base = stack[base - 2];
1064	1118	break;
1065	1119	}
1066		- case 23LLU: // delimiter
	1120	+ case 29LLU: // delimiter
1067	1121	{
1068	1122	//#define arg0 0
1069	1123	//#define arg1 1
1070	1124	// call DELIMITER from delimiter
1071		- stack[base + 2LLU] = 25LLU/throw to this address/;
	1125	+ stack[base + 2LLU] = 31LLU/throw to this address/;
1072	1126	stack[base + 3LLU] = base;
1073		- stack[base + 4LLU] = 26LLU;
	1127	+ stack[base + 4LLU] = 32LLU;
1074	1128	// arguments for call to DELIMITER
1075	1129	stack[base + 5LLU] = stack[base + 0]/fnid/;
1076	1130	stack[base + 6LLU] = stack[base + 1]/lookahead/;
1077	1131	// set stack-base & callee-address
1078	1132	base += 5LLU;
1079		- label = 13LLU; // DELIMITER
	1133	+ label = 17LLU; // DELIMITER
1080	1134	break;
1081	1135	}
1082		- case 25LLU: // copy-back deleter (DELIMITER to delimiter)
	1136	+ case 31LLU: // copy-back deleter (DELIMITER to delimiter)
1083	1137	{
1084	1138	fprintf(stderr, "in function delimiter: unrolling stack, copy-back (DELIMITER to delimiter)\n");
1085	1139	// copy mutable arguments back from call to DELIMITER
1086	1140	stack[base + 1]/lookahead/ = stack[base + 6LLU];
1087		- label = 24LLU; // continue to roll stack
	1141	+ label = 30LLU; // continue to roll stack
1088	1142	break;
1089	1143	}
1090		- case 26LLU: // return from DELIMITER to delimiter
	1144	+ case 32LLU: // return from DELIMITER to delimiter
1091	1145	{
1092	1146	// copy mutable arguments back from call to DELIMITER
1093	1147	stack[base + 1]/lookahead/ = stack[base + 6LLU];
1094	1148	// call getbyte from delimiter
1095		- stack[base + 2LLU] = 27LLU/throw to this address/;
	1149	+ stack[base + 2LLU] = 33LLU/throw to this address/;
1096	1150	stack[base + 3LLU] = base;
1097		- stack[base + 4LLU] = 28LLU;
	1151	+ stack[base + 4LLU] = 34LLU;
1098	1152	// arguments for call to getbyte
1099	1153	// set stack-base & callee-address
1100	1154	base += 5LLU;

		@@ -1101,14 +1155,14 @@
1101	1155	label = 18446744073709551593LLU; // getbyte
1102	1156	break;
1103	1157	}
1104		- case 27LLU: // copy-back deleter (getbyte to delimiter)
	1158	+ case 33LLU: // copy-back deleter (getbyte to delimiter)
1105	1159	{
1106	1160	fprintf(stderr, "in function delimiter: unrolling stack, copy-back (getbyte to delimiter)\n");
1107	1161	// copy mutable arguments back from call to getbyte
1108		- label = 24LLU; // continue to roll stack
	1162	+ label = 30LLU; // continue to roll stack
1109	1163	break;
1110	1164	}
1111		- case 28LLU: // return from getbyte to delimiter
	1165	+ case 34LLU: // return from getbyte to delimiter
1112	1166	{
1113	1167	// copy mutable arguments back from call to getbyte
1114	1168	// copy back results provided by call to getbyte

		@@ -1118,7 +1172,7 @@
1118	1172	base = stack[base - 2];
1119	1173	break;
1120	1174	}
1121		- case 30LLU: // function isalpha failed
	1175	+ case 36LLU: // function isalpha failed
1122	1176	{
1123	1177	fprintf(stderr, "function isalpha failed\n");
1124	1178	label = stack[base - 3];

		@@ -1125,33 +1179,33 @@
1125	1179	base = stack[base - 2];
1126	1180	break;
1127	1181	}
1128		- case 29LLU: // isalpha
	1182	+ case 35LLU: // isalpha
1129	1183	{
1130	1184	//#define res0 0
1131	1185	//#define arg0 1
1132		- label = 32LLU; // skip deleter
	1186	+ label = 38LLU; // skip deleter
1133	1187	break;
1134	1188	}
1135		- case 31LLU: // deleter
	1189	+ case 37LLU: // deleter
1136	1190	{
1137	1191	// throw from isalpha
1138	1192	if(!stack[base + 2])
1139	1193	{
1140	1194	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
1142	1196	break;
1143	1197	}
1144	1198	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
1146	1200	break;
1147	1201	}
1148		- case 32LLU: // skipped deleter
	1202	+ case 38LLU: // skipped deleter
1149	1203	{
1150	1204	stack[base + 2] = 0;
1151	1205	// call geq from isalpha
1152		- stack[base + 3LLU] = 33LLU/throw to this address/;
	1206	+ stack[base + 3LLU] = 39LLU/throw to this address/;
1153	1207	stack[base + 4LLU] = base;
1154		- stack[base + 5LLU] = 34LLU;
	1208	+ stack[base + 5LLU] = 40LLU;
1155	1209	// arguments for call to geq
1156	1210	stack[base + 7LLU] = stack[base + 1]/c/;
1157	1211	stack[base + 8LLU] = 97LLU;

		@@ -1160,14 +1214,14 @@
1160	1214	label = 18446744073709551596LLU; // geq
1161	1215	break;
1162	1216	}
1163		- case 33LLU: // copy-back deleter (geq to isalpha)
	1217	+ case 39LLU: // copy-back deleter (geq to isalpha)
1164	1218	{
1165	1219	fprintf(stderr, "in function isalpha: unrolling stack, copy-back (geq to isalpha)\n");
1166	1220	// copy mutable arguments back from call to geq
1167		- label = 31LLU; // continue to roll stack
	1221	+ label = 37LLU; // continue to roll stack
1168	1222	break;
1169	1223	}
1170		- case 34LLU: // return from geq to isalpha
	1224	+ case 40LLU: // return from geq to isalpha
1171	1225	{
1172	1226	// copy mutable arguments back from call to geq
1173	1227	// copy back results provided by call to geq

		@@ -1174,15 +1228,15 @@
1174	1228	stack[base + 2] = stack[base + 6LLU];
1175	1229	if(!stack[base + 2]/isequal/)
1176	1230	{
1177		- label = 35LLU; // jump to alternative
	1231	+ label = 41LLU; // jump to alternative
1178	1232	break;
1179	1233	}
1180	1234
1181	1235	// consequent
1182	1236	// call leq from isalpha
1183		- stack[base + 3LLU] = 37LLU/throw to this address/;
	1237	+ stack[base + 3LLU] = 43LLU/throw to this address/;
1184	1238	stack[base + 4LLU] = base;
1185		- stack[base + 5LLU] = 38LLU;
	1239	+ stack[base + 5LLU] = 44LLU;
1186	1240	// arguments for call to leq
1187	1241	stack[base + 7LLU] = stack[base + 1]/c/;
1188	1242	stack[base + 8LLU] = 122LLU;

		@@ -1191,27 +1245,27 @@
1191	1245	label = 18446744073709551598LLU; // leq
1192	1246	break;
1193	1247	}
1194		- case 37LLU: // copy-back deleter (leq to isalpha)
	1248	+ case 43LLU: // copy-back deleter (leq to isalpha)
1195	1249	{
1196	1250	fprintf(stderr, "in function isalpha: unrolling stack, copy-back (leq to isalpha)\n");
1197	1251	// copy mutable arguments back from call to leq
1198		- label = 31LLU; // continue to roll stack
	1252	+ label = 37LLU; // continue to roll stack
1199	1253	break;
1200	1254	}
1201		- case 38LLU: // return from leq to isalpha
	1255	+ case 44LLU: // return from leq to isalpha
1202	1256	{
1203	1257	// copy mutable arguments back from call to leq
1204	1258	// copy back results provided by call to leq
1205	1259	stack[base + 0] = stack[base + 6LLU];
1206		- label = 36LLU; // consequent complete
	1260	+ label = 42LLU; // consequent complete
1207	1261	break;
1208	1262	}
1209		- case 35LLU: // alternative
	1263	+ case 41LLU: // alternative
1210	1264	{
1211	1265	// call geq from isalpha
1212		- stack[base + 3LLU] = 39LLU/throw to this address/;
	1266	+ stack[base + 3LLU] = 45LLU/throw to this address/;
1213	1267	stack[base + 4LLU] = base;
1214		- stack[base + 5LLU] = 40LLU;
	1268	+ stack[base + 5LLU] = 46LLU;
1215	1269	// arguments for call to geq
1216	1270	stack[base + 7LLU] = stack[base + 1]/c/;
1217	1271	stack[base + 8LLU] = 65LLU;

		@@ -1220,14 +1274,14 @@
1220	1274	label = 18446744073709551596LLU; // geq
1221	1275	break;
1222	1276	}
1223		- case 39LLU: // copy-back deleter (geq to isalpha)
	1277	+ case 45LLU: // copy-back deleter (geq to isalpha)
1224	1278	{
1225	1279	fprintf(stderr, "in function isalpha: unrolling stack, copy-back (geq to isalpha)\n");
1226	1280	// copy mutable arguments back from call to geq
1227		- label = 31LLU; // continue to roll stack
	1281	+ label = 37LLU; // continue to roll stack
1228	1282	break;
1229	1283	}
1230		- case 40LLU: // return from geq to isalpha
	1284	+ case 46LLU: // return from geq to isalpha
1231	1285	{
1232	1286	// copy mutable arguments back from call to geq
1233	1287	// copy back results provided by call to geq

		@@ -1234,15 +1288,15 @@
1234	1288	stack[base + 2] = stack[base + 6LLU];
1235	1289	if(!stack[base + 2]/isequal/)
1236	1290	{
1237		- label = 41LLU; // jump to alternative
	1291	+ label = 47LLU; // jump to alternative
1238	1292	break;
1239	1293	}
1240	1294
1241	1295	// consequent
1242	1296	// call leq from isalpha
1243		- stack[base + 3LLU] = 43LLU/throw to this address/;
	1297	+ stack[base + 3LLU] = 49LLU/throw to this address/;
1244	1298	stack[base + 4LLU] = base;
1245		- stack[base + 5LLU] = 44LLU;
	1299	+ stack[base + 5LLU] = 50LLU;
1246	1300	// arguments for call to leq
1247	1301	stack[base + 7LLU] = stack[base + 1]/c/;
1248	1302	stack[base + 8LLU] = 90LLU;

		@@ -1251,51 +1305,51 @@
1251	1305	label = 18446744073709551598LLU; // leq
1252	1306	break;
1253	1307	}
1254		- case 43LLU: // copy-back deleter (leq to isalpha)
	1308	+ case 49LLU: // copy-back deleter (leq to isalpha)
1255	1309	{
1256	1310	fprintf(stderr, "in function isalpha: unrolling stack, copy-back (leq to isalpha)\n");
1257	1311	// copy mutable arguments back from call to leq
1258		- label = 31LLU; // continue to roll stack
	1312	+ label = 37LLU; // continue to roll stack
1259	1313	break;
1260	1314	}
1261		- case 44LLU: // return from leq to isalpha
	1315	+ case 50LLU: // return from leq to isalpha
1262	1316	{
1263	1317	// copy mutable arguments back from call to leq
1264	1318	// copy back results provided by call to leq
1265	1319	stack[base + 0] = stack[base + 6LLU];
1266		- label = 42LLU; // consequent complete
	1320	+ label = 48LLU; // consequent complete
1267	1321	break;
1268	1322	}
1269		- case 41LLU: // alternative
	1323	+ case 47LLU: // alternative
1270	1324	{
1271		- label = 46LLU; // skip deleter
	1325	+ label = 52LLU; // skip deleter
1272	1326	break;
1273	1327	}
1274		- case 45LLU: // deleter
	1328	+ case 51LLU: // deleter
1275	1329	{
1276	1330	// throw from isalpha
1277	1331	if(!stack[base + 0])
1278	1332	{
1279	1333	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
1281	1335	break;
1282	1336	}
1283	1337	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
1285	1339	break;
1286	1340	}
1287		- case 46LLU: // skipped deleter
	1341	+ case 52LLU: // skipped deleter
1288	1342	{
1289	1343	stack[base + 0] = 0;
1290		- label = 42LLU; // alternative complete
	1344	+ label = 48LLU; // alternative complete
1291	1345	break;
1292	1346	}
1293		- case 42LLU: // completed if-then-else
	1347	+ case 48LLU: // completed if-then-else
1294	1348	{
1295		- label = 36LLU; // alternative complete
	1349	+ label = 42LLU; // alternative complete
1296	1350	break;
1297	1351	}
1298		- case 36LLU: // completed if-then-else
	1352	+ case 42LLU: // completed if-then-else
1299	1353	{
1300	1354	// return from isalpha
1301	1355	label = stack[base - 1];

		@@ -1302,7 +1356,7 @@
1302	1356	base = stack[base - 2];
1303	1357	break;
1304	1358	}
1305		- case 48LLU: // function isspace failed
	1359	+ case 54LLU: // function isspace failed
1306	1360	{
1307	1361	fprintf(stderr, "function isspace failed\n");
1308	1362	label = stack[base - 3];

		@@ -1309,33 +1363,33 @@
1309	1363	base = stack[base - 2];
1310	1364	break;
1311	1365	}
1312		- case 47LLU: // isspace
	1366	+ case 53LLU: // isspace
1313	1367	{
1314	1368	//#define res0 0
1315	1369	//#define arg0 1
1316		- label = 50LLU; // skip deleter
	1370	+ label = 56LLU; // skip deleter
1317	1371	break;
1318	1372	}
1319		- case 49LLU: // deleter
	1373	+ case 55LLU: // deleter
1320	1374	{
1321	1375	// throw from isspace
1322	1376	if(!stack[base + 2])
1323	1377	{
1324	1378	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
1326	1380	break;
1327	1381	}
1328	1382	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
1330	1384	break;
1331	1385	}
1332		- case 50LLU: // skipped deleter
	1386	+ case 56LLU: // skipped deleter
1333	1387	{
1334	1388	stack[base + 2] = 0;
1335	1389	// call geq from isspace
1336		- stack[base + 3LLU] = 51LLU/throw to this address/;
	1390	+ stack[base + 3LLU] = 57LLU/throw to this address/;
1337	1391	stack[base + 4LLU] = base;
1338		- stack[base + 5LLU] = 52LLU;
	1392	+ stack[base + 5LLU] = 58LLU;
1339	1393	// arguments for call to geq
1340	1394	stack[base + 7LLU] = stack[base + 1]/c/;
1341	1395	stack[base + 8LLU] = 32LLU;

		@@ -1344,14 +1398,14 @@
1344	1398	label = 18446744073709551596LLU; // geq
1345	1399	break;
1346	1400	}
1347		- case 51LLU: // copy-back deleter (geq to isspace)
	1401	+ case 57LLU: // copy-back deleter (geq to isspace)
1348	1402	{
1349	1403	fprintf(stderr, "in function isspace: unrolling stack, copy-back (geq to isspace)\n");
1350	1404	// copy mutable arguments back from call to geq
1351		- label = 49LLU; // continue to roll stack
	1405	+ label = 55LLU; // continue to roll stack
1352	1406	break;
1353	1407	}
1354		- case 52LLU: // return from geq to isspace
	1408	+ case 58LLU: // return from geq to isspace
1355	1409	{
1356	1410	// copy mutable arguments back from call to geq
1357	1411	// copy back results provided by call to geq

		@@ -1358,15 +1412,15 @@
1358	1412	stack[base + 2] = stack[base + 6LLU];
1359	1413	if(!stack[base + 2]/isequal/)
1360	1414	{
1361		- label = 53LLU; // jump to alternative
	1415	+ label = 59LLU; // jump to alternative
1362	1416	break;
1363	1417	}
1364	1418
1365	1419	// consequent
1366	1420	// call leq from isspace
1367		- stack[base + 3LLU] = 55LLU/throw to this address/;
	1421	+ stack[base + 3LLU] = 61LLU/throw to this address/;
1368	1422	stack[base + 4LLU] = base;
1369		- stack[base + 5LLU] = 56LLU;
	1423	+ stack[base + 5LLU] = 62LLU;
1370	1424	// arguments for call to leq
1371	1425	stack[base + 7LLU] = stack[base + 1]/c/;
1372	1426	stack[base + 8LLU] = 10LLU;

		@@ -1375,27 +1429,27 @@
1375	1429	label = 18446744073709551598LLU; // leq
1376	1430	break;
1377	1431	}
1378		- case 55LLU: // copy-back deleter (leq to isspace)
	1432	+ case 61LLU: // copy-back deleter (leq to isspace)
1379	1433	{
1380	1434	fprintf(stderr, "in function isspace: unrolling stack, copy-back (leq to isspace)\n");
1381	1435	// copy mutable arguments back from call to leq
1382		- label = 49LLU; // continue to roll stack
	1436	+ label = 55LLU; // continue to roll stack
1383	1437	break;
1384	1438	}
1385		- case 56LLU: // return from leq to isspace
	1439	+ case 62LLU: // return from leq to isspace
1386	1440	{
1387	1441	// copy mutable arguments back from call to leq
1388	1442	// copy back results provided by call to leq
1389	1443	stack[base + 0] = stack[base + 6LLU];
1390		- label = 54LLU; // consequent complete
	1444	+ label = 60LLU; // consequent complete
1391	1445	break;
1392	1446	}
1393		- case 53LLU: // alternative
	1447	+ case 59LLU: // alternative
1394	1448	{
1395	1449	// call geq from isspace
1396		- stack[base + 3LLU] = 57LLU/throw to this address/;
	1450	+ stack[base + 3LLU] = 63LLU/throw to this address/;
1397	1451	stack[base + 4LLU] = base;
1398		- stack[base + 5LLU] = 58LLU;
	1452	+ stack[base + 5LLU] = 64LLU;
1399	1453	// arguments for call to geq
1400	1454	stack[base + 7LLU] = stack[base + 1]/c/;
1401	1455	stack[base + 8LLU] = 13LLU;

		@@ -1404,14 +1458,14 @@
1404	1458	label = 18446744073709551596LLU; // geq
1405	1459	break;
1406	1460	}
1407		- case 57LLU: // copy-back deleter (geq to isspace)
	1461	+ case 63LLU: // copy-back deleter (geq to isspace)
1408	1462	{
1409	1463	fprintf(stderr, "in function isspace: unrolling stack, copy-back (geq to isspace)\n");
1410	1464	// copy mutable arguments back from call to geq
1411		- label = 49LLU; // continue to roll stack
	1465	+ label = 55LLU; // continue to roll stack
1412	1466	break;
1413	1467	}
1414		- case 58LLU: // return from geq to isspace
	1468	+ case 64LLU: // return from geq to isspace
1415	1469	{
1416	1470	// copy mutable arguments back from call to geq
1417	1471	// copy back results provided by call to geq

		@@ -1418,15 +1472,15 @@
1418	1472	stack[base + 2] = stack[base + 6LLU];
1419	1473	if(!stack[base + 2]/isequal/)
1420	1474	{
1421		- label = 59LLU; // jump to alternative
	1475	+ label = 65LLU; // jump to alternative
1422	1476	break;
1423	1477	}
1424	1478
1425	1479	// consequent
1426	1480	// call geq from isspace
1427		- stack[base + 3LLU] = 61LLU/throw to this address/;
	1481	+ stack[base + 3LLU] = 67LLU/throw to this address/;
1428	1482	stack[base + 4LLU] = base;
1429		- stack[base + 5LLU] = 62LLU;
	1483	+ stack[base + 5LLU] = 68LLU;
1430	1484	// arguments for call to geq
1431	1485	stack[base + 7LLU] = stack[base + 1]/c/;
1432	1486	stack[base + 8LLU] = 11LLU;

		@@ -1435,14 +1489,14 @@
1435	1489	label = 18446744073709551596LLU; // geq
1436	1490	break;
1437	1491	}
1438		- case 61LLU: // copy-back deleter (geq to isspace)
	1492	+ case 67LLU: // copy-back deleter (geq to isspace)
1439	1493	{
1440	1494	fprintf(stderr, "in function isspace: unrolling stack, copy-back (geq to isspace)\n");
1441	1495	// copy mutable arguments back from call to geq
1442		- label = 49LLU; // continue to roll stack
	1496	+ label = 55LLU; // continue to roll stack
1443	1497	break;
1444	1498	}
1445		- case 62LLU: // return from geq to isspace
	1499	+ case 68LLU: // return from geq to isspace
1446	1500	{
1447	1501	// copy mutable arguments back from call to geq
1448	1502	// copy back results provided by call to geq

		@@ -1449,15 +1503,15 @@
1449	1503	stack[base + 2] = stack[base + 6LLU];
1450	1504	if(!stack[base + 2]/isequal/)
1451	1505	{
1452		- label = 63LLU; // jump to alternative
	1506	+ label = 69LLU; // jump to alternative
1453	1507	break;
1454	1508	}
1455	1509
1456	1510	// consequent
1457	1511	// call leq from isspace
1458		- stack[base + 3LLU] = 65LLU/throw to this address/;
	1512	+ stack[base + 3LLU] = 71LLU/throw to this address/;
1459	1513	stack[base + 4LLU] = base;
1460		- stack[base + 5LLU] = 66LLU;
	1514	+ stack[base + 5LLU] = 72LLU;
1461	1515	// arguments for call to leq
1462	1516	stack[base + 7LLU] = stack[base + 1]/c/;
1463	1517	stack[base + 8LLU] = 9LLU;

		@@ -1466,80 +1520,80 @@
1466	1520	label = 18446744073709551598LLU; // leq
1467	1521	break;
1468	1522	}
1469		- case 65LLU: // copy-back deleter (leq to isspace)
	1523	+ case 71LLU: // copy-back deleter (leq to isspace)
1470	1524	{
1471	1525	fprintf(stderr, "in function isspace: unrolling stack, copy-back (leq to isspace)\n");
1472	1526	// copy mutable arguments back from call to leq
1473		- label = 49LLU; // continue to roll stack
	1527	+ label = 55LLU; // continue to roll stack
1474	1528	break;
1475	1529	}
1476		- case 66LLU: // return from leq to isspace
	1530	+ case 72LLU: // return from leq to isspace
1477	1531	{
1478	1532	// copy mutable arguments back from call to leq
1479	1533	// copy back results provided by call to leq
1480	1534	stack[base + 0] = stack[base + 6LLU];
1481		- label = 64LLU; // consequent complete
	1535	+ label = 70LLU; // consequent complete
1482	1536	break;
1483	1537	}
1484		- case 63LLU: // alternative
	1538	+ case 69LLU: // alternative
1485	1539	{
1486		- label = 68LLU; // skip deleter
	1540	+ label = 74LLU; // skip deleter
1487	1541	break;
1488	1542	}
1489		- case 67LLU: // deleter
	1543	+ case 73LLU: // deleter
1490	1544	{
1491	1545	// throw from isspace
1492	1546	if(!stack[base + 0])
1493	1547	{
1494	1548	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
1496	1550	break;
1497	1551	}
1498	1552	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
1500	1554	break;
1501	1555	}
1502		- case 68LLU: // skipped deleter
	1556	+ case 74LLU: // skipped deleter
1503	1557	{
1504	1558	stack[base + 0] = 0;
1505		- label = 64LLU; // alternative complete
	1559	+ label = 70LLU; // alternative complete
1506	1560	break;
1507	1561	}
1508		- case 64LLU: // completed if-then-else
	1562	+ case 70LLU: // completed if-then-else
1509	1563	{
1510		- label = 60LLU; // consequent complete
	1564	+ label = 66LLU; // consequent complete
1511	1565	break;
1512	1566	}
1513		- case 59LLU: // alternative
	1567	+ case 65LLU: // alternative
1514	1568	{
1515		- label = 70LLU; // skip deleter
	1569	+ label = 76LLU; // skip deleter
1516	1570	break;
1517	1571	}
1518		- case 69LLU: // deleter
	1572	+ case 75LLU: // deleter
1519	1573	{
1520	1574	// throw from isspace
1521	1575	if(!stack[base + 0])
1522	1576	{
1523	1577	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
1525	1579	break;
1526	1580	}
1527	1581	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
1529	1583	break;
1530	1584	}
1531		- case 70LLU: // skipped deleter
	1585	+ case 76LLU: // skipped deleter
1532	1586	{
1533	1587	stack[base + 0] = 0;
1534		- label = 60LLU; // alternative complete
	1588	+ label = 66LLU; // alternative complete
1535	1589	break;
1536	1590	}
1537		- case 60LLU: // completed if-then-else
	1591	+ case 66LLU: // completed if-then-else
1538	1592	{
1539		- label = 54LLU; // alternative complete
	1593	+ label = 60LLU; // alternative complete
1540	1594	break;
1541	1595	}
1542		- case 54LLU: // completed if-then-else
	1596	+ case 60LLU: // completed if-then-else
1543	1597	{
1544	1598	// return from isspace
1545	1599	label = stack[base - 1];

		@@ -1546,7 +1600,7 @@
1546	1600	base = stack[base - 2];
1547	1601	break;
1548	1602	}
1549		- case 72LLU: // function EOSbyte failed
	1603	+ case 78LLU: // function EOSbyte failed
1550	1604	{
1551	1605	fprintf(stderr, "function EOSbyte failed\n");
1552	1606	label = stack[base - 3];

		@@ -1553,13 +1607,13 @@
1553	1607	base = stack[base - 2];
1554	1608	break;
1555	1609	}
1556		- case 71LLU: // EOSbyte
	1610	+ case 77LLU: // EOSbyte
1557	1611	{
1558	1612	//#define res0 0
1559	1613	// call sub from EOSbyte
1560		- stack[base + 1LLU] = 73LLU/throw to this address/;
	1614	+ stack[base + 1LLU] = 79LLU/throw to this address/;
1561	1615	stack[base + 2LLU] = base;
1562		- stack[base + 3LLU] = 74LLU;
	1616	+ stack[base + 3LLU] = 80LLU;
1563	1617	// arguments for call to sub
1564	1618	stack[base + 5LLU] = 0LLU;
1565	1619	stack[base + 6LLU] = 1LLU;

		@@ -1568,14 +1622,14 @@
1568	1622	label = 18446744073709551604LLU; // sub
1569	1623	break;
1570	1624	}
1571		- case 73LLU: // copy-back deleter (sub to EOSbyte)
	1625	+ case 79LLU: // copy-back deleter (sub to EOSbyte)
1572	1626	{
1573	1627	fprintf(stderr, "in function EOSbyte: unrolling stack, copy-back (sub to EOSbyte)\n");
1574	1628	// copy mutable arguments back from call to sub
1575		- label = 72LLU; // continue to roll stack
	1629	+ label = 78LLU; // continue to roll stack
1576	1630	break;
1577	1631	}
1578		- case 74LLU: // return from sub to EOSbyte
	1632	+ case 80LLU: // return from sub to EOSbyte
1579	1633	{
1580	1634	// copy mutable arguments back from call to sub
1581	1635	// copy back results provided by call to sub

		@@ -1585,7 +1639,7 @@
1585	1639	base = stack[base - 2];
1586	1640	break;
1587	1641	}
1588		- case 76LLU: // function skip failed
	1642	+ case 82LLU: // function skip failed
1589	1643	{
1590	1644	fprintf(stderr, "function skip failed\n");
1591	1645	label = stack[base - 3];

		@@ -1592,63 +1646,63 @@
1592	1646	base = stack[base - 2];
1593	1647	break;
1594	1648	}
1595		- case 75LLU: // skip
	1649	+ case 81LLU: // skip
1596	1650	{
1597	1651	//#define arg0 0
1598		- label = 78LLU; // skip deleter
	1652	+ label = 84LLU; // skip deleter
1599	1653	break;
1600	1654	}
1601		- case 77LLU: // deleter
	1655	+ case 83LLU: // deleter
1602	1656	{
1603	1657	// throw from skip
1604	1658	if(!stack[base + 1])
1605	1659	{
1606	1660	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
1608	1662	break;
1609	1663	}
1610	1664	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
1612	1666	break;
1613	1667	}
1614		- case 78LLU: // skipped deleter
	1668	+ case 84LLU: // skipped deleter
1615	1669	{
1616	1670	stack[base + 1] = stack[base + 0]/LOOKAHEAD/;
1617		- label = 80LLU; // skip deleter
	1671	+ label = 86LLU; // skip deleter
1618	1672	break;
1619	1673	}
1620		- case 79LLU: // deleter
	1674	+ case 85LLU: // deleter
1621	1675	{
1622	1676	// throw from skip
1623	1677	if(!stack[base + 2])
1624	1678	{
1625	1679	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
1627	1681	break;
1628	1682	}
1629	1683	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
1631	1685	break;
1632	1686	}
1633		- case 80LLU: // skipped deleter
	1687	+ case 86LLU: // skipped deleter
1634	1688	{
1635	1689	stack[base + 2] = 0;
1636		- label = 81LLU; // start to repeat
	1690	+ label = 87LLU; // start to repeat
1637	1691	break;
1638	1692	}
1639		- case 81LLU: // repeat from here
	1693	+ case 87LLU: // repeat from here
1640	1694	{
1641	1695	if(stack[base + 1]/lookahead/ > 0xFF)
1642	1696	{
1643		- label = 82LLU; // break loop
	1697	+ label = 88LLU; // break loop
1644	1698	break;
1645	1699	}
1646	1700
1647	1701	// loop body
1648	1702	// call equ from skip
1649		- stack[base + 3LLU] = 83LLU/throw to this address/;
	1703	+ stack[base + 3LLU] = 89LLU/throw to this address/;
1650	1704	stack[base + 4LLU] = base;
1651		- stack[base + 5LLU] = 84LLU;
	1705	+ stack[base + 5LLU] = 90LLU;
1652	1706	// arguments for call to equ
1653	1707	stack[base + 7LLU] = stack[base + 1]/lookahead/;
1654	1708	stack[base + 8LLU] = 47LLU;

		@@ -1657,14 +1711,14 @@
1657	1711	label = 18446744073709551600LLU; // equ
1658	1712	break;
1659	1713	}
1660		- case 83LLU: // copy-back deleter (equ to skip)
	1714	+ case 89LLU: // copy-back deleter (equ to skip)
1661	1715	{
1662	1716	fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
1663	1717	// copy mutable arguments back from call to equ
1664		- label = 79LLU; // continue to roll stack
	1718	+ label = 85LLU; // continue to roll stack
1665	1719	break;
1666	1720	}
1667		- case 84LLU: // return from equ to skip
	1721	+ case 90LLU: // return from equ to skip
1668	1722	{
1669	1723	// copy mutable arguments back from call to equ
1670	1724	// copy back results provided by call to equ

		@@ -1671,15 +1725,33 @@
1671	1725	stack[base + 2] = stack[base + 6LLU];
1672	1726	if(!stack[base + 2]/isequal/)
1673	1727	{
1674		- label = 85LLU; // jump to alternative
	1728	+ label = 91LLU; // jump to alternative
1675	1729	break;
1676	1730	}
1677	1731
1678	1732	// 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	+ {
1679	1751	// call peekbyte from skip
1680		- stack[base + 4LLU] = 87LLU/throw to this address/;
	1752	+ stack[base + 4LLU] = 95LLU/throw to this address/;
1681	1753	stack[base + 5LLU] = base;
1682		- stack[base + 6LLU] = 88LLU;
	1754	+ stack[base + 6LLU] = 96LLU;
1683	1755	// arguments for call to peekbyte
1684	1756	// set stack-base & callee-address
1685	1757	base += 7LLU;

		@@ -1686,22 +1758,22 @@
1686	1758	label = 18446744073709551594LLU; // peekbyte
1687	1759	break;
1688	1760	}
1689		- case 87LLU: // copy-back deleter (peekbyte to skip)
	1761	+ case 95LLU: // copy-back deleter (peekbyte to skip)
1690	1762	{
1691	1763	fprintf(stderr, "in function skip: unrolling stack, copy-back (peekbyte to skip)\n");
1692	1764	// copy mutable arguments back from call to peekbyte
1693		- label = 79LLU; // continue to roll stack
	1765	+ label = 85LLU; // continue to roll stack
1694	1766	break;
1695	1767	}
1696		- case 88LLU: // return from peekbyte to skip
	1768	+ case 96LLU: // return from peekbyte to skip
1697	1769	{
1698	1770	// copy mutable arguments back from call to peekbyte
1699	1771	// copy back results provided by call to peekbyte
1700	1772	stack[base + 3] = stack[base + 7LLU];
1701	1773	// call equ from skip
1702		- stack[base + 4LLU] = 89LLU/throw to this address/;
	1774	+ stack[base + 4LLU] = 97LLU/throw to this address/;
1703	1775	stack[base + 5LLU] = base;
1704		- stack[base + 6LLU] = 90LLU;
	1776	+ stack[base + 6LLU] = 98LLU;
1705	1777	// arguments for call to equ
1706	1778	stack[base + 8LLU] = stack[base + 3]/secondary/;
1707	1779	stack[base + 9LLU] = 47LLU;

		@@ -1710,14 +1782,14 @@
1710	1782	label = 18446744073709551600LLU; // equ
1711	1783	break;
1712	1784	}
1713		- case 89LLU: // copy-back deleter (equ to skip)
	1785	+ case 97LLU: // copy-back deleter (equ to skip)
1714	1786	{
1715	1787	fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
1716	1788	// copy mutable arguments back from call to equ
1717		- label = 79LLU; // continue to roll stack
	1789	+ label = 93LLU; // continue to roll stack
1718	1790	break;
1719	1791	}
1720		- case 90LLU: // return from equ to skip
	1792	+ case 98LLU: // return from equ to skip
1721	1793	{
1722	1794	// copy mutable arguments back from call to equ
1723	1795	// copy back results provided by call to equ

		@@ -1724,15 +1796,15 @@
1724	1796	stack[base + 2] = stack[base + 7LLU];
1725	1797	if(!stack[base + 2]/isequal/)
1726	1798	{
1727		- label = 91LLU; // jump to alternative
	1799	+ label = 99LLU; // jump to alternative
1728	1800	break;
1729	1801	}
1730	1802
1731	1803	// consequent
1732	1804	// call getbyte from skip
1733		- stack[base + 4LLU] = 93LLU/throw to this address/;
	1805	+ stack[base + 4LLU] = 101LLU/throw to this address/;
1734	1806	stack[base + 5LLU] = base;
1735		- stack[base + 6LLU] = 94LLU;
	1807	+ stack[base + 6LLU] = 102LLU;
1736	1808	// arguments for call to getbyte
1737	1809	// set stack-base & callee-address
1738	1810	base += 7LLU;

		@@ -1739,34 +1811,34 @@
1739	1811	label = 18446744073709551593LLU; // getbyte
1740	1812	break;
1741	1813	}
1742		- case 93LLU: // copy-back deleter (getbyte to skip)
	1814	+ case 101LLU: // copy-back deleter (getbyte to skip)
1743	1815	{
1744	1816	fprintf(stderr, "in function skip: unrolling stack, copy-back (getbyte to skip)\n");
1745	1817	// copy mutable arguments back from call to getbyte
1746		- label = 79LLU; // continue to roll stack
	1818	+ label = 93LLU; // continue to roll stack
1747	1819	break;
1748	1820	}
1749		- case 94LLU: // return from getbyte to skip
	1821	+ case 102LLU: // return from getbyte to skip
1750	1822	{
1751	1823	// copy mutable arguments back from call to getbyte
1752	1824	// copy back results provided by call to getbyte
1753	1825	stack[base + 1] = stack[base + 7LLU];
1754		- label = 95LLU; // start to repeat
	1826	+ label = 103LLU; // start to repeat
1755	1827	break;
1756	1828	}
1757		- case 95LLU: // repeat from here
	1829	+ case 103LLU: // repeat from here
1758	1830	{
1759	1831	if(stack[base + 1]/lookahead/ > 0xFF)
1760	1832	{
1761		- label = 96LLU; // break loop
	1833	+ label = 104LLU; // break loop
1762	1834	break;
1763	1835	}
1764	1836
1765	1837	// loop body
1766	1838	// call equ from skip
1767		- stack[base + 4LLU] = 97LLU/throw to this address/;
	1839	+ stack[base + 4LLU] = 105LLU/throw to this address/;
1768	1840	stack[base + 5LLU] = base;
1769		- stack[base + 6LLU] = 98LLU;
	1841	+ stack[base + 6LLU] = 106LLU;
1770	1842	// arguments for call to equ
1771	1843	stack[base + 8LLU] = stack[base + 1]/lookahead/;
1772	1844	stack[base + 9LLU] = 10LLU;

		@@ -1775,14 +1847,14 @@
1775	1847	label = 18446744073709551600LLU; // equ
1776	1848	break;
1777	1849	}
1778		- case 97LLU: // copy-back deleter (equ to skip)
	1850	+ case 105LLU: // copy-back deleter (equ to skip)
1779	1851	{
1780	1852	fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
1781	1853	// copy mutable arguments back from call to equ
1782		- label = 79LLU; // continue to roll stack
	1854	+ label = 93LLU; // continue to roll stack
1783	1855	break;
1784	1856	}
1785		- case 98LLU: // return from equ to skip
	1857	+ case 106LLU: // return from equ to skip
1786	1858	{
1787	1859	// copy mutable arguments back from call to equ
1788	1860	// copy back results provided by call to equ

		@@ -1789,59 +1861,59 @@
1789	1861	stack[base + 2] = stack[base + 7LLU];
1790	1862	if(!stack[base + 2]/isequal/)
1791	1863	{
1792		- label = 99LLU; // jump to alternative
	1864	+ label = 107LLU; // jump to alternative
1793	1865	break;
1794	1866	}
1795	1867
1796	1868	// consequent
1797	1869	// call EOSbyte from skip
1798		- stack[base + 4LLU] = 101LLU/throw to this address/;
	1870	+ stack[base + 4LLU] = 109LLU/throw to this address/;
1799	1871	stack[base + 5LLU] = base;
1800		- stack[base + 6LLU] = 102LLU;
	1872	+ stack[base + 6LLU] = 110LLU;
1801	1873	// arguments for call to EOSbyte
1802	1874	// set stack-base & callee-address
1803	1875	base += 7LLU;
1804		- label = 71LLU; // EOSbyte
	1876	+ label = 77LLU; // EOSbyte
1805	1877	break;
1806	1878	}
1807		- case 101LLU: // copy-back deleter (EOSbyte to skip)
	1879	+ case 109LLU: // copy-back deleter (EOSbyte to skip)
1808	1880	{
1809	1881	fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
1810	1882	// copy mutable arguments back from call to EOSbyte
1811		- label = 79LLU; // continue to roll stack
	1883	+ label = 93LLU; // continue to roll stack
1812	1884	break;
1813	1885	}
1814		- case 102LLU: // return from EOSbyte to skip
	1886	+ case 110LLU: // return from EOSbyte to skip
1815	1887	{
1816	1888	// copy mutable arguments back from call to EOSbyte
1817	1889	// copy back results provided by call to EOSbyte
1818	1890	stack[base + 1] = stack[base + 7LLU];
1819		- label = 100LLU; // consequent complete
	1891	+ label = 108LLU; // consequent complete
1820	1892	break;
1821	1893	}
1822		- case 99LLU: // alternative
	1894	+ case 107LLU: // alternative
1823	1895	{
1824		- label = 100LLU; // alternative complete
	1896	+ label = 108LLU; // alternative complete
1825	1897	break;
1826	1898	}
1827		- case 100LLU: // completed if-then-else
	1899	+ case 108LLU: // completed if-then-else
1828	1900	{
1829	1901	if(stack[base + 1]/lookahead/ <= 0xFF) stack[base + 1]/lookahead/ = getchar();
1830		- label = 95LLU; // repeat
	1902	+ label = 103LLU; // repeat
1831	1903	break;
1832	1904	}
1833		- case 96LLU: // loop finished
	1905	+ case 104LLU: // loop finished
1834	1906	{
1835	1907	stack[base + 1]/lookahead/ = 0;
1836		- label = 92LLU; // consequent complete
	1908	+ label = 100LLU; // consequent complete
1837	1909	break;
1838	1910	}
1839		- case 91LLU: // alternative
	1911	+ case 99LLU: // alternative
1840	1912	{
1841	1913	// call equ from skip
1842		- stack[base + 4LLU] = 103LLU/throw to this address/;
	1914	+ stack[base + 4LLU] = 111LLU/throw to this address/;
1843	1915	stack[base + 5LLU] = base;
1844		- stack[base + 6LLU] = 104LLU;
	1916	+ stack[base + 6LLU] = 112LLU;
1845	1917	// arguments for call to equ
1846	1918	stack[base + 8LLU] = stack[base + 3]/secondary/;
1847	1919	stack[base + 9LLU] = 42LLU;

		@@ -1850,14 +1922,14 @@
1850	1922	label = 18446744073709551600LLU; // equ
1851	1923	break;
1852	1924	}
1853		- case 103LLU: // copy-back deleter (equ to skip)
	1925	+ case 111LLU: // copy-back deleter (equ to skip)
1854	1926	{
1855	1927	fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
1856	1928	// copy mutable arguments back from call to equ
1857		- label = 79LLU; // continue to roll stack
	1929	+ label = 93LLU; // continue to roll stack
1858	1930	break;
1859	1931	}
1860		- case 104LLU: // return from equ to skip
	1932	+ case 112LLU: // return from equ to skip
1861	1933	{
1862	1934	// copy mutable arguments back from call to equ
1863	1935	// copy back results provided by call to equ

		@@ -1864,15 +1936,15 @@
1864	1936	stack[base + 2] = stack[base + 7LLU];
1865	1937	if(!stack[base + 2]/isequal/)
1866	1938	{
1867		- label = 105LLU; // jump to alternative
	1939	+ label = 113LLU; // jump to alternative
1868	1940	break;
1869	1941	}
1870	1942
1871	1943	// consequent
1872	1944	// call getbyte from skip
1873		- stack[base + 4LLU] = 107LLU/throw to this address/;
	1945	+ stack[base + 4LLU] = 115LLU/throw to this address/;
1874	1946	stack[base + 5LLU] = base;
1875		- stack[base + 6LLU] = 108LLU;
	1947	+ stack[base + 6LLU] = 116LLU;
1876	1948	// arguments for call to getbyte
1877	1949	// set stack-base & callee-address
1878	1950	base += 7LLU;

		@@ -1879,34 +1951,34 @@
1879	1951	label = 18446744073709551593LLU; // getbyte
1880	1952	break;
1881	1953	}
1882		- case 107LLU: // copy-back deleter (getbyte to skip)
	1954	+ case 115LLU: // copy-back deleter (getbyte to skip)
1883	1955	{
1884	1956	fprintf(stderr, "in function skip: unrolling stack, copy-back (getbyte to skip)\n");
1885	1957	// copy mutable arguments back from call to getbyte
1886		- label = 79LLU; // continue to roll stack
	1958	+ label = 93LLU; // continue to roll stack
1887	1959	break;
1888	1960	}
1889		- case 108LLU: // return from getbyte to skip
	1961	+ case 116LLU: // return from getbyte to skip
1890	1962	{
1891	1963	// copy mutable arguments back from call to getbyte
1892	1964	// copy back results provided by call to getbyte
1893	1965	stack[base + 1] = stack[base + 7LLU];
1894		- label = 109LLU; // start to repeat
	1966	+ label = 117LLU; // start to repeat
1895	1967	break;
1896	1968	}
1897		- case 109LLU: // repeat from here
	1969	+ case 117LLU: // repeat from here
1898	1970	{
1899	1971	if(stack[base + 1]/lookahead/ > 0xFF)
1900	1972	{
1901		- label = 110LLU; // break loop
	1973	+ label = 118LLU; // break loop
1902	1974	break;
1903	1975	}
1904	1976
1905	1977	// loop body
1906	1978	// call equ from skip
1907		- stack[base + 4LLU] = 111LLU/throw to this address/;
	1979	+ stack[base + 4LLU] = 119LLU/throw to this address/;
1908	1980	stack[base + 5LLU] = base;
1909		- stack[base + 6LLU] = 112LLU;
	1981	+ stack[base + 6LLU] = 120LLU;
1910	1982	// arguments for call to equ
1911	1983	stack[base + 8LLU] = stack[base + 1]/lookahead/;
1912	1984	stack[base + 9LLU] = 42LLU;

		@@ -1915,14 +1987,14 @@
1915	1987	label = 18446744073709551600LLU; // equ
1916	1988	break;
1917	1989	}
1918		- case 111LLU: // copy-back deleter (equ to skip)
	1990	+ case 119LLU: // copy-back deleter (equ to skip)
1919	1991	{
1920	1992	fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
1921	1993	// copy mutable arguments back from call to equ
1922		- label = 79LLU; // continue to roll stack
	1994	+ label = 93LLU; // continue to roll stack
1923	1995	break;
1924	1996	}
1925		- case 112LLU: // return from equ to skip
	1997	+ case 120LLU: // return from equ to skip
1926	1998	{
1927	1999	// copy mutable arguments back from call to equ
1928	2000	// copy back results provided by call to equ

		@@ -1929,15 +2001,15 @@
1929	2001	stack[base + 2] = stack[base + 7LLU];
1930	2002	if(!stack[base + 2]/isequal/)
1931	2003	{
1932		- label = 113LLU; // jump to alternative
	2004	+ label = 121LLU; // jump to alternative
1933	2005	break;
1934	2006	}
1935	2007
1936	2008	// consequent
1937	2009	// call peekbyte from skip
1938		- stack[base + 4LLU] = 115LLU/throw to this address/;
	2010	+ stack[base + 4LLU] = 123LLU/throw to this address/;
1939	2011	stack[base + 5LLU] = base;
1940		- stack[base + 6LLU] = 116LLU;
	2012	+ stack[base + 6LLU] = 124LLU;
1941	2013	// arguments for call to peekbyte
1942	2014	// set stack-base & callee-address
1943	2015	base += 7LLU;

		@@ -1944,22 +2016,22 @@
1944	2016	label = 18446744073709551594LLU; // peekbyte
1945	2017	break;
1946	2018	}
1947		- case 115LLU: // copy-back deleter (peekbyte to skip)
	2019	+ case 123LLU: // copy-back deleter (peekbyte to skip)
1948	2020	{
1949	2021	fprintf(stderr, "in function skip: unrolling stack, copy-back (peekbyte to skip)\n");
1950	2022	// copy mutable arguments back from call to peekbyte
1951		- label = 79LLU; // continue to roll stack
	2023	+ label = 93LLU; // continue to roll stack
1952	2024	break;
1953	2025	}
1954		- case 116LLU: // return from peekbyte to skip
	2026	+ case 124LLU: // return from peekbyte to skip
1955	2027	{
1956	2028	// copy mutable arguments back from call to peekbyte
1957	2029	// copy back results provided by call to peekbyte
1958	2030	stack[base + 3] = stack[base + 7LLU];
1959	2031	// call equ from skip
1960		- stack[base + 4LLU] = 117LLU/throw to this address/;
	2032	+ stack[base + 4LLU] = 125LLU/throw to this address/;
1961	2033	stack[base + 5LLU] = base;
1962		- stack[base + 6LLU] = 118LLU;
	2034	+ stack[base + 6LLU] = 126LLU;
1963	2035	// arguments for call to equ
1964	2036	stack[base + 8LLU] = stack[base + 3]/secondary/;
1965	2037	stack[base + 9LLU] = 47LLU;

		@@ -1968,14 +2040,14 @@
1968	2040	label = 18446744073709551600LLU; // equ
1969	2041	break;
1970	2042	}
1971		- case 117LLU: // copy-back deleter (equ to skip)
	2043	+ case 125LLU: // copy-back deleter (equ to skip)
1972	2044	{
1973	2045	fprintf(stderr, "in function skip: unrolling stack, copy-back (equ to skip)\n");
1974	2046	// copy mutable arguments back from call to equ
1975		- label = 79LLU; // continue to roll stack
	2047	+ label = 93LLU; // continue to roll stack
1976	2048	break;
1977	2049	}
1978		- case 118LLU: // return from equ to skip
	2050	+ case 126LLU: // return from equ to skip
1979	2051	{
1980	2052	// copy mutable arguments back from call to equ
1981	2053	// copy back results provided by call to equ

		@@ -1982,15 +2054,15 @@
1982	2054	stack[base + 2] = stack[base + 7LLU];
1983	2055	if(!stack[base + 2]/isequal/)
1984	2056	{
1985		- label = 119LLU; // jump to alternative
	2057	+ label = 127LLU; // jump to alternative
1986	2058	break;
1987	2059	}
1988	2060
1989	2061	// consequent
1990	2062	// call getbyte from skip
1991		- stack[base + 4LLU] = 121LLU/throw to this address/;
	2063	+ stack[base + 4LLU] = 129LLU/throw to this address/;
1992	2064	stack[base + 5LLU] = base;
1993		- stack[base + 6LLU] = 122LLU;
	2065	+ stack[base + 6LLU] = 130LLU;
1994	2066	// arguments for call to getbyte
1995	2067	// set stack-base & callee-address
1996	2068	base += 7LLU;

		@@ -1997,129 +2069,129 @@
1997	2069	label = 18446744073709551593LLU; // getbyte
1998	2070	break;
1999	2071	}
2000		- case 121LLU: // copy-back deleter (getbyte to skip)
	2072	+ case 129LLU: // copy-back deleter (getbyte to skip)
2001	2073	{
2002	2074	fprintf(stderr, "in function skip: unrolling stack, copy-back (getbyte to skip)\n");
2003	2075	// copy mutable arguments back from call to getbyte
2004		- label = 79LLU; // continue to roll stack
	2076	+ label = 93LLU; // continue to roll stack
2005	2077	break;
2006	2078	}
2007		- case 122LLU: // return from getbyte to skip
	2079	+ case 130LLU: // return from getbyte to skip
2008	2080	{
2009	2081	// copy mutable arguments back from call to getbyte
2010	2082	// copy back results provided by call to getbyte
2011	2083	stack[base + 1] = stack[base + 7LLU];
2012	2084	// call EOSbyte from skip
2013		- stack[base + 4LLU] = 123LLU/throw to this address/;
	2085	+ stack[base + 4LLU] = 131LLU/throw to this address/;
2014	2086	stack[base + 5LLU] = base;
2015		- stack[base + 6LLU] = 124LLU;
	2087	+ stack[base + 6LLU] = 132LLU;
2016	2088	// arguments for call to EOSbyte
2017	2089	// set stack-base & callee-address
2018	2090	base += 7LLU;
2019		- label = 71LLU; // EOSbyte
	2091	+ label = 77LLU; // EOSbyte
2020	2092	break;
2021	2093	}
2022		- case 123LLU: // copy-back deleter (EOSbyte to skip)
	2094	+ case 131LLU: // copy-back deleter (EOSbyte to skip)
2023	2095	{
2024	2096	fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
2025	2097	// copy mutable arguments back from call to EOSbyte
2026		- label = 79LLU; // continue to roll stack
	2098	+ label = 93LLU; // continue to roll stack
2027	2099	break;
2028	2100	}
2029		- case 124LLU: // return from EOSbyte to skip
	2101	+ case 132LLU: // return from EOSbyte to skip
2030	2102	{
2031	2103	// copy mutable arguments back from call to EOSbyte
2032	2104	// copy back results provided by call to EOSbyte
2033	2105	stack[base + 1] = stack[base + 7LLU];
2034		- label = 120LLU; // consequent complete
	2106	+ label = 128LLU; // consequent complete
2035	2107	break;
2036	2108	}
2037		- case 119LLU: // alternative
	2109	+ case 127LLU: // alternative
2038	2110	{
2039		- label = 120LLU; // alternative complete
	2111	+ label = 128LLU; // alternative complete
2040	2112	break;
2041	2113	}
2042		- case 120LLU: // completed if-then-else
	2114	+ case 128LLU: // completed if-then-else
2043	2115	{
2044		- label = 114LLU; // consequent complete
	2116	+ label = 122LLU; // consequent complete
2045	2117	break;
2046	2118	}
2047		- case 113LLU: // alternative
	2119	+ case 121LLU: // alternative
2048	2120	{
2049		- label = 114LLU; // alternative complete
	2121	+ label = 122LLU; // alternative complete
2050	2122	break;
2051	2123	}
2052		- case 114LLU: // completed if-then-else
	2124	+ case 122LLU: // completed if-then-else
2053	2125	{
2054	2126	if(stack[base + 1]/lookahead/ <= 0xFF) stack[base + 1]/lookahead/ = getchar();
2055		- label = 109LLU; // repeat
	2127	+ label = 117LLU; // repeat
2056	2128	break;
2057	2129	}
2058		- case 110LLU: // loop finished
	2130	+ case 118LLU: // loop finished
2059	2131	{
2060	2132	stack[base + 1]/lookahead/ = 0;
2061		- label = 106LLU; // consequent complete
	2133	+ label = 114LLU; // consequent complete
2062	2134	break;
2063	2135	}
2064		- case 105LLU: // alternative
	2136	+ case 113LLU: // alternative
2065	2137	{
2066	2138	stack[base + 0]/LOOKAHEAD/ = stack[base + 1]/lookahead/;
2067	2139	// call EOSbyte from skip
2068		- stack[base + 4LLU] = 125LLU/throw to this address/;
	2140	+ stack[base + 4LLU] = 133LLU/throw to this address/;
2069	2141	stack[base + 5LLU] = base;
2070		- stack[base + 6LLU] = 126LLU;
	2142	+ stack[base + 6LLU] = 134LLU;
2071	2143	// arguments for call to EOSbyte
2072	2144	// set stack-base & callee-address
2073	2145	base += 7LLU;
2074		- label = 71LLU; // EOSbyte
	2146	+ label = 77LLU; // EOSbyte
2075	2147	break;
2076	2148	}
2077		- case 125LLU: // copy-back deleter (EOSbyte to skip)
	2149	+ case 133LLU: // copy-back deleter (EOSbyte to skip)
2078	2150	{
2079	2151	fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
2080	2152	// copy mutable arguments back from call to EOSbyte
2081		- label = 79LLU; // continue to roll stack
	2153	+ label = 93LLU; // continue to roll stack
2082	2154	break;
2083	2155	}
2084		- case 126LLU: // return from EOSbyte to skip
	2156	+ case 134LLU: // return from EOSbyte to skip
2085	2157	{
2086	2158	// copy mutable arguments back from call to EOSbyte
2087	2159	// copy back results provided by call to EOSbyte
2088	2160	stack[base + 1] = stack[base + 7LLU];
2089		- label = 106LLU; // alternative complete
	2161	+ label = 114LLU; // alternative complete
2090	2162	break;
2091	2163	}
2092		- case 106LLU: // completed if-then-else
	2164	+ case 114LLU: // completed if-then-else
2093	2165	{
2094		- label = 92LLU; // alternative complete
	2166	+ label = 100LLU; // alternative complete
2095	2167	break;
2096	2168	}
2097		- case 92LLU: // completed if-then-else
	2169	+ case 100LLU: // completed if-then-else
2098	2170	{
2099		- label = 86LLU; // consequent complete
	2171	+ label = 92LLU; // consequent complete
2100	2172	break;
2101	2173	}
2102		- case 85LLU: // alternative
	2174	+ case 91LLU: // alternative
2103	2175	{
2104	2176	// call isspace from skip
2105		- stack[base + 3LLU] = 127LLU/throw to this address/;
	2177	+ stack[base + 3LLU] = 135LLU/throw to this address/;
2106	2178	stack[base + 4LLU] = base;
2107		- stack[base + 5LLU] = 128LLU;
	2179	+ stack[base + 5LLU] = 136LLU;
2108	2180	// arguments for call to isspace
2109	2181	stack[base + 7LLU] = stack[base + 1]/lookahead/;
2110	2182	// set stack-base & callee-address
2111	2183	base += 6LLU;
2112		- label = 47LLU; // isspace
	2184	+ label = 53LLU; // isspace
2113	2185	break;
2114	2186	}
2115		- case 127LLU: // copy-back deleter (isspace to skip)
	2187	+ case 135LLU: // copy-back deleter (isspace to skip)
2116	2188	{
2117	2189	fprintf(stderr, "in function skip: unrolling stack, copy-back (isspace to skip)\n");
2118	2190	// copy mutable arguments back from call to isspace
2119		- label = 79LLU; // continue to roll stack
	2191	+ label = 85LLU; // continue to roll stack
2120	2192	break;
2121	2193	}
2122		- case 128LLU: // return from isspace to skip
	2194	+ case 136LLU: // return from isspace to skip
2123	2195	{
2124	2196	// copy mutable arguments back from call to isspace
2125	2197	// copy back results provided by call to isspace

		@@ -2126,54 +2198,54 @@
2126	2198	stack[base + 2] = stack[base + 6LLU];
2127	2199	if(!stack[base + 2]/isequal/)
2128	2200	{
2129		- label = 129LLU; // jump to alternative
	2201	+ label = 137LLU; // jump to alternative
2130	2202	break;
2131	2203	}
2132	2204
2133	2205	// consequent
2134		- label = 130LLU; // consequent complete
	2206	+ label = 138LLU; // consequent complete
2135	2207	break;
2136	2208	}
2137		- case 129LLU: // alternative
	2209	+ case 137LLU: // alternative
2138	2210	{
2139	2211	stack[base + 0]/LOOKAHEAD/ = stack[base + 1]/lookahead/;
2140	2212	// call EOSbyte from skip
2141		- stack[base + 3LLU] = 131LLU/throw to this address/;
	2213	+ stack[base + 3LLU] = 139LLU/throw to this address/;
2142	2214	stack[base + 4LLU] = base;
2143		- stack[base + 5LLU] = 132LLU;
	2215	+ stack[base + 5LLU] = 140LLU;
2144	2216	// arguments for call to EOSbyte
2145	2217	// set stack-base & callee-address
2146	2218	base += 6LLU;
2147		- label = 71LLU; // EOSbyte
	2219	+ label = 77LLU; // EOSbyte
2148	2220	break;
2149	2221	}
2150		- case 131LLU: // copy-back deleter (EOSbyte to skip)
	2222	+ case 139LLU: // copy-back deleter (EOSbyte to skip)
2151	2223	{
2152	2224	fprintf(stderr, "in function skip: unrolling stack, copy-back (EOSbyte to skip)\n");
2153	2225	// copy mutable arguments back from call to EOSbyte
2154		- label = 79LLU; // continue to roll stack
	2226	+ label = 85LLU; // continue to roll stack
2155	2227	break;
2156	2228	}
2157		- case 132LLU: // return from EOSbyte to skip
	2229	+ case 140LLU: // return from EOSbyte to skip
2158	2230	{
2159	2231	// copy mutable arguments back from call to EOSbyte
2160	2232	// copy back results provided by call to EOSbyte
2161	2233	stack[base + 1] = stack[base + 6LLU];
2162		- label = 130LLU; // alternative complete
	2234	+ label = 138LLU; // alternative complete
2163	2235	break;
2164	2236	}
2165		- case 130LLU: // completed if-then-else
	2237	+ case 138LLU: // completed if-then-else
2166	2238	{
2167		- label = 86LLU; // alternative complete
	2239	+ label = 92LLU; // alternative complete
2168	2240	break;
2169	2241	}
2170		- case 86LLU: // completed if-then-else
	2242	+ case 92LLU: // completed if-then-else
2171	2243	{
2172	2244	if(stack[base + 1]/lookahead/ <= 0xFF) stack[base + 1]/lookahead/ = getchar();
2173		- label = 81LLU; // repeat
	2245	+ label = 87LLU; // repeat
2174	2246	break;
2175	2247	}
2176		- case 82LLU: // loop finished
	2248	+ case 88LLU: // loop finished
2177	2249	{
2178	2250	// return from skip
2179	2251	label = stack[base - 1];

		@@ -2180,7 +2252,7 @@
2180	2252	base = stack[base - 2];
2181	2253	break;
2182	2254	}
2183		- case 134LLU: // function deloffset failed
	2255	+ case 142LLU: // function deloffset failed
2184	2256	{
2185	2257	fprintf(stderr, "function deloffset failed\n");
2186	2258	label = stack[base - 3];

		@@ -2187,7 +2259,7 @@
2187	2259	base = stack[base - 2];
2188	2260	break;
2189	2261	}
2190		- case 133LLU: // deloffset
	2262	+ case 141LLU: // deloffset
2191	2263	{
2192	2264	printf("%s", "4");
2193	2265	// return from deloffset

		@@ -2195,7 +2267,7 @@
2195	2267	base = stack[base - 2];
2196	2268	break;
2197	2269	}
2198		- case 136LLU: // function emitinit failed
	2270	+ case 144LLU: // function emitinit failed
2199	2271	{
2200	2272	fprintf(stderr, "function emitinit failed\n");
2201	2273	label = stack[base - 3];

		@@ -2202,7 +2274,7 @@
2202	2274	base = stack[base - 2];
2203	2275	break;
2204	2276	}
2205		- case 135LLU: // emitinit
	2277	+ case 143LLU: // emitinit
2206	2278	{
2207	2279	printf("%s", "\n#include <ctype.h>");
2208	2280	printf("%s", "\n#include <inttypes.h>");

		@@ -2452,23 +2524,23 @@
2452	2524	printf("%s", "\n{");
2453	2525	printf("%s", "\n uint64_t memory = (uint64_t)Calloc(2 + ");
2454	2526	// call deloffset from emitinit
2455		- stack[base + 0LLU] = 137LLU/throw to this address/;
	2527	+ stack[base + 0LLU] = 145LLU/throw to this address/;
2456	2528	stack[base + 1LLU] = base;
2457		- stack[base + 2LLU] = 138LLU;
	2529	+ stack[base + 2LLU] = 146LLU;
2458	2530	// arguments for call to deloffset
2459	2531	// set stack-base & callee-address
2460	2532	base += 3LLU;
2461		- label = 133LLU; // deloffset
	2533	+ label = 141LLU; // deloffset
2462	2534	break;
2463	2535	}
2464		- case 137LLU: // copy-back deleter (deloffset to emitinit)
	2536	+ case 145LLU: // copy-back deleter (deloffset to emitinit)
2465	2537	{
2466	2538	fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
2467	2539	// copy mutable arguments back from call to deloffset
2468		- label = 136LLU; // continue to roll stack
	2540	+ label = 144LLU; // continue to roll stack
2469	2541	break;
2470	2542	}
2471		- case 138LLU: // return from deloffset to emitinit
	2543	+ case 146LLU: // return from deloffset to emitinit
2472	2544	{
2473	2545	// copy mutable arguments back from call to deloffset
2474	2546	printf("%s", ", sizeof(uint64_t));");

		@@ -2475,23 +2547,23 @@
2475	2547	printf("%s", "\n if(!memory) return 0;");
2476	2548	printf("%s", "\n if(!(((uint64_t *)memory)[1 + ");
2477	2549	// call deloffset from emitinit
2478		- stack[base + 0LLU] = 139LLU/throw to this address/;
	2550	+ stack[base + 0LLU] = 147LLU/throw to this address/;
2479	2551	stack[base + 1LLU] = base;
2480		- stack[base + 2LLU] = 140LLU;
	2552	+ stack[base + 2LLU] = 148LLU;
2481	2553	// arguments for call to deloffset
2482	2554	// set stack-base & callee-address
2483	2555	base += 3LLU;
2484		- label = 133LLU; // deloffset
	2556	+ label = 141LLU; // deloffset
2485	2557	break;
2486	2558	}
2487		- case 139LLU: // copy-back deleter (deloffset to emitinit)
	2559	+ case 147LLU: // copy-back deleter (deloffset to emitinit)
2488	2560	{
2489	2561	fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
2490	2562	// copy mutable arguments back from call to deloffset
2491		- label = 136LLU; // continue to roll stack
	2563	+ label = 144LLU; // continue to roll stack
2492	2564	break;
2493	2565	}
2494		- case 140LLU: // return from deloffset to emitinit
	2566	+ case 148LLU: // return from deloffset to emitinit
2495	2567	{
2496	2568	// copy mutable arguments back from call to deloffset
2497	2569	printf("%s", "] = (uint64_t)Calloc(varsize, sizeof(uint64_t))))");

		@@ -2498,23 +2570,23 @@
2498	2570	printf("%s", "\n {");
2499	2571	printf("%s", "\n Free(2 + ");
2500	2572	// call deloffset from emitinit
2501		- stack[base + 0LLU] = 141LLU/throw to this address/;
	2573	+ stack[base + 0LLU] = 149LLU/throw to this address/;
2502	2574	stack[base + 1LLU] = base;
2503		- stack[base + 2LLU] = 142LLU;
	2575	+ stack[base + 2LLU] = 150LLU;
2504	2576	// arguments for call to deloffset
2505	2577	// set stack-base & callee-address
2506	2578	base += 3LLU;
2507		- label = 133LLU; // deloffset
	2579	+ label = 141LLU; // deloffset
2508	2580	break;
2509	2581	}
2510		- case 141LLU: // copy-back deleter (deloffset to emitinit)
	2582	+ case 149LLU: // copy-back deleter (deloffset to emitinit)
2511	2583	{
2512	2584	fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
2513	2585	// copy mutable arguments back from call to deloffset
2514		- label = 136LLU; // continue to roll stack
	2586	+ label = 144LLU; // continue to roll stack
2515	2587	break;
2516	2588	}
2517		- case 142LLU: // return from deloffset to emitinit
	2589	+ case 150LLU: // return from deloffset to emitinit
2518	2590	{
2519	2591	// copy mutable arguments back from call to deloffset
2520	2592	printf("%s", ", sizeof(uint64_t), (void *)memory);");

		@@ -2522,23 +2594,23 @@
2522	2594	printf("%s", "\n }");
2523	2595	printf("%s", "\n return memory + sizeof(uint64_t) * ");
2524	2596	// call deloffset from emitinit
2525		- stack[base + 0LLU] = 143LLU/throw to this address/;
	2597	+ stack[base + 0LLU] = 151LLU/throw to this address/;
2526	2598	stack[base + 1LLU] = base;
2527		- stack[base + 2LLU] = 144LLU;
	2599	+ stack[base + 2LLU] = 152LLU;
2528	2600	// arguments for call to deloffset
2529	2601	// set stack-base & callee-address
2530	2602	base += 3LLU;
2531		- label = 133LLU; // deloffset
	2603	+ label = 141LLU; // deloffset
2532	2604	break;
2533	2605	}
2534		- case 143LLU: // copy-back deleter (deloffset to emitinit)
	2606	+ case 151LLU: // copy-back deleter (deloffset to emitinit)
2535	2607	{
2536	2608	fprintf(stderr, "in function emitinit: unrolling stack, copy-back (deloffset to emitinit)\n");
2537	2609	// copy mutable arguments back from call to deloffset
2538		- label = 136LLU; // continue to roll stack
	2610	+ label = 144LLU; // continue to roll stack
2539	2611	break;
2540	2612	}
2541		- case 144LLU: // return from deloffset to emitinit
	2613	+ case 152LLU: // return from deloffset to emitinit
2542	2614	{
2543	2615	// copy mutable arguments back from call to deloffset
2544	2616	printf("%s", ";");

		@@ -2563,7 +2635,7 @@
2563	2635	base = stack[base - 2];
2564	2636	break;
2565	2637	}
2566		- case 146LLU: // function existsid failed
	2638	+ case 154LLU: // function existsid failed
2567	2639	{
2568	2640	fprintf(stderr, "function existsid failed\n");
2569	2641	label = stack[base - 3];

		@@ -2570,39 +2642,39 @@
2570	2642	base = stack[base - 2];
2571	2643	break;
2572	2644	}
2573		- case 145LLU: // existsid
	2645	+ case 153LLU: // existsid
2574	2646	{
2575	2647	//#define res0 0
2576	2648	//#define arg0 1
2577	2649	//#define arg1 2
2578		- label = 148LLU; // skip deleter
	2650	+ label = 156LLU; // skip deleter
2579	2651	break;
2580	2652	}
2581		- case 147LLU: // deleter
	2653	+ case 155LLU: // deleter
2582	2654	{
2583	2655	// throw from existsid
2584	2656	if(!stack[base + 3])
2585	2657	{
2586	2658	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
2588	2660	break;
2589	2661	}
2590	2662	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
2592	2664	break;
2593	2665	}
2594		- case 148LLU: // skipped deleter
	2666	+ case 156LLU: // skipped deleter
2595	2667	{
2596	2668	stack[base + 3] = 0;
2597	2669	flippedassign(stack[base + 1]/ids/, &stack[base + 4]);
2598		- label = 149LLU; // start to repeat
	2670	+ label = 157LLU; // start to repeat
2599	2671	break;
2600	2672	}
2601		- case 149LLU: // repeat from here
	2673	+ case 157LLU: // repeat from here
2602	2674	{
2603	2675	if(!stack[base + 4])
2604	2676	{
2605		- label = 150LLU; // break loop
	2677	+ label = 158LLU; // break loop
2606	2678	break;
2607	2679	}
2608	2680

		@@ -2612,20 +2684,20 @@
2612	2684	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
2613	2685	if(!stack[base + 3]/found/)
2614	2686	{
2615		- label = 152LLU; // jump to alternative
	2687	+ label = 160LLU; // jump to alternative
2616	2688	break;
2617	2689	}
2618	2690
2619	2691	// consequent
2620		- label = 153LLU; // consequent complete
	2692	+ label = 161LLU; // consequent complete
2621	2693	break;
2622	2694	}
2623		- case 152LLU: // alternative
	2695	+ case 160LLU: // alternative
2624	2696	{
2625	2697	// call equ from existsid
2626		- stack[base + 7LLU] = 154LLU/throw to this address/;
	2698	+ stack[base + 7LLU] = 162LLU/throw to this address/;
2627	2699	stack[base + 8LLU] = base;
2628		- stack[base + 9LLU] = 155LLU;
	2700	+ stack[base + 9LLU] = 163LLU;
2629	2701	// arguments for call to equ
2630	2702	stack[base + 11LLU] = stack[base + 5]/current/;
2631	2703	stack[base + 12LLU] = stack[base + 2]/wanted/;

		@@ -2634,52 +2706,52 @@
2634	2706	label = 18446744073709551600LLU; // equ
2635	2707	break;
2636	2708	}
2637		- case 154LLU: // copy-back deleter (equ to existsid)
	2709	+ case 162LLU: // copy-back deleter (equ to existsid)
2638	2710	{
2639	2711	fprintf(stderr, "in function existsid: unrolling stack, copy-back (equ to existsid)\n");
2640	2712	// copy mutable arguments back from call to equ
2641		- label = 151LLU; // continue to roll stack
	2713	+ label = 159LLU; // continue to roll stack
2642	2714	break;
2643	2715	}
2644		- case 155LLU: // return from equ to existsid
	2716	+ case 163LLU: // return from equ to existsid
2645	2717	{
2646	2718	// copy mutable arguments back from call to equ
2647	2719	// copy back results provided by call to equ
2648	2720	stack[base + 3] = stack[base + 10LLU];
2649		- label = 153LLU; // alternative complete
	2721	+ label = 161LLU; // alternative complete
2650	2722	break;
2651	2723	}
2652		- case 153LLU: // completed if-then-else
	2724	+ case 161LLU: // completed if-then-else
2653	2725	{
2654	2726	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
2655		- label = 149LLU; // repeat
	2727	+ label = 157LLU; // repeat
2656	2728	break;
2657	2729	}
2658		- case 151LLU: // copy-back deleter for while next
	2730	+ case 159LLU: // copy-back deleter for while next
2659	2731	{
2660	2732	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
2661		- label = 147LLU; // continue to unroll stack
	2733	+ label = 155LLU; // continue to unroll stack
2662	2734	break;
2663	2735	}
2664		- case 150LLU: // loop finished
	2736	+ case 158LLU: // loop finished
2665	2737	{
2666		- label = 157LLU; // skip deleter
	2738	+ label = 165LLU; // skip deleter
2667	2739	break;
2668	2740	}
2669		- case 156LLU: // deleter
	2741	+ case 164LLU: // deleter
2670	2742	{
2671	2743	// throw from existsid
2672	2744	if(!stack[base + 0])
2673	2745	{
2674	2746	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
2676	2748	break;
2677	2749	}
2678	2750	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
2680	2752	break;
2681	2753	}
2682		- case 157LLU: // skipped deleter
	2754	+ case 165LLU: // skipped deleter
2683	2755	{
2684	2756	stack[base + 0] = stack[base + 3]/found/;
2685	2757	// return from existsid

		@@ -2687,7 +2759,7 @@
2687	2759	base = stack[base - 2];
2688	2760	break;
2689	2761	}
2690		- case 159LLU: // function issimple failed
	2762	+ case 167LLU: // function issimple failed
2691	2763	{
2692	2764	fprintf(stderr, "function issimple failed\n");
2693	2765	label = stack[base - 3];

		@@ -2694,35 +2766,35 @@
2694	2766	base = stack[base - 2];
2695	2767	break;
2696	2768	}
2697		- case 158LLU: // issimple
	2769	+ case 166LLU: // issimple
2698	2770	{
2699	2771	//#define res0 0
2700	2772	//#define arg0 1
2701	2773	//#define arg1 2
2702	2774	//#define arg2 3
2703		- label = 161LLU; // skip deleter
	2775	+ label = 169LLU; // skip deleter
2704	2776	break;
2705	2777	}
2706		- case 160LLU: // deleter
	2778	+ case 168LLU: // deleter
2707	2779	{
2708	2780	// throw from issimple
2709	2781	if(!stack[base + 4])
2710	2782	{
2711	2783	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
2713	2785	break;
2714	2786	}
2715	2787	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
2717	2789	break;
2718	2790	}
2719		- case 161LLU: // skipped deleter
	2791	+ case 169LLU: // skipped deleter
2720	2792	{
2721	2793	stack[base + 4] = 0;
2722	2794	// call equ from issimple
2723		- stack[base + 5LLU] = 162LLU/throw to this address/;
	2795	+ stack[base + 5LLU] = 170LLU/throw to this address/;
2724	2796	stack[base + 6LLU] = base;
2725		- stack[base + 7LLU] = 163LLU;
	2797	+ stack[base + 7LLU] = 171LLU;
2726	2798	// arguments for call to equ
2727	2799	stack[base + 9LLU] = stack[base + 1]/variant/;
2728	2800	stack[base + 10LLU] = 0LLU;

		@@ -2731,14 +2803,14 @@
2731	2803	label = 18446744073709551600LLU; // equ
2732	2804	break;
2733	2805	}
2734		- case 162LLU: // copy-back deleter (equ to issimple)
	2806	+ case 170LLU: // copy-back deleter (equ to issimple)
2735	2807	{
2736	2808	fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
2737	2809	// copy mutable arguments back from call to equ
2738		- label = 160LLU; // continue to roll stack
	2810	+ label = 168LLU; // continue to roll stack
2739	2811	break;
2740	2812	}
2741		- case 163LLU: // return from equ to issimple
	2813	+ case 171LLU: // return from equ to issimple
2742	2814	{
2743	2815	// copy mutable arguments back from call to equ
2744	2816	// copy back results provided by call to equ

		@@ -2745,15 +2817,15 @@
2745	2817	stack[base + 4] = stack[base + 8LLU];
2746	2818	if(!stack[base + 4]/isequal/)
2747	2819	{
2748		- label = 164LLU; // jump to alternative
	2820	+ label = 172LLU; // jump to alternative
2749	2821	break;
2750	2822	}
2751	2823
2752	2824	// consequent
2753	2825	// call equ from issimple
2754		- stack[base + 5LLU] = 166LLU/throw to this address/;
	2826	+ stack[base + 5LLU] = 174LLU/throw to this address/;
2755	2827	stack[base + 6LLU] = base;
2756		- stack[base + 7LLU] = 167LLU;
	2828	+ stack[base + 7LLU] = 175LLU;
2757	2829	// arguments for call to equ
2758	2830	stack[base + 9LLU] = stack[base + 3]/sym/;
2759	2831	stack[base + 10LLU] = stack[base + 2]/content/;

		@@ -2762,14 +2834,14 @@
2762	2834	label = 18446744073709551600LLU; // equ
2763	2835	break;
2764	2836	}
2765		- case 166LLU: // copy-back deleter (equ to issimple)
	2837	+ case 174LLU: // copy-back deleter (equ to issimple)
2766	2838	{
2767	2839	fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
2768	2840	// copy mutable arguments back from call to equ
2769		- label = 160LLU; // continue to roll stack
	2841	+ label = 168LLU; // continue to roll stack
2770	2842	break;
2771	2843	}
2772		- case 167LLU: // return from equ to issimple
	2844	+ case 175LLU: // return from equ to issimple
2773	2845	{
2774	2846	// copy mutable arguments back from call to equ
2775	2847	// copy back results provided by call to equ

		@@ -2776,87 +2848,87 @@
2776	2848	stack[base + 4] = stack[base + 8LLU];
2777	2849	if(!stack[base + 4]/isequal/)
2778	2850	{
2779		- label = 168LLU; // jump to alternative
	2851	+ label = 176LLU; // jump to alternative
2780	2852	break;
2781	2853	}
2782	2854
2783	2855	// consequent
2784		- label = 171LLU; // skip deleter
	2856	+ label = 179LLU; // skip deleter
2785	2857	break;
2786	2858	}
2787		- case 170LLU: // deleter
	2859	+ case 178LLU: // deleter
2788	2860	{
2789	2861	// throw from issimple
2790	2862	if(!stack[base + 0])
2791	2863	{
2792	2864	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
2794	2866	break;
2795	2867	}
2796	2868	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
2798	2870	break;
2799	2871	}
2800		- case 171LLU: // skipped deleter
	2872	+ case 179LLU: // skipped deleter
2801	2873	{
2802	2874	stack[base + 0] = 1;
2803		- label = 169LLU; // consequent complete
	2875	+ label = 177LLU; // consequent complete
2804	2876	break;
2805	2877	}
2806		- case 168LLU: // alternative
	2878	+ case 176LLU: // alternative
2807	2879	{
2808		- label = 173LLU; // skip deleter
	2880	+ label = 181LLU; // skip deleter
2809	2881	break;
2810	2882	}
2811		- case 172LLU: // deleter
	2883	+ case 180LLU: // deleter
2812	2884	{
2813	2885	// throw from issimple
2814	2886	if(!stack[base + 0])
2815	2887	{
2816	2888	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
2818	2890	break;
2819	2891	}
2820	2892	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
2822	2894	break;
2823	2895	}
2824		- case 173LLU: // skipped deleter
	2896	+ case 181LLU: // skipped deleter
2825	2897	{
2826	2898	stack[base + 0] = 0;
2827		- label = 169LLU; // alternative complete
	2899	+ label = 177LLU; // alternative complete
2828	2900	break;
2829	2901	}
2830		- case 169LLU: // completed if-then-else
	2902	+ case 177LLU: // completed if-then-else
2831	2903	{
2832		- label = 165LLU; // consequent complete
	2904	+ label = 173LLU; // consequent complete
2833	2905	break;
2834	2906	}
2835		- case 164LLU: // alternative
	2907	+ case 172LLU: // alternative
2836	2908	{
2837		- label = 175LLU; // skip deleter
	2909	+ label = 183LLU; // skip deleter
2838	2910	break;
2839	2911	}
2840		- case 174LLU: // deleter
	2912	+ case 182LLU: // deleter
2841	2913	{
2842	2914	// throw from issimple
2843	2915	if(!stack[base + 0])
2844	2916	{
2845	2917	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
2847	2919	break;
2848	2920	}
2849	2921	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
2851	2923	break;
2852	2924	}
2853		- case 175LLU: // skipped deleter
	2925	+ case 183LLU: // skipped deleter
2854	2926	{
2855	2927	stack[base + 0] = 0;
2856		- label = 165LLU; // alternative complete
	2928	+ label = 173LLU; // alternative complete
2857	2929	break;
2858	2930	}
2859		- case 165LLU: // completed if-then-else
	2931	+ case 173LLU: // completed if-then-else
2860	2932	{
2861	2933	// return from issimple
2862	2934	label = stack[base - 1];

		@@ -2863,7 +2935,7 @@
2863	2935	base = stack[base - 2];
2864	2936	break;
2865	2937	}
2866		- case 177LLU: // function isident failed
	2938	+ case 185LLU: // function isident failed
2867	2939	{
2868	2940	fprintf(stderr, "function isident failed\n");
2869	2941	label = stack[base - 3];

		@@ -2870,35 +2942,35 @@
2870	2942	base = stack[base - 2];
2871	2943	break;
2872	2944	}
2873		- case 176LLU: // isident
	2945	+ case 184LLU: // isident
2874	2946	{
2875	2947	//#define res0 0
2876	2948	//#define arg0 1
2877	2949	//#define arg1 2
2878	2950	//#define arg2 3
2879		- label = 179LLU; // skip deleter
	2951	+ label = 187LLU; // skip deleter
2880	2952	break;
2881	2953	}
2882		- case 178LLU: // deleter
	2954	+ case 186LLU: // deleter
2883	2955	{
2884	2956	// throw from isident
2885	2957	if(!stack[base + 4])
2886	2958	{
2887	2959	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
2889	2961	break;
2890	2962	}
2891	2963	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
2893	2965	break;
2894	2966	}
2895		- case 179LLU: // skipped deleter
	2967	+ case 187LLU: // skipped deleter
2896	2968	{
2897	2969	stack[base + 4] = 0;
2898	2970	// call equ from isident
2899		- stack[base + 5LLU] = 180LLU/throw to this address/;
	2971	+ stack[base + 5LLU] = 188LLU/throw to this address/;
2900	2972	stack[base + 6LLU] = base;
2901		- stack[base + 7LLU] = 181LLU;
	2973	+ stack[base + 7LLU] = 189LLU;
2902	2974	// arguments for call to equ
2903	2975	stack[base + 9LLU] = stack[base + 1]/variant/;
2904	2976	stack[base + 10LLU] = 4LLU;

		@@ -2907,14 +2979,14 @@
2907	2979	label = 18446744073709551600LLU; // equ
2908	2980	break;
2909	2981	}
2910		- case 180LLU: // copy-back deleter (equ to isident)
	2982	+ case 188LLU: // copy-back deleter (equ to isident)
2911	2983	{
2912	2984	fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
2913	2985	// copy mutable arguments back from call to equ
2914		- label = 178LLU; // continue to roll stack
	2986	+ label = 186LLU; // continue to roll stack
2915	2987	break;
2916	2988	}
2917		- case 181LLU: // return from equ to isident
	2989	+ case 189LLU: // return from equ to isident
2918	2990	{
2919	2991	// copy mutable arguments back from call to equ
2920	2992	// copy back results provided by call to equ

		@@ -2921,15 +2993,15 @@
2921	2993	stack[base + 4] = stack[base + 8LLU];
2922	2994	if(!stack[base + 4]/isequal/)
2923	2995	{
2924		- label = 182LLU; // jump to alternative
	2996	+ label = 190LLU; // jump to alternative
2925	2997	break;
2926	2998	}
2927	2999
2928	3000	// consequent
2929	3001	// call equ from isident
2930		- stack[base + 5LLU] = 184LLU/throw to this address/;
	3002	+ stack[base + 5LLU] = 192LLU/throw to this address/;
2931	3003	stack[base + 6LLU] = base;
2932		- stack[base + 7LLU] = 185LLU;
	3004	+ stack[base + 7LLU] = 193LLU;
2933	3005	// arguments for call to equ
2934	3006	stack[base + 9LLU] = stack[base + 3]/ident/;
2935	3007	stack[base + 10LLU] = stack[base + 2]/content/;

		@@ -2938,14 +3010,14 @@
2938	3010	label = 18446744073709551600LLU; // equ
2939	3011	break;
2940	3012	}
2941		- case 184LLU: // copy-back deleter (equ to isident)
	3013	+ case 192LLU: // copy-back deleter (equ to isident)
2942	3014	{
2943	3015	fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
2944	3016	// copy mutable arguments back from call to equ
2945		- label = 178LLU; // continue to roll stack
	3017	+ label = 186LLU; // continue to roll stack
2946	3018	break;
2947	3019	}
2948		- case 185LLU: // return from equ to isident
	3020	+ case 193LLU: // return from equ to isident
2949	3021	{
2950	3022	// copy mutable arguments back from call to equ
2951	3023	// copy back results provided by call to equ

		@@ -2952,87 +3024,87 @@
2952	3024	stack[base + 4] = stack[base + 8LLU];
2953	3025	if(!stack[base + 4]/isequal/)
2954	3026	{
2955		- label = 186LLU; // jump to alternative
	3027	+ label = 194LLU; // jump to alternative
2956	3028	break;
2957	3029	}
2958	3030
2959	3031	// consequent
2960		- label = 189LLU; // skip deleter
	3032	+ label = 197LLU; // skip deleter
2961	3033	break;
2962	3034	}
2963		- case 188LLU: // deleter
	3035	+ case 196LLU: // deleter
2964	3036	{
2965	3037	// throw from isident
2966	3038	if(!stack[base + 0])
2967	3039	{
2968	3040	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
2970	3042	break;
2971	3043	}
2972	3044	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
2974	3046	break;
2975	3047	}
2976		- case 189LLU: // skipped deleter
	3048	+ case 197LLU: // skipped deleter
2977	3049	{
2978	3050	stack[base + 0] = 1;
2979		- label = 187LLU; // consequent complete
	3051	+ label = 195LLU; // consequent complete
2980	3052	break;
2981	3053	}
2982		- case 186LLU: // alternative
	3054	+ case 194LLU: // alternative
2983	3055	{
2984		- label = 191LLU; // skip deleter
	3056	+ label = 199LLU; // skip deleter
2985	3057	break;
2986	3058	}
2987		- case 190LLU: // deleter
	3059	+ case 198LLU: // deleter
2988	3060	{
2989	3061	// throw from isident
2990	3062	if(!stack[base + 0])
2991	3063	{
2992	3064	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
2994	3066	break;
2995	3067	}
2996	3068	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
2998	3070	break;
2999	3071	}
3000		- case 191LLU: // skipped deleter
	3072	+ case 199LLU: // skipped deleter
3001	3073	{
3002	3074	stack[base + 0] = 0;
3003		- label = 187LLU; // alternative complete
	3075	+ label = 195LLU; // alternative complete
3004	3076	break;
3005	3077	}
3006		- case 187LLU: // completed if-then-else
	3078	+ case 195LLU: // completed if-then-else
3007	3079	{
3008		- label = 183LLU; // consequent complete
	3080	+ label = 191LLU; // consequent complete
3009	3081	break;
3010	3082	}
3011		- case 182LLU: // alternative
	3083	+ case 190LLU: // alternative
3012	3084	{
3013		- label = 193LLU; // skip deleter
	3085	+ label = 201LLU; // skip deleter
3014	3086	break;
3015	3087	}
3016		- case 192LLU: // deleter
	3088	+ case 200LLU: // deleter
3017	3089	{
3018	3090	// throw from isident
3019	3091	if(!stack[base + 0])
3020	3092	{
3021	3093	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
3023	3095	break;
3024	3096	}
3025	3097	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
3027	3099	break;
3028	3100	}
3029		- case 193LLU: // skipped deleter
	3101	+ case 201LLU: // skipped deleter
3030	3102	{
3031	3103	stack[base + 0] = 0;
3032		- label = 183LLU; // alternative complete
	3104	+ label = 191LLU; // alternative complete
3033	3105	break;
3034	3106	}
3035		- case 183LLU: // completed if-then-else
	3107	+ case 191LLU: // completed if-then-else
3036	3108	{
3037	3109	// return from isident
3038	3110	label = stack[base - 1];

		@@ -3039,7 +3111,7 @@
3039	3111	base = stack[base - 2];
3040	3112	break;
3041	3113	}
3042		- case 195LLU: // function iseos failed
	3114	+ case 203LLU: // function iseos failed
3043	3115	{
3044	3116	fprintf(stderr, "function iseos failed\n");
3045	3117	label = stack[base - 3];

		@@ -3046,14 +3118,14 @@
3046	3118	base = stack[base - 2];
3047	3119	break;
3048	3120	}
3049		- case 194LLU: // iseos
	3121	+ case 202LLU: // iseos
3050	3122	{
3051	3123	//#define res0 0
3052	3124	//#define arg0 1
3053	3125	// call equ from iseos
3054		- stack[base + 2LLU] = 196LLU/throw to this address/;
	3126	+ stack[base + 2LLU] = 204LLU/throw to this address/;
3055	3127	stack[base + 3LLU] = base;
3056		- stack[base + 4LLU] = 197LLU;
	3128	+ stack[base + 4LLU] = 205LLU;
3057	3129	// arguments for call to equ
3058	3130	stack[base + 6LLU] = stack[base + 1]/variantnr/;
3059	3131	stack[base + 7LLU] = 5LLU;

		@@ -3062,14 +3134,14 @@
3062	3134	label = 18446744073709551600LLU; // equ
3063	3135	break;
3064	3136	}
3065		- case 196LLU: // copy-back deleter (equ to iseos)
	3137	+ case 204LLU: // copy-back deleter (equ to iseos)
3066	3138	{
3067	3139	fprintf(stderr, "in function iseos: unrolling stack, copy-back (equ to iseos)\n");
3068	3140	// copy mutable arguments back from call to equ
3069		- label = 195LLU; // continue to roll stack
	3141	+ label = 203LLU; // continue to roll stack
3070	3142	break;
3071	3143	}
3072		- case 197LLU: // return from equ to iseos
	3144	+ case 205LLU: // return from equ to iseos
3073	3145	{
3074	3146	// copy mutable arguments back from call to equ
3075	3147	// copy back results provided by call to equ

		@@ -3079,7 +3151,7 @@
3079	3151	base = stack[base - 2];
3080	3152	break;
3081	3153	}
3082		- case 199LLU: // function MATCHPEEK failed
	3154	+ case 207LLU: // function MATCHPEEK failed
3083	3155	{
3084	3156	fprintf(stderr, "function MATCHPEEK failed\n");
3085	3157	label = stack[base - 3];

		@@ -3086,15 +3158,15 @@
3086	3158	base = stack[base - 2];
3087	3159	break;
3088	3160	}
3089		- case 198LLU: // MATCHPEEK
	3161	+ case 206LLU: // MATCHPEEK
3090	3162	{
3091	3163	//#define arg0 0
3092	3164	//#define arg1 1
3093	3165	//#define arg2 2
3094	3166	// call skipwscmnt from MATCHPEEK
3095		- stack[base + 3LLU] = 200LLU/throw to this address/;
	3167	+ stack[base + 3LLU] = 208LLU/throw to this address/;
3096	3168	stack[base + 4LLU] = base;
3097		- stack[base + 5LLU] = 201LLU;
	3169	+ stack[base + 5LLU] = 209LLU;
3098	3170	// arguments for call to skipwscmnt
3099	3171	stack[base + 7LLU] = stack[base + 2]/lookahead/;
3100	3172	// set stack-base & callee-address

		@@ -3102,22 +3174,40 @@
3102	3174	label = 18446744073709551580LLU; // skipwscmnt
3103	3175	break;
3104	3176	}
3105		- case 200LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
	3177	+ case 208LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
3106	3178	{
3107	3179	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (skipwscmnt to MATCHPEEK)\n");
3108	3180	// copy mutable arguments back from call to skipwscmnt
3109		- label = 199LLU; // continue to roll stack
	3181	+ label = 207LLU; // continue to roll stack
3110	3182	break;
3111	3183	}
3112		- case 201LLU: // return from skipwscmnt to MATCHPEEK
	3184	+ case 209LLU: // return from skipwscmnt to MATCHPEEK
3113	3185	{
3114	3186	// copy mutable arguments back from call to skipwscmnt
3115	3187	// copy back results provided by call to skipwscmnt
3116	3188	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	+ {
3117	3207	// call equ from MATCHPEEK
3118		- stack[base + 4LLU] = 202LLU/throw to this address/;
	3208	+ stack[base + 4LLU] = 212LLU/throw to this address/;
3119	3209	stack[base + 5LLU] = base;
3120		- stack[base + 6LLU] = 203LLU;
	3210	+ stack[base + 6LLU] = 213LLU;
3121	3211	// arguments for call to equ
3122	3212	stack[base + 8LLU] = stack[base + 2]/lookahead/;
3123	3213	stack[base + 9LLU] = stack[base + 1]/sym/;

		@@ -3126,14 +3216,14 @@
3126	3216	label = 18446744073709551600LLU; // equ
3127	3217	break;
3128	3218	}
3129		- case 202LLU: // copy-back deleter (equ to MATCHPEEK)
	3219	+ case 212LLU: // copy-back deleter (equ to MATCHPEEK)
3130	3220	{
3131	3221	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (equ to MATCHPEEK)\n");
3132	3222	// copy mutable arguments back from call to equ
3133		- label = 199LLU; // continue to roll stack
	3223	+ label = 207LLU; // continue to roll stack
3134	3224	break;
3135	3225	}
3136		- case 203LLU: // return from equ to MATCHPEEK
	3226	+ case 213LLU: // return from equ to MATCHPEEK
3137	3227	{
3138	3228	// copy mutable arguments back from call to equ
3139	3229	// copy back results provided by call to equ

		@@ -3140,21 +3230,21 @@
3140	3230	stack[base + 3] = stack[base + 7LLU];
3141	3231	if(!stack[base + 3]/isqual/)
3142	3232	{
3143		- label = 204LLU; // jump to alternative
	3233	+ label = 214LLU; // jump to alternative
3144	3234	break;
3145	3235	}
3146	3236
3147	3237	// consequent
3148		- label = 205LLU; // consequent complete
	3238	+ label = 215LLU; // consequent complete
3149	3239	break;
3150	3240	}
3151		- case 204LLU: // alternative
	3241	+ case 214LLU: // alternative
3152	3242	{
3153	3243	fprintf(stderr, "%s", "in function ");
3154	3244	// call reportid from MATCHPEEK
3155		- stack[base + 4LLU] = 206LLU/throw to this address/;
	3245	+ stack[base + 4LLU] = 216LLU/throw to this address/;
3156	3246	stack[base + 5LLU] = base;
3157		- stack[base + 6LLU] = 207LLU;
	3247	+ stack[base + 6LLU] = 217LLU;
3158	3248	// arguments for call to reportid
3159	3249	stack[base + 7LLU] = stack[base + 0]/fnid/;
3160	3250	// set stack-base & callee-address

		@@ -3162,22 +3252,22 @@
3162	3252	label = 18446744073709551586LLU; // reportid
3163	3253	break;
3164	3254	}
3165		- case 206LLU: // copy-back deleter (reportid to MATCHPEEK)
	3255	+ case 216LLU: // copy-back deleter (reportid to MATCHPEEK)
3166	3256	{
3167	3257	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportid to MATCHPEEK)\n");
3168	3258	// copy mutable arguments back from call to reportid
3169		- label = 199LLU; // continue to roll stack
	3259	+ label = 210LLU; // continue to roll stack
3170	3260	break;
3171	3261	}
3172		- case 207LLU: // return from reportid to MATCHPEEK
	3262	+ case 217LLU: // return from reportid to MATCHPEEK
3173	3263	{
3174	3264	// copy mutable arguments back from call to reportid
3175	3265	fprintf(stderr, "%s", ": ");
3176	3266	fprintf(stderr, "%s", "expected '");
3177	3267	// call reportbyte from MATCHPEEK
3178		- stack[base + 4LLU] = 208LLU/throw to this address/;
	3268	+ stack[base + 4LLU] = 218LLU/throw to this address/;
3179	3269	stack[base + 5LLU] = base;
3180		- stack[base + 6LLU] = 209LLU;
	3270	+ stack[base + 6LLU] = 219LLU;
3181	3271	// arguments for call to reportbyte
3182	3272	stack[base + 7LLU] = stack[base + 1]/sym/;
3183	3273	// set stack-base & callee-address

		@@ -3185,21 +3275,21 @@
3185	3275	label = 18446744073709551591LLU; // reportbyte
3186	3276	break;
3187	3277	}
3188		- case 208LLU: // copy-back deleter (reportbyte to MATCHPEEK)
	3278	+ case 218LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3189	3279	{
3190	3280	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
3191	3281	// copy mutable arguments back from call to reportbyte
3192		- label = 199LLU; // continue to roll stack
	3282	+ label = 210LLU; // continue to roll stack
3193	3283	break;
3194	3284	}
3195		- case 209LLU: // return from reportbyte to MATCHPEEK
	3285	+ case 219LLU: // return from reportbyte to MATCHPEEK
3196	3286	{
3197	3287	// copy mutable arguments back from call to reportbyte
3198	3288	fprintf(stderr, "%s", "' but found token ");
3199	3289	// call reportbyte from MATCHPEEK
3200		- stack[base + 4LLU] = 210LLU/throw to this address/;
	3290	+ stack[base + 4LLU] = 220LLU/throw to this address/;
3201	3291	stack[base + 5LLU] = base;
3202		- stack[base + 6LLU] = 211LLU;
	3292	+ stack[base + 6LLU] = 221LLU;
3203	3293	// arguments for call to reportbyte
3204	3294	stack[base + 7LLU] = stack[base + 2]/lookahead/;
3205	3295	// set stack-base & callee-address

		@@ -3207,22 +3297,22 @@
3207	3297	label = 18446744073709551591LLU; // reportbyte
3208	3298	break;
3209	3299	}
3210		- case 210LLU: // copy-back deleter (reportbyte to MATCHPEEK)
	3300	+ case 220LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3211	3301	{
3212	3302	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
3213	3303	// copy mutable arguments back from call to reportbyte
3214		- label = 199LLU; // continue to roll stack
	3304	+ label = 210LLU; // continue to roll stack
3215	3305	break;
3216	3306	}
3217		- case 211LLU: // return from reportbyte to MATCHPEEK
	3307	+ case 221LLU: // return from reportbyte to MATCHPEEK
3218	3308	{
3219	3309	// copy mutable arguments back from call to reportbyte
3220	3310	fprintf(stderr, "%s", "\n");
3221	3311	exit(-1);
3222		- label = 205LLU; // alternative complete
	3312	+ label = 215LLU; // alternative complete
3223	3313	break;
3224	3314	}
3225		- case 205LLU: // completed if-then-else
	3315	+ case 215LLU: // completed if-then-else
3226	3316	{
3227	3317	// return from MATCHPEEK
3228	3318	label = stack[base - 1];

		@@ -3229,7 +3319,7 @@
3229	3319	base = stack[base - 2];
3230	3320	break;
3231	3321	}
3232		- case 213LLU: // function matchsym failed
	3322	+ case 223LLU: // function matchsym failed
3233	3323	{
3234	3324	fprintf(stderr, "function matchsym failed\n");
3235	3325	label = stack[base - 3];

		@@ -3236,53 +3326,53 @@
3236	3326	base = stack[base - 2];
3237	3327	break;
3238	3328	}
3239		- case 212LLU: // matchsym
	3329	+ case 222LLU: // matchsym
3240	3330	{
3241	3331	//#define arg0 0
3242	3332	//#define arg1 1
3243	3333	//#define arg2 2
3244		- label = 215LLU; // skip deleter
	3334	+ label = 225LLU; // skip deleter
3245	3335	break;
3246	3336	}
3247		- case 214LLU: // deleter
	3337	+ case 224LLU: // deleter
3248	3338	{
3249	3339	// throw from matchsym
3250	3340	if(!stack[base + 3])
3251	3341	{
3252	3342	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
3254	3344	break;
3255	3345	}
3256	3346	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
3258	3348	break;
3259	3349	}
3260		- case 215LLU: // skipped deleter
	3350	+ case 225LLU: // skipped deleter
3261	3351	{
3262	3352	stack[base + 3] = 0;
3263		- label = 217LLU; // skip deleter
	3353	+ label = 227LLU; // skip deleter
3264	3354	break;
3265	3355	}
3266		- case 216LLU: // deleter
	3356	+ case 226LLU: // deleter
3267	3357	{
3268	3358	// throw from matchsym
3269	3359	if(!stack[base + 4])
3270	3360	{
3271	3361	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
3273	3363	break;
3274	3364	}
3275	3365	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
3277	3367	break;
3278	3368	}
3279		- case 217LLU: // skipped deleter
	3369	+ case 227LLU: // skipped deleter
3280	3370	{
3281	3371	stack[base + 4] = 0;
3282	3372	// call ParseToken from matchsym
3283		- stack[base + 5LLU] = 218LLU/throw to this address/;
	3373	+ stack[base + 5LLU] = 228LLU/throw to this address/;
3284	3374	stack[base + 6LLU] = base;
3285		- stack[base + 7LLU] = 219LLU;
	3375	+ stack[base + 7LLU] = 229LLU;
3286	3376	// arguments for call to ParseToken
3287	3377	stack[base + 10LLU] = stack[base + 2]/lookahead/;
3288	3378	// set stack-base & callee-address

		@@ -3290,15 +3380,15 @@
3290	3380	label = 3LLU; // ParseToken
3291	3381	break;
3292	3382	}
3293		- case 218LLU: // copy-back deleter (ParseToken to matchsym)
	3383	+ case 228LLU: // copy-back deleter (ParseToken to matchsym)
3294	3384	{
3295	3385	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (ParseToken to matchsym)\n");
3296	3386	// copy mutable arguments back from call to ParseToken
3297	3387	stack[base + 2]/lookahead/ = stack[base + 10LLU];
3298		- label = 216LLU; // continue to roll stack
	3388	+ label = 226LLU; // continue to roll stack
3299	3389	break;
3300	3390	}
3301		- case 219LLU: // return from ParseToken to matchsym
	3391	+ case 229LLU: // return from ParseToken to matchsym
3302	3392	{
3303	3393	// copy mutable arguments back from call to ParseToken
3304	3394	stack[base + 2]/lookahead/ = stack[base + 10LLU];

		@@ -3305,29 +3395,29 @@
3305	3395	// copy back results provided by call to ParseToken
3306	3396	stack[base + 3] = stack[base + 8LLU];
3307	3397	stack[base + 4] = stack[base + 9LLU];
3308		- label = 221LLU; // skip deleter
	3398	+ label = 231LLU; // skip deleter
3309	3399	break;
3310	3400	}
3311		- case 220LLU: // deleter
	3401	+ case 230LLU: // deleter
3312	3402	{
3313	3403	// throw from matchsym
3314	3404	if(!stack[base + 5])
3315	3405	{
3316	3406	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
3318	3408	break;
3319	3409	}
3320	3410	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
3322	3412	break;
3323	3413	}
3324		- case 221LLU: // skipped deleter
	3414	+ case 231LLU: // skipped deleter
3325	3415	{
3326	3416	stack[base + 5] = 0;
3327	3417	// call equ from matchsym
3328		- stack[base + 6LLU] = 222LLU/throw to this address/;
	3418	+ stack[base + 6LLU] = 232LLU/throw to this address/;
3329	3419	stack[base + 7LLU] = base;
3330		- stack[base + 8LLU] = 223LLU;
	3420	+ stack[base + 8LLU] = 233LLU;
3331	3421	// arguments for call to equ
3332	3422	stack[base + 10LLU] = stack[base + 3]/variant/;
3333	3423	stack[base + 11LLU] = 0LLU;

		@@ -3336,14 +3426,14 @@
3336	3426	label = 18446744073709551600LLU; // equ
3337	3427	break;
3338	3428	}
3339		- case 222LLU: // copy-back deleter (equ to matchsym)
	3429	+ case 232LLU: // copy-back deleter (equ to matchsym)
3340	3430	{
3341	3431	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
3342	3432	// copy mutable arguments back from call to equ
3343		- label = 220LLU; // continue to roll stack
	3433	+ label = 230LLU; // continue to roll stack
3344	3434	break;
3345	3435	}
3346		- case 223LLU: // return from equ to matchsym
	3436	+ case 233LLU: // return from equ to matchsym
3347	3437	{
3348	3438	// copy mutable arguments back from call to equ
3349	3439	// copy back results provided by call to equ

		@@ -3350,15 +3440,15 @@
3350	3440	stack[base + 5] = stack[base + 9LLU];
3351	3441	if(!stack[base + 5]/isqual/)
3352	3442	{
3353		- label = 224LLU; // jump to alternative
	3443	+ label = 234LLU; // jump to alternative
3354	3444	break;
3355	3445	}
3356	3446
3357	3447	// consequent
3358	3448	// call equ from matchsym
3359		- stack[base + 6LLU] = 226LLU/throw to this address/;
	3449	+ stack[base + 6LLU] = 236LLU/throw to this address/;
3360	3450	stack[base + 7LLU] = base;
3361		- stack[base + 8LLU] = 227LLU;
	3451	+ stack[base + 8LLU] = 237LLU;
3362	3452	// arguments for call to equ
3363	3453	stack[base + 10LLU] = stack[base + 1]/sym/;
3364	3454	stack[base + 11LLU] = stack[base + 4]/content/;

		@@ -3367,14 +3457,14 @@
3367	3457	label = 18446744073709551600LLU; // equ
3368	3458	break;
3369	3459	}
3370		- case 226LLU: // copy-back deleter (equ to matchsym)
	3460	+ case 236LLU: // copy-back deleter (equ to matchsym)
3371	3461	{
3372	3462	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
3373	3463	// copy mutable arguments back from call to equ
3374		- label = 220LLU; // continue to roll stack
	3464	+ label = 230LLU; // continue to roll stack
3375	3465	break;
3376	3466	}
3377		- case 227LLU: // return from equ to matchsym
	3467	+ case 237LLU: // return from equ to matchsym
3378	3468	{
3379	3469	// copy mutable arguments back from call to equ
3380	3470	// copy back results provided by call to equ

		@@ -3381,21 +3471,21 @@
3381	3471	stack[base + 5] = stack[base + 9LLU];
3382	3472	if(!stack[base + 5]/isqual/)
3383	3473	{
3384		- label = 228LLU; // jump to alternative
	3474	+ label = 238LLU; // jump to alternative
3385	3475	break;
3386	3476	}
3387	3477
3388	3478	// consequent
3389		- label = 229LLU; // consequent complete
	3479	+ label = 239LLU; // consequent complete
3390	3480	break;
3391	3481	}
3392		- case 228LLU: // alternative
	3482	+ case 238LLU: // alternative
3393	3483	{
3394	3484	fprintf(stderr, "%s", "in function ");
3395	3485	// call reportid from matchsym
3396		- stack[base + 6LLU] = 230LLU/throw to this address/;
	3486	+ stack[base + 6LLU] = 240LLU/throw to this address/;
3397	3487	stack[base + 7LLU] = base;
3398		- stack[base + 8LLU] = 231LLU;
	3488	+ stack[base + 8LLU] = 241LLU;
3399	3489	// arguments for call to reportid
3400	3490	stack[base + 9LLU] = stack[base + 0]/fnid/;
3401	3491	// set stack-base & callee-address

		@@ -3403,22 +3493,22 @@
3403	3493	label = 18446744073709551586LLU; // reportid
3404	3494	break;
3405	3495	}
3406		- case 230LLU: // copy-back deleter (reportid to matchsym)
	3496	+ case 240LLU: // copy-back deleter (reportid to matchsym)
3407	3497	{
3408	3498	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
3409	3499	// copy mutable arguments back from call to reportid
3410		- label = 220LLU; // continue to roll stack
	3500	+ label = 230LLU; // continue to roll stack
3411	3501	break;
3412	3502	}
3413		- case 231LLU: // return from reportid to matchsym
	3503	+ case 241LLU: // return from reportid to matchsym
3414	3504	{
3415	3505	// copy mutable arguments back from call to reportid
3416	3506	fprintf(stderr, "%s", ": ");
3417	3507	fprintf(stderr, "%s", "expected '");
3418	3508	// call reportbyte from matchsym
3419		- stack[base + 6LLU] = 232LLU/throw to this address/;
	3509	+ stack[base + 6LLU] = 242LLU/throw to this address/;
3420	3510	stack[base + 7LLU] = base;
3421		- stack[base + 8LLU] = 233LLU;
	3511	+ stack[base + 8LLU] = 243LLU;
3422	3512	// arguments for call to reportbyte
3423	3513	stack[base + 9LLU] = stack[base + 1]/sym/;
3424	3514	// set stack-base & callee-address

		@@ -3426,21 +3516,21 @@
3426	3516	label = 18446744073709551591LLU; // reportbyte
3427	3517	break;
3428	3518	}
3429		- case 232LLU: // copy-back deleter (reportbyte to matchsym)
	3519	+ case 242LLU: // copy-back deleter (reportbyte to matchsym)
3430	3520	{
3431	3521	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
3432	3522	// copy mutable arguments back from call to reportbyte
3433		- label = 220LLU; // continue to roll stack
	3523	+ label = 230LLU; // continue to roll stack
3434	3524	break;
3435	3525	}
3436		- case 233LLU: // return from reportbyte to matchsym
	3526	+ case 243LLU: // return from reportbyte to matchsym
3437	3527	{
3438	3528	// copy mutable arguments back from call to reportbyte
3439	3529	fprintf(stderr, "%s", "' but found token ");
3440	3530	// call reporttok from matchsym
3441		- stack[base + 6LLU] = 234LLU/throw to this address/;
	3531	+ stack[base + 6LLU] = 244LLU/throw to this address/;
3442	3532	stack[base + 7LLU] = base;
3443		- stack[base + 8LLU] = 235LLU;
	3533	+ stack[base + 8LLU] = 245LLU;
3444	3534	// arguments for call to reporttok
3445	3535	stack[base + 9LLU] = stack[base + 3]/variant/;
3446	3536	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3449,33 +3539,33 @@
3449	3539	label = 18446744073709551582LLU; // reporttok
3450	3540	break;
3451	3541	}
3452		- case 234LLU: // copy-back deleter (reporttok to matchsym)
	3542	+ case 244LLU: // copy-back deleter (reporttok to matchsym)
3453	3543	{
3454	3544	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
3455	3545	// copy mutable arguments back from call to reporttok
3456		- label = 220LLU; // continue to roll stack
	3546	+ label = 230LLU; // continue to roll stack
3457	3547	break;
3458	3548	}
3459		- case 235LLU: // return from reporttok to matchsym
	3549	+ case 245LLU: // return from reporttok to matchsym
3460	3550	{
3461	3551	// copy mutable arguments back from call to reporttok
3462	3552	fprintf(stderr, "%s", "\n");
3463	3553	exit(-1);
3464		- label = 229LLU; // alternative complete
	3554	+ label = 239LLU; // alternative complete
3465	3555	break;
3466	3556	}
3467		- case 229LLU: // completed if-then-else
	3557	+ case 239LLU: // completed if-then-else
3468	3558	{
3469		- label = 225LLU; // consequent complete
	3559	+ label = 235LLU; // consequent complete
3470	3560	break;
3471	3561	}
3472		- case 224LLU: // alternative
	3562	+ case 234LLU: // alternative
3473	3563	{
3474	3564	fprintf(stderr, "%s", "in function ");
3475	3565	// call reportid from matchsym
3476		- stack[base + 6LLU] = 236LLU/throw to this address/;
	3566	+ stack[base + 6LLU] = 246LLU/throw to this address/;
3477	3567	stack[base + 7LLU] = base;
3478		- stack[base + 8LLU] = 237LLU;
	3568	+ stack[base + 8LLU] = 247LLU;
3479	3569	// arguments for call to reportid
3480	3570	stack[base + 9LLU] = stack[base + 0]/fnid/;
3481	3571	// set stack-base & callee-address

		@@ -3483,22 +3573,22 @@
3483	3573	label = 18446744073709551586LLU; // reportid
3484	3574	break;
3485	3575	}
3486		- case 236LLU: // copy-back deleter (reportid to matchsym)
	3576	+ case 246LLU: // copy-back deleter (reportid to matchsym)
3487	3577	{
3488	3578	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
3489	3579	// copy mutable arguments back from call to reportid
3490		- label = 220LLU; // continue to roll stack
	3580	+ label = 230LLU; // continue to roll stack
3491	3581	break;
3492	3582	}
3493		- case 237LLU: // return from reportid to matchsym
	3583	+ case 247LLU: // return from reportid to matchsym
3494	3584	{
3495	3585	// copy mutable arguments back from call to reportid
3496	3586	fprintf(stderr, "%s", ": ");
3497	3587	fprintf(stderr, "%s", "expected '");
3498	3588	// call reportbyte from matchsym
3499		- stack[base + 6LLU] = 238LLU/throw to this address/;
	3589	+ stack[base + 6LLU] = 248LLU/throw to this address/;
3500	3590	stack[base + 7LLU] = base;
3501		- stack[base + 8LLU] = 239LLU;
	3591	+ stack[base + 8LLU] = 249LLU;
3502	3592	// arguments for call to reportbyte
3503	3593	stack[base + 9LLU] = stack[base + 1]/sym/;
3504	3594	// set stack-base & callee-address

		@@ -3506,21 +3596,21 @@
3506	3596	label = 18446744073709551591LLU; // reportbyte
3507	3597	break;
3508	3598	}
3509		- case 238LLU: // copy-back deleter (reportbyte to matchsym)
	3599	+ case 248LLU: // copy-back deleter (reportbyte to matchsym)
3510	3600	{
3511	3601	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
3512	3602	// copy mutable arguments back from call to reportbyte
3513		- label = 220LLU; // continue to roll stack
	3603	+ label = 230LLU; // continue to roll stack
3514	3604	break;
3515	3605	}
3516		- case 239LLU: // return from reportbyte to matchsym
	3606	+ case 249LLU: // return from reportbyte to matchsym
3517	3607	{
3518	3608	// copy mutable arguments back from call to reportbyte
3519	3609	fprintf(stderr, "%s", "' but found token ");
3520	3610	// call reporttok from matchsym
3521		- stack[base + 6LLU] = 240LLU/throw to this address/;
	3611	+ stack[base + 6LLU] = 250LLU/throw to this address/;
3522	3612	stack[base + 7LLU] = base;
3523		- stack[base + 8LLU] = 241LLU;
	3613	+ stack[base + 8LLU] = 251LLU;
3524	3614	// arguments for call to reporttok
3525	3615	stack[base + 9LLU] = stack[base + 3]/variant/;
3526	3616	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3529,22 +3619,22 @@
3529	3619	label = 18446744073709551582LLU; // reporttok
3530	3620	break;
3531	3621	}
3532		- case 240LLU: // copy-back deleter (reporttok to matchsym)
	3622	+ case 250LLU: // copy-back deleter (reporttok to matchsym)
3533	3623	{
3534	3624	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
3535	3625	// copy mutable arguments back from call to reporttok
3536		- label = 220LLU; // continue to roll stack
	3626	+ label = 230LLU; // continue to roll stack
3537	3627	break;
3538	3628	}
3539		- case 241LLU: // return from reporttok to matchsym
	3629	+ case 251LLU: // return from reporttok to matchsym
3540	3630	{
3541	3631	// copy mutable arguments back from call to reporttok
3542	3632	fprintf(stderr, "%s", "\n");
3543	3633	exit(-1);
3544		- label = 225LLU; // alternative complete
	3634	+ label = 235LLU; // alternative complete
3545	3635	break;
3546	3636	}
3547		- case 225LLU: // completed if-then-else
	3637	+ case 235LLU: // completed if-then-else
3548	3638	{
3549	3639	// return from matchsym
3550	3640	label = stack[base - 1];

		@@ -3551,7 +3641,7 @@
3551	3641	base = stack[base - 2];
3552	3642	break;
3553	3643	}
3554		- case 243LLU: // function matchid failed
	3644	+ case 253LLU: // function matchid failed
3555	3645	{
3556	3646	fprintf(stderr, "function matchid failed\n");
3557	3647	label = stack[base - 3];

		@@ -3558,53 +3648,53 @@
3558	3648	base = stack[base - 2];
3559	3649	break;
3560	3650	}
3561		- case 242LLU: // matchid
	3651	+ case 252LLU: // matchid
3562	3652	{
3563	3653	//#define arg0 0
3564	3654	//#define arg1 1
3565	3655	//#define arg2 2
3566		- label = 245LLU; // skip deleter
	3656	+ label = 255LLU; // skip deleter
3567	3657	break;
3568	3658	}
3569		- case 244LLU: // deleter
	3659	+ case 254LLU: // deleter
3570	3660	{
3571	3661	// throw from matchid
3572	3662	if(!stack[base + 3])
3573	3663	{
3574	3664	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
3576	3666	break;
3577	3667	}
3578	3668	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
3580	3670	break;
3581	3671	}
3582		- case 245LLU: // skipped deleter
	3672	+ case 255LLU: // skipped deleter
3583	3673	{
3584	3674	stack[base + 3] = 0;
3585		- label = 247LLU; // skip deleter
	3675	+ label = 257LLU; // skip deleter
3586	3676	break;
3587	3677	}
3588		- case 246LLU: // deleter
	3678	+ case 256LLU: // deleter
3589	3679	{
3590	3680	// throw from matchid
3591	3681	if(!stack[base + 4])
3592	3682	{
3593	3683	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
3595	3685	break;
3596	3686	}
3597	3687	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
3599	3689	break;
3600	3690	}
3601		- case 247LLU: // skipped deleter
	3691	+ case 257LLU: // skipped deleter
3602	3692	{
3603	3693	stack[base + 4] = 0;
3604	3694	// call ParseToken from matchid
3605		- stack[base + 5LLU] = 248LLU/throw to this address/;
	3695	+ stack[base + 5LLU] = 258LLU/throw to this address/;
3606	3696	stack[base + 6LLU] = base;
3607		- stack[base + 7LLU] = 249LLU;
	3697	+ stack[base + 7LLU] = 259LLU;
3608	3698	// arguments for call to ParseToken
3609	3699	stack[base + 10LLU] = stack[base + 2]/lookahead/;
3610	3700	// set stack-base & callee-address

		@@ -3612,15 +3702,15 @@
3612	3702	label = 3LLU; // ParseToken
3613	3703	break;
3614	3704	}
3615		- case 248LLU: // copy-back deleter (ParseToken to matchid)
	3705	+ case 258LLU: // copy-back deleter (ParseToken to matchid)
3616	3706	{
3617	3707	fprintf(stderr, "in function matchid: unrolling stack, copy-back (ParseToken to matchid)\n");
3618	3708	// copy mutable arguments back from call to ParseToken
3619	3709	stack[base + 2]/lookahead/ = stack[base + 10LLU];
3620		- label = 246LLU; // continue to roll stack
	3710	+ label = 256LLU; // continue to roll stack
3621	3711	break;
3622	3712	}
3623		- case 249LLU: // return from ParseToken to matchid
	3713	+ case 259LLU: // return from ParseToken to matchid
3624	3714	{
3625	3715	// copy mutable arguments back from call to ParseToken
3626	3716	stack[base + 2]/lookahead/ = stack[base + 10LLU];

		@@ -3627,29 +3717,29 @@
3627	3717	// copy back results provided by call to ParseToken
3628	3718	stack[base + 3] = stack[base + 8LLU];
3629	3719	stack[base + 4] = stack[base + 9LLU];
3630		- label = 251LLU; // skip deleter
	3720	+ label = 261LLU; // skip deleter
3631	3721	break;
3632	3722	}
3633		- case 250LLU: // deleter
	3723	+ case 260LLU: // deleter
3634	3724	{
3635	3725	// throw from matchid
3636	3726	if(!stack[base + 5])
3637	3727	{
3638	3728	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
3640	3730	break;
3641	3731	}
3642	3732	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
3644	3734	break;
3645	3735	}
3646		- case 251LLU: // skipped deleter
	3736	+ case 261LLU: // skipped deleter
3647	3737	{
3648	3738	stack[base + 5] = 0;
3649	3739	// call equ from matchid
3650		- stack[base + 6LLU] = 252LLU/throw to this address/;
	3740	+ stack[base + 6LLU] = 262LLU/throw to this address/;
3651	3741	stack[base + 7LLU] = base;
3652		- stack[base + 8LLU] = 253LLU;
	3742	+ stack[base + 8LLU] = 263LLU;
3653	3743	// arguments for call to equ
3654	3744	stack[base + 10LLU] = stack[base + 3]/variant/;
3655	3745	stack[base + 11LLU] = 4LLU;

		@@ -3658,14 +3748,14 @@
3658	3748	label = 18446744073709551600LLU; // equ
3659	3749	break;
3660	3750	}
3661		- case 252LLU: // copy-back deleter (equ to matchid)
	3751	+ case 262LLU: // copy-back deleter (equ to matchid)
3662	3752	{
3663	3753	fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
3664	3754	// copy mutable arguments back from call to equ
3665		- label = 250LLU; // continue to roll stack
	3755	+ label = 260LLU; // continue to roll stack
3666	3756	break;
3667	3757	}
3668		- case 253LLU: // return from equ to matchid
	3758	+ case 263LLU: // return from equ to matchid
3669	3759	{
3670	3760	// copy mutable arguments back from call to equ
3671	3761	// copy back results provided by call to equ

		@@ -3672,15 +3762,15 @@
3672	3762	stack[base + 5] = stack[base + 9LLU];
3673	3763	if(!stack[base + 5]/isqual/)
3674	3764	{
3675		- label = 254LLU; // jump to alternative
	3765	+ label = 264LLU; // jump to alternative
3676	3766	break;
3677	3767	}
3678	3768
3679	3769	// consequent
3680	3770	// call equ from matchid
3681		- stack[base + 6LLU] = 256LLU/throw to this address/;
	3771	+ stack[base + 6LLU] = 266LLU/throw to this address/;
3682	3772	stack[base + 7LLU] = base;
3683		- stack[base + 8LLU] = 257LLU;
	3773	+ stack[base + 8LLU] = 267LLU;
3684	3774	// arguments for call to equ
3685	3775	stack[base + 10LLU] = stack[base + 1]/id/;
3686	3776	stack[base + 11LLU] = stack[base + 4]/content/;

		@@ -3689,14 +3779,14 @@
3689	3779	label = 18446744073709551600LLU; // equ
3690	3780	break;
3691	3781	}
3692		- case 256LLU: // copy-back deleter (equ to matchid)
	3782	+ case 266LLU: // copy-back deleter (equ to matchid)
3693	3783	{
3694	3784	fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
3695	3785	// copy mutable arguments back from call to equ
3696		- label = 250LLU; // continue to roll stack
	3786	+ label = 260LLU; // continue to roll stack
3697	3787	break;
3698	3788	}
3699		- case 257LLU: // return from equ to matchid
	3789	+ case 267LLU: // return from equ to matchid
3700	3790	{
3701	3791	// copy mutable arguments back from call to equ
3702	3792	// copy back results provided by call to equ

		@@ -3703,21 +3793,21 @@
3703	3793	stack[base + 5] = stack[base + 9LLU];
3704	3794	if(!stack[base + 5]/isqual/)
3705	3795	{
3706		- label = 258LLU; // jump to alternative
	3796	+ label = 268LLU; // jump to alternative
3707	3797	break;
3708	3798	}
3709	3799
3710	3800	// consequent
3711		- label = 259LLU; // consequent complete
	3801	+ label = 269LLU; // consequent complete
3712	3802	break;
3713	3803	}
3714		- case 258LLU: // alternative
	3804	+ case 268LLU: // alternative
3715	3805	{
3716	3806	fprintf(stderr, "%s", "in function ");
3717	3807	// call reportid from matchid
3718		- stack[base + 6LLU] = 260LLU/throw to this address/;
	3808	+ stack[base + 6LLU] = 270LLU/throw to this address/;
3719	3809	stack[base + 7LLU] = base;
3720		- stack[base + 8LLU] = 261LLU;
	3810	+ stack[base + 8LLU] = 271LLU;
3721	3811	// arguments for call to reportid
3722	3812	stack[base + 9LLU] = stack[base + 0]/fnid/;
3723	3813	// set stack-base & callee-address

		@@ -3725,22 +3815,22 @@
3725	3815	label = 18446744073709551586LLU; // reportid
3726	3816	break;
3727	3817	}
3728		- case 260LLU: // copy-back deleter (reportid to matchid)
	3818	+ case 270LLU: // copy-back deleter (reportid to matchid)
3729	3819	{
3730	3820	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3731	3821	// copy mutable arguments back from call to reportid
3732		- label = 250LLU; // continue to roll stack
	3822	+ label = 260LLU; // continue to roll stack
3733	3823	break;
3734	3824	}
3735		- case 261LLU: // return from reportid to matchid
	3825	+ case 271LLU: // return from reportid to matchid
3736	3826	{
3737	3827	// copy mutable arguments back from call to reportid
3738	3828	fprintf(stderr, "%s", ": ");
3739	3829	fprintf(stderr, "%s", "expected ");
3740	3830	// call reportid from matchid
3741		- stack[base + 6LLU] = 262LLU/throw to this address/;
	3831	+ stack[base + 6LLU] = 272LLU/throw to this address/;
3742	3832	stack[base + 7LLU] = base;
3743		- stack[base + 8LLU] = 263LLU;
	3833	+ stack[base + 8LLU] = 273LLU;
3744	3834	// arguments for call to reportid
3745	3835	stack[base + 9LLU] = stack[base + 1]/id/;
3746	3836	// set stack-base & callee-address

		@@ -3748,21 +3838,21 @@
3748	3838	label = 18446744073709551586LLU; // reportid
3749	3839	break;
3750	3840	}
3751		- case 262LLU: // copy-back deleter (reportid to matchid)
	3841	+ case 272LLU: // copy-back deleter (reportid to matchid)
3752	3842	{
3753	3843	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3754	3844	// copy mutable arguments back from call to reportid
3755		- label = 250LLU; // continue to roll stack
	3845	+ label = 260LLU; // continue to roll stack
3756	3846	break;
3757	3847	}
3758		- case 263LLU: // return from reportid to matchid
	3848	+ case 273LLU: // return from reportid to matchid
3759	3849	{
3760	3850	// copy mutable arguments back from call to reportid
3761	3851	fprintf(stderr, "%s", " but found token ");
3762	3852	// call reporttok from matchid
3763		- stack[base + 6LLU] = 264LLU/throw to this address/;
	3853	+ stack[base + 6LLU] = 274LLU/throw to this address/;
3764	3854	stack[base + 7LLU] = base;
3765		- stack[base + 8LLU] = 265LLU;
	3855	+ stack[base + 8LLU] = 275LLU;
3766	3856	// arguments for call to reporttok
3767	3857	stack[base + 9LLU] = stack[base + 3]/variant/;
3768	3858	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3771,33 +3861,33 @@
3771	3861	label = 18446744073709551582LLU; // reporttok
3772	3862	break;
3773	3863	}
3774		- case 264LLU: // copy-back deleter (reporttok to matchid)
	3864	+ case 274LLU: // copy-back deleter (reporttok to matchid)
3775	3865	{
3776	3866	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
3777	3867	// copy mutable arguments back from call to reporttok
3778		- label = 250LLU; // continue to roll stack
	3868	+ label = 260LLU; // continue to roll stack
3779	3869	break;
3780	3870	}
3781		- case 265LLU: // return from reporttok to matchid
	3871	+ case 275LLU: // return from reporttok to matchid
3782	3872	{
3783	3873	// copy mutable arguments back from call to reporttok
3784	3874	fprintf(stderr, "%s", "\n");
3785	3875	exit(-1);
3786		- label = 259LLU; // alternative complete
	3876	+ label = 269LLU; // alternative complete
3787	3877	break;
3788	3878	}
3789		- case 259LLU: // completed if-then-else
	3879	+ case 269LLU: // completed if-then-else
3790	3880	{
3791		- label = 255LLU; // consequent complete
	3881	+ label = 265LLU; // consequent complete
3792	3882	break;
3793	3883	}
3794		- case 254LLU: // alternative
	3884	+ case 264LLU: // alternative
3795	3885	{
3796	3886	fprintf(stderr, "%s", "in function ");
3797	3887	// call reportid from matchid
3798		- stack[base + 6LLU] = 266LLU/throw to this address/;
	3888	+ stack[base + 6LLU] = 276LLU/throw to this address/;
3799	3889	stack[base + 7LLU] = base;
3800		- stack[base + 8LLU] = 267LLU;
	3890	+ stack[base + 8LLU] = 277LLU;
3801	3891	// arguments for call to reportid
3802	3892	stack[base + 9LLU] = stack[base + 0]/fnid/;
3803	3893	// set stack-base & callee-address

		@@ -3805,22 +3895,22 @@
3805	3895	label = 18446744073709551586LLU; // reportid
3806	3896	break;
3807	3897	}
3808		- case 266LLU: // copy-back deleter (reportid to matchid)
	3898	+ case 276LLU: // copy-back deleter (reportid to matchid)
3809	3899	{
3810	3900	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3811	3901	// copy mutable arguments back from call to reportid
3812		- label = 250LLU; // continue to roll stack
	3902	+ label = 260LLU; // continue to roll stack
3813	3903	break;
3814	3904	}
3815		- case 267LLU: // return from reportid to matchid
	3905	+ case 277LLU: // return from reportid to matchid
3816	3906	{
3817	3907	// copy mutable arguments back from call to reportid
3818	3908	fprintf(stderr, "%s", ": ");
3819	3909	fprintf(stderr, "%s", "expected ");
3820	3910	// call reportid from matchid
3821		- stack[base + 6LLU] = 268LLU/throw to this address/;
	3911	+ stack[base + 6LLU] = 278LLU/throw to this address/;
3822	3912	stack[base + 7LLU] = base;
3823		- stack[base + 8LLU] = 269LLU;
	3913	+ stack[base + 8LLU] = 279LLU;
3824	3914	// arguments for call to reportid
3825	3915	stack[base + 9LLU] = stack[base + 1]/id/;
3826	3916	// set stack-base & callee-address

		@@ -3828,21 +3918,21 @@
3828	3918	label = 18446744073709551586LLU; // reportid
3829	3919	break;
3830	3920	}
3831		- case 268LLU: // copy-back deleter (reportid to matchid)
	3921	+ case 278LLU: // copy-back deleter (reportid to matchid)
3832	3922	{
3833	3923	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3834	3924	// copy mutable arguments back from call to reportid
3835		- label = 250LLU; // continue to roll stack
	3925	+ label = 260LLU; // continue to roll stack
3836	3926	break;
3837	3927	}
3838		- case 269LLU: // return from reportid to matchid
	3928	+ case 279LLU: // return from reportid to matchid
3839	3929	{
3840	3930	// copy mutable arguments back from call to reportid
3841	3931	fprintf(stderr, "%s", " but found token ");
3842	3932	// call reporttok from matchid
3843		- stack[base + 6LLU] = 270LLU/throw to this address/;
	3933	+ stack[base + 6LLU] = 280LLU/throw to this address/;
3844	3934	stack[base + 7LLU] = base;
3845		- stack[base + 8LLU] = 271LLU;
	3935	+ stack[base + 8LLU] = 281LLU;
3846	3936	// arguments for call to reporttok
3847	3937	stack[base + 9LLU] = stack[base + 3]/variant/;
3848	3938	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3851,22 +3941,22 @@
3851	3941	label = 18446744073709551582LLU; // reporttok
3852	3942	break;
3853	3943	}
3854		- case 270LLU: // copy-back deleter (reporttok to matchid)
	3944	+ case 280LLU: // copy-back deleter (reporttok to matchid)
3855	3945	{
3856	3946	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
3857	3947	// copy mutable arguments back from call to reporttok
3858		- label = 250LLU; // continue to roll stack
	3948	+ label = 260LLU; // continue to roll stack
3859	3949	break;
3860	3950	}
3861		- case 271LLU: // return from reporttok to matchid
	3951	+ case 281LLU: // return from reporttok to matchid
3862	3952	{
3863	3953	// copy mutable arguments back from call to reporttok
3864	3954	fprintf(stderr, "%s", "\n");
3865	3955	exit(-1);
3866		- label = 255LLU; // alternative complete
	3956	+ label = 265LLU; // alternative complete
3867	3957	break;
3868	3958	}
3869		- case 255LLU: // completed if-then-else
	3959	+ case 265LLU: // completed if-then-else
3870	3960	{
3871	3961	// return from matchid
3872	3962	label = stack[base - 1];

		@@ -3873,7 +3963,7 @@
3873	3963	base = stack[base - 2];
3874	3964	break;
3875	3965	}
3876		- case 273LLU: // function isncs failed
	3966	+ case 283LLU: // function isncs failed
3877	3967	{
3878	3968	fprintf(stderr, "function isncs failed\n");
3879	3969	label = stack[base - 3];

		@@ -3880,33 +3970,33 @@
3880	3970	base = stack[base - 2];
3881	3971	break;
3882	3972	}
3883		- case 272LLU: // isncs
	3973	+ case 282LLU: // isncs
3884	3974	{
3885	3975	//#define res0 0
3886	3976	//#define arg0 1
3887		- label = 275LLU; // skip deleter
	3977	+ label = 285LLU; // skip deleter
3888	3978	break;
3889	3979	}
3890		- case 274LLU: // deleter
	3980	+ case 284LLU: // deleter
3891	3981	{
3892	3982	// throw from isncs
3893	3983	if(!stack[base + 2])
3894	3984	{
3895	3985	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
3897	3987	break;
3898	3988	}
3899	3989	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
3901	3991	break;
3902	3992	}
3903		- case 275LLU: // skipped deleter
	3993	+ case 285LLU: // skipped deleter
3904	3994	{
3905	3995	stack[base + 2] = 0;
3906	3996	// call equ from isncs
3907		- stack[base + 3LLU] = 276LLU/throw to this address/;
	3997	+ stack[base + 3LLU] = 286LLU/throw to this address/;
3908	3998	stack[base + 4LLU] = base;
3909		- stack[base + 5LLU] = 277LLU;
	3999	+ stack[base + 5LLU] = 287LLU;
3910	4000	// arguments for call to equ
3911	4001	stack[base + 7LLU] = stack[base + 1]/tokvar/;
3912	4002	stack[base + 8LLU] = 1LLU;

		@@ -3915,14 +4005,14 @@
3915	4005	label = 18446744073709551600LLU; // equ
3916	4006	break;
3917	4007	}
3918		- case 276LLU: // copy-back deleter (equ to isncs)
	4008	+ case 286LLU: // copy-back deleter (equ to isncs)
3919	4009	{
3920	4010	fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
3921	4011	// copy mutable arguments back from call to equ
3922		- label = 274LLU; // continue to roll stack
	4012	+ label = 284LLU; // continue to roll stack
3923	4013	break;
3924	4014	}
3925		- case 277LLU: // return from equ to isncs
	4015	+ case 287LLU: // return from equ to isncs
3926	4016	{
3927	4017	// copy mutable arguments back from call to equ
3928	4018	// copy back results provided by call to equ

		@@ -3929,39 +4019,39 @@
3929	4019	stack[base + 2] = stack[base + 6LLU];
3930	4020	if(!stack[base + 2]/isequal/)
3931	4021	{
3932		- label = 278LLU; // jump to alternative
	4022	+ label = 288LLU; // jump to alternative
3933	4023	break;
3934	4024	}
3935	4025
3936	4026	// consequent
3937		- label = 281LLU; // skip deleter
	4027	+ label = 291LLU; // skip deleter
3938	4028	break;
3939	4029	}
3940		- case 280LLU: // deleter
	4030	+ case 290LLU: // deleter
3941	4031	{
3942	4032	// throw from isncs
3943	4033	if(!stack[base + 0])
3944	4034	{
3945	4035	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
3947	4037	break;
3948	4038	}
3949	4039	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
3951	4041	break;
3952	4042	}
3953		- case 281LLU: // skipped deleter
	4043	+ case 291LLU: // skipped deleter
3954	4044	{
3955	4045	stack[base + 0] = 1;
3956		- label = 279LLU; // consequent complete
	4046	+ label = 289LLU; // consequent complete
3957	4047	break;
3958	4048	}
3959		- case 278LLU: // alternative
	4049	+ case 288LLU: // alternative
3960	4050	{
3961	4051	// call equ from isncs
3962		- stack[base + 3LLU] = 282LLU/throw to this address/;
	4052	+ stack[base + 3LLU] = 292LLU/throw to this address/;
3963	4053	stack[base + 4LLU] = base;
3964		- stack[base + 5LLU] = 283LLU;
	4054	+ stack[base + 5LLU] = 293LLU;
3965	4055	// arguments for call to equ
3966	4056	stack[base + 7LLU] = stack[base + 1]/tokvar/;
3967	4057	stack[base + 8LLU] = 2LLU;

		@@ -3970,14 +4060,14 @@
3970	4060	label = 18446744073709551600LLU; // equ
3971	4061	break;
3972	4062	}
3973		- case 282LLU: // copy-back deleter (equ to isncs)
	4063	+ case 292LLU: // copy-back deleter (equ to isncs)
3974	4064	{
3975	4065	fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
3976	4066	// copy mutable arguments back from call to equ
3977		- label = 274LLU; // continue to roll stack
	4067	+ label = 284LLU; // continue to roll stack
3978	4068	break;
3979	4069	}
3980		- case 283LLU: // return from equ to isncs
	4070	+ case 293LLU: // return from equ to isncs
3981	4071	{
3982	4072	// copy mutable arguments back from call to equ
3983	4073	// copy back results provided by call to equ

		@@ -3984,39 +4074,39 @@
3984	4074	stack[base + 2] = stack[base + 6LLU];
3985	4075	if(!stack[base + 2]/isequal/)
3986	4076	{
3987		- label = 284LLU; // jump to alternative
	4077	+ label = 294LLU; // jump to alternative
3988	4078	break;
3989	4079	}
3990	4080
3991	4081	// consequent
3992		- label = 287LLU; // skip deleter
	4082	+ label = 297LLU; // skip deleter
3993	4083	break;
3994	4084	}
3995		- case 286LLU: // deleter
	4085	+ case 296LLU: // deleter
3996	4086	{
3997	4087	// throw from isncs
3998	4088	if(!stack[base + 0])
3999	4089	{
4000	4090	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
4002	4092	break;
4003	4093	}
4004	4094	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
4006	4096	break;
4007	4097	}
4008		- case 287LLU: // skipped deleter
	4098	+ case 297LLU: // skipped deleter
4009	4099	{
4010	4100	stack[base + 0] = 1;
4011		- label = 285LLU; // consequent complete
	4101	+ label = 295LLU; // consequent complete
4012	4102	break;
4013	4103	}
4014		- case 284LLU: // alternative
	4104	+ case 294LLU: // alternative
4015	4105	{
4016	4106	// call equ from isncs
4017		- stack[base + 3LLU] = 288LLU/throw to this address/;
	4107	+ stack[base + 3LLU] = 298LLU/throw to this address/;
4018	4108	stack[base + 4LLU] = base;
4019		- stack[base + 5LLU] = 289LLU;
	4109	+ stack[base + 5LLU] = 299LLU;
4020	4110	// arguments for call to equ
4021	4111	stack[base + 7LLU] = stack[base + 1]/tokvar/;
4022	4112	stack[base + 8LLU] = 3LLU;

		@@ -4025,14 +4115,14 @@
4025	4115	label = 18446744073709551600LLU; // equ
4026	4116	break;
4027	4117	}
4028		- case 288LLU: // copy-back deleter (equ to isncs)
	4118	+ case 298LLU: // copy-back deleter (equ to isncs)
4029	4119	{
4030	4120	fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
4031	4121	// copy mutable arguments back from call to equ
4032		- label = 274LLU; // continue to roll stack
	4122	+ label = 284LLU; // continue to roll stack
4033	4123	break;
4034	4124	}
4035		- case 289LLU: // return from equ to isncs
	4125	+ case 299LLU: // return from equ to isncs
4036	4126	{
4037	4127	// copy mutable arguments back from call to equ
4038	4128	// copy back results provided by call to equ

		@@ -4039,68 +4129,68 @@
4039	4129	stack[base + 2] = stack[base + 6LLU];
4040	4130	if(!stack[base + 2]/isequal/)
4041	4131	{
4042		- label = 290LLU; // jump to alternative
	4132	+ label = 300LLU; // jump to alternative
4043	4133	break;
4044	4134	}
4045	4135
4046	4136	// consequent
4047		- label = 293LLU; // skip deleter
	4137	+ label = 303LLU; // skip deleter
4048	4138	break;
4049	4139	}
4050		- case 292LLU: // deleter
	4140	+ case 302LLU: // deleter
4051	4141	{
4052	4142	// throw from isncs
4053	4143	if(!stack[base + 0])
4054	4144	{
4055	4145	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
4057	4147	break;
4058	4148	}
4059	4149	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
4061	4151	break;
4062	4152	}
4063		- case 293LLU: // skipped deleter
	4153	+ case 303LLU: // skipped deleter
4064	4154	{
4065	4155	stack[base + 0] = 1;
4066		- label = 291LLU; // consequent complete
	4156	+ label = 301LLU; // consequent complete
4067	4157	break;
4068	4158	}
4069		- case 290LLU: // alternative
	4159	+ case 300LLU: // alternative
4070	4160	{
4071		- label = 295LLU; // skip deleter
	4161	+ label = 305LLU; // skip deleter
4072	4162	break;
4073	4163	}
4074		- case 294LLU: // deleter
	4164	+ case 304LLU: // deleter
4075	4165	{
4076	4166	// throw from isncs
4077	4167	if(!stack[base + 0])
4078	4168	{
4079	4169	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
4081	4171	break;
4082	4172	}
4083	4173	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
4085	4175	break;
4086	4176	}
4087		- case 295LLU: // skipped deleter
	4177	+ case 305LLU: // skipped deleter
4088	4178	{
4089	4179	stack[base + 0] = 0;
4090		- label = 291LLU; // alternative complete
	4180	+ label = 301LLU; // alternative complete
4091	4181	break;
4092	4182	}
4093		- case 291LLU: // completed if-then-else
	4183	+ case 301LLU: // completed if-then-else
4094	4184	{
4095		- label = 285LLU; // alternative complete
	4185	+ label = 295LLU; // alternative complete
4096	4186	break;
4097	4187	}
4098		- case 285LLU: // completed if-then-else
	4188	+ case 295LLU: // completed if-then-else
4099	4189	{
4100		- label = 279LLU; // alternative complete
	4190	+ label = 289LLU; // alternative complete
4101	4191	break;
4102	4192	}
4103		- case 279LLU: // completed if-then-else
	4193	+ case 289LLU: // completed if-then-else
4104	4194	{
4105	4195	// return from isncs
4106	4196	label = stack[base - 1];

		@@ -4107,7 +4197,7 @@
4107	4197	base = stack[base - 2];
4108	4198	break;
4109	4199	}
4110		- case 296LLU: // ~type
	4200	+ case 306LLU: // ~type
4111	4201	{
4112	4202	if(stack[base + 0]/variant-nr/ >= 2)
4113	4203	{

		@@ -4114,10 +4204,10 @@
4114	4204	fprintf(stderr, "in ~type: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
4115	4205	exit(-1);
4116	4206	}
4117		- label = 296LLU + 1LLU + stack[base + 0]/variant-nr/;
	4207	+ label = 306LLU + 1LLU + stack[base + 0]/variant-nr/;
4118	4208	break;
4119	4209	}
4120		- case 296LLU + 1LLU + 0LLU: // ~type.typename
	4210	+ case 306LLU + 1LLU + 0LLU: // ~type.typename
4121	4211	{
4122	4212	// release element name
4123	4213	// release variant container

		@@ -4126,7 +4216,7 @@
4126	4216	base = stack[base - 2];
4127	4217	break;
4128	4218	}
4129		- case 296LLU + 1LLU + 1LLU: // ~type.typelist
	4219	+ case 306LLU + 1LLU + 1LLU: // ~type.typelist
4130	4220	{
4131	4221	// release element subtype
4132	4222	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -4136,14 +4226,14 @@
4136	4226	newstack[0] = (uint64_t)stack; // backup stack location
4137	4227	newstack[1] = 1234567890;
4138	4228	newstack[2] = base;
4139		- newstack[3] = 299LLU;
	4229	+ newstack[3] = 309LLU;
4140	4230	stack = newstack;
4141	4231	// set stack-base & callee-address
4142	4232	base = 4/deloffset/;
4143		- label = 296LLU; // ~type
	4233	+ label = 306LLU; // ~type
4144	4234	break;
4145	4235	}
4146		- case 299LLU: // return from ~type to type
	4236	+ case 309LLU: // return from ~type to type
4147	4237	{
4148	4238	stack = (uint64_t *)stack[0];
4149	4239	// releasing toplevel container

		@@ -4155,7 +4245,7 @@
4155	4245	base = stack[base - 2];
4156	4246	break;
4157	4247	}
4158		- case 301LLU: // function mktypename failed
	4248	+ case 311LLU: // function mktypename failed
4159	4249	{
4160	4250	fprintf(stderr, "function mktypename failed\n");
4161	4251	label = stack[base - 3];

		@@ -4162,20 +4252,20 @@
4162	4252	base = stack[base - 2];
4163	4253	break;
4164	4254	}
4165		- case 300LLU: // mktypename
	4255	+ case 310LLU: // mktypename
4166	4256	{
4167	4257	//#define res0 0
4168	4258	//#define arg0 1
4169		- label = 303LLU; // skip deleter
	4259	+ label = 313LLU; // skip deleter
4170	4260	break;
4171	4261	}
4172		- case 302LLU: // deleter
	4262	+ case 312LLU: // deleter
4173	4263	{
4174	4264	// throw from mktypename
4175	4265	if(!stack[base + 0])
4176	4266	{
4177	4267	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
4179	4269	break;
4180	4270	}
4181	4271	fprintf(stderr, "in function mktypename: unrolling stack, variable type \n");

		@@ -4185,28 +4275,28 @@
4185	4275	newstack[0] = (uint64_t)stack; // backup stack location
4186	4276	newstack[1] = 1234567890;
4187	4277	newstack[2] = base;
4188		- newstack[3] = 304LLU;
	4278	+ newstack[3] = 314LLU;
4189	4279	stack = newstack;
4190	4280	// set stack-base & callee-address
4191	4281	base = 4/deloffset/;
4192		- label = 296LLU; // ~type
	4282	+ label = 306LLU; // ~type
4193	4283	break;
4194	4284	}
4195		- case 304LLU: // return from ~type to mktypename
	4285	+ case 314LLU: // return from ~type to mktypename
4196	4286	{
4197	4287	stack = (uint64_t *)stack[0];
4198	4288	// releasing toplevel container
4199	4289	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4200	4290
4201		- label = 301LLU; // continue unrolling stack, delete next variable
	4291	+ label = 311LLU; // continue unrolling stack, delete next variable
4202	4292	break;
4203	4293	}
4204		- case 303LLU: // skipped deleter
	4294	+ case 313LLU: // skipped deleter
4205	4295	{
4206	4296	// construct type.typename
4207	4297	if(!(stack[base + 0] = construct(1)))
4208	4298	{
4209		- label = 301LLU; // throw: begin to unroll stack
	4299	+ label = 311LLU; // throw: begin to unroll stack
4210	4300	break;
4211	4301	}
4212	4302

		@@ -4218,7 +4308,7 @@
4218	4308	base = stack[base - 2];
4219	4309	break;
4220	4310	}
4221		- case 306LLU: // function printtype failed
	4311	+ case 316LLU: // function printtype failed
4222	4312	{
4223	4313	fprintf(stderr, "function printtype failed\n");
4224	4314	label = stack[base - 3];

		@@ -4225,12 +4315,12 @@
4225	4315	base = stack[base - 2];
4226	4316	break;
4227	4317	}
4228		- case 305LLU: // printtype
	4318	+ case 315LLU: // printtype
4229	4319	{
4230	4320	//#define arg0 0
4231	4321	if(/typename/0 != ((uint64_t )(stack[base + 0]/type*/))[0])
4232	4322	{
4233		- label = 308LLU; // jump to alternative
	4323	+ label = 318LLU; // jump to alternative
4234	4324	break;
4235	4325	}
4236	4326

		@@ -4238,9 +4328,9 @@
4238	4328
4239	4329	// case
4240	4330	// call printid from printtype
4241		- stack[base + 2LLU] = 310LLU/throw to this address/;
	4331	+ stack[base + 2LLU] = 320LLU/throw to this address/;
4242	4332	stack[base + 3LLU] = base;
4243		- stack[base + 4LLU] = 311LLU;
	4333	+ stack[base + 4LLU] = 321LLU;
4244	4334	// arguments for call to printid
4245	4335	stack[base + 5LLU] = stack[base + 1]/name/;
4246	4336	// set stack-base & callee-address

		@@ -4248,31 +4338,31 @@
4248	4338	label = 18446744073709551587LLU; // printid
4249	4339	break;
4250	4340	}
4251		- case 310LLU: // copy-back deleter (printid to printtype)
	4341	+ case 320LLU: // copy-back deleter (printid to printtype)
4252	4342	{
4253	4343	fprintf(stderr, "in function printtype: unrolling stack, copy-back (printid to printtype)\n");
4254	4344	// copy mutable arguments back from call to printid
4255		- label = 309LLU; // continue to roll stack
	4345	+ label = 319LLU; // continue to roll stack
4256	4346	break;
4257	4347	}
4258		- case 311LLU: // return from printid to printtype
	4348	+ case 321LLU: // return from printid to printtype
4259	4349	{
4260	4350	// copy mutable arguments back from call to printid
4261	4351	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4262		- label = 307LLU; // case complete
	4352	+ label = 317LLU; // case complete
4263	4353	break;
4264	4354	}
4265		- case 309LLU: // copy-back deleter (switch)
	4355	+ case 319LLU: // copy-back deleter (switch)
4266	4356	{
4267	4357	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4268		- label = 306LLU; // continue to unroll stack
	4358	+ label = 316LLU; // continue to unroll stack
4269	4359	break;
4270	4360	}
4271		- case 308LLU: // try next case
	4361	+ case 318LLU: // try next case
4272	4362	{
4273	4363	if(/typelist/1 != ((uint64_t )(stack[base + 0]/type*/))[0])
4274	4364	{
4275		- label = 312LLU; // jump to alternative
	4365	+ label = 322LLU; // jump to alternative
4276	4366	break;
4277	4367	}
4278	4368

		@@ -4283,7 +4373,7 @@
4283	4373	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
4284	4374	if(!newstack)
4285	4375	{
4286		- label = 313LLU; // throw: begin to unroll stack
	4376	+ label = 323LLU; // throw: begin to unroll stack
4287	4377	break;
4288	4378	}
4289	4379

		@@ -4290,18 +4380,18 @@
4290	4380	newstack[10LLU] = 9876543210LLU; // overflow-marker
4291	4381	// call printtype from printtype
4292	4382	newstack[0] = (uint64_t)stack; // backup stack location
4293		- newstack[1] = 314LLU;
	4383	+ newstack[1] = 324LLU;
4294	4384	newstack[2] = base;
4295		- newstack[3] = 315LLU;
	4385	+ newstack[3] = 325LLU;
4296	4386	// arguments for call to printtype
4297	4387	newstack[4LLU] = stack[base + 1]/subtype/;
4298	4388	stack = newstack;
4299	4389	// set stack-base & callee-address
4300	4390	base = 4/deloffset/;
4301		- label = 305LLU; // printtype
	4391	+ label = 315LLU; // printtype
4302	4392	break;
4303	4393	}
4304		- case 314LLU: // copy-back deleter (printtype to printtype)
	4394	+ case 324LLU: // copy-back deleter (printtype to printtype)
4305	4395	{
4306	4396	fprintf(stderr, "in function printtype: unrolling stack, copy-back (printtype to printtype)\n");
4307	4397	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4313,10 +4403,10 @@
4313	4403	}
4314	4404	Free(10LLU + 1, sizeof(uint64_t), stack);
4315	4405	stack = oldstack;
4316		- label = 313LLU; // continue to unroll stack
	4406	+ label = 323LLU; // continue to unroll stack
4317	4407	break;
4318	4408	}
4319		- case 315LLU: // return from printtype to printtype
	4409	+ case 325LLU: // return from printtype to printtype
4320	4410	{
4321	4411	uint64_t oldstack = (uint64_t )stack[0];
4322	4412	// copy mutable arguments back from call to printtype

		@@ -4329,21 +4419,21 @@
4329	4419	stack = oldstack;
4330	4420	printf("%s", "]");
4331	4421	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4332		- label = 307LLU; // case complete
	4422	+ label = 317LLU; // case complete
4333	4423	break;
4334	4424	}
4335		- case 313LLU: // copy-back deleter (switch)
	4425	+ case 323LLU: // copy-back deleter (switch)
4336	4426	{
4337	4427	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4338		- label = 306LLU; // continue to unroll stack
	4428	+ label = 316LLU; // continue to unroll stack
4339	4429	break;
4340	4430	}
4341		- case 312LLU: // try next case
	4431	+ case 322LLU: // try next case
4342	4432	{
4343	4433	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4344	4434	exit(-1);
4345	4435	}
4346		- case 307LLU: // completed switch
	4436	+ case 317LLU: // completed switch
4347	4437	{
4348	4438	// return from printtype
4349	4439	label = stack[base - 1];

		@@ -4350,7 +4440,7 @@
4350	4440	base = stack[base - 2];
4351	4441	break;
4352	4442	}
4353		- case 317LLU: // function reporttype failed
	4443	+ case 327LLU: // function reporttype failed
4354	4444	{
4355	4445	fprintf(stderr, "function reporttype failed\n");
4356	4446	label = stack[base - 3];

		@@ -4357,12 +4447,12 @@
4357	4447	base = stack[base - 2];
4358	4448	break;
4359	4449	}
4360		- case 316LLU: // reporttype
	4450	+ case 326LLU: // reporttype
4361	4451	{
4362	4452	//#define arg0 0
4363	4453	if(/typename/0 != ((uint64_t )(stack[base + 0]/type*/))[0])
4364	4454	{
4365		- label = 319LLU; // jump to alternative
	4455	+ label = 329LLU; // jump to alternative
4366	4456	break;
4367	4457	}
4368	4458

		@@ -4370,9 +4460,9 @@
4370	4460
4371	4461	// case
4372	4462	// call reportid from reporttype
4373		- stack[base + 2LLU] = 321LLU/throw to this address/;
	4463	+ stack[base + 2LLU] = 331LLU/throw to this address/;
4374	4464	stack[base + 3LLU] = base;
4375		- stack[base + 4LLU] = 322LLU;
	4465	+ stack[base + 4LLU] = 332LLU;
4376	4466	// arguments for call to reportid
4377	4467	stack[base + 5LLU] = stack[base + 1]/name/;
4378	4468	// set stack-base & callee-address

		@@ -4380,31 +4470,31 @@
4380	4470	label = 18446744073709551586LLU; // reportid
4381	4471	break;
4382	4472	}
4383		- case 321LLU: // copy-back deleter (reportid to reporttype)
	4473	+ case 331LLU: // copy-back deleter (reportid to reporttype)
4384	4474	{
4385	4475	fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reportid to reporttype)\n");
4386	4476	// copy mutable arguments back from call to reportid
4387		- label = 320LLU; // continue to roll stack
	4477	+ label = 330LLU; // continue to roll stack
4388	4478	break;
4389	4479	}
4390		- case 322LLU: // return from reportid to reporttype
	4480	+ case 332LLU: // return from reportid to reporttype
4391	4481	{
4392	4482	// copy mutable arguments back from call to reportid
4393	4483	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4394		- label = 318LLU; // case complete
	4484	+ label = 328LLU; // case complete
4395	4485	break;
4396	4486	}
4397		- case 320LLU: // copy-back deleter (switch)
	4487	+ case 330LLU: // copy-back deleter (switch)
4398	4488	{
4399	4489	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4400		- label = 317LLU; // continue to unroll stack
	4490	+ label = 327LLU; // continue to unroll stack
4401	4491	break;
4402	4492	}
4403		- case 319LLU: // try next case
	4493	+ case 329LLU: // try next case
4404	4494	{
4405	4495	if(/typelist/1 != ((uint64_t )(stack[base + 0]/type*/))[0])
4406	4496	{
4407		- label = 323LLU; // jump to alternative
	4497	+ label = 333LLU; // jump to alternative
4408	4498	break;
4409	4499	}
4410	4500

		@@ -4415,7 +4505,7 @@
4415	4505	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
4416	4506	if(!newstack)
4417	4507	{
4418		- label = 324LLU; // throw: begin to unroll stack
	4508	+ label = 334LLU; // throw: begin to unroll stack
4419	4509	break;
4420	4510	}
4421	4511

		@@ -4422,18 +4512,18 @@
4422	4512	newstack[10LLU] = 9876543210LLU; // overflow-marker
4423	4513	// call reporttype from reporttype
4424	4514	newstack[0] = (uint64_t)stack; // backup stack location
4425		- newstack[1] = 325LLU;
	4515	+ newstack[1] = 335LLU;
4426	4516	newstack[2] = base;
4427		- newstack[3] = 326LLU;
	4517	+ newstack[3] = 336LLU;
4428	4518	// arguments for call to reporttype
4429	4519	newstack[4LLU] = stack[base + 1]/subtype/;
4430	4520	stack = newstack;
4431	4521	// set stack-base & callee-address
4432	4522	base = 4/deloffset/;
4433		- label = 316LLU; // reporttype
	4523	+ label = 326LLU; // reporttype
4434	4524	break;
4435	4525	}
4436		- case 325LLU: // copy-back deleter (reporttype to reporttype)
	4526	+ case 335LLU: // copy-back deleter (reporttype to reporttype)
4437	4527	{
4438	4528	fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reporttype to reporttype)\n");
4439	4529	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4445,10 +4535,10 @@
4445	4535	}
4446	4536	Free(10LLU + 1, sizeof(uint64_t), stack);
4447	4537	stack = oldstack;
4448		- label = 324LLU; // continue to unroll stack
	4538	+ label = 334LLU; // continue to unroll stack
4449	4539	break;
4450	4540	}
4451		- case 326LLU: // return from reporttype to reporttype
	4541	+ case 336LLU: // return from reporttype to reporttype
4452	4542	{
4453	4543	uint64_t oldstack = (uint64_t )stack[0];
4454	4544	// copy mutable arguments back from call to reporttype

		@@ -4461,21 +4551,21 @@
4461	4551	stack = oldstack;
4462	4552	fprintf(stderr, "%s", "]");
4463	4553	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4464		- label = 318LLU; // case complete
	4554	+ label = 328LLU; // case complete
4465	4555	break;
4466	4556	}
4467		- case 324LLU: // copy-back deleter (switch)
	4557	+ case 334LLU: // copy-back deleter (switch)
4468	4558	{
4469	4559	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4470		- label = 317LLU; // continue to unroll stack
	4560	+ label = 327LLU; // continue to unroll stack
4471	4561	break;
4472	4562	}
4473		- case 323LLU: // try next case
	4563	+ case 333LLU: // try next case
4474	4564	{
4475	4565	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4476	4566	exit(-1);
4477	4567	}
4478		- case 318LLU: // completed switch
	4568	+ case 328LLU: // completed switch
4479	4569	{
4480	4570	// return from reporttype
4481	4571	label = stack[base - 1];

		@@ -4482,7 +4572,7 @@
4482	4572	base = stack[base - 2];
4483	4573	break;
4484	4574	}
4485		- case 328LLU: // function copytype failed
	4575	+ case 338LLU: // function copytype failed
4486	4576	{
4487	4577	fprintf(stderr, "function copytype failed\n");
4488	4578	label = stack[base - 3];

		@@ -4489,13 +4579,13 @@
4489	4579	base = stack[base - 2];
4490	4580	break;
4491	4581	}
4492		- case 327LLU: // copytype
	4582	+ case 337LLU: // copytype
4493	4583	{
4494	4584	//#define res0 0
4495	4585	//#define arg0 1
4496	4586	if(/typename/0 != ((uint64_t )(stack[base + 1]/type*/))[0])
4497	4587	{
4498		- label = 330LLU; // jump to alternative
	4588	+ label = 340LLU; // jump to alternative
4499	4589	break;
4500	4590	}
4501	4591

		@@ -4502,16 +4592,16 @@
4502	4592	/name/stack[base + 2] = ((uint64_t *)(stack[base + 1]/type/))[1][0]/name*/;
4503	4593
4504	4594	// case
4505		- label = 333LLU; // skip deleter
	4595	+ label = 343LLU; // skip deleter
4506	4596	break;
4507	4597	}
4508		- case 332LLU: // deleter
	4598	+ case 342LLU: // deleter
4509	4599	{
4510	4600	// throw from copytype
4511	4601	if(!stack[base + 0])
4512	4602	{
4513	4603	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
4515	4605	break;
4516	4606	}
4517	4607	fprintf(stderr, "in function copytype: unrolling stack, variable type \n");

		@@ -4521,28 +4611,28 @@
4521	4611	newstack[0] = (uint64_t)stack; // backup stack location
4522	4612	newstack[1] = 1234567890;
4523	4613	newstack[2] = base;
4524		- newstack[3] = 334LLU;
	4614	+ newstack[3] = 344LLU;
4525	4615	stack = newstack;
4526	4616	// set stack-base & callee-address
4527	4617	base = 4/deloffset/;
4528		- label = 296LLU; // ~type
	4618	+ label = 306LLU; // ~type
4529	4619	break;
4530	4620	}
4531		- case 334LLU: // return from ~type to copytype
	4621	+ case 344LLU: // return from ~type to copytype
4532	4622	{
4533	4623	stack = (uint64_t *)stack[0];
4534	4624	// releasing toplevel container
4535	4625	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4536	4626
4537		- label = 331LLU; // continue unrolling stack, delete next variable
	4627	+ label = 341LLU; // continue unrolling stack, delete next variable
4538	4628	break;
4539	4629	}
4540		- case 333LLU: // skipped deleter
	4630	+ case 343LLU: // skipped deleter
4541	4631	{
4542	4632	// construct type.typename
4543	4633	if(!(stack[base + 0] = construct(1)))
4544	4634	{
4545		- label = 331LLU; // throw: begin to unroll stack
	4635	+ label = 341LLU; // throw: begin to unroll stack
4546	4636	break;
4547	4637	}
4548	4638

		@@ -4550,20 +4640,20 @@
4550	4640	((uint64_t *)stack[base + 0])[0] = 0;
4551	4641	(((uint64_t *)(stack[base + 0]))[1][0]) = stack[base + 2]/name*/;
4552	4642	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4553		- label = 329LLU; // case complete
	4643	+ label = 339LLU; // case complete
4554	4644	break;
4555	4645	}
4556		- case 331LLU: // copy-back deleter (switch)
	4646	+ case 341LLU: // copy-back deleter (switch)
4557	4647	{
4558	4648	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4559		- label = 328LLU; // continue to unroll stack
	4649	+ label = 338LLU; // continue to unroll stack
4560	4650	break;
4561	4651	}
4562		- case 330LLU: // try next case
	4652	+ case 340LLU: // try next case
4563	4653	{
4564	4654	if(/typelist/1 != ((uint64_t )(stack[base + 1]/type*/))[0])
4565	4655	{
4566		- label = 335LLU; // jump to alternative
	4656	+ label = 345LLU; // jump to alternative
4567	4657	break;
4568	4658	}
4569	4659

		@@ -4570,10 +4660,47 @@
4570	4660	/original/stack[base + 2] = ((uint64_t *)(stack[base + 1]/type/))[1][0]/subtype*/;
4571	4661
4572	4662	// 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	+ {
4573	4700	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4574	4701	if(!newstack)
4575	4702	{
4576		- label = 336LLU; // throw: begin to unroll stack
	4703	+ label = 346LLU; // throw: begin to unroll stack
4577	4704	break;
4578	4705	}
4579	4706

		@@ -4580,18 +4707,18 @@
4580	4707	newstack[15LLU] = 9876543210LLU; // overflow-marker
4581	4708	// call copytype from copytype
4582	4709	newstack[0] = (uint64_t)stack; // backup stack location
4583		- newstack[1] = 337LLU;
	4710	+ newstack[1] = 350LLU;
4584	4711	newstack[2] = base;
4585		- newstack[3] = 338LLU;
	4712	+ newstack[3] = 351LLU;
4586	4713	// arguments for call to copytype
4587	4714	newstack[5LLU] = stack[base + 2]/original/;
4588	4715	stack = newstack;
4589	4716	// set stack-base & callee-address
4590	4717	base = 4/deloffset/;
4591		- label = 327LLU; // copytype
	4718	+ label = 337LLU; // copytype
4592	4719	break;
4593	4720	}
4594		- case 337LLU: // copy-back deleter (copytype to copytype)
	4721	+ case 350LLU: // copy-back deleter (copytype to copytype)
4595	4722	{
4596	4723	fprintf(stderr, "in function copytype: unrolling stack, copy-back (copytype to copytype)\n");
4597	4724	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4603,10 +4730,10 @@
4603	4730	}
4604	4731	Free(15LLU + 1, sizeof(uint64_t), stack);
4605	4732	stack = oldstack;
4606		- label = 336LLU; // continue to unroll stack
	4733	+ label = 346LLU; // continue to unroll stack
4607	4734	break;
4608	4735	}
4609		- case 338LLU: // return from copytype to copytype
	4736	+ case 351LLU: // return from copytype to copytype
4610	4737	{
4611	4738	uint64_t oldstack = (uint64_t )stack[0];
4612	4739	// copy mutable arguments back from call to copytype

		@@ -4619,16 +4746,16 @@
4619	4746	}
4620	4747	Free(15LLU + 1, sizeof(uint64_t), stack);
4621	4748	stack = oldstack;
4622		- label = 340LLU; // skip deleter
	4749	+ label = 353LLU; // skip deleter
4623	4750	break;
4624	4751	}
4625		- case 339LLU: // deleter
	4752	+ case 352LLU: // deleter
4626	4753	{
4627	4754	// throw from copytype
4628	4755	if(!stack[base + 0])
4629	4756	{
4630	4757	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
4632	4759	break;
4633	4760	}
4634	4761	fprintf(stderr, "in function copytype: unrolling stack, variable type \n");

		@@ -4638,28 +4765,28 @@
4638	4765	newstack[0] = (uint64_t)stack; // backup stack location
4639	4766	newstack[1] = 1234567890;
4640	4767	newstack[2] = base;
4641		- newstack[3] = 341LLU;
	4768	+ newstack[3] = 354LLU;
4642	4769	stack = newstack;
4643	4770	// set stack-base & callee-address
4644	4771	base = 4/deloffset/;
4645		- label = 296LLU; // ~type
	4772	+ label = 306LLU; // ~type
4646	4773	break;
4647	4774	}
4648		- case 341LLU: // return from ~type to copytype
	4775	+ case 354LLU: // return from ~type to copytype
4649	4776	{
4650	4777	stack = (uint64_t *)stack[0];
4651	4778	// releasing toplevel container
4652	4779	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4653	4780
4654		- label = 336LLU; // continue unrolling stack, delete next variable
	4781	+ label = 347LLU; // continue unrolling stack, delete next variable
4655	4782	break;
4656	4783	}
4657		- case 340LLU: // skipped deleter
	4784	+ case 353LLU: // skipped deleter
4658	4785	{
4659	4786	// construct type.typelist
4660	4787	if(!(stack[base + 0] = construct(1)))
4661	4788	{
4662		- label = 336LLU; // throw: begin to unroll stack
	4789	+ label = 347LLU; // throw: begin to unroll stack
4663	4790	break;
4664	4791	}
4665	4792

		@@ -4667,21 +4794,21 @@
4667	4794	((uint64_t *)stack[base + 0])[0] = 1;
4668	4795	INIT(&(((uint64_t *)(stack[base + 0]))[1][0]), &stack[base + 3]/copy*/);
4669	4796	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4670		- label = 329LLU; // case complete
	4797	+ label = 339LLU; // case complete
4671	4798	break;
4672	4799	}
4673		- case 336LLU: // copy-back deleter (switch)
	4800	+ case 346LLU: // copy-back deleter (switch)
4674	4801	{
4675	4802	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4676		- label = 328LLU; // continue to unroll stack
	4803	+ label = 338LLU; // continue to unroll stack
4677	4804	break;
4678	4805	}
4679		- case 335LLU: // try next case
	4806	+ case 345LLU: // try next case
4680	4807	{
4681	4808	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4682	4809	exit(-1);
4683	4810	}
4684		- case 329LLU: // completed switch
	4811	+ case 339LLU: // completed switch
4685	4812	{
4686	4813	// return from copytype
4687	4814	label = stack[base - 1];

		@@ -4688,7 +4815,7 @@
4688	4815	base = stack[base - 2];
4689	4816	break;
4690	4817	}
4691		- case 343LLU: // function equtype failed
	4818	+ case 356LLU: // function equtype failed
4692	4819	{
4693	4820	fprintf(stderr, "function equtype failed\n");
4694	4821	label = stack[base - 3];

		@@ -4695,7 +4822,7 @@
4695	4822	base = stack[base - 2];
4696	4823	break;
4697	4824	}
4698		- case 342LLU: // equtype
	4825	+ case 355LLU: // equtype
4699	4826	{
4700	4827	//#define res0 0
4701	4828	//#define arg0 1

		@@ -4702,7 +4829,7 @@
4702	4829	//#define arg1 2
4703	4830	if(/typename/0 != ((uint64_t )(stack[base + 1]/x*/))[0])
4704	4831	{
4705		- label = 345LLU; // jump to alternative
	4832	+ label = 358LLU; // jump to alternative
4706	4833	break;
4707	4834	}
4708	4835

		@@ -4710,7 +4837,7 @@
4710	4837
4711	4838	if(/typename/0 != ((uint64_t )(stack[base + 2]/y*/))[0])
4712	4839	{
4713		- label = 345LLU; // jump to alternative
	4840	+ label = 358LLU; // jump to alternative
4714	4841	break;
4715	4842	}
4716	4843

		@@ -4718,9 +4845,9 @@
4718	4845
4719	4846	// case
4720	4847	// call equ from equtype
4721		- stack[base + 5LLU] = 347LLU/throw to this address/;
	4848	+ stack[base + 5LLU] = 360LLU/throw to this address/;
4722	4849	stack[base + 6LLU] = base;
4723		- stack[base + 7LLU] = 348LLU;
	4850	+ stack[base + 7LLU] = 361LLU;
4724	4851	// arguments for call to equ
4725	4852	stack[base + 9LLU] = stack[base + 3]/xname/;
4726	4853	stack[base + 10LLU] = stack[base + 4]/yname/;

		@@ -4729,14 +4856,14 @@
4729	4856	label = 18446744073709551600LLU; // equ
4730	4857	break;
4731	4858	}
4732		- case 347LLU: // copy-back deleter (equ to equtype)
	4859	+ case 360LLU: // copy-back deleter (equ to equtype)
4733	4860	{
4734	4861	fprintf(stderr, "in function equtype: unrolling stack, copy-back (equ to equtype)\n");
4735	4862	// copy mutable arguments back from call to equ
4736		- label = 346LLU; // continue to roll stack
	4863	+ label = 359LLU; // continue to roll stack
4737	4864	break;
4738	4865	}
4739		- case 348LLU: // return from equ to equtype
	4866	+ case 361LLU: // return from equ to equtype
4740	4867	{
4741	4868	// copy mutable arguments back from call to equ
4742	4869	// copy back results provided by call to equ

		@@ -4743,21 +4870,21 @@
4743	4870	stack[base + 0] = stack[base + 8LLU];
4744	4871	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4745	4872	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4746		- label = 344LLU; // case complete
	4873	+ label = 357LLU; // case complete
4747	4874	break;
4748	4875	}
4749		- case 346LLU: // copy-back deleter (switch)
	4876	+ case 359LLU: // copy-back deleter (switch)
4750	4877	{
4751	4878	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4752	4879	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4753		- label = 343LLU; // continue to unroll stack
	4880	+ label = 356LLU; // continue to unroll stack
4754	4881	break;
4755	4882	}
4756		- case 345LLU: // try next case
	4883	+ case 358LLU: // try next case
4757	4884	{
4758	4885	if(/typelist/1 != ((uint64_t )(stack[base + 1]/x*/))[0])
4759	4886	{
4760		- label = 349LLU; // jump to alternative
	4887	+ label = 362LLU; // jump to alternative
4761	4888	break;
4762	4889	}
4763	4890

		@@ -4765,7 +4892,7 @@
4765	4892
4766	4893	if(/typelist/1 != ((uint64_t )(stack[base + 2]/y*/))[0])
4767	4894	{
4768		- label = 349LLU; // jump to alternative
	4895	+ label = 362LLU; // jump to alternative
4769	4896	break;
4770	4897	}
4771	4898

		@@ -4775,7 +4902,7 @@
4775	4902	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4776	4903	if(!newstack)
4777	4904	{
4778		- label = 350LLU; // throw: begin to unroll stack
	4905	+ label = 363LLU; // throw: begin to unroll stack
4779	4906	break;
4780	4907	}
4781	4908

		@@ -4782,9 +4909,9 @@
4782	4909	newstack[15LLU] = 9876543210LLU; // overflow-marker
4783	4910	// call equtype from equtype
4784	4911	newstack[0] = (uint64_t)stack; // backup stack location
4785		- newstack[1] = 351LLU;
	4912	+ newstack[1] = 364LLU;
4786	4913	newstack[2] = base;
4787		- newstack[3] = 352LLU;
	4914	+ newstack[3] = 365LLU;
4788	4915	// arguments for call to equtype
4789	4916	newstack[5LLU] = stack[base + 3]/xsubtype/;
4790	4917	newstack[6LLU] = stack[base + 4]/ysubtype/;

		@@ -4791,10 +4918,10 @@
4791	4918	stack = newstack;
4792	4919	// set stack-base & callee-address
4793	4920	base = 4/deloffset/;
4794		- label = 342LLU; // equtype
	4921	+ label = 355LLU; // equtype
4795	4922	break;
4796	4923	}
4797		- case 351LLU: // copy-back deleter (equtype to equtype)
	4924	+ case 364LLU: // copy-back deleter (equtype to equtype)
4798	4925	{
4799	4926	fprintf(stderr, "in function equtype: unrolling stack, copy-back (equtype to equtype)\n");
4800	4927	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4806,10 +4933,10 @@
4806	4933	}
4807	4934	Free(15LLU + 1, sizeof(uint64_t), stack);
4808	4935	stack = oldstack;
4809		- label = 350LLU; // continue to unroll stack
	4936	+ label = 363LLU; // continue to unroll stack
4810	4937	break;
4811	4938	}
4812		- case 352LLU: // return from equtype to equtype
	4939	+ case 365LLU: // return from equtype to equtype
4813	4940	{
4814	4941	uint64_t oldstack = (uint64_t )stack[0];
4815	4942	// copy mutable arguments back from call to equtype

		@@ -4824,42 +4951,42 @@
4824	4951	stack = oldstack;
4825	4952	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4826	4953	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4827		- label = 344LLU; // case complete
	4954	+ label = 357LLU; // case complete
4828	4955	break;
4829	4956	}
4830		- case 350LLU: // copy-back deleter (switch)
	4957	+ case 363LLU: // copy-back deleter (switch)
4831	4958	{
4832	4959	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4833	4960	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4834		- label = 343LLU; // continue to unroll stack
	4961	+ label = 356LLU; // continue to unroll stack
4835	4962	break;
4836	4963	}
4837		- case 349LLU: // try next case
	4964	+ case 362LLU: // try next case
4838	4965	{
4839	4966	// default
4840		- label = 354LLU; // skip deleter
	4967	+ label = 367LLU; // skip deleter
4841	4968	break;
4842	4969	}
4843		- case 353LLU: // deleter
	4970	+ case 366LLU: // deleter
4844	4971	{
4845	4972	// throw from equtype
4846	4973	if(!stack[base + 0])
4847	4974	{
4848	4975	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
4850	4977	break;
4851	4978	}
4852	4979	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
4854	4981	break;
4855	4982	}
4856		- case 354LLU: // skipped deleter
	4983	+ case 367LLU: // skipped deleter
4857	4984	{
4858	4985	stack[base + 0] = 0;
4859		- label = 344LLU; // default complete
	4986	+ label = 357LLU; // default complete
4860	4987	break;
4861	4988	}
4862		- case 344LLU: // completed switch
	4989	+ case 357LLU: // completed switch
4863	4990	{
4864	4991	// return from equtype
4865	4992	label = stack[base - 1];

		@@ -4866,7 +4993,7 @@
4866	4993	base = stack[base - 2];
4867	4994	break;
4868	4995	}
4869		- case 355LLU: // ~typeid
	4996	+ case 368LLU: // ~typeid
4870	4997	{
4871	4998	if(stack[base + 0]/variant-nr/ >= 1)
4872	4999	{

		@@ -4873,10 +5000,10 @@
4873	5000	fprintf(stderr, "in ~typeid: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
4874	5001	exit(-1);
4875	5002	}
4876		- label = 355LLU + 1LLU + stack[base + 0]/variant-nr/;
	5003	+ label = 368LLU + 1LLU + stack[base + 0]/variant-nr/;
4877	5004	break;
4878	5005	}
4879		- case 355LLU + 1LLU + 0LLU: // ~typeid.typeid
	5006	+ case 368LLU + 1LLU + 0LLU: // ~typeid.typeid
4880	5007	{
4881	5008	// release element type
4882	5009	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -4886,14 +5013,14 @@
4886	5013	newstack[0] = (uint64_t)stack; // backup stack location
4887	5014	newstack[1] = 1234567890;
4888	5015	newstack[2] = base;
4889		- newstack[3] = 357LLU;
	5016	+ newstack[3] = 370LLU;
4890	5017	stack = newstack;
4891	5018	// set stack-base & callee-address
4892	5019	base = 4/deloffset/;
4893		- label = 296LLU; // ~type
	5020	+ label = 306LLU; // ~type
4894	5021	break;
4895	5022	}
4896		- case 357LLU: // return from ~type to typeid
	5023	+ case 370LLU: // return from ~type to typeid
4897	5024	{
4898	5025	stack = (uint64_t *)stack[0];
4899	5026	// releasing toplevel container

		@@ -4906,7 +5033,7 @@
4906	5033	base = stack[base - 2];
4907	5034	break;
4908	5035	}
4909		- case 359LLU: // function copytypeid failed
	5036	+ case 372LLU: // function copytypeid failed
4910	5037	{
4911	5038	fprintf(stderr, "function copytypeid failed\n");
4912	5039	label = stack[base - 3];

		@@ -4913,13 +5040,13 @@
4913	5040	base = stack[base - 2];
4914	5041	break;
4915	5042	}
4916		- case 358LLU: // copytypeid
	5043	+ case 371LLU: // copytypeid
4917	5044	{
4918	5045	//#define res0 0
4919	5046	//#define arg0 1
4920	5047	if(/typeid/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
4921	5048	{
4922		- label = 361LLU; // jump to alternative
	5049	+ label = 374LLU; // jump to alternative
4923	5050	break;
4924	5051	}
4925	5052

		@@ -4927,10 +5054,47 @@
4927	5054	/origid/stack[base + 3] = ((uint64_t *)(stack[base + 1]/original/))[1][1]/id*/;
4928	5055
4929	5056	// 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	+ {
4930	5094	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4931	5095	if(!newstack)
4932	5096	{
4933		- label = 362LLU; // throw: begin to unroll stack
	5097	+ label = 375LLU; // throw: begin to unroll stack
4934	5098	break;
4935	5099	}
4936	5100

		@@ -4937,18 +5101,18 @@
4937	5101	newstack[15LLU] = 9876543210LLU; // overflow-marker
4938	5102	// call copytype from copytypeid
4939	5103	newstack[0] = (uint64_t)stack; // backup stack location
4940		- newstack[1] = 363LLU;
	5104	+ newstack[1] = 379LLU;
4941	5105	newstack[2] = base;
4942		- newstack[3] = 364LLU;
	5106	+ newstack[3] = 380LLU;
4943	5107	// arguments for call to copytype
4944	5108	newstack[5LLU] = stack[base + 2]/origtype/;
4945	5109	stack = newstack;
4946	5110	// set stack-base & callee-address
4947	5111	base = 4/deloffset/;
4948		- label = 327LLU; // copytype
	5112	+ label = 337LLU; // copytype
4949	5113	break;
4950	5114	}
4951		- case 363LLU: // copy-back deleter (copytype to copytypeid)
	5115	+ case 379LLU: // copy-back deleter (copytype to copytypeid)
4952	5116	{
4953	5117	fprintf(stderr, "in function copytypeid: unrolling stack, copy-back (copytype to copytypeid)\n");
4954	5118	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4960,10 +5124,10 @@
4960	5124	}
4961	5125	Free(15LLU + 1, sizeof(uint64_t), stack);
4962	5126	stack = oldstack;
4963		- label = 362LLU; // continue to unroll stack
	5127	+ label = 375LLU; // continue to unroll stack
4964	5128	break;
4965	5129	}
4966		- case 364LLU: // return from copytype to copytypeid
	5130	+ case 380LLU: // return from copytype to copytypeid
4967	5131	{
4968	5132	uint64_t oldstack = (uint64_t )stack[0];
4969	5133	// copy mutable arguments back from call to copytype

		@@ -4976,35 +5140,35 @@
4976	5140	}
4977	5141	Free(15LLU + 1, sizeof(uint64_t), stack);
4978	5142	stack = oldstack;
4979		- label = 366LLU; // skip deleter
	5143	+ label = 382LLU; // skip deleter
4980	5144	break;
4981	5145	}
4982		- case 365LLU: // deleter
	5146	+ case 381LLU: // deleter
4983	5147	{
4984	5148	// throw from copytypeid
4985	5149	if(!stack[base + 5])
4986	5150	{
4987	5151	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
4989	5153	break;
4990	5154	}
4991	5155	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
4993	5157	break;
4994	5158	}
4995		- case 366LLU: // skipped deleter
	5159	+ case 382LLU: // skipped deleter
4996	5160	{
4997	5161	stack[base + 5] = stack[base + 3]/origid/;
4998		- label = 368LLU; // skip deleter
	5162	+ label = 384LLU; // skip deleter
4999	5163	break;
5000	5164	}
5001		- case 367LLU: // deleter
	5165	+ case 383LLU: // deleter
5002	5166	{
5003	5167	// throw from copytypeid
5004	5168	if(!stack[base + 0])
5005	5169	{
5006	5170	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
5008	5172	break;
5009	5173	}
5010	5174	fprintf(stderr, "in function copytypeid: unrolling stack, variable typeid \n");

		@@ -5014,28 +5178,28 @@
5014	5178	newstack[0] = (uint64_t)stack; // backup stack location
5015	5179	newstack[1] = 1234567890;
5016	5180	newstack[2] = base;
5017		- newstack[3] = 369LLU;
	5181	+ newstack[3] = 385LLU;
5018	5182	stack = newstack;
5019	5183	// set stack-base & callee-address
5020	5184	base = 4/deloffset/;
5021		- label = 355LLU; // ~typeid
	5185	+ label = 368LLU; // ~typeid
5022	5186	break;
5023	5187	}
5024		- case 369LLU: // return from ~typeid to copytypeid
	5188	+ case 385LLU: // return from ~typeid to copytypeid
5025	5189	{
5026	5190	stack = (uint64_t *)stack[0];
5027	5191	// releasing toplevel container
5028	5192	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5029	5193
5030		- label = 365LLU; // continue unrolling stack, delete next variable
	5194	+ label = 381LLU; // continue unrolling stack, delete next variable
5031	5195	break;
5032	5196	}
5033		- case 368LLU: // skipped deleter
	5197	+ case 384LLU: // skipped deleter
5034	5198	{
5035	5199	// construct typeid.typeid
5036	5200	if(!(stack[base + 0] = construct(2)))
5037	5201	{
5038		- label = 365LLU; // throw: begin to unroll stack
	5202	+ label = 381LLU; // throw: begin to unroll stack
5039	5203	break;
5040	5204	}
5041	5205

		@@ -5045,22 +5209,22 @@
5045	5209	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/copyid*/;
5046	5210	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5047	5211	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5048		- label = 360LLU; // case complete
	5212	+ label = 373LLU; // case complete
5049	5213	break;
5050	5214	}
5051		- case 362LLU: // copy-back deleter (switch)
	5215	+ case 375LLU: // copy-back deleter (switch)
5052	5216	{
5053	5217	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5054	5218	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5055		- label = 359LLU; // continue to unroll stack
	5219	+ label = 372LLU; // continue to unroll stack
5056	5220	break;
5057	5221	}
5058		- case 361LLU: // try next case
	5222	+ case 374LLU: // try next case
5059	5223	{
5060	5224	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5061	5225	exit(-1);
5062	5226	}
5063		- case 360LLU: // completed switch
	5227	+ case 373LLU: // completed switch
5064	5228	{
5065	5229	// return from copytypeid
5066	5230	label = stack[base - 1];

		@@ -5067,7 +5231,7 @@
5067	5231	base = stack[base - 2];
5068	5232	break;
5069	5233	}
5070		- case 371LLU: // function reportti failed
	5234	+ case 387LLU: // function reportti failed
5071	5235	{
5072	5236	fprintf(stderr, "function reportti failed\n");
5073	5237	label = stack[base - 3];

		@@ -5074,12 +5238,12 @@
5074	5238	base = stack[base - 2];
5075	5239	break;
5076	5240	}
5077		- case 370LLU: // reportti
	5241	+ case 386LLU: // reportti
5078	5242	{
5079	5243	//#define arg0 0
5080	5244	if(/typeid/0 != ((uint64_t )(stack[base + 0]/typeid*/))[0])
5081	5245	{
5082		- label = 373LLU; // jump to alternative
	5246	+ label = 389LLU; // jump to alternative
5083	5247	break;
5084	5248	}
5085	5249

		@@ -5090,7 +5254,7 @@
5090	5254	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
5091	5255	if(!newstack)
5092	5256	{
5093		- label = 374LLU; // throw: begin to unroll stack
	5257	+ label = 390LLU; // throw: begin to unroll stack
5094	5258	break;
5095	5259	}
5096	5260

		@@ -5097,18 +5261,18 @@
5097	5261	newstack[10LLU] = 9876543210LLU; // overflow-marker
5098	5262	// call reporttype from reportti
5099	5263	newstack[0] = (uint64_t)stack; // backup stack location
5100		- newstack[1] = 375LLU;
	5264	+ newstack[1] = 391LLU;
5101	5265	newstack[2] = base;
5102		- newstack[3] = 376LLU;
	5266	+ newstack[3] = 392LLU;
5103	5267	// arguments for call to reporttype
5104	5268	newstack[4LLU] = stack[base + 1]/type/;
5105	5269	stack = newstack;
5106	5270	// set stack-base & callee-address
5107	5271	base = 4/deloffset/;
5108		- label = 316LLU; // reporttype
	5272	+ label = 326LLU; // reporttype
5109	5273	break;
5110	5274	}
5111		- case 375LLU: // copy-back deleter (reporttype to reportti)
	5275	+ case 391LLU: // copy-back deleter (reporttype to reportti)
5112	5276	{
5113	5277	fprintf(stderr, "in function reportti: unrolling stack, copy-back (reporttype to reportti)\n");
5114	5278	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5120,10 +5284,10 @@
5120	5284	}
5121	5285	Free(10LLU + 1, sizeof(uint64_t), stack);
5122	5286	stack = oldstack;
5123		- label = 374LLU; // continue to unroll stack
	5287	+ label = 390LLU; // continue to unroll stack
5124	5288	break;
5125	5289	}
5126		- case 376LLU: // return from reporttype to reportti
	5290	+ case 392LLU: // return from reporttype to reportti
5127	5291	{
5128	5292	uint64_t oldstack = (uint64_t )stack[0];
5129	5293	// copy mutable arguments back from call to reporttype

		@@ -5136,9 +5300,9 @@
5136	5300	stack = oldstack;
5137	5301	fprintf(stderr, "%s", " ");
5138	5302	// call reportid from reportti
5139		- stack[base + 3LLU] = 377LLU/throw to this address/;
	5303	+ stack[base + 3LLU] = 393LLU/throw to this address/;
5140	5304	stack[base + 4LLU] = base;
5141		- stack[base + 5LLU] = 378LLU;
	5305	+ stack[base + 5LLU] = 394LLU;
5142	5306	// arguments for call to reportid
5143	5307	stack[base + 6LLU] = stack[base + 2]/id/;
5144	5308	// set stack-base & callee-address

		@@ -5146,34 +5310,34 @@
5146	5310	label = 18446744073709551586LLU; // reportid
5147	5311	break;
5148	5312	}
5149		- case 377LLU: // copy-back deleter (reportid to reportti)
	5313	+ case 393LLU: // copy-back deleter (reportid to reportti)
5150	5314	{
5151	5315	fprintf(stderr, "in function reportti: unrolling stack, copy-back (reportid to reportti)\n");
5152	5316	// copy mutable arguments back from call to reportid
5153		- label = 374LLU; // continue to roll stack
	5317	+ label = 390LLU; // continue to roll stack
5154	5318	break;
5155	5319	}
5156		- case 378LLU: // return from reportid to reportti
	5320	+ case 394LLU: // return from reportid to reportti
5157	5321	{
5158	5322	// copy mutable arguments back from call to reportid
5159	5323	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5160	5324	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5161		- label = 372LLU; // case complete
	5325	+ label = 388LLU; // case complete
5162	5326	break;
5163	5327	}
5164		- case 374LLU: // copy-back deleter (switch)
	5328	+ case 390LLU: // copy-back deleter (switch)
5165	5329	{
5166	5330	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5167	5331	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5168		- label = 371LLU; // continue to unroll stack
	5332	+ label = 387LLU; // continue to unroll stack
5169	5333	break;
5170	5334	}
5171		- case 373LLU: // try next case
	5335	+ case 389LLU: // try next case
5172	5336	{
5173	5337	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5174	5338	exit(-1);
5175	5339	}
5176		- case 372LLU: // completed switch
	5340	+ case 388LLU: // completed switch
5177	5341	{
5178	5342	// return from reportti
5179	5343	label = stack[base - 1];

		@@ -5180,7 +5344,7 @@
5180	5344	base = stack[base - 2];
5181	5345	break;
5182	5346	}
5183		- case 379LLU: // ~typeidx
	5347	+ case 395LLU: // ~typeidx
5184	5348	{
5185	5349	if(stack[base + 0]/variant-nr/ >= 1)
5186	5350	{

		@@ -5187,10 +5351,10 @@
5187	5351	fprintf(stderr, "in ~typeidx: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5188	5352	exit(-1);
5189	5353	}
5190		- label = 379LLU + 1LLU + stack[base + 0]/variant-nr/;
	5354	+ label = 395LLU + 1LLU + stack[base + 0]/variant-nr/;
5191	5355	break;
5192	5356	}
5193		- case 379LLU + 1LLU + 0LLU: // ~typeidx.typeidx
	5357	+ case 395LLU + 1LLU + 0LLU: // ~typeidx.typeidx
5194	5358	{
5195	5359	// release element type
5196	5360	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5200,14 +5364,14 @@
5200	5364	newstack[0] = (uint64_t)stack; // backup stack location
5201	5365	newstack[1] = 1234567890;
5202	5366	newstack[2] = base;
5203		- newstack[3] = 381LLU;
	5367	+ newstack[3] = 397LLU;
5204	5368	stack = newstack;
5205	5369	// set stack-base & callee-address
5206	5370	base = 4/deloffset/;
5207		- label = 296LLU; // ~type
	5371	+ label = 306LLU; // ~type
5208	5372	break;
5209	5373	}
5210		- case 381LLU: // return from ~type to typeidx
	5374	+ case 397LLU: // return from ~type to typeidx
5211	5375	{
5212	5376	stack = (uint64_t *)stack[0];
5213	5377	// releasing toplevel container

		@@ -5220,7 +5384,7 @@
5220	5384	base = stack[base - 2];
5221	5385	break;
5222	5386	}
5223		- case 383LLU: // function cptypeidx failed
	5387	+ case 399LLU: // function cptypeidx failed
5224	5388	{
5225	5389	fprintf(stderr, "function cptypeidx failed\n");
5226	5390	label = stack[base - 3];

		@@ -5227,13 +5391,13 @@
5227	5391	base = stack[base - 2];
5228	5392	break;
5229	5393	}
5230		- case 382LLU: // cptypeidx
	5394	+ case 398LLU: // cptypeidx
5231	5395	{
5232	5396	//#define res0 0
5233	5397	//#define arg0 1
5234	5398	if(/typeidx/0 != ((uint64_t )(stack[base + 1]/orig*/))[0])
5235	5399	{
5236		- label = 385LLU; // jump to alternative
	5400	+ label = 401LLU; // jump to alternative
5237	5401	break;
5238	5402	}
5239	5403

		@@ -5241,10 +5405,47 @@
5241	5405	/oidx/stack[base + 3] = ((uint64_t *)(stack[base + 1]/orig/))[1][1]/idx*/;
5242	5406
5243	5407	// 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	+ {
5244	5445	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
5245	5446	if(!newstack)
5246	5447	{
5247		- label = 386LLU; // throw: begin to unroll stack
	5448	+ label = 402LLU; // throw: begin to unroll stack
5248	5449	break;
5249	5450	}
5250	5451

		@@ -5251,18 +5452,18 @@
5251	5452	newstack[15LLU] = 9876543210LLU; // overflow-marker
5252	5453	// call copytype from cptypeidx
5253	5454	newstack[0] = (uint64_t)stack; // backup stack location
5254		- newstack[1] = 387LLU;
	5455	+ newstack[1] = 406LLU;
5255	5456	newstack[2] = base;
5256		- newstack[3] = 388LLU;
	5457	+ newstack[3] = 407LLU;
5257	5458	// arguments for call to copytype
5258	5459	newstack[5LLU] = stack[base + 2]/otype/;
5259	5460	stack = newstack;
5260	5461	// set stack-base & callee-address
5261	5462	base = 4/deloffset/;
5262		- label = 327LLU; // copytype
	5463	+ label = 337LLU; // copytype
5263	5464	break;
5264	5465	}
5265		- case 387LLU: // copy-back deleter (copytype to cptypeidx)
	5466	+ case 406LLU: // copy-back deleter (copytype to cptypeidx)
5266	5467	{
5267	5468	fprintf(stderr, "in function cptypeidx: unrolling stack, copy-back (copytype to cptypeidx)\n");
5268	5469	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5274,10 +5475,10 @@
5274	5475	}
5275	5476	Free(15LLU + 1, sizeof(uint64_t), stack);
5276	5477	stack = oldstack;
5277		- label = 386LLU; // continue to unroll stack
	5478	+ label = 402LLU; // continue to unroll stack
5278	5479	break;
5279	5480	}
5280		- case 388LLU: // return from copytype to cptypeidx
	5481	+ case 407LLU: // return from copytype to cptypeidx
5281	5482	{
5282	5483	uint64_t oldstack = (uint64_t )stack[0];
5283	5484	// copy mutable arguments back from call to copytype

		@@ -5290,35 +5491,35 @@
5290	5491	}
5291	5492	Free(15LLU + 1, sizeof(uint64_t), stack);
5292	5493	stack = oldstack;
5293		- label = 390LLU; // skip deleter
	5494	+ label = 409LLU; // skip deleter
5294	5495	break;
5295	5496	}
5296		- case 389LLU: // deleter
	5497	+ case 408LLU: // deleter
5297	5498	{
5298	5499	// throw from cptypeidx
5299	5500	if(!stack[base + 5])
5300	5501	{
5301	5502	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
5303	5504	break;
5304	5505	}
5305	5506	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
5307	5508	break;
5308	5509	}
5309		- case 390LLU: // skipped deleter
	5510	+ case 409LLU: // skipped deleter
5310	5511	{
5311	5512	stack[base + 5] = stack[base + 3]/oidx/;
5312		- label = 392LLU; // skip deleter
	5513	+ label = 411LLU; // skip deleter
5313	5514	break;
5314	5515	}
5315		- case 391LLU: // deleter
	5516	+ case 410LLU: // deleter
5316	5517	{
5317	5518	// throw from cptypeidx
5318	5519	if(!stack[base + 0])
5319	5520	{
5320	5521	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
5322	5523	break;
5323	5524	}
5324	5525	fprintf(stderr, "in function cptypeidx: unrolling stack, variable typeidx \n");

		@@ -5328,28 +5529,28 @@
5328	5529	newstack[0] = (uint64_t)stack; // backup stack location
5329	5530	newstack[1] = 1234567890;
5330	5531	newstack[2] = base;
5331		- newstack[3] = 393LLU;
	5532	+ newstack[3] = 412LLU;
5332	5533	stack = newstack;
5333	5534	// set stack-base & callee-address
5334	5535	base = 4/deloffset/;
5335		- label = 379LLU; // ~typeidx
	5536	+ label = 395LLU; // ~typeidx
5336	5537	break;
5337	5538	}
5338		- case 393LLU: // return from ~typeidx to cptypeidx
	5539	+ case 412LLU: // return from ~typeidx to cptypeidx
5339	5540	{
5340	5541	stack = (uint64_t *)stack[0];
5341	5542	// releasing toplevel container
5342	5543	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5343	5544
5344		- label = 389LLU; // continue unrolling stack, delete next variable
	5545	+ label = 408LLU; // continue unrolling stack, delete next variable
5345	5546	break;
5346	5547	}
5347		- case 392LLU: // skipped deleter
	5548	+ case 411LLU: // skipped deleter
5348	5549	{
5349	5550	// construct typeidx.typeidx
5350	5551	if(!(stack[base + 0] = construct(2)))
5351	5552	{
5352		- label = 389LLU; // throw: begin to unroll stack
	5553	+ label = 408LLU; // throw: begin to unroll stack
5353	5554	break;
5354	5555	}
5355	5556

		@@ -5359,22 +5560,22 @@
5359	5560	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/cidx*/;
5360	5561	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5361	5562	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5362		- label = 384LLU; // case complete
	5563	+ label = 400LLU; // case complete
5363	5564	break;
5364	5565	}
5365		- case 386LLU: // copy-back deleter (switch)
	5566	+ case 402LLU: // copy-back deleter (switch)
5366	5567	{
5367	5568	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5368	5569	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5369		- label = 383LLU; // continue to unroll stack
	5570	+ label = 399LLU; // continue to unroll stack
5370	5571	break;
5371	5572	}
5372		- case 385LLU: // try next case
	5573	+ case 401LLU: // try next case
5373	5574	{
5374	5575	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5375	5576	exit(-1);
5376	5577	}
5377		- case 384LLU: // completed switch
	5578	+ case 400LLU: // completed switch
5378	5579	{
5379	5580	// return from cptypeidx
5380	5581	label = stack[base - 1];

		@@ -5381,7 +5582,7 @@
5381	5582	base = stack[base - 2];
5382	5583	break;
5383	5584	}
5384		- case 394LLU: // ~result
	5585	+ case 413LLU: // ~result
5385	5586	{
5386	5587	if(stack[base + 0]/variant-nr/ >= 1)
5387	5588	{

		@@ -5388,10 +5589,10 @@
5388	5589	fprintf(stderr, "in ~result: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5389	5590	exit(-1);
5390	5591	}
5391		- label = 394LLU + 1LLU + stack[base + 0]/variant-nr/;
	5592	+ label = 413LLU + 1LLU + stack[base + 0]/variant-nr/;
5392	5593	break;
5393	5594	}
5394		- case 394LLU + 1LLU + 0LLU: // ~result.result
	5595	+ case 413LLU + 1LLU + 0LLU: // ~result.result
5395	5596	{
5396	5597	// release element type
5397	5598	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5401,14 +5602,14 @@
5401	5602	newstack[0] = (uint64_t)stack; // backup stack location
5402	5603	newstack[1] = 1234567890;
5403	5604	newstack[2] = base;
5404		- newstack[3] = 396LLU;
	5605	+ newstack[3] = 415LLU;
5405	5606	stack = newstack;
5406	5607	// set stack-base & callee-address
5407	5608	base = 4/deloffset/;
5408		- label = 296LLU; // ~type
	5609	+ label = 306LLU; // ~type
5409	5610	break;
5410	5611	}
5411		- case 396LLU: // return from ~type to result
	5612	+ case 415LLU: // return from ~type to result
5412	5613	{
5413	5614	stack = (uint64_t *)stack[0];
5414	5615	// releasing toplevel container

		@@ -5421,7 +5622,7 @@
5421	5622	base = stack[base - 2];
5422	5623	break;
5423	5624	}
5424		- case 398LLU: // function copyresult failed
	5625	+ case 417LLU: // function copyresult failed
5425	5626	{
5426	5627	fprintf(stderr, "function copyresult failed\n");
5427	5628	label = stack[base - 3];

		@@ -5428,13 +5629,13 @@
5428	5629	base = stack[base - 2];
5429	5630	break;
5430	5631	}
5431		- case 397LLU: // copyresult
	5632	+ case 416LLU: // copyresult
5432	5633	{
5433	5634	//#define res0 0
5434	5635	//#define arg0 1
5435	5636	if(/result/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
5436	5637	{
5437		- label = 400LLU; // jump to alternative
	5638	+ label = 419LLU; // jump to alternative
5438	5639	break;
5439	5640	}
5440	5641

		@@ -5442,10 +5643,47 @@
5442	5643	/RESERVED/stack[base + 3] = ((uint64_t *)(stack[base + 1]/original/))[1][1]/RESERVED*/;
5443	5644
5444	5645	// 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	+ {
5445	5683	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
5446	5684	if(!newstack)
5447	5685	{
5448		- label = 401LLU; // throw: begin to unroll stack
	5686	+ label = 420LLU; // throw: begin to unroll stack
5449	5687	break;
5450	5688	}
5451	5689

		@@ -5452,18 +5690,18 @@
5452	5690	newstack[15LLU] = 9876543210LLU; // overflow-marker
5453	5691	// call copytype from copyresult
5454	5692	newstack[0] = (uint64_t)stack; // backup stack location
5455		- newstack[1] = 402LLU;
	5693	+ newstack[1] = 424LLU;
5456	5694	newstack[2] = base;
5457		- newstack[3] = 403LLU;
	5695	+ newstack[3] = 425LLU;
5458	5696	// arguments for call to copytype
5459	5697	newstack[5LLU] = stack[base + 2]/origtype/;
5460	5698	stack = newstack;
5461	5699	// set stack-base & callee-address
5462	5700	base = 4/deloffset/;
5463		- label = 327LLU; // copytype
	5701	+ label = 337LLU; // copytype
5464	5702	break;
5465	5703	}
5466		- case 402LLU: // copy-back deleter (copytype to copyresult)
	5704	+ case 424LLU: // copy-back deleter (copytype to copyresult)
5467	5705	{
5468	5706	fprintf(stderr, "in function copyresult: unrolling stack, copy-back (copytype to copyresult)\n");
5469	5707	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5475,10 +5713,10 @@
5475	5713	}
5476	5714	Free(15LLU + 1, sizeof(uint64_t), stack);
5477	5715	stack = oldstack;
5478		- label = 401LLU; // continue to unroll stack
	5716	+ label = 420LLU; // continue to unroll stack
5479	5717	break;
5480	5718	}
5481		- case 403LLU: // return from copytype to copyresult
	5719	+ case 425LLU: // return from copytype to copyresult
5482	5720	{
5483	5721	uint64_t oldstack = (uint64_t )stack[0];
5484	5722	// copy mutable arguments back from call to copytype

		@@ -5491,16 +5729,16 @@
5491	5729	}
5492	5730	Free(15LLU + 1, sizeof(uint64_t), stack);
5493	5731	stack = oldstack;
5494		- label = 405LLU; // skip deleter
	5732	+ label = 427LLU; // skip deleter
5495	5733	break;
5496	5734	}
5497		- case 404LLU: // deleter
	5735	+ case 426LLU: // deleter
5498	5736	{
5499	5737	// throw from copyresult
5500	5738	if(!stack[base + 0])
5501	5739	{
5502	5740	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
5504	5742	break;
5505	5743	}
5506	5744	fprintf(stderr, "in function copyresult: unrolling stack, variable result \n");

		@@ -5510,28 +5748,28 @@
5510	5748	newstack[0] = (uint64_t)stack; // backup stack location
5511	5749	newstack[1] = 1234567890;
5512	5750	newstack[2] = base;
5513		- newstack[3] = 406LLU;
	5751	+ newstack[3] = 428LLU;
5514	5752	stack = newstack;
5515	5753	// set stack-base & callee-address
5516	5754	base = 4/deloffset/;
5517		- label = 394LLU; // ~result
	5755	+ label = 413LLU; // ~result
5518	5756	break;
5519	5757	}
5520		- case 406LLU: // return from ~result to copyresult
	5758	+ case 428LLU: // return from ~result to copyresult
5521	5759	{
5522	5760	stack = (uint64_t *)stack[0];
5523	5761	// releasing toplevel container
5524	5762	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5525	5763
5526		- label = 401LLU; // continue unrolling stack, delete next variable
	5764	+ label = 421LLU; // continue unrolling stack, delete next variable
5527	5765	break;
5528	5766	}
5529		- case 405LLU: // skipped deleter
	5767	+ case 427LLU: // skipped deleter
5530	5768	{
5531	5769	// construct result.result
5532	5770	if(!(stack[base + 0] = construct(2)))
5533	5771	{
5534		- label = 401LLU; // throw: begin to unroll stack
	5772	+ label = 421LLU; // throw: begin to unroll stack
5535	5773	break;
5536	5774	}
5537	5775

		@@ -5541,22 +5779,22 @@
5541	5779	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 3]/RESERVED*/;
5542	5780	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5543	5781	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5544		- label = 399LLU; // case complete
	5782	+ label = 418LLU; // case complete
5545	5783	break;
5546	5784	}
5547		- case 401LLU: // copy-back deleter (switch)
	5785	+ case 420LLU: // copy-back deleter (switch)
5548	5786	{
5549	5787	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5550	5788	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5551		- label = 398LLU; // continue to unroll stack
	5789	+ label = 417LLU; // continue to unroll stack
5552	5790	break;
5553	5791	}
5554		- case 400LLU: // try next case
	5792	+ case 419LLU: // try next case
5555	5793	{
5556	5794	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5557	5795	exit(-1);
5558	5796	}
5559		- case 399LLU: // completed switch
	5797	+ case 418LLU: // completed switch
5560	5798	{
5561	5799	// return from copyresult
5562	5800	label = stack[base - 1];

		@@ -5563,7 +5801,7 @@
5563	5801	base = stack[base - 2];
5564	5802	break;
5565	5803	}
5566		- case 408LLU: // function represult failed
	5804	+ case 430LLU: // function represult failed
5567	5805	{
5568	5806	fprintf(stderr, "function represult failed\n");
5569	5807	label = stack[base - 3];

		@@ -5570,12 +5808,12 @@
5570	5808	base = stack[base - 2];
5571	5809	break;
5572	5810	}
5573		- case 407LLU: // represult
	5811	+ case 429LLU: // represult
5574	5812	{
5575	5813	//#define arg0 0
5576	5814	if(/result/0 != ((uint64_t )(stack[base + 0]/result*/))[0])
5577	5815	{
5578		- label = 410LLU; // jump to alternative
	5816	+ label = 432LLU; // jump to alternative
5579	5817	break;
5580	5818	}
5581	5819

		@@ -5586,7 +5824,7 @@
5586	5824	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
5587	5825	if(!newstack)
5588	5826	{
5589		- label = 411LLU; // throw: begin to unroll stack
	5827	+ label = 433LLU; // throw: begin to unroll stack
5590	5828	break;
5591	5829	}
5592	5830

		@@ -5593,18 +5831,18 @@
5593	5831	newstack[10LLU] = 9876543210LLU; // overflow-marker
5594	5832	// call reporttype from represult
5595	5833	newstack[0] = (uint64_t)stack; // backup stack location
5596		- newstack[1] = 412LLU;
	5834	+ newstack[1] = 434LLU;
5597	5835	newstack[2] = base;
5598		- newstack[3] = 413LLU;
	5836	+ newstack[3] = 435LLU;
5599	5837	// arguments for call to reporttype
5600	5838	newstack[4LLU] = stack[base + 1]/type/;
5601	5839	stack = newstack;
5602	5840	// set stack-base & callee-address
5603	5841	base = 4/deloffset/;
5604		- label = 316LLU; // reporttype
	5842	+ label = 326LLU; // reporttype
5605	5843	break;
5606	5844	}
5607		- case 412LLU: // copy-back deleter (reporttype to represult)
	5845	+ case 434LLU: // copy-back deleter (reporttype to represult)
5608	5846	{
5609	5847	fprintf(stderr, "in function represult: unrolling stack, copy-back (reporttype to represult)\n");
5610	5848	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5616,10 +5854,10 @@
5616	5854	}
5617	5855	Free(10LLU + 1, sizeof(uint64_t), stack);
5618	5856	stack = oldstack;
5619		- label = 411LLU; // continue to unroll stack
	5857	+ label = 433LLU; // continue to unroll stack
5620	5858	break;
5621	5859	}
5622		- case 413LLU: // return from reporttype to represult
	5860	+ case 435LLU: // return from reporttype to represult
5623	5861	{
5624	5862	uint64_t oldstack = (uint64_t )stack[0];
5625	5863	// copy mutable arguments back from call to reporttype

		@@ -5632,22 +5870,22 @@
5632	5870	stack = oldstack;
5633	5871	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5634	5872	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5635		- label = 409LLU; // case complete
	5873	+ label = 431LLU; // case complete
5636	5874	break;
5637	5875	}
5638		- case 411LLU: // copy-back deleter (switch)
	5876	+ case 433LLU: // copy-back deleter (switch)
5639	5877	{
5640	5878	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5641	5879	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5642		- label = 408LLU; // continue to unroll stack
	5880	+ label = 430LLU; // continue to unroll stack
5643	5881	break;
5644	5882	}
5645		- case 410LLU: // try next case
	5883	+ case 432LLU: // try next case
5646	5884	{
5647	5885	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5648	5886	exit(-1);
5649	5887	}
5650		- case 409LLU: // completed switch
	5888	+ case 431LLU: // completed switch
5651	5889	{
5652	5890	// return from represult
5653	5891	label = stack[base - 1];

		@@ -5654,7 +5892,7 @@
5654	5892	base = stack[base - 2];
5655	5893	break;
5656	5894	}
5657		- case 414LLU: // ~param
	5895	+ case 436LLU: // ~param
5658	5896	{
5659	5897	if(stack[base + 0]/variant-nr/ >= 1)
5660	5898	{

		@@ -5661,10 +5899,10 @@
5661	5899	fprintf(stderr, "in ~param: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5662	5900	exit(-1);
5663	5901	}
5664		- label = 414LLU + 1LLU + stack[base + 0]/variant-nr/;
	5902	+ label = 436LLU + 1LLU + stack[base + 0]/variant-nr/;
5665	5903	break;
5666	5904	}
5667		- case 414LLU + 1LLU + 0LLU: // ~param.param
	5905	+ case 436LLU + 1LLU + 0LLU: // ~param.param
5668	5906	{
5669	5907	// release element typeid
5670	5908	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5674,14 +5912,14 @@
5674	5912	newstack[0] = (uint64_t)stack; // backup stack location
5675	5913	newstack[1] = 1234567890;
5676	5914	newstack[2] = base;
5677		- newstack[3] = 416LLU;
	5915	+ newstack[3] = 438LLU;
5678	5916	stack = newstack;
5679	5917	// set stack-base & callee-address
5680	5918	base = 4/deloffset/;
5681		- label = 355LLU; // ~typeid
	5919	+ label = 368LLU; // ~typeid
5682	5920	break;
5683	5921	}
5684		- case 416LLU: // return from ~typeid to param
	5922	+ case 438LLU: // return from ~typeid to param
5685	5923	{
5686	5924	stack = (uint64_t *)stack[0];
5687	5925	// releasing toplevel container

		@@ -5694,7 +5932,7 @@
5694	5932	base = stack[base - 2];
5695	5933	break;
5696	5934	}
5697		- case 418LLU: // function copyparam failed
	5935	+ case 440LLU: // function copyparam failed
5698	5936	{
5699	5937	fprintf(stderr, "function copyparam failed\n");
5700	5938	label = stack[base - 3];

		@@ -5701,13 +5939,13 @@
5701	5939	base = stack[base - 2];
5702	5940	break;
5703	5941	}
5704		- case 417LLU: // copyparam
	5942	+ case 439LLU: // copyparam
5705	5943	{
5706	5944	//#define res0 0
5707	5945	//#define arg0 1
5708	5946	if(/param/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
5709	5947	{
5710		- label = 420LLU; // jump to alternative
	5948	+ label = 442LLU; // jump to alternative
5711	5949	break;
5712	5950	}
5713	5951

		@@ -5715,58 +5953,95 @@
5715	5953	/origmut/stack[base + 3] = ((uint64_t *)(stack[base + 1]/original/))[1][1]/mutable*/;
5716	5954
5717	5955	// 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	+ {
5718	5993	// call copytypeid from copyparam
5719		- stack[base + 5LLU] = 422LLU/throw to this address/;
	5994	+ stack[base + 5LLU] = 447LLU/throw to this address/;
5720	5995	stack[base + 6LLU] = base;
5721		- stack[base + 7LLU] = 423LLU;
	5996	+ stack[base + 7LLU] = 448LLU;
5722	5997	// arguments for call to copytypeid
5723	5998	stack[base + 9LLU] = stack[base + 2]/origtypeid/;
5724	5999	// set stack-base & callee-address
5725	6000	base += 8LLU;
5726		- label = 358LLU; // copytypeid
	6001	+ label = 371LLU; // copytypeid
5727	6002	break;
5728	6003	}
5729		- case 422LLU: // copy-back deleter (copytypeid to copyparam)
	6004	+ case 447LLU: // copy-back deleter (copytypeid to copyparam)
5730	6005	{
5731	6006	fprintf(stderr, "in function copyparam: unrolling stack, copy-back (copytypeid to copyparam)\n");
5732	6007	// copy mutable arguments back from call to copytypeid
5733		- label = 421LLU; // continue to roll stack
	6008	+ label = 443LLU; // continue to roll stack
5734	6009	break;
5735	6010	}
5736		- case 423LLU: // return from copytypeid to copyparam
	6011	+ case 448LLU: // return from copytypeid to copyparam
5737	6012	{
5738	6013	// copy mutable arguments back from call to copytypeid
5739	6014	// copy back results provided by call to copytypeid
5740	6015	stack[base + 4] = stack[base + 8LLU];
5741		- label = 425LLU; // skip deleter
	6016	+ label = 450LLU; // skip deleter
5742	6017	break;
5743	6018	}
5744		- case 424LLU: // deleter
	6019	+ case 449LLU: // deleter
5745	6020	{
5746	6021	// throw from copyparam
5747	6022	if(!stack[base + 5])
5748	6023	{
5749	6024	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
5751	6026	break;
5752	6027	}
5753	6028	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
5755	6030	break;
5756	6031	}
5757		- case 425LLU: // skipped deleter
	6032	+ case 450LLU: // skipped deleter
5758	6033	{
5759	6034	stack[base + 5] = stack[base + 3]/origmut/;
5760		- label = 427LLU; // skip deleter
	6035	+ label = 452LLU; // skip deleter
5761	6036	break;
5762	6037	}
5763		- case 426LLU: // deleter
	6038	+ case 451LLU: // deleter
5764	6039	{
5765	6040	// throw from copyparam
5766	6041	if(!stack[base + 0])
5767	6042	{
5768	6043	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
5770	6045	break;
5771	6046	}
5772	6047	fprintf(stderr, "in function copyparam: unrolling stack, variable param \n");

		@@ -5776,28 +6051,28 @@
5776	6051	newstack[0] = (uint64_t)stack; // backup stack location
5777	6052	newstack[1] = 1234567890;
5778	6053	newstack[2] = base;
5779		- newstack[3] = 428LLU;
	6054	+ newstack[3] = 453LLU;
5780	6055	stack = newstack;
5781	6056	// set stack-base & callee-address
5782	6057	base = 4/deloffset/;
5783		- label = 414LLU; // ~param
	6058	+ label = 436LLU; // ~param
5784	6059	break;
5785	6060	}
5786		- case 428LLU: // return from ~param to copyparam
	6061	+ case 453LLU: // return from ~param to copyparam
5787	6062	{
5788	6063	stack = (uint64_t *)stack[0];
5789	6064	// releasing toplevel container
5790	6065	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5791	6066
5792		- label = 424LLU; // continue unrolling stack, delete next variable
	6067	+ label = 449LLU; // continue unrolling stack, delete next variable
5793	6068	break;
5794	6069	}
5795		- case 427LLU: // skipped deleter
	6070	+ case 452LLU: // skipped deleter
5796	6071	{
5797	6072	// construct param.param
5798	6073	if(!(stack[base + 0] = construct(2)))
5799	6074	{
5800		- label = 424LLU; // throw: begin to unroll stack
	6075	+ label = 449LLU; // throw: begin to unroll stack
5801	6076	break;
5802	6077	}
5803	6078

		@@ -5807,22 +6082,22 @@
5807	6082	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/copymut*/;
5808	6083	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5809	6084	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5810		- label = 419LLU; // case complete
	6085	+ label = 441LLU; // case complete
5811	6086	break;
5812	6087	}
5813		- case 421LLU: // copy-back deleter (switch)
	6088	+ case 443LLU: // copy-back deleter (switch)
5814	6089	{
5815	6090	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5816	6091	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5817		- label = 418LLU; // continue to unroll stack
	6092	+ label = 440LLU; // continue to unroll stack
5818	6093	break;
5819	6094	}
5820		- case 420LLU: // try next case
	6095	+ case 442LLU: // try next case
5821	6096	{
5822	6097	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5823	6098	exit(-1);
5824	6099	}
5825		- case 419LLU: // completed switch
	6100	+ case 441LLU: // completed switch
5826	6101	{
5827	6102	// return from copyparam
5828	6103	label = stack[base - 1];

		@@ -5829,7 +6104,7 @@
5829	6104	base = stack[base - 2];
5830	6105	break;
5831	6106	}
5832		- case 430LLU: // function repparam failed
	6107	+ case 455LLU: // function repparam failed
5833	6108	{
5834	6109	fprintf(stderr, "function repparam failed\n");
5835	6110	label = stack[base - 3];

		@@ -5836,12 +6111,12 @@
5836	6111	base = stack[base - 2];
5837	6112	break;
5838	6113	}
5839		- case 429LLU: // repparam
	6114	+ case 454LLU: // repparam
5840	6115	{
5841	6116	//#define arg0 0
5842	6117	if(/param/0 != ((uint64_t )(stack[base + 0]/param*/))[0])
5843	6118	{
5844		- label = 432LLU; // jump to alternative
	6119	+ label = 457LLU; // jump to alternative
5845	6120	break;
5846	6121	}
5847	6122

		@@ -5851,61 +6126,61 @@
5851	6126	// case
5852	6127	if(!stack[base + 2]/mutable/)
5853	6128	{
5854		- label = 434LLU; // jump to alternative
	6129	+ label = 459LLU; // jump to alternative
5855	6130	break;
5856	6131	}
5857	6132
5858	6133	// consequent
5859	6134	fprintf(stderr, "%s", "mut ");
5860		- label = 435LLU; // consequent complete
	6135	+ label = 460LLU; // consequent complete
5861	6136	break;
5862	6137	}
5863		- case 434LLU: // alternative
	6138	+ case 459LLU: // alternative
5864	6139	{
5865		- label = 435LLU; // alternative complete
	6140	+ label = 460LLU; // alternative complete
5866	6141	break;
5867	6142	}
5868		- case 435LLU: // completed if-then-else
	6143	+ case 460LLU: // completed if-then-else
5869	6144	{
5870	6145	// call reportti from repparam
5871		- stack[base + 3LLU] = 436LLU/throw to this address/;
	6146	+ stack[base + 3LLU] = 461LLU/throw to this address/;
5872	6147	stack[base + 4LLU] = base;
5873		- stack[base + 5LLU] = 437LLU;
	6148	+ stack[base + 5LLU] = 462LLU;
5874	6149	// arguments for call to reportti
5875	6150	stack[base + 6LLU] = stack[base + 1]/typeid/;
5876	6151	// set stack-base & callee-address
5877	6152	base += 6LLU;
5878		- label = 370LLU; // reportti
	6153	+ label = 386LLU; // reportti
5879	6154	break;
5880	6155	}
5881		- case 436LLU: // copy-back deleter (reportti to repparam)
	6156	+ case 461LLU: // copy-back deleter (reportti to repparam)
5882	6157	{
5883	6158	fprintf(stderr, "in function repparam: unrolling stack, copy-back (reportti to repparam)\n");
5884	6159	// copy mutable arguments back from call to reportti
5885		- label = 433LLU; // continue to roll stack
	6160	+ label = 458LLU; // continue to roll stack
5886	6161	break;
5887	6162	}
5888		- case 437LLU: // return from reportti to repparam
	6163	+ case 462LLU: // return from reportti to repparam
5889	6164	{
5890	6165	// copy mutable arguments back from call to reportti
5891	6166	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5892	6167	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5893		- label = 431LLU; // case complete
	6168	+ label = 456LLU; // case complete
5894	6169	break;
5895	6170	}
5896		- case 433LLU: // copy-back deleter (switch)
	6171	+ case 458LLU: // copy-back deleter (switch)
5897	6172	{
5898	6173	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5899	6174	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5900		- label = 430LLU; // continue to unroll stack
	6175	+ label = 455LLU; // continue to unroll stack
5901	6176	break;
5902	6177	}
5903		- case 432LLU: // try next case
	6178	+ case 457LLU: // try next case
5904	6179	{
5905	6180	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5906	6181	exit(-1);
5907	6182	}
5908		- case 431LLU: // completed switch
	6183	+ case 456LLU: // completed switch
5909	6184	{
5910	6185	// return from repparam
5911	6186	label = stack[base - 1];

		@@ -5912,7 +6187,7 @@
5912	6187	base = stack[base - 2];
5913	6188	break;
5914	6189	}
5915		- case 439LLU: // function lookparam failed
	6190	+ case 464LLU: // function lookparam failed
5916	6191	{
5917	6192	fprintf(stderr, "function lookparam failed\n");
5918	6193	label = stack[base - 3];

		@@ -5919,39 +6194,39 @@
5919	6194	base = stack[base - 2];
5920	6195	break;
5921	6196	}
5922		- case 438LLU: // lookparam
	6197	+ case 463LLU: // lookparam
5923	6198	{
5924	6199	//#define res0 0
5925	6200	//#define arg0 1
5926	6201	//#define arg1 2
5927		- label = 441LLU; // skip deleter
	6202	+ label = 466LLU; // skip deleter
5928	6203	break;
5929	6204	}
5930		- case 440LLU: // deleter
	6205	+ case 465LLU: // deleter
5931	6206	{
5932	6207	// throw from lookparam
5933	6208	if(!stack[base + 3])
5934	6209	{
5935	6210	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
5937	6212	break;
5938	6213	}
5939	6214	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
5941	6216	break;
5942	6217	}
5943		- case 441LLU: // skipped deleter
	6218	+ case 466LLU: // skipped deleter
5944	6219	{
5945	6220	stack[base + 3] = 0;
5946	6221	flippedassign(stack[base + 1]/params/, &stack[base + 4]);
5947		- label = 442LLU; // start to repeat
	6222	+ label = 467LLU; // start to repeat
5948	6223	break;
5949	6224	}
5950		- case 442LLU: // repeat from here
	6225	+ case 467LLU: // repeat from here
5951	6226	{
5952	6227	if(!stack[base + 4])
5953	6228	{
5954		- label = 443LLU; // break loop
	6229	+ label = 468LLU; // break loop
5955	6230	break;
5956	6231	}
5957	6232

		@@ -5961,19 +6236,19 @@
5961	6236	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
5962	6237	if(!stack[base + 3]/found/)
5963	6238	{
5964		- label = 445LLU; // jump to alternative
	6239	+ label = 470LLU; // jump to alternative
5965	6240	break;
5966	6241	}
5967	6242
5968	6243	// consequent
5969		- label = 446LLU; // consequent complete
	6244	+ label = 471LLU; // consequent complete
5970	6245	break;
5971	6246	}
5972		- case 445LLU: // alternative
	6247	+ case 470LLU: // alternative
5973	6248	{
5974	6249	if(/param/0 != ((uint64_t )(stack[base + 5]/param*/))[0])
5975	6250	{
5976		- label = 448LLU; // jump to alternative
	6251	+ label = 473LLU; // jump to alternative
5977	6252	break;
5978	6253	}
5979	6254

		@@ -5983,7 +6258,7 @@
5983	6258	// case
5984	6259	if(/typeid/0 != ((uint64_t )(stack[base + 7]/typeid*/))[0])
5985	6260	{
5986		- label = 451LLU; // jump to alternative
	6261	+ label = 476LLU; // jump to alternative
5987	6262	break;
5988	6263	}
5989	6264

		@@ -5992,9 +6267,9 @@
5992	6267
5993	6268	// case
5994	6269	// call equ from lookparam
5995		- stack[base + 11LLU] = 453LLU/throw to this address/;
	6270	+ stack[base + 11LLU] = 478LLU/throw to this address/;
5996	6271	stack[base + 12LLU] = base;
5997		- stack[base + 13LLU] = 454LLU;
	6272	+ stack[base + 13LLU] = 479LLU;
5998	6273	// arguments for call to equ
5999	6274	stack[base + 15LLU] = stack[base + 10]/id/;
6000	6275	stack[base + 16LLU] = stack[base + 2]/wanted/;

		@@ -6003,14 +6278,14 @@
6003	6278	label = 18446744073709551600LLU; // equ
6004	6279	break;
6005	6280	}
6006		- case 453LLU: // copy-back deleter (equ to lookparam)
	6281	+ case 478LLU: // copy-back deleter (equ to lookparam)
6007	6282	{
6008	6283	fprintf(stderr, "in function lookparam: unrolling stack, copy-back (equ to lookparam)\n");
6009	6284	// copy mutable arguments back from call to equ
6010		- label = 452LLU; // continue to roll stack
	6285	+ label = 477LLU; // continue to roll stack
6011	6286	break;
6012	6287	}
6013		- case 454LLU: // return from equ to lookparam
	6288	+ case 479LLU: // return from equ to lookparam
6014	6289	{
6015	6290	// copy mutable arguments back from call to equ
6016	6291	// copy back results provided by call to equ

		@@ -6017,76 +6292,76 @@
6017	6292	stack[base + 3] = stack[base + 14LLU];
6018	6293	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
6019	6294	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6020		- label = 450LLU; // case complete
	6295	+ label = 475LLU; // case complete
6021	6296	break;
6022	6297	}
6023		- case 452LLU: // copy-back deleter (switch)
	6298	+ case 477LLU: // copy-back deleter (switch)
6024	6299	{
6025	6300	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
6026	6301	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6027		- label = 449LLU; // continue to unroll stack
	6302	+ label = 474LLU; // continue to unroll stack
6028	6303	break;
6029	6304	}
6030		- case 451LLU: // try next case
	6305	+ case 476LLU: // try next case
6031	6306	{
6032	6307	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6033	6308	exit(-1);
6034	6309	}
6035		- case 450LLU: // completed switch
	6310	+ case 475LLU: // completed switch
6036	6311	{
6037	6312	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
6038	6313	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6039		- label = 447LLU; // case complete
	6314	+ label = 472LLU; // case complete
6040	6315	break;
6041	6316	}
6042		- case 449LLU: // copy-back deleter (switch)
	6317	+ case 474LLU: // copy-back deleter (switch)
6043	6318	{
6044	6319	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
6045	6320	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6046		- label = 444LLU; // continue to unroll stack
	6321	+ label = 469LLU; // continue to unroll stack
6047	6322	break;
6048	6323	}
6049		- case 448LLU: // try next case
	6324	+ case 473LLU: // try next case
6050	6325	{
6051	6326	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6052	6327	exit(-1);
6053	6328	}
6054		- case 447LLU: // completed switch
	6329	+ case 472LLU: // completed switch
6055	6330	{
6056		- label = 446LLU; // alternative complete
	6331	+ label = 471LLU; // alternative complete
6057	6332	break;
6058	6333	}
6059		- case 446LLU: // completed if-then-else
	6334	+ case 471LLU: // completed if-then-else
6060	6335	{
6061	6336	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
6062		- label = 442LLU; // repeat
	6337	+ label = 467LLU; // repeat
6063	6338	break;
6064	6339	}
6065		- case 444LLU: // copy-back deleter for while next
	6340	+ case 469LLU: // copy-back deleter for while next
6066	6341	{
6067	6342	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
6068		- label = 440LLU; // continue to unroll stack
	6343	+ label = 465LLU; // continue to unroll stack
6069	6344	break;
6070	6345	}
6071		- case 443LLU: // loop finished
	6346	+ case 468LLU: // loop finished
6072	6347	{
6073		- label = 456LLU; // skip deleter
	6348	+ label = 481LLU; // skip deleter
6074	6349	break;
6075	6350	}
6076		- case 455LLU: // deleter
	6351	+ case 480LLU: // deleter
6077	6352	{
6078	6353	// throw from lookparam
6079	6354	if(!stack[base + 0])
6080	6355	{
6081	6356	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
6083	6358	break;
6084	6359	}
6085	6360	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
6087	6362	break;
6088	6363	}
6089		- case 456LLU: // skipped deleter
	6364	+ case 481LLU: // skipped deleter
6090	6365	{
6091	6366	stack[base + 0] = stack[base + 3]/found/;
6092	6367	// return from lookparam

		@@ -6094,7 +6369,7 @@
6094	6369	base = stack[base - 2];
6095	6370	break;
6096	6371	}
6097		- case 457LLU: // ~letdef
	6372	+ case 482LLU: // ~letdef
6098	6373	{
6099	6374	if(stack[base + 0]/variant-nr/ >= 1)
6100	6375	{

		@@ -6101,10 +6376,10 @@
6101	6376	fprintf(stderr, "in ~letdef: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
6102	6377	exit(-1);
6103	6378	}
6104		- label = 457LLU + 1LLU + stack[base + 0]/variant-nr/;
	6379	+ label = 482LLU + 1LLU + stack[base + 0]/variant-nr/;
6105	6380	break;
6106	6381	}
6107		- case 457LLU + 1LLU + 0LLU: // ~letdef.letdef
	6382	+ case 482LLU + 1LLU + 0LLU: // ~letdef.letdef
6108	6383	{
6109	6384	// release element type
6110	6385	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -6114,14 +6389,14 @@
6114	6389	newstack[0] = (uint64_t)stack; // backup stack location
6115	6390	newstack[1] = 1234567890;
6116	6391	newstack[2] = base;
6117		- newstack[3] = 459LLU;
	6392	+ newstack[3] = 484LLU;
6118	6393	stack = newstack;
6119	6394	// set stack-base & callee-address
6120	6395	base = 4/deloffset/;
6121		- label = 296LLU; // ~type
	6396	+ label = 306LLU; // ~type
6122	6397	break;
6123	6398	}
6124		- case 459LLU: // return from ~type to letdef
	6399	+ case 484LLU: // return from ~type to letdef
6125	6400	{
6126	6401	stack = (uint64_t *)stack[0];
6127	6402	// releasing toplevel container

		@@ -6137,7 +6412,7 @@
6137	6412	base = stack[base - 2];
6138	6413	break;
6139	6414	}
6140		- case 461LLU: // function mkletdummy failed
	6415	+ case 486LLU: // function mkletdummy failed
6141	6416	{
6142	6417	fprintf(stderr, "function mkletdummy failed\n");
6143	6418	label = stack[base - 3];

		@@ -6144,38 +6419,38 @@
6144	6419	base = stack[base - 2];
6145	6420	break;
6146	6421	}
6147		- case 460LLU: // mkletdummy
	6422	+ case 485LLU: // mkletdummy
6148	6423	{
6149	6424	//#define res0 0
6150		- label = 463LLU; // skip deleter
	6425	+ label = 488LLU; // skip deleter
6151	6426	break;
6152	6427	}
6153		- case 462LLU: // deleter
	6428	+ case 487LLU: // deleter
6154	6429	{
6155	6430	// throw from mkletdummy
6156	6431	if(!stack[base + 1])
6157	6432	{
6158	6433	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
6160	6435	break;
6161	6436	}
6162	6437	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
6164	6439	break;
6165	6440	}
6166		- case 463LLU: // skipped deleter
	6441	+ case 488LLU: // skipped deleter
6167	6442	{
6168	6443	stack[base + 1] = 78026663350239232;
6169		- label = 465LLU; // skip deleter
	6444	+ label = 490LLU; // skip deleter
6170	6445	break;
6171	6446	}
6172		- case 464LLU: // deleter
	6447	+ case 489LLU: // deleter
6173	6448	{
6174	6449	// throw from mkletdummy
6175	6450	if(!stack[base + 2])
6176	6451	{
6177	6452	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
6179	6454	break;
6180	6455	}
6181	6456	fprintf(stderr, "in function mkletdummy: unrolling stack, variable type newtype\n");

		@@ -6185,28 +6460,28 @@
6185	6460	newstack[0] = (uint64_t)stack; // backup stack location
6186	6461	newstack[1] = 1234567890;
6187	6462	newstack[2] = base;
6188		- newstack[3] = 466LLU;
	6463	+ newstack[3] = 491LLU;
6189	6464	stack = newstack;
6190	6465	// set stack-base & callee-address
6191	6466	base = 4/deloffset/;
6192		- label = 296LLU; // ~type
	6467	+ label = 306LLU; // ~type
6193	6468	break;
6194	6469	}
6195		- case 466LLU: // return from ~type to mkletdummy
	6470	+ case 491LLU: // return from ~type to mkletdummy
6196	6471	{
6197	6472	stack = (uint64_t *)stack[0];
6198	6473	// releasing toplevel container
6199	6474	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 2] - sizeof(uint64_t) 4));
6200	6475
6201		- label = 462LLU; // continue unrolling stack, delete next variable
	6476	+ label = 487LLU; // continue unrolling stack, delete next variable
6202	6477	break;
6203	6478	}
6204		- case 465LLU: // skipped deleter
	6479	+ case 490LLU: // skipped deleter
6205	6480	{
6206	6481	// construct type.typename
6207	6482	if(!(stack[base + 2] = construct(1)))
6208	6483	{
6209		- label = 462LLU; // throw: begin to unroll stack
	6484	+ label = 487LLU; // throw: begin to unroll stack
6210	6485	break;
6211	6486	}
6212	6487

		@@ -6213,73 +6488,73 @@
6213	6488	// consequent
6214	6489	((uint64_t *)stack[base + 2])[0] = 0;
6215	6490	(((uint64_t *)(stack[base + 2]))[1][0]) = stack[base + 1]/newid*/;
6216		- label = 468LLU; // skip deleter
	6491	+ label = 493LLU; // skip deleter
6217	6492	break;
6218	6493	}
6219		- case 467LLU: // deleter
	6494	+ case 492LLU: // deleter
6220	6495	{
6221	6496	// throw from mkletdummy
6222	6497	if(!stack[base + 3])
6223	6498	{
6224	6499	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
6226	6501	break;
6227	6502	}
6228	6503	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
6230	6505	break;
6231	6506	}
6232		- case 468LLU: // skipped deleter
	6507	+ case 493LLU: // skipped deleter
6233	6508	{
6234	6509	stack[base + 3] = 0;
6235		- label = 470LLU; // skip deleter
	6510	+ label = 495LLU; // skip deleter
6236	6511	break;
6237	6512	}
6238		- case 469LLU: // deleter
	6513	+ case 494LLU: // deleter
6239	6514	{
6240	6515	// throw from mkletdummy
6241	6516	if(!stack[base + 4])
6242	6517	{
6243	6518	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
6245	6520	break;
6246	6521	}
6247	6522	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
6249	6524	break;
6250	6525	}
6251		- case 470LLU: // skipped deleter
	6526	+ case 495LLU: // skipped deleter
6252	6527	{
6253	6528	stack[base + 4] = 0;
6254		- label = 472LLU; // skip deleter
	6529	+ label = 497LLU; // skip deleter
6255	6530	break;
6256	6531	}
6257		- case 471LLU: // deleter
	6532	+ case 496LLU: // deleter
6258	6533	{
6259	6534	// throw from mkletdummy
6260	6535	if(!stack[base + 5])
6261	6536	{
6262	6537	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
6264	6539	break;
6265	6540	}
6266	6541	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
6268	6543	break;
6269	6544	}
6270		- case 472LLU: // skipped deleter
	6545	+ case 497LLU: // skipped deleter
6271	6546	{
6272	6547	stack[base + 5] = 0;
6273		- label = 474LLU; // skip deleter
	6548	+ label = 499LLU; // skip deleter
6274	6549	break;
6275	6550	}
6276		- case 473LLU: // deleter
	6551	+ case 498LLU: // deleter
6277	6552	{
6278	6553	// throw from mkletdummy
6279	6554	if(!stack[base + 0])
6280	6555	{
6281	6556	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
6283	6558	break;
6284	6559	}
6285	6560	fprintf(stderr, "in function mkletdummy: unrolling stack, variable letdef \n");

		@@ -6289,28 +6564,28 @@
6289	6564	newstack[0] = (uint64_t)stack; // backup stack location
6290	6565	newstack[1] = 1234567890;
6291	6566	newstack[2] = base;
6292		- newstack[3] = 475LLU;
	6567	+ newstack[3] = 500LLU;
6293	6568	stack = newstack;
6294	6569	// set stack-base & callee-address
6295	6570	base = 4/deloffset/;
6296		- label = 457LLU; // ~letdef
	6571	+ label = 482LLU; // ~letdef
6297	6572	break;
6298	6573	}
6299		- case 475LLU: // return from ~letdef to mkletdummy
	6574	+ case 500LLU: // return from ~letdef to mkletdummy
6300	6575	{
6301	6576	stack = (uint64_t *)stack[0];
6302	6577	// releasing toplevel container
6303	6578	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
6304	6579
6305		- label = 471LLU; // continue unrolling stack, delete next variable
	6580	+ label = 496LLU; // continue unrolling stack, delete next variable
6306	6581	break;
6307	6582	}
6308		- case 474LLU: // skipped deleter
	6583	+ case 499LLU: // skipped deleter
6309	6584	{
6310	6585	// construct letdef.letdef
6311	6586	if(!(stack[base + 0] = construct(5)))
6312	6587	{
6313		- label = 471LLU; // throw: begin to unroll stack
	6588	+ label = 496LLU; // throw: begin to unroll stack
6314	6589	break;
6315	6590	}
6316	6591

		@@ -6326,7 +6601,7 @@
6326	6601	base = stack[base - 2];
6327	6602	break;
6328	6603	}
6329		- case 477LLU: // function reportlet failed
	6604	+ case 502LLU: // function reportlet failed
6330	6605	{
6331	6606	fprintf(stderr, "function reportlet failed\n");
6332	6607	label = stack[base - 3];

		@@ -6333,12 +6608,12 @@
6333	6608	base = stack[base - 2];
6334	6609	break;
6335	6610	}
6336		- case 476LLU: // reportlet
	6611	+ case 501LLU: // reportlet
6337	6612	{
6338	6613	//#define arg0 0
6339	6614	if(/letdef/0 != ((uint64_t )(stack[base + 0]/letdef*/))[0])
6340	6615	{
6341		- label = 479LLU; // jump to alternative
	6616	+ label = 504LLU; // jump to alternative
6342	6617	break;
6343	6618	}
6344	6619

		@@ -6351,26 +6626,26 @@
6351	6626	// case
6352	6627	if(!stack[base + 4]/mutable/)
6353	6628	{
6354		- label = 481LLU; // jump to alternative
	6629	+ label = 506LLU; // jump to alternative
6355	6630	break;
6356	6631	}
6357	6632
6358	6633	// consequent
6359	6634	fprintf(stderr, "%s", "mut ");
6360		- label = 482LLU; // consequent complete
	6635	+ label = 507LLU; // consequent complete
6361	6636	break;
6362	6637	}
6363		- case 481LLU: // alternative
	6638	+ case 506LLU: // alternative
6364	6639	{
6365		- label = 482LLU; // alternative complete
	6640	+ label = 507LLU; // alternative complete
6366	6641	break;
6367	6642	}
6368		- case 482LLU: // completed if-then-else
	6643	+ case 507LLU: // completed if-then-else
6369	6644	{
6370	6645	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
6371	6646	if(!newstack)
6372	6647	{
6373		- label = 480LLU; // throw: begin to unroll stack
	6648	+ label = 505LLU; // throw: begin to unroll stack
6374	6649	break;
6375	6650	}
6376	6651

		@@ -6377,18 +6652,18 @@
6377	6652	newstack[10LLU] = 9876543210LLU; // overflow-marker
6378	6653	// call reporttype from reportlet
6379	6654	newstack[0] = (uint64_t)stack; // backup stack location
6380		- newstack[1] = 483LLU;
	6655	+ newstack[1] = 508LLU;
6381	6656	newstack[2] = base;
6382		- newstack[3] = 484LLU;
	6657	+ newstack[3] = 509LLU;
6383	6658	// arguments for call to reporttype
6384	6659	newstack[4LLU] = stack[base + 1]/type/;
6385	6660	stack = newstack;
6386	6661	// set stack-base & callee-address
6387	6662	base = 4/deloffset/;
6388		- label = 316LLU; // reporttype
	6663	+ label = 326LLU; // reporttype
6389	6664	break;
6390	6665	}
6391		- case 483LLU: // copy-back deleter (reporttype to reportlet)
	6666	+ case 508LLU: // copy-back deleter (reporttype to reportlet)
6392	6667	{
6393	6668	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reporttype to reportlet)\n");
6394	6669	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6400,10 +6675,10 @@
6400	6675	}
6401	6676	Free(10LLU + 1, sizeof(uint64_t), stack);
6402	6677	stack = oldstack;
6403		- label = 480LLU; // continue to unroll stack
	6678	+ label = 505LLU; // continue to unroll stack
6404	6679	break;
6405	6680	}
6406		- case 484LLU: // return from reporttype to reportlet
	6681	+ case 509LLU: // return from reporttype to reportlet
6407	6682	{
6408	6683	uint64_t oldstack = (uint64_t )stack[0];
6409	6684	// copy mutable arguments back from call to reporttype

		@@ -6416,9 +6691,9 @@
6416	6691	stack = oldstack;
6417	6692	fprintf(stderr, "%s", " ");
6418	6693	// call reportid from reportlet
6419		- stack[base + 6LLU] = 485LLU/throw to this address/;
	6694	+ stack[base + 6LLU] = 510LLU/throw to this address/;
6420	6695	stack[base + 7LLU] = base;
6421		- stack[base + 8LLU] = 486LLU;
	6696	+ stack[base + 8LLU] = 511LLU;
6422	6697	// arguments for call to reportid
6423	6698	stack[base + 9LLU] = stack[base + 2]/id/;
6424	6699	// set stack-base & callee-address

		@@ -6426,21 +6701,21 @@
6426	6701	label = 18446744073709551586LLU; // reportid
6427	6702	break;
6428	6703	}
6429		- case 485LLU: // copy-back deleter (reportid to reportlet)
	6704	+ case 510LLU: // copy-back deleter (reportid to reportlet)
6430	6705	{
6431	6706	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportid to reportlet)\n");
6432	6707	// copy mutable arguments back from call to reportid
6433		- label = 480LLU; // continue to roll stack
	6708	+ label = 505LLU; // continue to roll stack
6434	6709	break;
6435	6710	}
6436		- case 486LLU: // return from reportid to reportlet
	6711	+ case 511LLU: // return from reportid to reportlet
6437	6712	{
6438	6713	// copy mutable arguments back from call to reportid
6439	6714	fprintf(stderr, "%s", " ");
6440	6715	// call reportnr from reportlet
6441		- stack[base + 6LLU] = 487LLU/throw to this address/;
	6716	+ stack[base + 6LLU] = 512LLU/throw to this address/;
6442	6717	stack[base + 7LLU] = base;
6443		- stack[base + 8LLU] = 488LLU;
	6718	+ stack[base + 8LLU] = 513LLU;
6444	6719	// arguments for call to reportnr
6445	6720	stack[base + 9LLU] = stack[base + 3]/index/;
6446	6721	// set stack-base & callee-address

		@@ -6448,14 +6723,14 @@
6448	6723	label = 18446744073709551589LLU; // reportnr
6449	6724	break;
6450	6725	}
6451		- case 487LLU: // copy-back deleter (reportnr to reportlet)
	6726	+ case 512LLU: // copy-back deleter (reportnr to reportlet)
6452	6727	{
6453	6728	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportnr to reportlet)\n");
6454	6729	// copy mutable arguments back from call to reportnr
6455		- label = 480LLU; // continue to roll stack
	6730	+ label = 505LLU; // continue to roll stack
6456	6731	break;
6457	6732	}
6458		- case 488LLU: // return from reportnr to reportlet
	6733	+ case 513LLU: // return from reportnr to reportlet
6459	6734	{
6460	6735	// copy mutable arguments back from call to reportnr
6461	6736	((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];

		@@ -6463,10 +6738,10 @@
6463	6738	((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
6464	6739	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
6465	6740	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6466		- label = 478LLU; // case complete
	6741	+ label = 503LLU; // case complete
6467	6742	break;
6468	6743	}
6469		- case 480LLU: // copy-back deleter (switch)
	6744	+ case 505LLU: // copy-back deleter (switch)
6470	6745	{
6471	6746	((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
6472	6747	((uint64_t **)(stack[base + 0]))[1][3] = stack[base + 4];

		@@ -6473,15 +6748,15 @@
6473	6748	((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
6474	6749	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
6475	6750	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6476		- label = 477LLU; // continue to unroll stack
	6751	+ label = 502LLU; // continue to unroll stack
6477	6752	break;
6478	6753	}
6479		- case 479LLU: // try next case
	6754	+ case 504LLU: // try next case
6480	6755	{
6481	6756	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6482	6757	exit(-1);
6483	6758	}
6484		- case 478LLU: // completed switch
	6759	+ case 503LLU: // completed switch
6485	6760	{
6486	6761	// return from reportlet
6487	6762	label = stack[base - 1];

		@@ -6488,7 +6763,7 @@
6488	6763	base = stack[base - 2];
6489	6764	break;
6490	6765	}
6491		- case 490LLU: // function equletdef failed
	6766	+ case 515LLU: // function equletdef failed
6492	6767	{
6493	6768	fprintf(stderr, "function equletdef failed\n");
6494	6769	label = stack[base - 3];

		@@ -6495,7 +6770,7 @@
6495	6770	base = stack[base - 2];
6496	6771	break;
6497	6772	}
6498		- case 489LLU: // equletdef
	6773	+ case 514LLU: // equletdef
6499	6774	{
6500	6775	//#define res0 0
6501	6776	//#define arg0 1

		@@ -6502,7 +6777,7 @@
6502	6777	//#define arg1 2
6503	6778	if(/letdef/0 != ((uint64_t )(stack[base + 1]/x*/))[0])
6504	6779	{
6505		- label = 492LLU; // jump to alternative
	6780	+ label = 517LLU; // jump to alternative
6506	6781	break;
6507	6782	}
6508	6783

		@@ -6514,7 +6789,7 @@
6514	6789
6515	6790	if(/letdef/0 != ((uint64_t )(stack[base + 2]/y*/))[0])
6516	6791	{
6517		- label = 492LLU; // jump to alternative
	6792	+ label = 517LLU; // jump to alternative
6518	6793	break;
6519	6794	}
6520	6795

		@@ -6525,48 +6800,48 @@
6525	6800	/ysubstruct/stack[base + 12] = ((uint64_t *)(stack[base + 2]/y/))[1][4]/substruct*/;
6526	6801
6527	6802	// case
6528		- label = 495LLU; // skip deleter
	6803	+ label = 520LLU; // skip deleter
6529	6804	break;
6530	6805	}
6531		- case 494LLU: // deleter
	6806	+ case 519LLU: // deleter
6532	6807	{
6533	6808	// throw from equletdef
6534	6809	if(!stack[base + 13])
6535	6810	{
6536	6811	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
6538	6813	break;
6539	6814	}
6540	6815	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
6542	6817	break;
6543	6818	}
6544		- case 495LLU: // skipped deleter
	6819	+ case 520LLU: // skipped deleter
6545	6820	{
6546	6821	stack[base + 13] = 1;
6547		- label = 497LLU; // skip deleter
	6822	+ label = 522LLU; // skip deleter
6548	6823	break;
6549	6824	}
6550		- case 496LLU: // deleter
	6825	+ case 521LLU: // deleter
6551	6826	{
6552	6827	// throw from equletdef
6553	6828	if(!stack[base + 14])
6554	6829	{
6555	6830	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
6557	6832	break;
6558	6833	}
6559	6834	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
6561	6836	break;
6562	6837	}
6563		- case 497LLU: // skipped deleter
	6838	+ case 522LLU: // skipped deleter
6564	6839	{
6565	6840	stack[base + 14] = 0;
6566	6841	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
6567	6842	if(!newstack)
6568	6843	{
6569		- label = 496LLU; // throw: begin to unroll stack
	6844	+ label = 521LLU; // throw: begin to unroll stack
6570	6845	break;
6571	6846	}
6572	6847

		@@ -6573,9 +6848,9 @@
6573	6848	newstack[15LLU] = 9876543210LLU; // overflow-marker
6574	6849	// call equtype from equletdef
6575	6850	newstack[0] = (uint64_t)stack; // backup stack location
6576		- newstack[1] = 498LLU;
	6851	+ newstack[1] = 523LLU;
6577	6852	newstack[2] = base;
6578		- newstack[3] = 499LLU;
	6853	+ newstack[3] = 524LLU;
6579	6854	// arguments for call to equtype
6580	6855	newstack[5LLU] = stack[base + 3]/xtype/;
6581	6856	newstack[6LLU] = stack[base + 8]/ytype/;

		@@ -6582,10 +6857,10 @@
6582	6857	stack = newstack;
6583	6858	// set stack-base & callee-address
6584	6859	base = 4/deloffset/;
6585		- label = 342LLU; // equtype
	6860	+ label = 355LLU; // equtype
6586	6861	break;
6587	6862	}
6588		- case 498LLU: // copy-back deleter (equtype to equletdef)
	6863	+ case 523LLU: // copy-back deleter (equtype to equletdef)
6589	6864	{
6590	6865	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equtype to equletdef)\n");
6591	6866	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6597,10 +6872,10 @@
6597	6872	}
6598	6873	Free(15LLU + 1, sizeof(uint64_t), stack);
6599	6874	stack = oldstack;
6600		- label = 496LLU; // continue to unroll stack
	6875	+ label = 521LLU; // continue to unroll stack
6601	6876	break;
6602	6877	}
6603		- case 499LLU: // return from equtype to equletdef
	6878	+ case 524LLU: // return from equtype to equletdef
6604	6879	{
6605	6880	uint64_t oldstack = (uint64_t )stack[0];
6606	6881	// copy mutable arguments back from call to equtype

		@@ -6614,9 +6889,9 @@
6614	6889	Free(15LLU + 1, sizeof(uint64_t), stack);
6615	6890	stack = oldstack;
6616	6891	// call and from equletdef
6617		- stack[base + 15LLU] = 500LLU/throw to this address/;
	6892	+ stack[base + 15LLU] = 525LLU/throw to this address/;
6618	6893	stack[base + 16LLU] = base;
6619		- stack[base + 17LLU] = 501LLU;
	6894	+ stack[base + 17LLU] = 526LLU;
6620	6895	// arguments for call to and
6621	6896	stack[base + 19LLU] = stack[base + 13]/result/;
6622	6897	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6625,22 +6900,22 @@
6625	6900	label = 18446744073709551613LLU; // and
6626	6901	break;
6627	6902	}
6628		- case 500LLU: // copy-back deleter (and to equletdef)
	6903	+ case 525LLU: // copy-back deleter (and to equletdef)
6629	6904	{
6630	6905	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6631	6906	// copy mutable arguments back from call to and
6632		- label = 496LLU; // continue to roll stack
	6907	+ label = 521LLU; // continue to roll stack
6633	6908	break;
6634	6909	}
6635		- case 501LLU: // return from and to equletdef
	6910	+ case 526LLU: // return from and to equletdef
6636	6911	{
6637	6912	// copy mutable arguments back from call to and
6638	6913	// copy back results provided by call to and
6639	6914	stack[base + 13] = stack[base + 18LLU];
6640	6915	// call equ from equletdef
6641		- stack[base + 15LLU] = 502LLU/throw to this address/;
	6916	+ stack[base + 15LLU] = 527LLU/throw to this address/;
6642	6917	stack[base + 16LLU] = base;
6643		- stack[base + 17LLU] = 503LLU;
	6918	+ stack[base + 17LLU] = 528LLU;
6644	6919	// arguments for call to equ
6645	6920	stack[base + 19LLU] = stack[base + 4]/xid/;
6646	6921	stack[base + 20LLU] = stack[base + 9]/yid/;

		@@ -6649,22 +6924,22 @@
6649	6924	label = 18446744073709551600LLU; // equ
6650	6925	break;
6651	6926	}
6652		- case 502LLU: // copy-back deleter (equ to equletdef)
	6927	+ case 527LLU: // copy-back deleter (equ to equletdef)
6653	6928	{
6654	6929	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6655	6930	// copy mutable arguments back from call to equ
6656		- label = 496LLU; // continue to roll stack
	6931	+ label = 521LLU; // continue to roll stack
6657	6932	break;
6658	6933	}
6659		- case 503LLU: // return from equ to equletdef
	6934	+ case 528LLU: // return from equ to equletdef
6660	6935	{
6661	6936	// copy mutable arguments back from call to equ
6662	6937	// copy back results provided by call to equ
6663	6938	stack[base + 14] = stack[base + 18LLU];
6664	6939	// call and from equletdef
6665		- stack[base + 15LLU] = 504LLU/throw to this address/;
	6940	+ stack[base + 15LLU] = 529LLU/throw to this address/;
6666	6941	stack[base + 16LLU] = base;
6667		- stack[base + 17LLU] = 505LLU;
	6942	+ stack[base + 17LLU] = 530LLU;
6668	6943	// arguments for call to and
6669	6944	stack[base + 19LLU] = stack[base + 13]/result/;
6670	6945	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6673,22 +6948,22 @@
6673	6948	label = 18446744073709551613LLU; // and
6674	6949	break;
6675	6950	}
6676		- case 504LLU: // copy-back deleter (and to equletdef)
	6951	+ case 529LLU: // copy-back deleter (and to equletdef)
6677	6952	{
6678	6953	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6679	6954	// copy mutable arguments back from call to and
6680		- label = 496LLU; // continue to roll stack
	6955	+ label = 521LLU; // continue to roll stack
6681	6956	break;
6682	6957	}
6683		- case 505LLU: // return from and to equletdef
	6958	+ case 530LLU: // return from and to equletdef
6684	6959	{
6685	6960	// copy mutable arguments back from call to and
6686	6961	// copy back results provided by call to and
6687	6962	stack[base + 13] = stack[base + 18LLU];
6688	6963	// call equ from equletdef
6689		- stack[base + 15LLU] = 506LLU/throw to this address/;
	6964	+ stack[base + 15LLU] = 531LLU/throw to this address/;
6690	6965	stack[base + 16LLU] = base;
6691		- stack[base + 17LLU] = 507LLU;
	6966	+ stack[base + 17LLU] = 532LLU;
6692	6967	// arguments for call to equ
6693	6968	stack[base + 19LLU] = stack[base + 5]/xindex/;
6694	6969	stack[base + 20LLU] = stack[base + 10]/yindex/;

		@@ -6697,22 +6972,22 @@
6697	6972	label = 18446744073709551600LLU; // equ
6698	6973	break;
6699	6974	}
6700		- case 506LLU: // copy-back deleter (equ to equletdef)
	6975	+ case 531LLU: // copy-back deleter (equ to equletdef)
6701	6976	{
6702	6977	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6703	6978	// copy mutable arguments back from call to equ
6704		- label = 496LLU; // continue to roll stack
	6979	+ label = 521LLU; // continue to roll stack
6705	6980	break;
6706	6981	}
6707		- case 507LLU: // return from equ to equletdef
	6982	+ case 532LLU: // return from equ to equletdef
6708	6983	{
6709	6984	// copy mutable arguments back from call to equ
6710	6985	// copy back results provided by call to equ
6711	6986	stack[base + 14] = stack[base + 18LLU];
6712	6987	// call and from equletdef
6713		- stack[base + 15LLU] = 508LLU/throw to this address/;
	6988	+ stack[base + 15LLU] = 533LLU/throw to this address/;
6714	6989	stack[base + 16LLU] = base;
6715		- stack[base + 17LLU] = 509LLU;
	6990	+ stack[base + 17LLU] = 534LLU;
6716	6991	// arguments for call to and
6717	6992	stack[base + 19LLU] = stack[base + 13]/result/;
6718	6993	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6721,22 +6996,22 @@
6721	6996	label = 18446744073709551613LLU; // and
6722	6997	break;
6723	6998	}
6724		- case 508LLU: // copy-back deleter (and to equletdef)
	6999	+ case 533LLU: // copy-back deleter (and to equletdef)
6725	7000	{
6726	7001	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6727	7002	// copy mutable arguments back from call to and
6728		- label = 496LLU; // continue to roll stack
	7003	+ label = 521LLU; // continue to roll stack
6729	7004	break;
6730	7005	}
6731		- case 509LLU: // return from and to equletdef
	7006	+ case 534LLU: // return from and to equletdef
6732	7007	{
6733	7008	// copy mutable arguments back from call to and
6734	7009	// copy back results provided by call to and
6735	7010	stack[base + 13] = stack[base + 18LLU];
6736	7011	// call equ from equletdef
6737		- stack[base + 15LLU] = 510LLU/throw to this address/;
	7012	+ stack[base + 15LLU] = 535LLU/throw to this address/;
6738	7013	stack[base + 16LLU] = base;
6739		- stack[base + 17LLU] = 511LLU;
	7014	+ stack[base + 17LLU] = 536LLU;
6740	7015	// arguments for call to equ
6741	7016	stack[base + 19LLU] = stack[base + 6]/xmutable/;
6742	7017	stack[base + 20LLU] = stack[base + 11]/ymutable/;

		@@ -6745,22 +7020,22 @@
6745	7020	label = 18446744073709551600LLU; // equ
6746	7021	break;
6747	7022	}
6748		- case 510LLU: // copy-back deleter (equ to equletdef)
	7023	+ case 535LLU: // copy-back deleter (equ to equletdef)
6749	7024	{
6750	7025	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6751	7026	// copy mutable arguments back from call to equ
6752		- label = 496LLU; // continue to roll stack
	7027	+ label = 521LLU; // continue to roll stack
6753	7028	break;
6754	7029	}
6755		- case 511LLU: // return from equ to equletdef
	7030	+ case 536LLU: // return from equ to equletdef
6756	7031	{
6757	7032	// copy mutable arguments back from call to equ
6758	7033	// copy back results provided by call to equ
6759	7034	stack[base + 14] = stack[base + 18LLU];
6760	7035	// call and from equletdef
6761		- stack[base + 15LLU] = 512LLU/throw to this address/;
	7036	+ stack[base + 15LLU] = 537LLU/throw to this address/;
6762	7037	stack[base + 16LLU] = base;
6763		- stack[base + 17LLU] = 513LLU;
	7038	+ stack[base + 17LLU] = 538LLU;
6764	7039	// arguments for call to and
6765	7040	stack[base + 19LLU] = stack[base + 13]/result/;
6766	7041	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6769,22 +7044,22 @@
6769	7044	label = 18446744073709551613LLU; // and
6770	7045	break;
6771	7046	}
6772		- case 512LLU: // copy-back deleter (and to equletdef)
	7047	+ case 537LLU: // copy-back deleter (and to equletdef)
6773	7048	{
6774	7049	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6775	7050	// copy mutable arguments back from call to and
6776		- label = 496LLU; // continue to roll stack
	7051	+ label = 521LLU; // continue to roll stack
6777	7052	break;
6778	7053	}
6779		- case 513LLU: // return from and to equletdef
	7054	+ case 538LLU: // return from and to equletdef
6780	7055	{
6781	7056	// copy mutable arguments back from call to and
6782	7057	// copy back results provided by call to and
6783	7058	stack[base + 13] = stack[base + 18LLU];
6784	7059	// call equ from equletdef
6785		- stack[base + 15LLU] = 514LLU/throw to this address/;
	7060	+ stack[base + 15LLU] = 539LLU/throw to this address/;
6786	7061	stack[base + 16LLU] = base;
6787		- stack[base + 17LLU] = 515LLU;
	7062	+ stack[base + 17LLU] = 540LLU;
6788	7063	// arguments for call to equ
6789	7064	stack[base + 19LLU] = stack[base + 7]/xsubstruct/;
6790	7065	stack[base + 20LLU] = stack[base + 12]/ysubstruct/;

		@@ -6793,22 +7068,22 @@
6793	7068	label = 18446744073709551600LLU; // equ
6794	7069	break;
6795	7070	}
6796		- case 514LLU: // copy-back deleter (equ to equletdef)
	7071	+ case 539LLU: // copy-back deleter (equ to equletdef)
6797	7072	{
6798	7073	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6799	7074	// copy mutable arguments back from call to equ
6800		- label = 496LLU; // continue to roll stack
	7075	+ label = 521LLU; // continue to roll stack
6801	7076	break;
6802	7077	}
6803		- case 515LLU: // return from equ to equletdef
	7078	+ case 540LLU: // return from equ to equletdef
6804	7079	{
6805	7080	// copy mutable arguments back from call to equ
6806	7081	// copy back results provided by call to equ
6807	7082	stack[base + 14] = stack[base + 18LLU];
6808	7083	// call and from equletdef
6809		- stack[base + 15LLU] = 516LLU/throw to this address/;
	7084	+ stack[base + 15LLU] = 541LLU/throw to this address/;
6810	7085	stack[base + 16LLU] = base;
6811		- stack[base + 17LLU] = 517LLU;
	7086	+ stack[base + 17LLU] = 542LLU;
6812	7087	// arguments for call to and
6813	7088	stack[base + 19LLU] = stack[base + 13]/result/;
6814	7089	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6817,35 +7092,35 @@
6817	7092	label = 18446744073709551613LLU; // and
6818	7093	break;
6819	7094	}
6820		- case 516LLU: // copy-back deleter (and to equletdef)
	7095	+ case 541LLU: // copy-back deleter (and to equletdef)
6821	7096	{
6822	7097	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6823	7098	// copy mutable arguments back from call to and
6824		- label = 496LLU; // continue to roll stack
	7099	+ label = 521LLU; // continue to roll stack
6825	7100	break;
6826	7101	}
6827		- case 517LLU: // return from and to equletdef
	7102	+ case 542LLU: // return from and to equletdef
6828	7103	{
6829	7104	// copy mutable arguments back from call to and
6830	7105	// copy back results provided by call to and
6831	7106	stack[base + 13] = stack[base + 18LLU];
6832		- label = 519LLU; // skip deleter
	7107	+ label = 544LLU; // skip deleter
6833	7108	break;
6834	7109	}
6835		- case 518LLU: // deleter
	7110	+ case 543LLU: // deleter
6836	7111	{
6837	7112	// throw from equletdef
6838	7113	if(!stack[base + 0])
6839	7114	{
6840	7115	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
6842	7117	break;
6843	7118	}
6844	7119	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
6846	7121	break;
6847	7122	}
6848		- case 519LLU: // skipped deleter
	7123	+ case 544LLU: // skipped deleter
6849	7124	{
6850	7125	stack[base + 0] = stack[base + 13]/result/;
6851	7126	((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];

		@@ -6858,10 +7133,10 @@
6858	7133	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
6859	7134	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
6860	7135	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6861		- label = 491LLU; // case complete
	7136	+ label = 516LLU; // case complete
6862	7137	break;
6863	7138	}
6864		- case 493LLU: // copy-back deleter (switch)
	7139	+ case 518LLU: // copy-back deleter (switch)
6865	7140	{
6866	7141	((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
6867	7142	((uint64_t **)(stack[base + 2]))[1][3] = stack[base + 11];

		@@ -6873,15 +7148,15 @@
6873	7148	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
6874	7149	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
6875	7150	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6876		- label = 490LLU; // continue to unroll stack
	7151	+ label = 515LLU; // continue to unroll stack
6877	7152	break;
6878	7153	}
6879		- case 492LLU: // try next case
	7154	+ case 517LLU: // try next case
6880	7155	{
6881	7156	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6882	7157	exit(-1);
6883	7158	}
6884		- case 491LLU: // completed switch
	7159	+ case 516LLU: // completed switch
6885	7160	{
6886	7161	// return from equletdef
6887	7162	label = stack[base - 1];

		@@ -6888,7 +7163,7 @@
6888	7163	base = stack[base - 2];
6889	7164	break;
6890	7165	}
6891		- case 521LLU: // function copyletdef failed
	7166	+ case 546LLU: // function copyletdef failed
6892	7167	{
6893	7168	fprintf(stderr, "function copyletdef failed\n");
6894	7169	label = stack[base - 3];

		@@ -6895,13 +7170,13 @@
6895	7170	base = stack[base - 2];
6896	7171	break;
6897	7172	}
6898		- case 520LLU: // copyletdef
	7173	+ case 545LLU: // copyletdef
6899	7174	{
6900	7175	//#define res0 0
6901	7176	//#define arg0 1
6902	7177	if(/letdef/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
6903	7178	{
6904		- label = 523LLU; // jump to alternative
	7179	+ label = 548LLU; // jump to alternative
6905	7180	break;
6906	7181	}
6907	7182

		@@ -6912,10 +7187,47 @@
6912	7187	/substruct/stack[base + 6] = ((uint64_t *)(stack[base + 1]/original/))[1][4]/substruct*/;
6913	7188
6914	7189	// 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	+ {
6915	7227	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
6916	7228	if(!newstack)
6917	7229	{
6918		- label = 524LLU; // throw: begin to unroll stack
	7230	+ label = 549LLU; // throw: begin to unroll stack
6919	7231	break;
6920	7232	}
6921	7233

		@@ -6922,18 +7234,18 @@
6922	7234	newstack[15LLU] = 9876543210LLU; // overflow-marker
6923	7235	// call copytype from copyletdef
6924	7236	newstack[0] = (uint64_t)stack; // backup stack location
6925		- newstack[1] = 525LLU;
	7237	+ newstack[1] = 553LLU;
6926	7238	newstack[2] = base;
6927		- newstack[3] = 526LLU;
	7239	+ newstack[3] = 554LLU;
6928	7240	// arguments for call to copytype
6929	7241	newstack[5LLU] = stack[base + 2]/type/;
6930	7242	stack = newstack;
6931	7243	// set stack-base & callee-address
6932	7244	base = 4/deloffset/;
6933		- label = 327LLU; // copytype
	7245	+ label = 337LLU; // copytype
6934	7246	break;
6935	7247	}
6936		- case 525LLU: // copy-back deleter (copytype to copyletdef)
	7248	+ case 553LLU: // copy-back deleter (copytype to copyletdef)
6937	7249	{
6938	7250	fprintf(stderr, "in function copyletdef: unrolling stack, copy-back (copytype to copyletdef)\n");
6939	7251	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6945,10 +7257,10 @@
6945	7257	}
6946	7258	Free(15LLU + 1, sizeof(uint64_t), stack);
6947	7259	stack = oldstack;
6948		- label = 524LLU; // continue to unroll stack
	7260	+ label = 549LLU; // continue to unroll stack
6949	7261	break;
6950	7262	}
6951		- case 526LLU: // return from copytype to copyletdef
	7263	+ case 554LLU: // return from copytype to copyletdef
6952	7264	{
6953	7265	uint64_t oldstack = (uint64_t )stack[0];
6954	7266	// copy mutable arguments back from call to copytype

		@@ -6961,16 +7273,16 @@
6961	7273	}
6962	7274	Free(15LLU + 1, sizeof(uint64_t), stack);
6963	7275	stack = oldstack;
6964		- label = 528LLU; // skip deleter
	7276	+ label = 556LLU; // skip deleter
6965	7277	break;
6966	7278	}
6967		- case 527LLU: // deleter
	7279	+ case 555LLU: // deleter
6968	7280	{
6969	7281	// throw from copyletdef
6970	7282	if(!stack[base + 0])
6971	7283	{
6972	7284	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
6974	7286	break;
6975	7287	}
6976	7288	fprintf(stderr, "in function copyletdef: unrolling stack, variable letdef \n");

		@@ -6980,28 +7292,28 @@
6980	7292	newstack[0] = (uint64_t)stack; // backup stack location
6981	7293	newstack[1] = 1234567890;
6982	7294	newstack[2] = base;
6983		- newstack[3] = 529LLU;
	7295	+ newstack[3] = 557LLU;
6984	7296	stack = newstack;
6985	7297	// set stack-base & callee-address
6986	7298	base = 4/deloffset/;
6987		- label = 457LLU; // ~letdef
	7299	+ label = 482LLU; // ~letdef
6988	7300	break;
6989	7301	}
6990		- case 529LLU: // return from ~letdef to copyletdef
	7302	+ case 557LLU: // return from ~letdef to copyletdef
6991	7303	{
6992	7304	stack = (uint64_t *)stack[0];
6993	7305	// releasing toplevel container
6994	7306	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
6995	7307
6996		- label = 524LLU; // continue unrolling stack, delete next variable
	7308	+ label = 550LLU; // continue unrolling stack, delete next variable
6997	7309	break;
6998	7310	}
6999		- case 528LLU: // skipped deleter
	7311	+ case 556LLU: // skipped deleter
7000	7312	{
7001	7313	// construct letdef.letdef
7002	7314	if(!(stack[base + 0] = construct(5)))
7003	7315	{
7004		- label = 524LLU; // throw: begin to unroll stack
	7316	+ label = 550LLU; // throw: begin to unroll stack
7005	7317	break;
7006	7318	}
7007	7319

		@@ -7017,10 +7329,10 @@
7017	7329	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
7018	7330	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7019	7331	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7020		- label = 522LLU; // case complete
	7332	+ label = 547LLU; // case complete
7021	7333	break;
7022	7334	}
7023		- case 524LLU: // copy-back deleter (switch)
	7335	+ case 549LLU: // copy-back deleter (switch)
7024	7336	{
7025	7337	((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 6];
7026	7338	((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 5];

		@@ -7027,15 +7339,15 @@
7027	7339	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
7028	7340	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7029	7341	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7030		- label = 521LLU; // continue to unroll stack
	7342	+ label = 546LLU; // continue to unroll stack
7031	7343	break;
7032	7344	}
7033		- case 523LLU: // try next case
	7345	+ case 548LLU: // try next case
7034	7346	{
7035	7347	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7036	7348	exit(-1);
7037	7349	}
7038		- case 522LLU: // completed switch
	7350	+ case 547LLU: // completed switch
7039	7351	{
7040	7352	// return from copyletdef
7041	7353	label = stack[base - 1];

		@@ -7042,7 +7354,7 @@
7042	7354	base = stack[base - 2];
7043	7355	break;
7044	7356	}
7045		- case 530LLU: // ~scope
	7357	+ case 558LLU: // ~scope
7046	7358	{
7047	7359	if(stack[base + 0]/variant-nr/ >= 1)
7048	7360	{

		@@ -7049,23 +7361,23 @@
7049	7361	fprintf(stderr, "in ~scope: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
7050	7362	exit(-1);
7051	7363	}
7052		- label = 530LLU + 1LLU + stack[base + 0]/variant-nr/;
	7364	+ label = 558LLU + 1LLU + stack[base + 0]/variant-nr/;
7053	7365	break;
7054	7366	}
7055		- case 530LLU + 1LLU + 0LLU: // ~scope.scope
	7367	+ case 558LLU + 1LLU + 0LLU: // ~scope.scope
7056	7368	{
7057	7369	// release element deleteaddr
7058	7370	// release element letdefs
7059	7371	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[1/element-nr*/];
7060	7372	// delete list
7061		- label = 532LLU; // start to repeat
	7373	+ label = 560LLU; // start to repeat
7062	7374	break;
7063	7375	}
7064		- case 532LLU: // repeat from here
	7376	+ case 560LLU: // repeat from here
7065	7377	{
7066	7378	if(!stack[base + 0])
7067	7379	{
7068		- label = 533LLU; // break loop
	7380	+ label = 561LLU; // break loop
7069	7381	break;
7070	7382	}
7071	7383

		@@ -7076,14 +7388,14 @@
7076	7388	newstack[0] = (uint64_t)stack; // backup stack location
7077	7389	newstack[1] = 1234567890;
7078	7390	newstack[2] = base;
7079		- newstack[3] = 534LLU;
	7391	+ newstack[3] = 562LLU;
7080	7392	stack = newstack;
7081	7393	// set stack-base & callee-address
7082	7394	base = 4/deloffset/;
7083		- label = 457LLU; // ~letdef
	7395	+ label = 482LLU; // ~letdef
7084	7396	break;
7085	7397	}
7086		- case 534LLU: // return from ~letdef to scope
	7398	+ case 562LLU: // return from ~letdef to scope
7087	7399	{
7088	7400	stack = (uint64_t *)stack[0];
7089	7401	// releasing toplevel container

		@@ -7094,10 +7406,10 @@
7094	7406	stack[base + 0] = (uint64_t)list->next;
7095	7407	Free(1, sizeof(struct listnode), list);
7096	7408	}
7097		- label = 532LLU; // repeat
	7409	+ label = 560LLU; // repeat
7098	7410	break;
7099	7411	}
7100		- case 533LLU: // loop finished
	7412	+ case 561LLU: // loop finished
7101	7413	{
7102	7414	// release variant container
7103	7415	Free(2, sizeof(uint64_t), ((uint64_t )stack[base + 1]/variant*/));

		@@ -7105,7 +7417,7 @@
7105	7417	base = stack[base - 2];
7106	7418	break;
7107	7419	}
7108		- case 536LLU: // function emptyscope failed
	7420	+ case 564LLU: // function emptyscope failed
7109	7421	{
7110	7422	fprintf(stderr, "function emptyscope failed\n");
7111	7423	label = stack[base - 3];

		@@ -7112,50 +7424,50 @@
7112	7424	base = stack[base - 2];
7113	7425	break;
7114	7426	}
7115		- case 535LLU: // emptyscope
	7427	+ case 563LLU: // emptyscope
7116	7428	{
7117	7429	//#define res0 0
7118		- label = 538LLU; // skip deleter
	7430	+ label = 566LLU; // skip deleter
7119	7431	break;
7120	7432	}
7121		- case 537LLU: // deleter
	7433	+ case 565LLU: // deleter
7122	7434	{
7123	7435	// throw from emptyscope
7124	7436	if(!stack[base + 1])
7125	7437	{
7126	7438	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
7128	7440	break;
7129	7441	}
7130	7442	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
7132	7444	break;
7133	7445	}
7134		- case 538LLU: // skipped deleter
	7446	+ case 566LLU: // skipped deleter
7135	7447	{
7136	7448	stack[base + 1] = 1234567890;
7137		- label = 540LLU; // skip deleter
	7449	+ label = 568LLU; // skip deleter
7138	7450	break;
7139	7451	}
7140		- case 539LLU: // deleter
	7452	+ case 567LLU: // deleter
7141	7453	{
7142	7454	// throw from emptyscope
7143	7455	if(!stack[base + 2])
7144	7456	{
7145	7457	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
7147	7459	break;
7148	7460	}
7149	7461	fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] letdefs\n");
7150	7462	// delete list
7151		- label = 541LLU; // start to repeat
	7463	+ label = 569LLU; // start to repeat
7152	7464	break;
7153	7465	}
7154		- case 541LLU: // repeat from here
	7466	+ case 569LLU: // repeat from here
7155	7467	{
7156	7468	if(!stack[base + 2])
7157	7469	{
7158		- label = 542LLU; // break loop
	7470	+ label = 570LLU; // break loop
7159	7471	break;
7160	7472	}
7161	7473

		@@ -7166,14 +7478,14 @@
7166	7478	newstack[0] = (uint64_t)stack; // backup stack location
7167	7479	newstack[1] = 1234567890;
7168	7480	newstack[2] = base;
7169		- newstack[3] = 543LLU;
	7481	+ newstack[3] = 571LLU;
7170	7482	stack = newstack;
7171	7483	// set stack-base & callee-address
7172	7484	base = 4/deloffset/;
7173		- label = 457LLU; // ~letdef
	7485	+ label = 482LLU; // ~letdef
7174	7486	break;
7175	7487	}
7176		- case 543LLU: // return from ~letdef to emptyscope
	7488	+ case 571LLU: // return from ~letdef to emptyscope
7177	7489	{
7178	7490	stack = (uint64_t *)stack[0];
7179	7491	// releasing toplevel container

		@@ -7184,27 +7496,27 @@
7184	7496	stack[base + 2] = (uint64_t)list->next;
7185	7497	Free(1, sizeof(struct listnode), list);
7186	7498	}
7187		- label = 541LLU; // repeat
	7499	+ label = 569LLU; // repeat
7188	7500	break;
7189	7501	}
7190		- case 542LLU: // loop finished
	7502	+ case 570LLU: // loop finished
7191	7503	{
7192		- label = 537LLU; // continue unrolling stack, delete next variable
	7504	+ label = 565LLU; // continue unrolling stack, delete next variable
7193	7505	break;
7194	7506	}
7195		- case 540LLU: // skipped deleter
	7507	+ case 568LLU: // skipped deleter
7196	7508	{
7197	7509	stack[base + 2] = 0;
7198		- label = 545LLU; // skip deleter
	7510	+ label = 573LLU; // skip deleter
7199	7511	break;
7200	7512	}
7201		- case 544LLU: // deleter
	7513	+ case 572LLU: // deleter
7202	7514	{
7203	7515	// throw from emptyscope
7204	7516	if(!stack[base + 0])
7205	7517	{
7206	7518	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
7208	7520	break;
7209	7521	}
7210	7522	fprintf(stderr, "in function emptyscope: unrolling stack, variable scope \n");

		@@ -7214,28 +7526,28 @@
7214	7526	newstack[0] = (uint64_t)stack; // backup stack location
7215	7527	newstack[1] = 1234567890;
7216	7528	newstack[2] = base;
7217		- newstack[3] = 546LLU;
	7529	+ newstack[3] = 574LLU;
7218	7530	stack = newstack;
7219	7531	// set stack-base & callee-address
7220	7532	base = 4/deloffset/;
7221		- label = 530LLU; // ~scope
	7533	+ label = 558LLU; // ~scope
7222	7534	break;
7223	7535	}
7224		- case 546LLU: // return from ~scope to emptyscope
	7536	+ case 574LLU: // return from ~scope to emptyscope
7225	7537	{
7226	7538	stack = (uint64_t *)stack[0];
7227	7539	// releasing toplevel container
7228	7540	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
7229	7541
7230		- label = 539LLU; // continue unrolling stack, delete next variable
	7542	+ label = 567LLU; // continue unrolling stack, delete next variable
7231	7543	break;
7232	7544	}
7233		- case 545LLU: // skipped deleter
	7545	+ case 573LLU: // skipped deleter
7234	7546	{
7235	7547	// construct scope.scope
7236	7548	if(!(stack[base + 0] = construct(2)))
7237	7549	{
7238		- label = 539LLU; // throw: begin to unroll stack
	7550	+ label = 567LLU; // throw: begin to unroll stack
7239	7551	break;
7240	7552	}
7241	7553

		@@ -7248,7 +7560,7 @@
7248	7560	base = stack[base - 2];
7249	7561	break;
7250	7562	}
7251		- case 548LLU: // function chainscope failed
	7563	+ case 576LLU: // function chainscope failed
7252	7564	{
7253	7565	fprintf(stderr, "function chainscope failed\n");
7254	7566	label = stack[base - 3];

		@@ -7255,32 +7567,32 @@
7255	7567	base = stack[base - 2];
7256	7568	break;
7257	7569	}
7258		- case 547LLU: // chainscope
	7570	+ case 575LLU: // chainscope
7259	7571	{
7260	7572	//#define res0 0
7261	7573	//#define arg0 1
7262		- label = 550LLU; // skip deleter
	7574	+ label = 578LLU; // skip deleter
7263	7575	break;
7264	7576	}
7265		- case 549LLU: // deleter
	7577	+ case 577LLU: // deleter
7266	7578	{
7267	7579	// throw from chainscope
7268	7580	if(!stack[base + 2])
7269	7581	{
7270	7582	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
7272	7584	break;
7273	7585	}
7274	7586	fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] letdefs\n");
7275	7587	// delete list
7276		- label = 551LLU; // start to repeat
	7588	+ label = 579LLU; // start to repeat
7277	7589	break;
7278	7590	}
7279		- case 551LLU: // repeat from here
	7591	+ case 579LLU: // repeat from here
7280	7592	{
7281	7593	if(!stack[base + 2])
7282	7594	{
7283		- label = 552LLU; // break loop
	7595	+ label = 580LLU; // break loop
7284	7596	break;
7285	7597	}
7286	7598

		@@ -7291,14 +7603,14 @@
7291	7603	newstack[0] = (uint64_t)stack; // backup stack location
7292	7604	newstack[1] = 1234567890;
7293	7605	newstack[2] = base;
7294		- newstack[3] = 553LLU;
	7606	+ newstack[3] = 581LLU;
7295	7607	stack = newstack;
7296	7608	// set stack-base & callee-address
7297	7609	base = 4/deloffset/;
7298		- label = 457LLU; // ~letdef
	7610	+ label = 482LLU; // ~letdef
7299	7611	break;
7300	7612	}
7301		- case 553LLU: // return from ~letdef to chainscope
	7613	+ case 581LLU: // return from ~letdef to chainscope
7302	7614	{
7303	7615	stack = (uint64_t *)stack[0];
7304	7616	// releasing toplevel container

		@@ -7309,27 +7621,27 @@
7309	7621	stack[base + 2] = (uint64_t)list->next;
7310	7622	Free(1, sizeof(struct listnode), list);
7311	7623	}
7312		- label = 551LLU; // repeat
	7624	+ label = 579LLU; // repeat
7313	7625	break;
7314	7626	}
7315		- case 552LLU: // loop finished
	7627	+ case 580LLU: // loop finished
7316	7628	{
7317		- label = 548LLU; // continue unrolling stack, delete next variable
	7629	+ label = 576LLU; // continue unrolling stack, delete next variable
7318	7630	break;
7319	7631	}
7320		- case 550LLU: // skipped deleter
	7632	+ case 578LLU: // skipped deleter
7321	7633	{
7322	7634	stack[base + 2] = 0;
7323		- label = 555LLU; // skip deleter
	7635	+ label = 583LLU; // skip deleter
7324	7636	break;
7325	7637	}
7326		- case 554LLU: // deleter
	7638	+ case 582LLU: // deleter
7327	7639	{
7328	7640	// throw from chainscope
7329	7641	if(!stack[base + 0])
7330	7642	{
7331	7643	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
7333	7645	break;
7334	7646	}
7335	7647	fprintf(stderr, "in function chainscope: unrolling stack, variable scope \n");

		@@ -7339,28 +7651,28 @@
7339	7651	newstack[0] = (uint64_t)stack; // backup stack location
7340	7652	newstack[1] = 1234567890;
7341	7653	newstack[2] = base;
7342		- newstack[3] = 556LLU;
	7654	+ newstack[3] = 584LLU;
7343	7655	stack = newstack;
7344	7656	// set stack-base & callee-address
7345	7657	base = 4/deloffset/;
7346		- label = 530LLU; // ~scope
	7658	+ label = 558LLU; // ~scope
7347	7659	break;
7348	7660	}
7349		- case 556LLU: // return from ~scope to chainscope
	7661	+ case 584LLU: // return from ~scope to chainscope
7350	7662	{
7351	7663	stack = (uint64_t *)stack[0];
7352	7664	// releasing toplevel container
7353	7665	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
7354	7666
7355		- label = 549LLU; // continue unrolling stack, delete next variable
	7667	+ label = 577LLU; // continue unrolling stack, delete next variable
7356	7668	break;
7357	7669	}
7358		- case 555LLU: // skipped deleter
	7670	+ case 583LLU: // skipped deleter
7359	7671	{
7360	7672	// construct scope.scope
7361	7673	if(!(stack[base + 0] = construct(2)))
7362	7674	{
7363		- label = 549LLU; // throw: begin to unroll stack
	7675	+ label = 577LLU; // throw: begin to unroll stack
7364	7676	break;
7365	7677	}
7366	7678

		@@ -7373,7 +7685,7 @@
7373	7685	base = stack[base - 2];
7374	7686	break;
7375	7687	}
7376		- case 558LLU: // function linkscope failed
	7688	+ case 586LLU: // function linkscope failed
7377	7689	{
7378	7690	fprintf(stderr, "function linkscope failed\n");
7379	7691	label = stack[base - 3];

		@@ -7380,13 +7692,13 @@
7380	7692	base = stack[base - 2];
7381	7693	break;
7382	7694	}
7383		- case 557LLU: // linkscope
	7695	+ case 585LLU: // linkscope
7384	7696	{
7385	7697	//#define res0 0
7386	7698	//#define arg0 1
7387	7699	if(/scope/0 != ((uint64_t )(stack[base + 1]/scope*/))[0])
7388	7700	{
7389		- label = 560LLU; // jump to alternative
	7701	+ label = 588LLU; // jump to alternative
7390	7702	break;
7391	7703	}
7392	7704

		@@ -7395,24 +7707,24 @@
7395	7707
7396	7708	// case
7397	7709	// call chainscope from linkscope
7398		- stack[base + 4LLU] = 562LLU/throw to this address/;
	7710	+ stack[base + 4LLU] = 590LLU/throw to this address/;
7399	7711	stack[base + 5LLU] = base;
7400		- stack[base + 6LLU] = 563LLU;
	7712	+ stack[base + 6LLU] = 591LLU;
7401	7713	// arguments for call to chainscope
7402	7714	stack[base + 8LLU] = stack[base + 2]/labelthrow/;
7403	7715	// set stack-base & callee-address
7404	7716	base += 7LLU;
7405		- label = 547LLU; // chainscope
	7717	+ label = 575LLU; // chainscope
7406	7718	break;
7407	7719	}
7408		- case 562LLU: // copy-back deleter (chainscope to linkscope)
	7720	+ case 590LLU: // copy-back deleter (chainscope to linkscope)
7409	7721	{
7410	7722	fprintf(stderr, "in function linkscope: unrolling stack, copy-back (chainscope to linkscope)\n");
7411	7723	// copy mutable arguments back from call to chainscope
7412		- label = 561LLU; // continue to roll stack
	7724	+ label = 589LLU; // continue to roll stack
7413	7725	break;
7414	7726	}
7415		- case 563LLU: // return from chainscope to linkscope
	7727	+ case 591LLU: // return from chainscope to linkscope
7416	7728	{
7417	7729	// copy mutable arguments back from call to chainscope
7418	7730	// copy back results provided by call to chainscope

		@@ -7419,22 +7731,22 @@
7419	7731	stack[base + 0] = stack[base + 7LLU];
7420	7732	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7421	7733	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7422		- label = 559LLU; // case complete
	7734	+ label = 587LLU; // case complete
7423	7735	break;
7424	7736	}
7425		- case 561LLU: // copy-back deleter (switch)
	7737	+ case 589LLU: // copy-back deleter (switch)
7426	7738	{
7427	7739	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7428	7740	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7429		- label = 558LLU; // continue to unroll stack
	7741	+ label = 586LLU; // continue to unroll stack
7430	7742	break;
7431	7743	}
7432		- case 560LLU: // try next case
	7744	+ case 588LLU: // try next case
7433	7745	{
7434	7746	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7435	7747	exit(-1);
7436	7748	}
7437		- case 559LLU: // completed switch
	7749	+ case 587LLU: // completed switch
7438	7750	{
7439	7751	// return from linkscope
7440	7752	label = stack[base - 1];

		@@ -7441,7 +7753,7 @@
7441	7753	base = stack[base - 2];
7442	7754	break;
7443	7755	}
7444		- case 565LLU: // function getdeladdr failed
	7756	+ case 593LLU: // function getdeladdr failed
7445	7757	{
7446	7758	fprintf(stderr, "function getdeladdr failed\n");
7447	7759	label = stack[base - 3];

		@@ -7448,13 +7760,13 @@
7448	7760	base = stack[base - 2];
7449	7761	break;
7450	7762	}
7451		- case 564LLU: // getdeladdr
	7763	+ case 592LLU: // getdeladdr
7452	7764	{
7453	7765	//#define res0 0
7454	7766	//#define arg0 1
7455	7767	if(/scope/0 != ((uint64_t )(stack[base + 1]/scope*/))[0])
7456	7768	{
7457		- label = 567LLU; // jump to alternative
	7769	+ label = 595LLU; // jump to alternative
7458	7770	break;
7459	7771	}
7460	7772

		@@ -7462,43 +7774,43 @@
7462	7774	/letdefs/stack[base + 3] = ((uint64_t *)(stack[base + 1]/scope/))[1][1]/letdefs*/;
7463	7775
7464	7776	// case
7465		- label = 570LLU; // skip deleter
	7777	+ label = 598LLU; // skip deleter
7466	7778	break;
7467	7779	}
7468		- case 569LLU: // deleter
	7780	+ case 597LLU: // deleter
7469	7781	{
7470	7782	// throw from getdeladdr
7471	7783	if(!stack[base + 0])
7472	7784	{
7473	7785	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
7475	7787	break;
7476	7788	}
7477	7789	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
7479	7791	break;
7480	7792	}
7481		- case 570LLU: // skipped deleter
	7793	+ case 598LLU: // skipped deleter
7482	7794	{
7483	7795	stack[base + 0] = stack[base + 2]/labelthrow/;
7484	7796	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7485	7797	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7486		- label = 566LLU; // case complete
	7798	+ label = 594LLU; // case complete
7487	7799	break;
7488	7800	}
7489		- case 568LLU: // copy-back deleter (switch)
	7801	+ case 596LLU: // copy-back deleter (switch)
7490	7802	{
7491	7803	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7492	7804	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7493		- label = 565LLU; // continue to unroll stack
	7805	+ label = 593LLU; // continue to unroll stack
7494	7806	break;
7495	7807	}
7496		- case 567LLU: // try next case
	7808	+ case 595LLU: // try next case
7497	7809	{
7498	7810	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7499	7811	exit(-1);
7500	7812	}
7501		- case 566LLU: // completed switch
	7813	+ case 594LLU: // completed switch
7502	7814	{
7503	7815	// return from getdeladdr
7504	7816	label = stack[base - 1];

		@@ -7505,7 +7817,7 @@
7505	7817	base = stack[base - 2];
7506	7818	break;
7507	7819	}
7508		- case 572LLU: // function existslet failed
	7820	+ case 600LLU: // function existslet failed
7509	7821	{
7510	7822	fprintf(stderr, "function existslet failed\n");
7511	7823	label = stack[base - 3];

		@@ -7512,39 +7824,39 @@
7512	7824	base = stack[base - 2];
7513	7825	break;
7514	7826	}
7515		- case 571LLU: // existslet
	7827	+ case 599LLU: // existslet
7516	7828	{
7517	7829	//#define res0 0
7518	7830	//#define arg0 1
7519	7831	//#define arg1 2
7520		- label = 574LLU; // skip deleter
	7832	+ label = 602LLU; // skip deleter
7521	7833	break;
7522	7834	}
7523		- case 573LLU: // deleter
	7835	+ case 601LLU: // deleter
7524	7836	{
7525	7837	// throw from existslet
7526	7838	if(!stack[base + 3])
7527	7839	{
7528	7840	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
7530	7842	break;
7531	7843	}
7532	7844	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
7534	7846	break;
7535	7847	}
7536		- case 574LLU: // skipped deleter
	7848	+ case 602LLU: // skipped deleter
7537	7849	{
7538	7850	stack[base + 3] = 0;
7539	7851	flippedassign(stack[base + 1]/letdefs/, &stack[base + 4]);
7540		- label = 575LLU; // start to repeat
	7852	+ label = 603LLU; // start to repeat
7541	7853	break;
7542	7854	}
7543		- case 575LLU: // repeat from here
	7855	+ case 603LLU: // repeat from here
7544	7856	{
7545	7857	if(!stack[base + 4])
7546	7858	{
7547		- label = 576LLU; // break loop
	7859	+ label = 604LLU; // break loop
7548	7860	break;
7549	7861	}
7550	7862

		@@ -7554,19 +7866,19 @@
7554	7866	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
7555	7867	if(!stack[base + 3]/found/)
7556	7868	{
7557		- label = 578LLU; // jump to alternative
	7869	+ label = 606LLU; // jump to alternative
7558	7870	break;
7559	7871	}
7560	7872
7561	7873	// consequent
7562		- label = 579LLU; // consequent complete
	7874	+ label = 607LLU; // consequent complete
7563	7875	break;
7564	7876	}
7565		- case 578LLU: // alternative
	7877	+ case 606LLU: // alternative
7566	7878	{
7567	7879	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
7568	7880	{
7569		- label = 581LLU; // jump to alternative
	7881	+ label = 609LLU; // jump to alternative
7570	7882	break;
7571	7883	}
7572	7884

		@@ -7578,9 +7890,9 @@
7578	7890
7579	7891	// case
7580	7892	// call equ from existslet
7581		- stack[base + 12LLU] = 583LLU/throw to this address/;
	7893	+ stack[base + 12LLU] = 611LLU/throw to this address/;
7582	7894	stack[base + 13LLU] = base;
7583		- stack[base + 14LLU] = 584LLU;
	7895	+ stack[base + 14LLU] = 612LLU;
7584	7896	// arguments for call to equ
7585	7897	stack[base + 16LLU] = stack[base + 8]/curid/;
7586	7898	stack[base + 17LLU] = stack[base + 2]/id/;

		@@ -7589,14 +7901,14 @@
7589	7901	label = 18446744073709551600LLU; // equ
7590	7902	break;
7591	7903	}
7592		- case 583LLU: // copy-back deleter (equ to existslet)
	7904	+ case 611LLU: // copy-back deleter (equ to existslet)
7593	7905	{
7594	7906	fprintf(stderr, "in function existslet: unrolling stack, copy-back (equ to existslet)\n");
7595	7907	// copy mutable arguments back from call to equ
7596		- label = 582LLU; // continue to roll stack
	7908	+ label = 610LLU; // continue to roll stack
7597	7909	break;
7598	7910	}
7599		- case 584LLU: // return from equ to existslet
	7911	+ case 612LLU: // return from equ to existslet
7600	7912	{
7601	7913	// copy mutable arguments back from call to equ
7602	7914	// copy back results provided by call to equ

		@@ -7606,10 +7918,10 @@
7606	7918	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
7607	7919	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
7608	7920	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7609		- label = 580LLU; // case complete
	7921	+ label = 608LLU; // case complete
7610	7922	break;
7611	7923	}
7612		- case 582LLU: // copy-back deleter (switch)
	7924	+ case 610LLU: // copy-back deleter (switch)
7613	7925	{
7614	7926	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 11];
7615	7927	((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];

		@@ -7616,50 +7928,50 @@
7616	7928	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
7617	7929	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
7618	7930	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7619		- label = 577LLU; // continue to unroll stack
	7931	+ label = 605LLU; // continue to unroll stack
7620	7932	break;
7621	7933	}
7622		- case 581LLU: // try next case
	7934	+ case 609LLU: // try next case
7623	7935	{
7624	7936	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7625	7937	exit(-1);
7626	7938	}
7627		- case 580LLU: // completed switch
	7939	+ case 608LLU: // completed switch
7628	7940	{
7629		- label = 579LLU; // alternative complete
	7941	+ label = 607LLU; // alternative complete
7630	7942	break;
7631	7943	}
7632		- case 579LLU: // completed if-then-else
	7944	+ case 607LLU: // completed if-then-else
7633	7945	{
7634	7946	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
7635		- label = 575LLU; // repeat
	7947	+ label = 603LLU; // repeat
7636	7948	break;
7637	7949	}
7638		- case 577LLU: // copy-back deleter for while next
	7950	+ case 605LLU: // copy-back deleter for while next
7639	7951	{
7640	7952	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
7641		- label = 573LLU; // continue to unroll stack
	7953	+ label = 601LLU; // continue to unroll stack
7642	7954	break;
7643	7955	}
7644		- case 576LLU: // loop finished
	7956	+ case 604LLU: // loop finished
7645	7957	{
7646		- label = 586LLU; // skip deleter
	7958	+ label = 614LLU; // skip deleter
7647	7959	break;
7648	7960	}
7649		- case 585LLU: // deleter
	7961	+ case 613LLU: // deleter
7650	7962	{
7651	7963	// throw from existslet
7652	7964	if(!stack[base + 0])
7653	7965	{
7654	7966	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
7656	7968	break;
7657	7969	}
7658	7970	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
7660	7972	break;
7661	7973	}
7662		- case 586LLU: // skipped deleter
	7974	+ case 614LLU: // skipped deleter
7663	7975	{
7664	7976	stack[base + 0] = stack[base + 3]/found/;
7665	7977	// return from existslet

		@@ -7667,7 +7979,7 @@
7667	7979	base = stack[base - 2];
7668	7980	break;
7669	7981	}
7670		- case 588LLU: // function FindLetNew failed
	7982	+ case 616LLU: // function FindLetNew failed
7671	7983	{
7672	7984	fprintf(stderr, "function FindLetNew failed\n");
7673	7985	label = stack[base - 3];

		@@ -7674,7 +7986,7 @@
7674	7986	base = stack