OSDN -- Develop and Download Open Source Software
  • R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1159 (tree)
Time2021-02-17 05:00:51
Authorjakobthomsen

Log Message

conditional call

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1158)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1159)
@@ -10921,7 +10921,7 @@
1092110921 base = stack[base - 2];
1092210922 break;
1092310923 }
10924- case 688LLU: // ProcCall
10924+ case 688LLU: // PrcCallRec
1092510925 {
1092610926 //#define arg0 0
1092710927 //#define arg1 1
@@ -10940,11 +10940,2322 @@
1094010940 //#define arg14 14
1094110941 //#define arg15 15
1094210942 //#define arg16 16
10943+//#define arg17 17
10944+//#define arg18 18
10945+//#define arg19 19
10946+//#define arg20 20
10947+//#define arg21 21
10948+//#define arg22 22
10949+//#define arg23 23
10950+ stack[base + 24] = 0;
10951+ stack[base + 25] = 0;
10952+ if(!stack[base + 5]/*fnerr*/)
10953+ {
10954+ label = 689LLU; // jump to alternative
10955+ break;
10956+ }
10957+
10958+ // consequent
10959+ label = 690LLU; // consequent complete
10960+ break;
10961+ }
10962+ case 689LLU: // alternative
10963+ {
10964+ if(!stack[base + 17]/*ceerr*/)
10965+ {
10966+ label = 691LLU; // jump to alternative
10967+ break;
10968+ }
10969+
10970+ // consequent
10971+ fprintf(stderr, "%s", "in function ");
10972+ // call reportid from PrcCallRec
10973+ stack[base + 26LLU] = base;
10974+ stack[base + 27LLU] = 693LLU;
10975+ // arguments for call to reportid
10976+ stack[base + 28LLU] = stack[base + 6]/*fnid*/;
10977+ // set stack-base & callee-address
10978+ base += 28LLU;
10979+ label = 18446744073709551586LLU; // reportid
10980+ break;
10981+ }
10982+ case 693LLU: // return from reportid to PrcCallRec
10983+ {
10984+ // copy mutable arguments back from call to reportid
10985+ fprintf(stderr, "%s", ": partial function ");
10986+ // call reportid from PrcCallRec
10987+ stack[base + 26LLU] = base;
10988+ stack[base + 27LLU] = 694LLU;
10989+ // arguments for call to reportid
10990+ stack[base + 28LLU] = stack[base + 15]/*ceid*/;
10991+ // set stack-base & callee-address
10992+ base += 28LLU;
10993+ label = 18446744073709551586LLU; // reportid
10994+ break;
10995+ }
10996+ case 694LLU: // return from reportid to PrcCallRec
10997+ {
10998+ // copy mutable arguments back from call to reportid
10999+ fprintf(stderr, "%s", " cannot be called from total function - define caller-function as fallible: prefix return-type with '!'\n");
11000+ exit(-1);
11001+ label = 692LLU; // consequent complete
11002+ break;
11003+ }
11004+ case 691LLU: // alternative
11005+ {
11006+ label = 692LLU; // alternative complete
11007+ break;
11008+ }
11009+ case 692LLU: // completed if-then-else
11010+ {
11011+ label = 690LLU; // alternative complete
11012+ break;
11013+ }
11014+ case 690LLU: // completed if-then-else
11015+ {
11016+ stack[base + 26] = 0;
11017+ stack[base + 26]/*cerescount*/ = list_size(((struct listnode *)(stack[base + 12]/*cerestypes*/)));
11018+ stack[base + 27] = 0;
11019+ stack[base + 27]/*ceargcount*/ = list_size(((struct listnode *)(stack[base + 13]/*ceargtypes*/)));
11020+ if(!stack[base + 11]/*celabel*/)
11021+ {
11022+ label = 695LLU; // jump to alternative
11023+ break;
11024+ }
11025+
11026+ // consequent
11027+ label = 696LLU; // consequent complete
11028+ break;
11029+ }
11030+ case 695LLU: // alternative
11031+ {
11032+ fprintf(stderr, "%s", " NULL-label!\n");
11033+ exit(-1);
11034+ label = 696LLU; // alternative complete
11035+ break;
11036+ }
11037+ case 696LLU: // completed if-then-else
11038+ {
11039+ stack[base + 28] = 0;
11040+ stack[base + 29] = 0;
11041+ stack[base + 30] = 0;
11042+ if(!stack[base + 16]/*cerec*/)
11043+ {
11044+ label = 697LLU; // jump to alternative
11045+ break;
11046+ }
11047+
11048+ // consequent
11049+ stack[base + 31] = 0;
11050+ stack[base + 31]/*recsztotal*/ = 0;
11051+ // call add from PrcCallRec
11052+ stack[base + 32LLU] = base;
11053+ stack[base + 33LLU] = 699LLU;
11054+ // arguments for call to add
11055+ stack[base + 35LLU] = 3LLU;
11056+ stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
11057+ // set stack-base & callee-address
11058+ base += 34LLU;
11059+ label = 18446744073709551605LLU; // add
11060+ break;
11061+ }
11062+ case 699LLU: // return from add to PrcCallRec
11063+ {
11064+ // copy mutable arguments back from call to add
11065+ // copy back results provided by call to add
11066+ stack[base + 31] = stack[base + 34LLU];
11067+ // call add from PrcCallRec
11068+ stack[base + 32LLU] = base;
11069+ stack[base + 33LLU] = 700LLU;
11070+ // arguments for call to add
11071+ stack[base + 35LLU] = stack[base + 26]/*cerescount*/;
11072+ stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
11073+ // set stack-base & callee-address
11074+ base += 34LLU;
11075+ label = 18446744073709551605LLU; // add
11076+ break;
11077+ }
11078+ case 700LLU: // return from add to PrcCallRec
11079+ {
11080+ // copy mutable arguments back from call to add
11081+ // copy back results provided by call to add
11082+ stack[base + 31] = stack[base + 34LLU];
11083+ // call add from PrcCallRec
11084+ stack[base + 32LLU] = base;
11085+ stack[base + 33LLU] = 701LLU;
11086+ // arguments for call to add
11087+ stack[base + 35LLU] = stack[base + 27]/*ceargcount*/;
11088+ stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
11089+ // set stack-base & callee-address
11090+ base += 34LLU;
11091+ label = 18446744073709551605LLU; // add
11092+ break;
11093+ }
11094+ case 701LLU: // return from add to PrcCallRec
11095+ {
11096+ // copy mutable arguments back from call to add
11097+ // copy back results provided by call to add
11098+ stack[base + 31] = stack[base + 34LLU];
11099+ // call add from PrcCallRec
11100+ stack[base + 32LLU] = base;
11101+ stack[base + 33LLU] = 702LLU;
11102+ // arguments for call to add
11103+ stack[base + 35LLU] = stack[base + 14]/*cemaxcount*/;
11104+ stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
11105+ // set stack-base & callee-address
11106+ base += 34LLU;
11107+ label = 18446744073709551605LLU; // add
11108+ break;
11109+ }
11110+ case 702LLU: // return from add to PrcCallRec
11111+ {
11112+ // copy mutable arguments back from call to add
11113+ // copy back results provided by call to add
11114+ stack[base + 31] = stack[base + 34LLU];
11115+ printf("%s", "\n uint64_t *newstack = (uint64_t *)Calloc(");
11116+ // call printnr from PrcCallRec
11117+ stack[base + 32LLU] = base;
11118+ stack[base + 33LLU] = 703LLU;
11119+ // arguments for call to printnr
11120+ stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
11121+ // set stack-base & callee-address
11122+ base += 34LLU;
11123+ label = 18446744073709551590LLU; // printnr
11124+ break;
11125+ }
11126+ case 703LLU: // return from printnr to PrcCallRec
11127+ {
11128+ // copy mutable arguments back from call to printnr
11129+ printf("%s", "LLU + 1, sizeof(uint64_t));");
11130+ printf("%s", "\n if(!newstack)");
11131+ printf("%s", "\n {");
11132+ printf("%s", "\n label = ");
11133+ // call printnr from PrcCallRec
11134+ stack[base + 32LLU] = base;
11135+ stack[base + 33LLU] = 704LLU;
11136+ // arguments for call to printnr
11137+ stack[base + 34LLU] = stack[base + 22]/*labelalt*/;
11138+ // set stack-base & callee-address
11139+ base += 34LLU;
11140+ label = 18446744073709551590LLU; // printnr
11141+ break;
11142+ }
11143+ case 704LLU: // return from printnr to PrcCallRec
11144+ {
11145+ // copy mutable arguments back from call to printnr
11146+ printf("%s", "LLU; // out of memory - jump to alternative");
11147+ printf("%s", "\n break;");
11148+ printf("%s", "\n }");
11149+ printf("%s", "\n newstack[");
11150+ // call printnr from PrcCallRec
11151+ stack[base + 32LLU] = base;
11152+ stack[base + 33LLU] = 705LLU;
11153+ // arguments for call to printnr
11154+ stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
11155+ // set stack-base & callee-address
11156+ base += 34LLU;
11157+ label = 18446744073709551590LLU; // printnr
11158+ break;
11159+ }
11160+ case 705LLU: // return from printnr to PrcCallRec
11161+ {
11162+ // copy mutable arguments back from call to printnr
11163+ printf("%s", "LLU] = 9876543210LLU; // overflow-marker");
11164+ printf("%s", "\n // call ");
11165+ // call printid from PrcCallRec
11166+ stack[base + 32LLU] = base;
11167+ stack[base + 33LLU] = 706LLU;
11168+ // arguments for call to printid
11169+ stack[base + 34LLU] = stack[base + 15]/*ceid*/;
11170+ // set stack-base & callee-address
11171+ base += 34LLU;
11172+ label = 18446744073709551587LLU; // printid
11173+ break;
11174+ }
11175+ case 706LLU: // return from printid to PrcCallRec
11176+ {
11177+ // copy mutable arguments back from call to printid
11178+ printf("%s", " from ");
11179+ // call printid from PrcCallRec
11180+ stack[base + 32LLU] = base;
11181+ stack[base + 33LLU] = 707LLU;
11182+ // arguments for call to printid
11183+ stack[base + 34LLU] = stack[base + 6]/*fnid*/;
11184+ // set stack-base & callee-address
11185+ base += 34LLU;
11186+ label = 18446744073709551587LLU; // printid
11187+ break;
11188+ }
11189+ case 707LLU: // return from printid to PrcCallRec
11190+ {
11191+ // copy mutable arguments back from call to printid
11192+ printf("%s", "\n newstack[0] = (uint64_t)stack; // backup stack location");
11193+ printf("%s", "\n newstack[1] = base;");
11194+ // call add from PrcCallRec
11195+ stack[base + 32LLU] = base;
11196+ stack[base + 33LLU] = 708LLU;
11197+ // arguments for call to add
11198+ stack[base + 35LLU] = 1LLU;
11199+ stack[base + 36LLU] = stack[base + 21]/*label*/;
11200+ // set stack-base & callee-address
11201+ base += 34LLU;
11202+ label = 18446744073709551605LLU; // add
11203+ break;
11204+ }
11205+ case 708LLU: // return from add to PrcCallRec
11206+ {
11207+ // copy mutable arguments back from call to add
11208+ // copy back results provided by call to add
11209+ stack[base + 21] = stack[base + 34LLU];
11210+ printf("%s", "\n newstack[2] = ");
11211+ // call printnr from PrcCallRec
11212+ stack[base + 32LLU] = base;
11213+ stack[base + 33LLU] = 709LLU;
11214+ // arguments for call to printnr
11215+ stack[base + 34LLU] = stack[base + 21]/*label*/;
11216+ // set stack-base & callee-address
11217+ base += 34LLU;
11218+ label = 18446744073709551590LLU; // printnr
11219+ break;
11220+ }
11221+ case 709LLU: // return from printnr to PrcCallRec
11222+ {
11223+ // copy mutable arguments back from call to printnr
11224+ printf("%s", "LLU;");
11225+ stack[base + 29]/*n*/ = stack[base + 27]/*ceargcount*/;
11226+ printf("%s", "\n // arguments for call to ");
11227+ // call printid from PrcCallRec
11228+ stack[base + 32LLU] = base;
11229+ stack[base + 33LLU] = 710LLU;
11230+ // arguments for call to printid
11231+ stack[base + 34LLU] = stack[base + 15]/*ceid*/;
11232+ // set stack-base & callee-address
11233+ base += 34LLU;
11234+ label = 18446744073709551587LLU; // printid
11235+ break;
11236+ }
11237+ case 710LLU: // return from printid to PrcCallRec
11238+ {
11239+ // copy mutable arguments back from call to printid
11240+ stack[base + 32] = 0;
11241+ flippedassign(stack[base + 13]/*ceargtypes*/, &stack[base + 33]);
11242+ label = 711LLU; // start to repeat
11243+ break;
11244+ }
11245+ case 711LLU: // repeat from here
11246+ {
11247+ if(!stack[base + 33])
11248+ {
11249+ label = 712LLU; // break loop
11250+ break;
11251+ }
11252+
11253+ // loop body
11254+ stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->data);
11255+ stack[base + 35]/*previous*/ = stack[base + 33];
11256+ stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->next);
11257+ // call sub from PrcCallRec
11258+ stack[base + 36LLU] = base;
11259+ stack[base + 37LLU] = 713LLU;
11260+ // arguments for call to sub
11261+ stack[base + 39LLU] = stack[base + 27]/*ceargcount*/;
11262+ stack[base + 40LLU] = stack[base + 29]/*n*/;
11263+ // set stack-base & callee-address
11264+ base += 38LLU;
11265+ label = 18446744073709551604LLU; // sub
11266+ break;
11267+ }
11268+ case 713LLU: // return from sub to PrcCallRec
11269+ {
11270+ // copy mutable arguments back from call to sub
11271+ // copy back results provided by call to sub
11272+ stack[base + 30] = stack[base + 38LLU];
11273+ // call sub from PrcCallRec
11274+ stack[base + 36LLU] = base;
11275+ stack[base + 37LLU] = 714LLU;
11276+ // arguments for call to sub
11277+ stack[base + 39LLU] = stack[base + 29]/*n*/;
11278+ stack[base + 40LLU] = 1LLU;
11279+ // set stack-base & callee-address
11280+ base += 38LLU;
11281+ label = 18446744073709551604LLU; // sub
11282+ break;
11283+ }
11284+ case 714LLU: // return from sub to PrcCallRec
11285+ {
11286+ // copy mutable arguments back from call to sub
11287+ // copy back results provided by call to sub
11288+ stack[base + 29] = stack[base + 38LLU];
11289+ if(!stack[base + 30]/*index*/)
11290+ {
11291+ label = 715LLU; // jump to alternative
11292+ break;
11293+ }
11294+
11295+ // consequent
11296+ // call matchsym from PrcCallRec
11297+ stack[base + 36LLU] = base;
11298+ stack[base + 37LLU] = 717LLU;
11299+ // arguments for call to matchsym
11300+ stack[base + 38LLU] = stack[base + 6]/*fnid*/;
11301+ stack[base + 39LLU] = 44LLU;
11302+ stack[base + 40LLU] = stack[base + 18]/*lookahead*/;
11303+ // set stack-base & callee-address
11304+ base += 38LLU;
11305+ label = 110LLU; // matchsym
11306+ break;
11307+ }
11308+ case 717LLU: // return from matchsym to PrcCallRec
11309+ {
11310+ // copy mutable arguments back from call to matchsym
11311+ stack[base + 18]/*lookahead*/ = stack[base + 40LLU];
11312+ label = 716LLU; // consequent complete
11313+ break;
11314+ }
11315+ case 715LLU: // alternative
11316+ {
11317+ label = 716LLU; // alternative complete
11318+ break;
11319+ }
11320+ case 716LLU: // completed if-then-else
11321+ {
11322+ stack[base + 28]/*sum*/ = 0;
11323+ // call add from PrcCallRec
11324+ stack[base + 36LLU] = base;
11325+ stack[base + 37LLU] = 718LLU;
11326+ // arguments for call to add
11327+ stack[base + 39LLU] = 3LLU;
11328+ stack[base + 40LLU] = stack[base + 28]/*sum*/;
11329+ // set stack-base & callee-address
11330+ base += 38LLU;
11331+ label = 18446744073709551605LLU; // add
11332+ break;
11333+ }
11334+ case 718LLU: // return from add to PrcCallRec
11335+ {
11336+ // copy mutable arguments back from call to add
11337+ // copy back results provided by call to add
11338+ stack[base + 28] = stack[base + 38LLU];
11339+ // call add from PrcCallRec
11340+ stack[base + 36LLU] = base;
11341+ stack[base + 37LLU] = 719LLU;
11342+ // arguments for call to add
11343+ stack[base + 39LLU] = stack[base + 26]/*cerescount*/;
11344+ stack[base + 40LLU] = stack[base + 28]/*sum*/;
11345+ // set stack-base & callee-address
11346+ base += 38LLU;
11347+ label = 18446744073709551605LLU; // add
11348+ break;
11349+ }
11350+ case 719LLU: // return from add to PrcCallRec
11351+ {
11352+ // copy mutable arguments back from call to add
11353+ // copy back results provided by call to add
11354+ stack[base + 28] = stack[base + 38LLU];
11355+ // call add from PrcCallRec
11356+ stack[base + 36LLU] = base;
11357+ stack[base + 37LLU] = 720LLU;
11358+ // arguments for call to add
11359+ stack[base + 39LLU] = stack[base + 30]/*index*/;
11360+ stack[base + 40LLU] = stack[base + 28]/*sum*/;
11361+ // set stack-base & callee-address
11362+ base += 38LLU;
11363+ label = 18446744073709551605LLU; // add
11364+ break;
11365+ }
11366+ case 720LLU: // return from add to PrcCallRec
11367+ {
11368+ // copy mutable arguments back from call to add
11369+ // copy back results provided by call to add
11370+ stack[base + 28] = stack[base + 38LLU];
11371+ // call ParseToken from PrcCallRec
11372+ stack[base + 36LLU] = base;
11373+ stack[base + 37LLU] = 721LLU;
11374+ // arguments for call to ParseToken
11375+ stack[base + 40LLU] = stack[base + 18]/*lookahead*/;
11376+ // set stack-base & callee-address
11377+ base += 38LLU;
11378+ label = 2LLU; // ParseToken
11379+ break;
11380+ }
11381+ case 721LLU: // return from ParseToken to PrcCallRec
11382+ {
11383+ // copy mutable arguments back from call to ParseToken
11384+ stack[base + 18]/*lookahead*/ = stack[base + 40LLU];
11385+ // copy back results provided by call to ParseToken
11386+ stack[base + 19] = stack[base + 38LLU];
11387+ stack[base + 20] = stack[base + 39LLU];
11388+ // call isncs from PrcCallRec
11389+ stack[base + 36LLU] = base;
11390+ stack[base + 37LLU] = 722LLU;
11391+ // arguments for call to isncs
11392+ stack[base + 39LLU] = stack[base + 19]/*variant*/;
11393+ // set stack-base & callee-address
11394+ base += 38LLU;
11395+ label = 138LLU; // isncs
11396+ break;
11397+ }
11398+ case 722LLU: // return from isncs to PrcCallRec
11399+ {
11400+ // copy mutable arguments back from call to isncs
11401+ // copy back results provided by call to isncs
11402+ stack[base + 24] = stack[base + 38LLU];
11403+ if(!stack[base + 24]/*isequal*/)
11404+ {
11405+ label = 723LLU; // jump to alternative
11406+ break;
11407+ }
11408+
11409+ // consequent
11410+ if(/*param*/0 != ((uint64_t *)(stack[base + 34]/*param*/))[0])
11411+ {
11412+ label = 726LLU; // jump to alternative
11413+ break;
11414+ }
11415+
11416+ /*typeid*/stack[base + 36] = ((uint64_t **)(stack[base + 34]/*param*/))[1][0]/*typeid*/;
11417+ /*mutable*/stack[base + 37] = ((uint64_t **)(stack[base + 34]/*param*/))[1][1]/*mutable*/;
11418+
11419+ // case
11420+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 36]/*typeid*/))[0])
11421+ {
11422+ label = 728LLU; // jump to alternative
11423+ break;
11424+ }
11425+
11426+ /*expected*/stack[base + 38] = ((uint64_t **)(stack[base + 36]/*typeid*/))[1][0]/*type*/;
11427+ /*paramname*/stack[base + 39] = ((uint64_t **)(stack[base + 36]/*typeid*/))[1][1]/*id*/;
11428+
11429+ // case
11430+ // call mktypename from PrcCallRec
11431+ stack[base + 41LLU] = base;
11432+ stack[base + 42LLU] = 729LLU;
11433+ // arguments for call to mktypename
11434+ stack[base + 44LLU] = 881834713755418624LLU;
11435+ // set stack-base & callee-address
11436+ base += 43LLU;
11437+ label = 152LLU; // mktypename
11438+ break;
11439+ }
11440+ case 729LLU: // return from mktypename to PrcCallRec
11441+ {
11442+ // copy mutable arguments back from call to mktypename
11443+ // copy back results provided by call to mktypename
11444+ stack[base + 40] = stack[base + 43LLU];
11445+ uint64_t *newstack = (uint64_t *)Calloc(13LLU + 1, sizeof(uint64_t));
11446+ if(!newstack)
11447+ {
11448+ fprintf(stderr, "in function PrcCallRec call to equtype: OUT OF MEMORY!");
11449+ exit(-1);
11450+ }
11451+ newstack[13LLU] = 9876543210LLU; // overflow-marker
11452+ // call equtype from PrcCallRec
11453+ newstack[0] = (uint64_t)stack; // backup stack location
11454+ newstack[1] = base;
11455+ newstack[2] = 730LLU;
11456+ // arguments for call to equtype
11457+ newstack[4LLU] = stack[base + 40]/*type*/;
11458+ newstack[5LLU] = stack[base + 38]/*expected*/;
11459+ stack = newstack;
11460+ // set stack-base & callee-address
11461+ base = 3;
11462+ label = 170LLU; // equtype
11463+ break;
11464+ }
11465+ case 730LLU: // return from equtype to PrcCallRec
11466+ {
11467+ uint64_t *oldstack = (uint64_t *)stack[0];
11468+ // copy mutable arguments back from call to equtype
11469+ // copy back results provided by call to equtype
11470+ oldstack[base + 24] = stack[3LLU];
11471+ if(stack[13LLU] != 9876543210LLU)
11472+ {
11473+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
11474+ exit(-1);
11475+ }
11476+ Free(13LLU + 1, sizeof(uint64_t), stack);
11477+ stack = oldstack;
11478+ if(!stack[base + 24]/*isequal*/)
11479+ {
11480+ label = 731LLU; // jump to alternative
11481+ break;
11482+ }
11483+
11484+ // consequent
11485+ label = 732LLU; // consequent complete
11486+ break;
11487+ }
11488+ case 731LLU: // alternative
11489+ {
11490+ fprintf(stderr, "%s", "in function ");
11491+ // call reportid from PrcCallRec
11492+ stack[base + 41LLU] = base;
11493+ stack[base + 42LLU] = 733LLU;
11494+ // arguments for call to reportid
11495+ stack[base + 43LLU] = stack[base + 6]/*fnid*/;
11496+ // set stack-base & callee-address
11497+ base += 43LLU;
11498+ label = 18446744073709551586LLU; // reportid
11499+ break;
11500+ }
11501+ case 733LLU: // return from reportid to PrcCallRec
11502+ {
11503+ // copy mutable arguments back from call to reportid
11504+ fprintf(stderr, "%s", " call to ");
11505+ // call reportid from PrcCallRec
11506+ stack[base + 41LLU] = base;
11507+ stack[base + 42LLU] = 734LLU;
11508+ // arguments for call to reportid
11509+ stack[base + 43LLU] = stack[base + 15]/*ceid*/;
11510+ // set stack-base & callee-address
11511+ base += 43LLU;
11512+ label = 18446744073709551586LLU; // reportid
11513+ break;
11514+ }
11515+ case 734LLU: // return from reportid to PrcCallRec
11516+ {
11517+ // copy mutable arguments back from call to reportid
11518+ fprintf(stderr, "%s", " at position ");
11519+ // call reportnr from PrcCallRec
11520+ stack[base + 41LLU] = base;
11521+ stack[base + 42LLU] = 735LLU;
11522+ // arguments for call to reportnr
11523+ stack[base + 43LLU] = stack[base + 30]/*index*/;
11524+ // set stack-base & callee-address
11525+ base += 43LLU;
11526+ label = 18446744073709551589LLU; // reportnr
11527+ break;
11528+ }
11529+ case 735LLU: // return from reportnr to PrcCallRec
11530+ {
11531+ // copy mutable arguments back from call to reportnr
11532+ fprintf(stderr, "%s", " expected parameter of type ");
11533+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
11534+ if(!newstack)
11535+ {
11536+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
11537+ exit(-1);
11538+ }
11539+ newstack[8LLU] = 9876543210LLU; // overflow-marker
11540+ // call reporttype from PrcCallRec
11541+ newstack[0] = (uint64_t)stack; // backup stack location
11542+ newstack[1] = base;
11543+ newstack[2] = 736LLU;
11544+ // arguments for call to reporttype
11545+ newstack[3LLU] = stack[base + 38]/*expected*/;
11546+ stack = newstack;
11547+ // set stack-base & callee-address
11548+ base = 3;
11549+ label = 159LLU; // reporttype
11550+ break;
11551+ }
11552+ case 736LLU: // return from reporttype to PrcCallRec
11553+ {
11554+ uint64_t *oldstack = (uint64_t *)stack[0];
11555+ // copy mutable arguments back from call to reporttype
11556+ if(stack[8LLU] != 9876543210LLU)
11557+ {
11558+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
11559+ exit(-1);
11560+ }
11561+ Free(8LLU + 1, sizeof(uint64_t), stack);
11562+ stack = oldstack;
11563+ fprintf(stderr, "%s", " but found constant-argument of type u64");
11564+ fprintf(stderr, "%s", "\n");
11565+ exit(-1);
11566+ label = 732LLU; // alternative complete
11567+ break;
11568+ }
11569+ case 732LLU: // completed if-then-else
11570+ {
11571+
11572+ uint64_t *newstack = (uint64_t *)(stack[base + 40] - sizeof(uint64_t) * 3);
11573+ // call ~type from PrcCallRec
11574+ newstack[0] = (uint64_t)stack; // backup stack location
11575+ newstack[1] = base;
11576+ newstack[2] = 737LLU;
11577+ stack = newstack;
11578+ // set stack-base & callee-address
11579+ base = 3;
11580+ label = 148LLU; // ~type
11581+ break;
11582+ }
11583+ case 737LLU: // return from ~type to PrcCallRec
11584+ {
11585+ stack = (uint64_t *)stack[0];
11586+ // releasing toplevel container
11587+ Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 40] - sizeof(uint64_t) * 3));
11588+
11589+ ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 39];
11590+ ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 38];
11591+ label = 727LLU; // case complete
11592+ break;
11593+ }
11594+ case 728LLU: // try next case
11595+ {
11596+ fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
11597+ exit(-1);
11598+ }
11599+ case 727LLU: // completed switch
11600+ {
11601+ if(!stack[base + 37]/*mutable*/)
11602+ {
11603+ label = 738LLU; // jump to alternative
11604+ break;
11605+ }
11606+
11607+ // consequent
11608+ fprintf(stderr, "%s", "in function ");
11609+ // call reportid from PrcCallRec
11610+ stack[base + 38LLU] = base;
11611+ stack[base + 39LLU] = 740LLU;
11612+ // arguments for call to reportid
11613+ stack[base + 40LLU] = stack[base + 6]/*fnid*/;
11614+ // set stack-base & callee-address
11615+ base += 40LLU;
11616+ label = 18446744073709551586LLU; // reportid
11617+ break;
11618+ }
11619+ case 740LLU: // return from reportid to PrcCallRec
11620+ {
11621+ // copy mutable arguments back from call to reportid
11622+ fprintf(stderr, "%s", ", calling ");
11623+ // call reportid from PrcCallRec
11624+ stack[base + 38LLU] = base;
11625+ stack[base + 39LLU] = 741LLU;
11626+ // arguments for call to reportid
11627+ stack[base + 40LLU] = stack[base + 15]/*ceid*/;
11628+ // set stack-base & callee-address
11629+ base += 40LLU;
11630+ label = 18446744073709551586LLU; // reportid
11631+ break;
11632+ }
11633+ case 741LLU: // return from reportid to PrcCallRec
11634+ {
11635+ // copy mutable arguments back from call to reportid
11636+ fprintf(stderr, "%s", ": ");
11637+ fprintf(stderr, "%s", "can't use constant argument ");
11638+ // call printnr from PrcCallRec
11639+ stack[base + 38LLU] = base;
11640+ stack[base + 39LLU] = 742LLU;
11641+ // arguments for call to printnr
11642+ stack[base + 40LLU] = stack[base + 20]/*content*/;
11643+ // set stack-base & callee-address
11644+ base += 40LLU;
11645+ label = 18446744073709551590LLU; // printnr
11646+ break;
11647+ }
11648+ case 742LLU: // return from printnr to PrcCallRec
11649+ {
11650+ // copy mutable arguments back from call to printnr
11651+ printf("%s", " for mutable parameter ");
11652+ // call reportti from PrcCallRec
11653+ stack[base + 38LLU] = base;
11654+ stack[base + 39LLU] = 743LLU;
11655+ // arguments for call to reportti
11656+ stack[base + 40LLU] = stack[base + 36]/*typeid*/;
11657+ // set stack-base & callee-address
11658+ base += 40LLU;
11659+ label = 183LLU; // reportti
11660+ break;
11661+ }
11662+ case 743LLU: // return from reportti to PrcCallRec
11663+ {
11664+ // copy mutable arguments back from call to reportti
11665+ fprintf(stderr, "%s", "\n");
11666+ exit(-1);
11667+ label = 739LLU; // consequent complete
11668+ break;
11669+ }
11670+ case 738LLU: // alternative
11671+ {
11672+ label = 739LLU; // alternative complete
11673+ break;
11674+ }
11675+ case 739LLU: // completed if-then-else
11676+ {
11677+ ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
11678+ ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
11679+ label = 725LLU; // case complete
11680+ break;
11681+ }
11682+ case 726LLU: // try next case
11683+ {
11684+ fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
11685+ exit(-1);
11686+ }
11687+ case 725LLU: // completed switch
11688+ {
11689+ printf("%s", "\n newstack[");
11690+ // call printnr from PrcCallRec
11691+ stack[base + 36LLU] = base;
11692+ stack[base + 37LLU] = 744LLU;
11693+ // arguments for call to printnr
11694+ stack[base + 38LLU] = stack[base + 28]/*sum*/;
11695+ // set stack-base & callee-address
11696+ base += 38LLU;
11697+ label = 18446744073709551590LLU; // printnr
11698+ break;
11699+ }
11700+ case 744LLU: // return from printnr to PrcCallRec
11701+ {
11702+ // copy mutable arguments back from call to printnr
11703+ printf("%s", "LLU] = ");
11704+ // call printnr from PrcCallRec
11705+ stack[base + 36LLU] = base;
11706+ stack[base + 37LLU] = 745LLU;
11707+ // arguments for call to printnr
11708+ stack[base + 38LLU] = stack[base + 20]/*content*/;
11709+ // set stack-base & callee-address
11710+ base += 38LLU;
11711+ label = 18446744073709551590LLU; // printnr
11712+ break;
11713+ }
11714+ case 745LLU: // return from printnr to PrcCallRec
11715+ {
11716+ // copy mutable arguments back from call to printnr
11717+ printf("%s", "LLU; // ");
11718+ // call printid from PrcCallRec
11719+ stack[base + 36LLU] = base;
11720+ stack[base + 37LLU] = 746LLU;
11721+ // arguments for call to printid
11722+ stack[base + 38LLU] = stack[base + 20]/*content*/;
11723+ // set stack-base & callee-address
11724+ base += 38LLU;
11725+ label = 18446744073709551587LLU; // printid
11726+ break;
11727+ }
11728+ case 746LLU: // return from printid to PrcCallRec
11729+ {
11730+ // copy mutable arguments back from call to printid
11731+ label = 724LLU; // consequent complete
11732+ break;
11733+ }
11734+ case 723LLU: // alternative
11735+ {
11736+ // call equ from PrcCallRec
11737+ stack[base + 36LLU] = base;
11738+ stack[base + 37LLU] = 747LLU;
11739+ // arguments for call to equ
11740+ stack[base + 39LLU] = stack[base + 19]/*variant*/;
11741+ stack[base + 40LLU] = 4LLU;
11742+ // set stack-base & callee-address
11743+ base += 38LLU;
11744+ label = 18446744073709551600LLU; // equ
11745+ break;
11746+ }
11747+ case 747LLU: // return from equ to PrcCallRec
11748+ {
11749+ // copy mutable arguments back from call to equ
11750+ // copy back results provided by call to equ
11751+ stack[base + 24] = stack[base + 38LLU];
11752+ if(!stack[base + 24]/*isequal*/)
11753+ {
11754+ label = 748LLU; // jump to alternative
11755+ break;
11756+ }
11757+
11758+ // consequent
11759+ if(/*param*/0 != ((uint64_t *)(stack[base + 34]/*param*/))[0])
11760+ {
11761+ label = 751LLU; // jump to alternative
11762+ break;
11763+ }
11764+
11765+ /*typeid*/stack[base + 36] = ((uint64_t **)(stack[base + 34]/*param*/))[1][0]/*typeid*/;
11766+ /*mutable*/stack[base + 37] = ((uint64_t **)(stack[base + 34]/*param*/))[1][1]/*mutable*/;
11767+
11768+ // case
11769+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 36]/*typeid*/))[0])
11770+ {
11771+ label = 753LLU; // jump to alternative
11772+ break;
11773+ }
11774+
11775+ /*expected*/stack[base + 38] = ((uint64_t **)(stack[base + 36]/*typeid*/))[1][0]/*type*/;
11776+ /*paramname*/stack[base + 39] = ((uint64_t **)(stack[base + 36]/*typeid*/))[1][1]/*id*/;
11777+
11778+ // case
11779+ // call equ from PrcCallRec
11780+ stack[base + 40LLU] = base;
11781+ stack[base + 41LLU] = 754LLU;
11782+ // arguments for call to equ
11783+ stack[base + 43LLU] = stack[base + 20]/*content*/;
11784+ stack[base + 44LLU] = 621705506259468288LLU;
11785+ // set stack-base & callee-address
11786+ base += 42LLU;
11787+ label = 18446744073709551600LLU; // equ
11788+ break;
11789+ }
11790+ case 754LLU: // return from equ to PrcCallRec
11791+ {
11792+ // copy mutable arguments back from call to equ
11793+ // copy back results provided by call to equ
11794+ stack[base + 24] = stack[base + 42LLU];
11795+ if(!stack[base + 24]/*isequal*/)
11796+ {
11797+ label = 755LLU; // jump to alternative
11798+ break;
11799+ }
11800+
11801+ // consequent
11802+ // call matchsym from PrcCallRec
11803+ stack[base + 40LLU] = base;
11804+ stack[base + 41LLU] = 757LLU;
11805+ // arguments for call to matchsym
11806+ stack[base + 42LLU] = stack[base + 6]/*fnid*/;
11807+ stack[base + 43LLU] = 40LLU;
11808+ stack[base + 44LLU] = stack[base + 18]/*lookahead*/;
11809+ // set stack-base & callee-address
11810+ base += 42LLU;
11811+ label = 110LLU; // matchsym
11812+ break;
11813+ }
11814+ case 757LLU: // return from matchsym to PrcCallRec
11815+ {
11816+ // copy mutable arguments back from call to matchsym
11817+ stack[base + 18]/*lookahead*/ = stack[base + 44LLU];
11818+ // call matchsym from PrcCallRec
11819+ stack[base + 40LLU] = base;
11820+ stack[base + 41LLU] = 758LLU;
11821+ // arguments for call to matchsym
11822+ stack[base + 42LLU] = stack[base + 6]/*fnid*/;
11823+ stack[base + 43LLU] = 41LLU;
11824+ stack[base + 44LLU] = stack[base + 18]/*lookahead*/;
11825+ // set stack-base & callee-address
11826+ base += 42LLU;
11827+ label = 110LLU; // matchsym
11828+ break;
11829+ }
11830+ case 758LLU: // return from matchsym to PrcCallRec
11831+ {
11832+ // copy mutable arguments back from call to matchsym
11833+ stack[base + 18]/*lookahead*/ = stack[base + 44LLU];
11834+ if(/*typename*/0 != ((uint64_t *)(stack[base + 38]/*expected*/))[0])
11835+ {
11836+ label = 760LLU; // jump to alternative
11837+ break;
11838+ }
11839+
11840+ /*name*/stack[base + 40] = ((uint64_t **)(stack[base + 38]/*expected*/))[1][0]/*name*/;
11841+
11842+ // case
11843+ // call equ from PrcCallRec
11844+ stack[base + 41LLU] = base;
11845+ stack[base + 42LLU] = 761LLU;
11846+ // arguments for call to equ
11847+ stack[base + 44LLU] = stack[base + 40]/*name*/;
11848+ stack[base + 45LLU] = 881834713755418624LLU;
11849+ // set stack-base & callee-address
11850+ base += 43LLU;
11851+ label = 18446744073709551600LLU; // equ
11852+ break;
11853+ }
11854+ case 761LLU: // return from equ to PrcCallRec
11855+ {
11856+ // copy mutable arguments back from call to equ
11857+ // copy back results provided by call to equ
11858+ stack[base + 24] = stack[base + 43LLU];
11859+ if(!stack[base + 24]/*isequal*/)
11860+ {
11861+ label = 762LLU; // jump to alternative
11862+ break;
11863+ }
11864+
11865+ // consequent
11866+ if(!stack[base + 37]/*mutable*/)
11867+ {
11868+ label = 764LLU; // jump to alternative
11869+ break;
11870+ }
11871+
11872+ // consequent
11873+ fprintf(stderr, "%s", "in function ");
11874+ // call reportid from PrcCallRec
11875+ stack[base + 41LLU] = base;
11876+ stack[base + 42LLU] = 766LLU;
11877+ // arguments for call to reportid
11878+ stack[base + 43LLU] = stack[base + 6]/*fnid*/;
11879+ // set stack-base & callee-address
11880+ base += 43LLU;
11881+ label = 18446744073709551586LLU; // reportid
11882+ break;
11883+ }
11884+ case 766LLU: // return from reportid to PrcCallRec
11885+ {
11886+ // copy mutable arguments back from call to reportid
11887+ fprintf(stderr, "%s", ", call to ");
11888+ // call reportid from PrcCallRec
11889+ stack[base + 41LLU] = base;
11890+ stack[base + 42LLU] = 767LLU;
11891+ // arguments for call to reportid
11892+ stack[base + 43LLU] = stack[base + 15]/*ceid*/;
11893+ // set stack-base & callee-address
11894+ base += 43LLU;
11895+ label = 18446744073709551586LLU; // reportid
11896+ break;
11897+ }
11898+ case 767LLU: // return from reportid to PrcCallRec
11899+ {
11900+ // copy mutable arguments back from call to reportid
11901+ fprintf(stderr, "%s", ": can't put constant argument u64 getbyte() into mutable parameter ");
11902+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
11903+ if(!newstack)
11904+ {
11905+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
11906+ exit(-1);
11907+ }
11908+ newstack[8LLU] = 9876543210LLU; // overflow-marker
11909+ // call reporttype from PrcCallRec
11910+ newstack[0] = (uint64_t)stack; // backup stack location
11911+ newstack[1] = base;
11912+ newstack[2] = 768LLU;
11913+ // arguments for call to reporttype
11914+ newstack[3LLU] = stack[base + 38]/*expected*/;
11915+ stack = newstack;
11916+ // set stack-base & callee-address
11917+ base = 3;
11918+ label = 159LLU; // reporttype
11919+ break;
11920+ }
11921+ case 768LLU: // return from reporttype to PrcCallRec
11922+ {
11923+ uint64_t *oldstack = (uint64_t *)stack[0];
11924+ // copy mutable arguments back from call to reporttype
11925+ if(stack[8LLU] != 9876543210LLU)
11926+ {
11927+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
11928+ exit(-1);
11929+ }
11930+ Free(8LLU + 1, sizeof(uint64_t), stack);
11931+ stack = oldstack;
11932+ // call reportid from PrcCallRec
11933+ stack[base + 41LLU] = base;
11934+ stack[base + 42LLU] = 769LLU;
11935+ // arguments for call to reportid
11936+ stack[base + 43LLU] = stack[base + 39]/*paramname*/;
11937+ // set stack-base & callee-address
11938+ base += 43LLU;
11939+ label = 18446744073709551586LLU; // reportid
11940+ break;
11941+ }
11942+ case 769LLU: // return from reportid to PrcCallRec
11943+ {
11944+ // copy mutable arguments back from call to reportid
11945+ fprintf(stderr, "%s", "\n");
11946+ exit(-1);
11947+ label = 765LLU; // consequent complete
11948+ break;
11949+ }
11950+ case 764LLU: // alternative
11951+ {
11952+ stack[base + 32]/*csubstruct*/ = 1;
11953+ printf("%s", "\n newstack[");
11954+ // call printnr from PrcCallRec
11955+ stack[base + 41LLU] = base;
11956+ stack[base + 42LLU] = 770LLU;
11957+ // arguments for call to printnr
11958+ stack[base + 43LLU] = stack[base + 28]/*sum*/;
11959+ // set stack-base & callee-address
11960+ base += 43LLU;
11961+ label = 18446744073709551590LLU; // printnr
11962+ break;
11963+ }
11964+ case 770LLU: // return from printnr to PrcCallRec
11965+ {
11966+ // copy mutable arguments back from call to printnr
11967+ printf("%s", "LLU] = getchar();");
11968+ label = 765LLU; // alternative complete
11969+ break;
11970+ }
11971+ case 765LLU: // completed if-then-else
11972+ {
11973+ label = 763LLU; // consequent complete
11974+ break;
11975+ }
11976+ case 762LLU: // alternative
11977+ {
11978+ fprintf(stderr, "%s", "in function ");
11979+ // call reportid from PrcCallRec
11980+ stack[base + 41LLU] = base;
11981+ stack[base + 42LLU] = 771LLU;
11982+ // arguments for call to reportid
11983+ stack[base + 43LLU] = stack[base + 6]/*fnid*/;
11984+ // set stack-base & callee-address
11985+ base += 43LLU;
11986+ label = 18446744073709551586LLU; // reportid
11987+ break;
11988+ }
11989+ case 771LLU: // return from reportid to PrcCallRec
11990+ {
11991+ // copy mutable arguments back from call to reportid
11992+ fprintf(stderr, "%s", " recursive call to ");
11993+ // call reportid from PrcCallRec
11994+ stack[base + 41LLU] = base;
11995+ stack[base + 42LLU] = 772LLU;
11996+ // arguments for call to reportid
11997+ stack[base + 43LLU] = stack[base + 15]/*ceid*/;
11998+ // set stack-base & callee-address
11999+ base += 43LLU;
12000+ label = 18446744073709551586LLU; // reportid
12001+ break;
12002+ }
12003+ case 772LLU: // return from reportid to PrcCallRec
12004+ {
12005+ // copy mutable arguments back from call to reportid
12006+ fprintf(stderr, "%s", " at position ");
12007+ // call reportnr from PrcCallRec
12008+ stack[base + 41LLU] = base;
12009+ stack[base + 42LLU] = 773LLU;
12010+ // arguments for call to reportnr
12011+ stack[base + 43LLU] = stack[base + 30]/*index*/;
12012+ // set stack-base & callee-address
12013+ base += 43LLU;
12014+ label = 18446744073709551589LLU; // reportnr
12015+ break;
12016+ }
12017+ case 773LLU: // return from reportnr to PrcCallRec
12018+ {
12019+ // copy mutable arguments back from call to reportnr
12020+ fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
12021+ fprintf(stderr, "%s", " parameter type ");
12022+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
12023+ if(!newstack)
12024+ {
12025+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
12026+ exit(-1);
12027+ }
12028+ newstack[8LLU] = 9876543210LLU; // overflow-marker
12029+ // call reporttype from PrcCallRec
12030+ newstack[0] = (uint64_t)stack; // backup stack location
12031+ newstack[1] = base;
12032+ newstack[2] = 774LLU;
12033+ // arguments for call to reporttype
12034+ newstack[3LLU] = stack[base + 38]/*expected*/;
12035+ stack = newstack;
12036+ // set stack-base & callee-address
12037+ base = 3;
12038+ label = 159LLU; // reporttype
12039+ break;
12040+ }
12041+ case 774LLU: // return from reporttype to PrcCallRec
12042+ {
12043+ uint64_t *oldstack = (uint64_t *)stack[0];
12044+ // copy mutable arguments back from call to reporttype
12045+ if(stack[8LLU] != 9876543210LLU)
12046+ {
12047+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
12048+ exit(-1);
12049+ }
12050+ Free(8LLU + 1, sizeof(uint64_t), stack);
12051+ stack = oldstack;
12052+ fprintf(stderr, "%s", "\n");
12053+ exit(-1);
12054+ label = 763LLU; // alternative complete
12055+ break;
12056+ }
12057+ case 763LLU: // completed if-then-else
12058+ {
12059+ ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
12060+ label = 759LLU; // case complete
12061+ break;
12062+ }
12063+ case 760LLU: // try next case
12064+ {
12065+ // default
12066+ fprintf(stderr, "%s", "in function ");
12067+ // call reportid from PrcCallRec
12068+ stack[base + 40LLU] = base;
12069+ stack[base + 41LLU] = 775LLU;
12070+ // arguments for call to reportid
12071+ stack[base + 42LLU] = stack[base + 6]/*fnid*/;
12072+ // set stack-base & callee-address
12073+ base += 42LLU;
12074+ label = 18446744073709551586LLU; // reportid
12075+ break;
12076+ }
12077+ case 775LLU: // return from reportid to PrcCallRec
12078+ {
12079+ // copy mutable arguments back from call to reportid
12080+ fprintf(stderr, "%s", " recursive call to ");
12081+ // call reportid from PrcCallRec
12082+ stack[base + 40LLU] = base;
12083+ stack[base + 41LLU] = 776LLU;
12084+ // arguments for call to reportid
12085+ stack[base + 42LLU] = stack[base + 15]/*ceid*/;
12086+ // set stack-base & callee-address
12087+ base += 42LLU;
12088+ label = 18446744073709551586LLU; // reportid
12089+ break;
12090+ }
12091+ case 776LLU: // return from reportid to PrcCallRec
12092+ {
12093+ // copy mutable arguments back from call to reportid
12094+ fprintf(stderr, "%s", " at position ");
12095+ // call reportnr from PrcCallRec
12096+ stack[base + 40LLU] = base;
12097+ stack[base + 41LLU] = 777LLU;
12098+ // arguments for call to reportnr
12099+ stack[base + 42LLU] = stack[base + 30]/*index*/;
12100+ // set stack-base & callee-address
12101+ base += 42LLU;
12102+ label = 18446744073709551589LLU; // reportnr
12103+ break;
12104+ }
12105+ case 777LLU: // return from reportnr to PrcCallRec
12106+ {
12107+ // copy mutable arguments back from call to reportnr
12108+ fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
12109+ fprintf(stderr, "%s", " parameter type ");
12110+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
12111+ if(!newstack)
12112+ {
12113+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
12114+ exit(-1);
12115+ }
12116+ newstack[8LLU] = 9876543210LLU; // overflow-marker
12117+ // call reporttype from PrcCallRec
12118+ newstack[0] = (uint64_t)stack; // backup stack location
12119+ newstack[1] = base;
12120+ newstack[2] = 778LLU;
12121+ // arguments for call to reporttype
12122+ newstack[3LLU] = stack[base + 38]/*expected*/;
12123+ stack = newstack;
12124+ // set stack-base & callee-address
12125+ base = 3;
12126+ label = 159LLU; // reporttype
12127+ break;
12128+ }
12129+ case 778LLU: // return from reporttype to PrcCallRec
12130+ {
12131+ uint64_t *oldstack = (uint64_t *)stack[0];
12132+ // copy mutable arguments back from call to reporttype
12133+ if(stack[8LLU] != 9876543210LLU)
12134+ {
12135+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
12136+ exit(-1);
12137+ }
12138+ Free(8LLU + 1, sizeof(uint64_t), stack);
12139+ stack = oldstack;
12140+ fprintf(stderr, "%s", "\n");
12141+ exit(-1);
12142+ label = 759LLU; // default complete
12143+ break;
12144+ }
12145+ case 759LLU: // completed switch
12146+ {
12147+ label = 756LLU; // consequent complete
12148+ break;
12149+ }
12150+ case 755LLU: // alternative
12151+ {
12152+ // call FindLetNew from PrcCallRec
12153+ stack[base + 41LLU] = base;
12154+ stack[base + 42LLU] = 779LLU;
12155+ // arguments for call to FindLetNew
12156+ stack[base + 44LLU] = stack[base + 6]/*fnid*/;
12157+ stack[base + 45LLU] = stack[base + 20]/*content*/;
12158+ stack[base + 46LLU] = stack[base + 1]/*scopes*/;
12159+ stack[base + 47LLU] = stack[base + 2]/*scope*/;
12160+ // set stack-base & callee-address
12161+ base += 43LLU;
12162+ label = 290LLU; // FindLetNew
12163+ break;
12164+ }
12165+ case 779LLU: // return from FindLetNew to PrcCallRec
12166+ {
12167+ // copy mutable arguments back from call to FindLetNew
12168+ // copy back results provided by call to FindLetNew
12169+ stack[base + 40] = stack[base + 43LLU];
12170+ if(/*letdef*/0 != ((uint64_t *)(stack[base + 40]/*letdef*/))[0])
12171+ {
12172+ label = 781LLU; // jump to alternative
12173+ break;
12174+ }
12175+
12176+ /*type*/stack[base + 41] = ((uint64_t **)(stack[base + 40]/*letdef*/))[1][0]/*type*/;
12177+ /*ldid*/stack[base + 42] = ((uint64_t **)(stack[base + 40]/*letdef*/))[1][1]/*id*/;
12178+ /*ldindex*/stack[base + 43] = ((uint64_t **)(stack[base + 40]/*letdef*/))[1][2]/*index*/;
12179+ /*mutarg*/stack[base + 44] = ((uint64_t **)(stack[base + 40]/*letdef*/))[1][3]/*mutable*/;
12180+ /*substruct*/stack[base + 45] = ((uint64_t **)(stack[base + 40]/*letdef*/))[1][4]/*substruct*/;
12181+
12182+ // case
12183+ // call or from PrcCallRec
12184+ stack[base + 46LLU] = base;
12185+ stack[base + 47LLU] = 782LLU;
12186+ // arguments for call to or
12187+ stack[base + 49LLU] = stack[base + 32]/*csubstruct*/;
12188+ stack[base + 50LLU] = stack[base + 45]/*substruct*/;
12189+ // set stack-base & callee-address
12190+ base += 48LLU;
12191+ label = 18446744073709551611LLU; // or
12192+ break;
12193+ }
12194+ case 782LLU: // return from or to PrcCallRec
12195+ {
12196+ // copy mutable arguments back from call to or
12197+ // copy back results provided by call to or
12198+ stack[base + 32] = stack[base + 48LLU];
12199+ uint64_t *newstack = (uint64_t *)Calloc(13LLU + 1, sizeof(uint64_t));
12200+ if(!newstack)
12201+ {
12202+ fprintf(stderr, "in function PrcCallRec call to equtype: OUT OF MEMORY!");
12203+ exit(-1);
12204+ }
12205+ newstack[13LLU] = 9876543210LLU; // overflow-marker
12206+ // call equtype from PrcCallRec
12207+ newstack[0] = (uint64_t)stack; // backup stack location
12208+ newstack[1] = base;
12209+ newstack[2] = 783LLU;
12210+ // arguments for call to equtype
12211+ newstack[4LLU] = stack[base + 41]/*type*/;
12212+ newstack[5LLU] = stack[base + 38]/*expected*/;
12213+ stack = newstack;
12214+ // set stack-base & callee-address
12215+ base = 3;
12216+ label = 170LLU; // equtype
12217+ break;
12218+ }
12219+ case 783LLU: // return from equtype to PrcCallRec
12220+ {
12221+ uint64_t *oldstack = (uint64_t *)stack[0];
12222+ // copy mutable arguments back from call to equtype
12223+ // copy back results provided by call to equtype
12224+ oldstack[base + 24] = stack[3LLU];
12225+ if(stack[13LLU] != 9876543210LLU)
12226+ {
12227+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
12228+ exit(-1);
12229+ }
12230+ Free(13LLU + 1, sizeof(uint64_t), stack);
12231+ stack = oldstack;
12232+ if(!stack[base + 24]/*isequal*/)
12233+ {
12234+ label = 784LLU; // jump to alternative
12235+ break;
12236+ }
12237+
12238+ // consequent
12239+ label = 785LLU; // consequent complete
12240+ break;
12241+ }
12242+ case 784LLU: // alternative
12243+ {
12244+ fprintf(stderr, "%s", "in function ");
12245+ // call reportid from PrcCallRec
12246+ stack[base + 46LLU] = base;
12247+ stack[base + 47LLU] = 786LLU;
12248+ // arguments for call to reportid
12249+ stack[base + 48LLU] = stack[base + 6]/*fnid*/;
12250+ // set stack-base & callee-address
12251+ base += 48LLU;
12252+ label = 18446744073709551586LLU; // reportid
12253+ break;
12254+ }
12255+ case 786LLU: // return from reportid to PrcCallRec
12256+ {
12257+ // copy mutable arguments back from call to reportid
12258+ fprintf(stderr, "%s", " call to ");
12259+ // call reportid from PrcCallRec
12260+ stack[base + 46LLU] = base;
12261+ stack[base + 47LLU] = 787LLU;
12262+ // arguments for call to reportid
12263+ stack[base + 48LLU] = stack[base + 15]/*ceid*/;
12264+ // set stack-base & callee-address
12265+ base += 48LLU;
12266+ label = 18446744073709551586LLU; // reportid
12267+ break;
12268+ }
12269+ case 787LLU: // return from reportid to PrcCallRec
12270+ {
12271+ // copy mutable arguments back from call to reportid
12272+ fprintf(stderr, "%s", " at position ");
12273+ // call reportnr from PrcCallRec
12274+ stack[base + 46LLU] = base;
12275+ stack[base + 47LLU] = 788LLU;
12276+ // arguments for call to reportnr
12277+ stack[base + 48LLU] = stack[base + 30]/*index*/;
12278+ // set stack-base & callee-address
12279+ base += 48LLU;
12280+ label = 18446744073709551589LLU; // reportnr
12281+ break;
12282+ }
12283+ case 788LLU: // return from reportnr to PrcCallRec
12284+ {
12285+ // copy mutable arguments back from call to reportnr
12286+ fprintf(stderr, "%s", " parameter type ");
12287+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
12288+ if(!newstack)
12289+ {
12290+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
12291+ exit(-1);
12292+ }
12293+ newstack[8LLU] = 9876543210LLU; // overflow-marker
12294+ // call reporttype from PrcCallRec
12295+ newstack[0] = (uint64_t)stack; // backup stack location
12296+ newstack[1] = base;
12297+ newstack[2] = 789LLU;
12298+ // arguments for call to reporttype
12299+ newstack[3LLU] = stack[base + 38]/*expected*/;
12300+ stack = newstack;
12301+ // set stack-base & callee-address
12302+ base = 3;
12303+ label = 159LLU; // reporttype
12304+ break;
12305+ }
12306+ case 789LLU: // return from reporttype to PrcCallRec
12307+ {
12308+ uint64_t *oldstack = (uint64_t *)stack[0];
12309+ // copy mutable arguments back from call to reporttype
12310+ if(stack[8LLU] != 9876543210LLU)
12311+ {
12312+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
12313+ exit(-1);
12314+ }
12315+ Free(8LLU + 1, sizeof(uint64_t), stack);
12316+ stack = oldstack;
12317+ fprintf(stderr, "%s", " but argument type ");
12318+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
12319+ if(!newstack)
12320+ {
12321+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
12322+ exit(-1);
12323+ }
12324+ newstack[8LLU] = 9876543210LLU; // overflow-marker
12325+ // call reporttype from PrcCallRec
12326+ newstack[0] = (uint64_t)stack; // backup stack location
12327+ newstack[1] = base;
12328+ newstack[2] = 790LLU;
12329+ // arguments for call to reporttype
12330+ newstack[3LLU] = stack[base + 41]/*type*/;
12331+ stack = newstack;
12332+ // set stack-base & callee-address
12333+ base = 3;
12334+ label = 159LLU; // reporttype
12335+ break;
12336+ }
12337+ case 790LLU: // return from reporttype to PrcCallRec
12338+ {
12339+ uint64_t *oldstack = (uint64_t *)stack[0];
12340+ // copy mutable arguments back from call to reporttype
12341+ if(stack[8LLU] != 9876543210LLU)
12342+ {
12343+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
12344+ exit(-1);
12345+ }
12346+ Free(8LLU + 1, sizeof(uint64_t), stack);
12347+ stack = oldstack;
12348+ fprintf(stderr, "%s", "\n");
12349+ exit(-1);
12350+ label = 785LLU; // alternative complete
12351+ break;
12352+ }
12353+ case 785LLU: // completed if-then-else
12354+ {
12355+ if(!stack[base + 37]/*mutable*/)
12356+ {
12357+ label = 791LLU; // jump to alternative
12358+ break;
12359+ }
12360+
12361+ // consequent
12362+ if(!stack[base + 44]/*mutarg*/)
12363+ {
12364+ label = 793LLU; // jump to alternative
12365+ break;
12366+ }
12367+
12368+ // consequent
12369+ // call lookidnr from PrcCallRec
12370+ stack[base + 47LLU] = base;
12371+ stack[base + 48LLU] = 795LLU;
12372+ // arguments for call to lookidnr
12373+ stack[base + 50LLU] = stack[base + 25]/*copyback*/;
12374+ stack[base + 51LLU] = stack[base + 20]/*content*/;
12375+ // set stack-base & callee-address
12376+ base += 49LLU;
12377+ label = 373LLU; // lookidnr
12378+ break;
12379+ }
12380+ case 795LLU: // return from lookidnr to PrcCallRec
12381+ {
12382+ // copy mutable arguments back from call to lookidnr
12383+ // copy back results provided by call to lookidnr
12384+ stack[base + 46] = stack[base + 49LLU];
12385+ if(!stack[base + 46]/*found*/)
12386+ {
12387+ label = 796LLU; // jump to alternative
12388+ break;
12389+ }
12390+
12391+ // consequent
12392+ fprintf(stderr, "%s", "in function ");
12393+ // call reportid from PrcCallRec
12394+ stack[base + 47LLU] = base;
12395+ stack[base + 48LLU] = 798LLU;
12396+ // arguments for call to reportid
12397+ stack[base + 49LLU] = stack[base + 6]/*fnid*/;
12398+ // set stack-base & callee-address
12399+ base += 49LLU;
12400+ label = 18446744073709551586LLU; // reportid
12401+ break;
12402+ }
12403+ case 798LLU: // return from reportid to PrcCallRec
12404+ {
12405+ // copy mutable arguments back from call to reportid
12406+ fprintf(stderr, "%s", " call to ");
12407+ // call reportid from PrcCallRec
12408+ stack[base + 47LLU] = base;
12409+ stack[base + 48LLU] = 799LLU;
12410+ // arguments for call to reportid
12411+ stack[base + 49LLU] = stack[base + 15]/*ceid*/;
12412+ // set stack-base & callee-address
12413+ base += 49LLU;
12414+ label = 18446744073709551586LLU; // reportid
12415+ break;
12416+ }
12417+ case 799LLU: // return from reportid to PrcCallRec
12418+ {
12419+ // copy mutable arguments back from call to reportid
12420+ fprintf(stderr, "%s", " - duplicate mutable argument ");
12421+ // call reportid from PrcCallRec
12422+ stack[base + 47LLU] = base;
12423+ stack[base + 48LLU] = 800LLU;
12424+ // arguments for call to reportid
12425+ stack[base + 49LLU] = stack[base + 20]/*content*/;
12426+ // set stack-base & callee-address
12427+ base += 49LLU;
12428+ label = 18446744073709551586LLU; // reportid
12429+ break;
12430+ }
12431+ case 800LLU: // return from reportid to PrcCallRec
12432+ {
12433+ // copy mutable arguments back from call to reportid
12434+ fprintf(stderr, "%s", "\n");
12435+ exit(-1);
12436+ label = 797LLU; // consequent complete
12437+ break;
12438+ }
12439+ case 796LLU: // alternative
12440+ {
12441+ label = 797LLU; // alternative complete
12442+ break;
12443+ }
12444+ case 797LLU: // completed if-then-else
12445+ {
12446+ // construct idnr.idnr
12447+ if(!(stack[base + 46] = (uint64_t)Calloc(2 + 3, sizeof(uint64_t)) + sizeof(uint64_t) * 3))
12448+ {
12449+ fprintf(stderr, "%s", "ERROR: failed to construct idnr.idnr\n");
12450+ exit(-1);
12451+ }
12452+ ((uint64_t *)stack[base + 46])[0] = 0;
12453+ if(!(((uint64_t *)stack[base + 46])[1] = (uint64_t)Calloc(2, sizeof(uint64_t))))
12454+ {
12455+ Free(2, sizeof(uint64_t), ((uint64_t **)stack[base + 46])[1]);
12456+ fprintf(stderr, "%s", "ERROR: failed to construct idnr.idnr\n");
12457+ exit(-1);
12458+ }
12459+ (((uint64_t **)(stack[base + 46]))[1][0]) = stack[base + 20]/*content*/;
12460+ (((uint64_t **)(stack[base + 46]))[1][1]) = stack[base + 28]/*sum*/;
12461+ {
12462+ struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode));
12463+ if(!list)
12464+ {
12465+ fprintf(stderr, "in function PrcCallRec push to [idnr]: OUT OF MEMORY!");
12466+ exit(-1);
12467+ }
12468+ list->next = (struct listnode *)stack[base + 25]/*copyback*/;
12469+ stack[base + 25]/*copyback*/ = (uint64_t)list;
12470+ MOVE(&list->data, &stack[base + 46]/*idnr*/);
12471+ }
12472+ label = 794LLU; // consequent complete
12473+ break;
12474+ }
12475+ case 793LLU: // alternative
12476+ {
12477+ fprintf(stderr, "%s", "in function ");
12478+ // call reportid from PrcCallRec
12479+ stack[base + 46LLU] = base;
12480+ stack[base + 47LLU] = 801LLU;
12481+ // arguments for call to reportid
12482+ stack[base + 48LLU] = stack[base + 6]/*fnid*/;
12483+ // set stack-base & callee-address
12484+ base += 48LLU;
12485+ label = 18446744073709551586LLU; // reportid
12486+ break;
12487+ }
12488+ case 801LLU: // return from reportid to PrcCallRec
12489+ {
12490+ // copy mutable arguments back from call to reportid
12491+ fprintf(stderr, "%s", ", call to ");
12492+ // call reportid from PrcCallRec
12493+ stack[base + 46LLU] = base;
12494+ stack[base + 47LLU] = 802LLU;
12495+ // arguments for call to reportid
12496+ stack[base + 48LLU] = stack[base + 15]/*ceid*/;
12497+ // set stack-base & callee-address
12498+ base += 48LLU;
12499+ label = 18446744073709551586LLU; // reportid
12500+ break;
12501+ }
12502+ case 802LLU: // return from reportid to PrcCallRec
12503+ {
12504+ // copy mutable arguments back from call to reportid
12505+ fprintf(stderr, "%s", ": can't put constant argument ");
12506+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
12507+ if(!newstack)
12508+ {
12509+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
12510+ exit(-1);
12511+ }
12512+ newstack[8LLU] = 9876543210LLU; // overflow-marker
12513+ // call reporttype from PrcCallRec
12514+ newstack[0] = (uint64_t)stack; // backup stack location
12515+ newstack[1] = base;
12516+ newstack[2] = 803LLU;
12517+ // arguments for call to reporttype
12518+ newstack[3LLU] = stack[base + 41]/*type*/;
12519+ stack = newstack;
12520+ // set stack-base & callee-address
12521+ base = 3;
12522+ label = 159LLU; // reporttype
12523+ break;
12524+ }
12525+ case 803LLU: // return from reporttype to PrcCallRec
12526+ {
12527+ uint64_t *oldstack = (uint64_t *)stack[0];
12528+ // copy mutable arguments back from call to reporttype
12529+ if(stack[8LLU] != 9876543210LLU)
12530+ {
12531+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
12532+ exit(-1);
12533+ }
12534+ Free(8LLU + 1, sizeof(uint64_t), stack);
12535+ stack = oldstack;
12536+ fprintf(stderr, "%s", " ");
12537+ // call reportid from PrcCallRec
12538+ stack[base + 46LLU] = base;
12539+ stack[base + 47LLU] = 804LLU;
12540+ // arguments for call to reportid
12541+ stack[base + 48LLU] = stack[base + 20]/*content*/;
12542+ // set stack-base & callee-address
12543+ base += 48LLU;
12544+ label = 18446744073709551586LLU; // reportid
12545+ break;
12546+ }
12547+ case 804LLU: // return from reportid to PrcCallRec
12548+ {
12549+ // copy mutable arguments back from call to reportid
12550+ fprintf(stderr, "%s", " into mutable parameter ");
12551+ uint64_t *newstack = (uint64_t *)Calloc(8LLU + 1, sizeof(uint64_t));
12552+ if(!newstack)
12553+ {
12554+ fprintf(stderr, "in function PrcCallRec call to reporttype: OUT OF MEMORY!");
12555+ exit(-1);
12556+ }
12557+ newstack[8LLU] = 9876543210LLU; // overflow-marker
12558+ // call reporttype from PrcCallRec
12559+ newstack[0] = (uint64_t)stack; // backup stack location
12560+ newstack[1] = base;
12561+ newstack[2] = 805LLU;
12562+ // arguments for call to reporttype
12563+ newstack[3LLU] = stack[base + 38]/*expected*/;
12564+ stack = newstack;
12565+ // set stack-base & callee-address
12566+ base = 3;
12567+ label = 159LLU; // reporttype
12568+ break;
12569+ }
12570+ case 805LLU: // return from reporttype to PrcCallRec
12571+ {
12572+ uint64_t *oldstack = (uint64_t *)stack[0];
12573+ // copy mutable arguments back from call to reporttype
12574+ if(stack[8LLU] != 9876543210LLU)
12575+ {
12576+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!");
12577+ exit(-1);
12578+ }
12579+ Free(8LLU + 1, sizeof(uint64_t), stack);
12580+ stack = oldstack;
12581+ // call reportid from PrcCallRec
12582+ stack[base + 46LLU] = base;
12583+ stack[base + 47LLU] = 806LLU;
12584+ // arguments for call to reportid
12585+ stack[base + 48LLU] = stack[base + 39]/*paramname*/;
12586+ // set stack-base & callee-address
12587+ base += 48LLU;
12588+ label = 18446744073709551586LLU; // reportid
12589+ break;
12590+ }
12591+ case 806LLU: // return from reportid to PrcCallRec
12592+ {
12593+ // copy mutable arguments back from call to reportid
12594+ fprintf(stderr, "%s", "\n");
12595+ exit(-1);
12596+ label = 794LLU; // alternative complete
12597+ break;
12598+ }
12599+ case 794LLU: // completed if-then-else
12600+ {
12601+ label = 792LLU; // consequent complete
12602+ break;
12603+ }
12604+ case 791LLU: // alternative
12605+ {
12606+ label = 792LLU; // alternative complete
12607+ break;
12608+ }
12609+ case 792LLU: // completed if-then-else
12610+ {
12611+ ((uint64_t **)(stack[base + 40]))[1][4] = stack[base + 45];
12612+ ((uint64_t **)(stack[base + 40]))[1][3] = stack[base + 44];
12613+ ((uint64_t **)(stack[base + 40]))[1][2] = stack[base + 43];
12614+ ((uint64_t **)(stack[base + 40]))[1][1] = stack[base + 42];
12615+ ((uint64_t **)(stack[base + 40]))[1][0] = stack[base + 41];
12616+ label = 780LLU; // case complete
12617+ break;
12618+ }
12619+ case 781LLU: // try next case
12620+ {
12621+ fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
12622+ exit(-1);
12623+ }
12624+ case 780LLU: // completed switch
12625+ {
12626+ printf("%s", "\n newstack[");
12627+ // call printnr from PrcCallRec
12628+ stack[base + 41LLU] = base;
12629+ stack[base + 42LLU] = 807LLU;
12630+ // arguments for call to printnr
12631+ stack[base + 43LLU] = stack[base + 28]/*sum*/;
12632+ // set stack-base & callee-address
12633+ base += 43LLU;
12634+ label = 18446744073709551590LLU; // printnr
12635+ break;
12636+ }
12637+ case 807LLU: // return from printnr to PrcCallRec
12638+ {
12639+ // copy mutable arguments back from call to printnr
12640+ printf("%s", "LLU] = ");
12641+ // call emitvar from PrcCallRec
12642+ stack[base + 41LLU] = base;
12643+ stack[base + 42LLU] = 808LLU;
12644+ // arguments for call to emitvar
12645+ stack[base + 43LLU] = stack[base + 6]/*fnid*/;
12646+ stack[base + 44LLU] = stack[base + 20]/*content*/;
12647+ stack[base + 45LLU] = stack[base + 1]/*scopes*/;
12648+ stack[base + 46LLU] = stack[base + 2]/*scope*/;
12649+ // set stack-base & callee-address
12650+ base += 43LLU;
12651+ label = 349LLU; // emitvar
12652+ break;
12653+ }
12654+ case 808LLU: // return from emitvar to PrcCallRec
12655+ {
12656+ // copy mutable arguments back from call to emitvar
12657+ printf("%s", ";");
12658+
12659+ uint64_t *newstack = (uint64_t *)(stack[base + 40] - sizeof(uint64_t) * 3);
12660+ // call ~letdef from PrcCallRec
12661+ newstack[0] = (uint64_t)stack; // backup stack location
12662+ newstack[1] = base;
12663+ newstack[2] = 809LLU;
12664+ stack = newstack;
12665+ // set stack-base & callee-address
12666+ base = 3;
12667+ label = 229LLU; // ~letdef
12668+ break;
12669+ }
12670+ case 809LLU: // return from ~letdef to PrcCallRec
12671+ {
12672+ stack = (uint64_t *)stack[0];
12673+ // releasing toplevel container
12674+ Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 40] - sizeof(uint64_t) * 3));
12675+
12676+ label = 756LLU; // alternative complete
12677+ break;
12678+ }
12679+ case 756LLU: // completed if-then-else
12680+ {
12681+ ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 39];
12682+ ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 38];
12683+ label = 752LLU; // case complete
12684+ break;
12685+ }
12686+ case 753LLU: // try next case
12687+ {
12688+ fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
12689+ exit(-1);
12690+ }
12691+ case 752LLU: // completed switch
12692+ {
12693+ ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
12694+ ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
12695+ label = 750LLU; // case complete
12696+ break;
12697+ }
12698+ case 751LLU: // try next case
12699+ {
12700+ fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
12701+ exit(-1);
12702+ }
12703+ case 750LLU: // completed switch
12704+ {
12705+ label = 749LLU; // consequent complete
12706+ break;
12707+ }
12708+ case 748LLU: // alternative
12709+ {
12710+ fprintf(stderr, "%s", "in function ");
12711+ // call reportid from PrcCallRec
12712+ stack[base + 36LLU] = base;
12713+ stack[base + 37LLU] = 810LLU;
12714+ // arguments for call to reportid
12715+ stack[base + 38LLU] = stack[base + 6]/*fnid*/;
12716+ // set stack-base & callee-address
12717+ base += 38LLU;
12718+ label = 18446744073709551586LLU; // reportid
12719+ break;
12720+ }
12721+ case 810LLU: // return from reportid to PrcCallRec
12722+ {
12723+ // copy mutable arguments back from call to reportid
12724+ fprintf(stderr, "%s", " call to ");
12725+ // call reportid from PrcCallRec
12726+ stack[base + 36LLU] = base;
12727+ stack[base + 37LLU] = 811LLU;
12728+ // arguments for call to reportid
12729+ stack[base + 38LLU] = stack[base + 15]/*ceid*/;
12730+ // set stack-base & callee-address
12731+ base += 38LLU;
12732+ label = 18446744073709551586LLU; // reportid
12733+ break;
12734+ }
12735+ case 811LLU: // return from reportid to PrcCallRec
12736+ {
12737+ // copy mutable arguments back from call to reportid
12738+ fprintf(stderr, "%s", ": expected identifier or constant argument but found ");
12739+ // call printtoken from PrcCallRec
12740+ stack[base + 36LLU] = base;
12741+ stack[base + 37LLU] = 812LLU;
12742+ // arguments for call to printtoken
12743+ stack[base + 38LLU] = stack[base + 19]/*variant*/;
12744+ stack[base + 39LLU] = stack[base + 20]/*content*/;
12745+ // set stack-base & callee-address
12746+ base += 38LLU;
12747+ label = 18446744073709551583LLU; // printtoken
12748+ break;
12749+ }
12750+ case 812LLU: // return from printtoken to PrcCallRec
12751+ {
12752+ // copy mutable arguments back from call to printtoken
12753+ fprintf(stderr, "%s", "\n");
12754+ exit(-1);
12755+ label = 749LLU; // alternative complete
12756+ break;
12757+ }
12758+ case 749LLU: // completed if-then-else
12759+ {
12760+ label = 724LLU; // alternative complete
12761+ break;
12762+ }
12763+ case 724LLU: // completed if-then-else
12764+ {
12765+ ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34];
12766+ label = 711LLU; // repeat
12767+ break;
12768+ }
12769+ case 712LLU: // loop finished
12770+ {
12771+ // call equ from PrcCallRec
12772+ stack[base + 36LLU] = base;
12773+ stack[base + 37LLU] = 813LLU;
12774+ // arguments for call to equ
12775+ stack[base + 39LLU] = stack[base + 6]/*fnid*/;
12776+ stack[base + 40LLU] = stack[base + 15]/*ceid*/;
12777+ // set stack-base & callee-address
12778+ base += 38LLU;
12779+ label = 18446744073709551600LLU; // equ
12780+ break;
12781+ }
12782+ case 813LLU: // return from equ to PrcCallRec
12783+ {
12784+ // copy mutable arguments back from call to equ
12785+ // copy back results provided by call to equ
12786+ stack[base + 24] = stack[base + 38LLU];
12787+ if(!stack[base + 24]/*isequal*/)
12788+ {
12789+ label = 814LLU; // jump to alternative
12790+ break;
12791+ }
12792+
12793+ // consequent
12794+ if(!stack[base + 32]/*csubstruct*/)
12795+ {
12796+ label = 816LLU; // jump to alternative
12797+ break;
12798+ }
12799+
12800+ // consequent
12801+ label = 817LLU; // consequent complete
12802+ break;
12803+ }
12804+ case 816LLU: // alternative
12805+ {
12806+ fprintf(stderr, "%s", "in function ");
12807+ // call reportid from PrcCallRec
12808+ stack[base + 36LLU] = base;
12809+ stack[base + 37LLU] = 818LLU;
12810+ // arguments for call to reportid
12811+ stack[base + 38LLU] = stack[base + 6]/*fnid*/;
12812+ // set stack-base & callee-address
12813+ base += 38LLU;
12814+ label = 18446744073709551586LLU; // reportid
12815+ break;
12816+ }
12817+ case 818LLU: // return from reportid to PrcCallRec
12818+ {
12819+ // copy mutable arguments back from call to reportid
12820+ fprintf(stderr, "%s", " recursive call to ");
12821+ // call reportid from PrcCallRec
12822+ stack[base + 36LLU] = base;
12823+ stack[base + 37LLU] = 819LLU;
12824+ // arguments for call to reportid
12825+ stack[base + 38LLU] = stack[base + 15]/*ceid*/;
12826+ // set stack-base & callee-address
12827+ base += 38LLU;
12828+ label = 18446744073709551586LLU; // reportid
12829+ break;
12830+ }
12831+ case 819LLU: // return from reportid to PrcCallRec
12832+ {
12833+ // copy mutable arguments back from call to reportid
12834+ fprintf(stderr, "%s", ": at least one argument must be a substructure (i.e. part of parameter obtained by switch)\n");
12835+ exit(-1);
12836+ label = 817LLU; // alternative complete
12837+ break;
12838+ }
12839+ case 817LLU: // completed if-then-else
12840+ {
12841+ label = 815LLU; // consequent complete
12842+ break;
12843+ }
12844+ case 814LLU: // alternative
12845+ {
12846+ label = 815LLU; // alternative complete
12847+ break;
12848+ }
12849+ case 815LLU: // completed if-then-else
12850+ {
12851+ printf("%s", "\n stack = newstack;");
12852+ printf("%s", "\n // set stack-base & callee-address");
12853+ printf("%s", "\n base = 3;");
12854+ printf("%s", "\n label = ");
12855+ // call printnr from PrcCallRec
12856+ stack[base + 32LLU] = base;
12857+ stack[base + 33LLU] = 820LLU;
12858+ // arguments for call to printnr
12859+ stack[base + 34LLU] = stack[base + 11]/*celabel*/;
12860+ // set stack-base & callee-address
12861+ base += 34LLU;
12862+ label = 18446744073709551590LLU; // printnr
12863+ break;
12864+ }
12865+ case 820LLU: // return from printnr to PrcCallRec
12866+ {
12867+ // copy mutable arguments back from call to printnr
12868+ printf("%s", "LLU; // ");
12869+ // call printid from PrcCallRec
12870+ stack[base + 32LLU] = base;
12871+ stack[base + 33LLU] = 821LLU;
12872+ // arguments for call to printid
12873+ stack[base + 34LLU] = stack[base + 15]/*ceid*/;
12874+ // set stack-base & callee-address
12875+ base += 34LLU;
12876+ label = 18446744073709551587LLU; // printid
12877+ break;
12878+ }
12879+ case 821LLU: // return from printid to PrcCallRec
12880+ {
12881+ // copy mutable arguments back from call to printid
12882+ printf("%s", "\n break;");
12883+ printf("%s", "\n }");
12884+ printf("%s", "\n case ");
12885+ // call printnr from PrcCallRec
12886+ stack[base + 32LLU] = base;
12887+ stack[base + 33LLU] = 822LLU;
12888+ // arguments for call to printnr
12889+ stack[base + 34LLU] = stack[base + 21]/*label*/;
12890+ // set stack-base & callee-address
12891+ base += 34LLU;
12892+ label = 18446744073709551590LLU; // printnr
12893+ break;
12894+ }
12895+ case 822LLU: // return from printnr to PrcCallRec
12896+ {
12897+ // copy mutable arguments back from call to printnr
12898+ printf("%s", "LLU: // return from ");
12899+ // call printid from PrcCallRec
12900+ stack[base + 32LLU] = base;
12901+ stack[base + 33LLU] = 823LLU;
12902+ // arguments for call to printid
12903+ stack[base + 34LLU] = stack[base + 15]/*ceid*/;
12904+ // set stack-base & callee-address
12905+ base += 34LLU;
12906+ label = 18446744073709551587LLU; // printid
12907+ break;
12908+ }
12909+ case 823LLU: // return from printid to PrcCallRec
12910+ {
12911+ // copy mutable arguments back from call to printid
12912+ printf("%s", " to ");
12913+ // call printid from PrcCallRec
12914+ stack[base + 32LLU] = base;
12915+ stack[base + 33LLU] = 824LLU;
12916+ // arguments for call to printid
12917+ stack[base + 34LLU] = stack[base + 6]/*fnid*/;
12918+ // set stack-base & callee-address
12919+ base += 34LLU;
12920+ label = 18446744073709551587LLU; // printid
12921+ break;
12922+ }
12923+ case 824LLU: // return from printid to PrcCallRec
12924+ {
12925+ // copy mutable arguments back from call to printid
12926+ printf("%s", "\n {");
12927+ printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
12928+ printf("%s", "\n // copy mutable arguments back from call to ");
12929+ // call printid from PrcCallRec
12930+ stack[base + 32LLU] = base;
12931+ stack[base + 33LLU] = 825LLU;
12932+ // arguments for call to printid
12933+ stack[base + 34LLU] = stack[base + 15]/*ceid*/;
12934+ // set stack-base & callee-address
12935+ base += 34LLU;
12936+ label = 18446744073709551587LLU; // printid
12937+ break;
12938+ }
12939+ case 825LLU: // return from printid to PrcCallRec
12940+ {
12941+ // copy mutable arguments back from call to printid
12942+ label = 826LLU; // start to repeat
12943+ break;
12944+ }
12945+ case 826LLU: // repeat from here
12946+ {
12947+ if(!stack[base + 25])
12948+ {
12949+ label = 827LLU; // break loop
12950+ break;
12951+ }
12952+
12953+ // loop body
12954+ stack[base + 32] = (uint64_t)(((const struct listnode *)(stack[base + 25]))->data);
12955+ {
12956+ struct listnode *list = (struct listnode *)(stack[base + 25]);
12957+ stack[base + 25] = (uint64_t)list->next;
12958+ Free(1, sizeof(struct listnode), list);
12959+ }
12960+ if(/*idnr*/0 != ((uint64_t *)(stack[base + 32]/*idnr*/))[0])
12961+ {
12962+ label = 829LLU; // jump to alternative
12963+ break;
12964+ }
12965+
12966+ /*content*/stack[base + 33] = ((uint64_t **)(stack[base + 32]/*idnr*/))[1][0]/*id*/;
12967+ /*sum*/stack[base + 34] = ((uint64_t **)(stack[base + 32]/*idnr*/))[1][1]/*nr*/;
12968+
12969+ // case
12970+ printf("%s", "\n old");
12971+ // call emitvar from PrcCallRec
12972+ stack[base + 35LLU] = base;
12973+ stack[base + 36LLU] = 830LLU;
12974+ // arguments for call to emitvar
12975+ stack[base + 37LLU] = stack[base + 6]/*fnid*/;
12976+ stack[base + 38LLU] = stack[base + 33]/*content*/;
12977+ stack[base + 39LLU] = stack[base + 1]/*scopes*/;
12978+ stack[base + 40LLU] = stack[base + 2]/*scope*/;
12979+ // set stack-base & callee-address
12980+ base += 37LLU;
12981+ label = 349LLU; // emitvar
12982+ break;
12983+ }
12984+ case 830LLU: // return from emitvar to PrcCallRec
12985+ {
12986+ // copy mutable arguments back from call to emitvar
12987+ printf("%s", " = stack[");
12988+ // call printnr from PrcCallRec
12989+ stack[base + 35LLU] = base;
12990+ stack[base + 36LLU] = 831LLU;
12991+ // arguments for call to printnr
12992+ stack[base + 37LLU] = stack[base + 34]/*sum*/;
12993+ // set stack-base & callee-address
12994+ base += 37LLU;
12995+ label = 18446744073709551590LLU; // printnr
12996+ break;
12997+ }
12998+ case 831LLU: // return from printnr to PrcCallRec
12999+ {
13000+ // copy mutable arguments back from call to printnr
13001+ printf("%s", "LLU];");
13002+ ((uint64_t **)(stack[base + 32]))[1][1] = stack[base + 34];
13003+ ((uint64_t **)(stack[base + 32]))[1][0] = stack[base + 33];
13004+ label = 828LLU; // case complete
13005+ break;
13006+ }
13007+ case 829LLU: // try next case
13008+ {
13009+ fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
13010+ exit(-1);
13011+ }
13012+ case 828LLU: // completed switch
13013+ {
13014+
13015+ uint64_t *newstack = (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 3);
13016+ // call ~idnr from PrcCallRec
13017+ newstack[0] = (uint64_t)stack; // backup stack location
13018+ newstack[1] = base;
13019+ newstack[2] = 832LLU;
13020+ stack = newstack;
13021+ // set stack-base & callee-address
13022+ base = 3;
13023+ label = 371LLU; // ~idnr
13024+ break;
13025+ }
13026+ case 832LLU: // return from ~idnr to PrcCallRec
13027+ {
13028+ stack = (uint64_t *)stack[0];
13029+ // releasing toplevel container
13030+ Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 3));
13031+
13032+ label = 826LLU; // repeat
13033+ break;
13034+ }
13035+ case 827LLU: // loop finished
13036+ {
13037+ if(!stack[base + 26]/*cerescount*/)
13038+ {
13039+ label = 833LLU; // jump to alternative
13040+ break;
13041+ }
13042+
13043+ // consequent
13044+ fprintf(stderr, "%s", "in function ");
13045+ // call reportid from PrcCallRec
13046+ stack[base + 32LLU] = base;
13047+ stack[base + 33LLU] = 835LLU;
13048+ // arguments for call to reportid
13049+ stack[base + 34LLU] = stack[base + 6]/*fnid*/;
13050+ // set stack-base & callee-address
13051+ base += 34LLU;
13052+ label = 18446744073709551586LLU; // reportid
13053+ break;
13054+ }
13055+ case 835LLU: // return from reportid to PrcCallRec
13056+ {
13057+ // copy mutable arguments back from call to reportid
13058+ fprintf(stderr, "%s", ", conditional call: callee ");
13059+ // call reportid from PrcCallRec
13060+ stack[base + 32LLU] = base;
13061+ stack[base + 33LLU] = 836LLU;
13062+ // arguments for call to reportid
13063+ stack[base + 34LLU] = stack[base + 15]/*ceid*/;
13064+ // set stack-base & callee-address
13065+ base += 34LLU;
13066+ label = 18446744073709551586LLU; // reportid
13067+ break;
13068+ }
13069+ case 836LLU: // return from reportid to PrcCallRec
13070+ {
13071+ // copy mutable arguments back from call to reportid
13072+ fprintf(stderr, "%s", " must not return results\n");
13073+ exit(-1);
13074+ label = 834LLU; // consequent complete
13075+ break;
13076+ }
13077+ case 833LLU: // alternative
13078+ {
13079+ label = 834LLU; // alternative complete
13080+ break;
13081+ }
13082+ case 834LLU: // completed if-then-else
13083+ {
13084+ printf("%s", "\n if(stack[");
13085+ // call printnr from PrcCallRec
13086+ stack[base + 32LLU] = base;
13087+ stack[base + 33LLU] = 837LLU;
13088+ // arguments for call to printnr
13089+ stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
13090+ // set stack-base & callee-address
13091+ base += 34LLU;
13092+ label = 18446744073709551590LLU; // printnr
13093+ break;
13094+ }
13095+ case 837LLU: // return from printnr to PrcCallRec
13096+ {
13097+ // copy mutable arguments back from call to printnr
13098+ printf("%s", "LLU] != 9876543210LLU)");
13099+ printf("%s", "\n {");
13100+ printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
13101+ // call printid from PrcCallRec
13102+ stack[base + 32LLU] = base;
13103+ stack[base + 33LLU] = 838LLU;
13104+ // arguments for call to printid
13105+ stack[base + 34LLU] = stack[base + 15]/*ceid*/;
13106+ // set stack-base & callee-address
13107+ base += 34LLU;
13108+ label = 18446744073709551587LLU; // printid
13109+ break;
13110+ }
13111+ case 838LLU: // return from printid to PrcCallRec
13112+ {
13113+ // copy mutable arguments back from call to printid
13114+ printf("%s", ")!\");");
13115+ printf("%s", "\n exit(-1);");
13116+ printf("%s", "\n }");
13117+ printf("%s", "\n Free(");
13118+ // call printnr from PrcCallRec
13119+ stack[base + 32LLU] = base;
13120+ stack[base + 33LLU] = 839LLU;
13121+ // arguments for call to printnr
13122+ stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
13123+ // set stack-base & callee-address
13124+ base += 34LLU;
13125+ label = 18446744073709551590LLU; // printnr
13126+ break;
13127+ }
13128+ case 839LLU: // return from printnr to PrcCallRec
13129+ {
13130+ // copy mutable arguments back from call to printnr
13131+ printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
13132+ printf("%s", "\n stack = oldstack;");
13133+ label = 698LLU; // consequent complete
13134+ break;
13135+ }
13136+ case 697LLU: // alternative
13137+ {
13138+ fprintf(stderr, "%s", "in function ");
13139+ // call reportid from PrcCallRec
13140+ stack[base + 31LLU] = base;
13141+ stack[base + 32LLU] = 840LLU;
13142+ // arguments for call to reportid
13143+ stack[base + 33LLU] = stack[base + 6]/*fnid*/;
13144+ // set stack-base & callee-address
13145+ base += 33LLU;
13146+ label = 18446744073709551586LLU; // reportid
13147+ break;
13148+ }
13149+ case 840LLU: // return from reportid to PrcCallRec
13150+ {
13151+ // copy mutable arguments back from call to reportid
13152+ fprintf(stderr, "%s", ", conditional call: callee ");
13153+ // call reportid from PrcCallRec
13154+ stack[base + 31LLU] = base;
13155+ stack[base + 32LLU] = 841LLU;
13156+ // arguments for call to reportid
13157+ stack[base + 33LLU] = stack[base + 15]/*ceid*/;
13158+ // set stack-base & callee-address
13159+ base += 33LLU;
13160+ label = 18446744073709551586LLU; // reportid
13161+ break;
13162+ }
13163+ case 841LLU: // return from reportid to PrcCallRec
13164+ {
13165+ // copy mutable arguments back from call to reportid
13166+ fprintf(stderr, "%s", " must be declared recursive\n");
13167+ exit(-1);
13168+ label = 698LLU; // alternative complete
13169+ break;
13170+ }
13171+ case 698LLU: // completed if-then-else
13172+ {
13173+ // call MATCHPEEK from PrcCallRec
13174+ stack[base + 28LLU] = base;
13175+ stack[base + 29LLU] = 842LLU;
13176+ // arguments for call to MATCHPEEK
13177+ stack[base + 30LLU] = stack[base + 6]/*fnid*/;
13178+ stack[base + 31LLU] = 41LLU;
13179+ stack[base + 32LLU] = stack[base + 18]/*lookahead*/;
13180+ // set stack-base & callee-address
13181+ base += 30LLU;
13182+ label = 102LLU; // MATCHPEEK
13183+ break;
13184+ }
13185+ case 842LLU: // return from MATCHPEEK to PrcCallRec
13186+ {
13187+ // copy mutable arguments back from call to MATCHPEEK
13188+ stack[base + 18]/*lookahead*/ = stack[base + 32LLU];
13189+ // delete list
13190+ label = 843LLU; // start to repeat
13191+ break;
13192+ }
13193+ case 843LLU: // repeat from here
13194+ {
13195+ if(!stack[base + 25])
13196+ {
13197+ label = 844LLU; // break loop
13198+ break;
13199+ }
13200+
13201+ // delete list loop body
13202+
13203+ uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 25])->data - sizeof(uint64_t) * 3);
13204+ // call ~idnr from PrcCallRec
13205+ newstack[0] = (uint64_t)stack; // backup stack location
13206+ newstack[1] = base;
13207+ newstack[2] = 845LLU;
13208+ stack = newstack;
13209+ // set stack-base & callee-address
13210+ base = 3;
13211+ label = 371LLU; // ~idnr
13212+ break;
13213+ }
13214+ case 845LLU: // return from ~idnr to PrcCallRec
13215+ {
13216+ stack = (uint64_t *)stack[0];
13217+ // releasing toplevel container
13218+ Free(2 + 3, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 25])->data - sizeof(uint64_t) * 3));
13219+
13220+ {
13221+ struct listnode *list = (struct listnode *)stack[base + 25];
13222+ stack[base + 25] = (uint64_t)list->next;
13223+ Free(1, sizeof(struct listnode), list);
13224+ }
13225+ label = 843LLU; // repeat
13226+ break;
13227+ }
13228+ case 844LLU: // loop finished
13229+ {
13230+ // return from PrcCallRec
13231+ label = stack[base - 1];
13232+ base = stack[base - 2];
13233+ break;
13234+ }
13235+ case 846LLU: // ProcCall
13236+ {
13237+//#define arg0 0
13238+//#define arg1 1
13239+//#define arg2 2
13240+//#define arg3 3
13241+//#define arg4 4
13242+//#define arg5 5
13243+//#define arg6 6
13244+//#define arg7 7
13245+//#define arg8 8
13246+//#define arg9 9
13247+//#define arg10 10
13248+//#define arg11 11
13249+//#define arg12 12
13250+//#define arg13 13
13251+//#define arg14 14
13252+//#define arg15 15
13253+//#define arg16 16
1094313254 stack[base + 17] = 0;
1094413255 stack[base + 18] = 0;
1094513256 if(/*fndef*/0 != ((uint64_t *)(stack[base + 12]/*calleedef*/))[0])
1094613257 {
10947- label = 690LLU; // jump to alternative
13258+ label = 848LLU; // jump to alternative
1094813259 break;
1094913260 }
1095013261
@@ -10959,19 +13270,19 @@
1095913270 // case
1096013271 if(!stack[base + 6]/*fnerr*/)
1096113272 {
10962- label = 691LLU; // jump to alternative
13273+ label = 849LLU; // jump to alternative
1096313274 break;
1096413275 }
1096513276
1096613277 // consequent
10967- label = 692LLU; // consequent complete
13278+ label = 850LLU; // consequent complete
1096813279 break;
1096913280 }
10970- case 691LLU: // alternative
13281+ case 849LLU: // alternative
1097113282 {
1097213283 if(!stack[base + 25]/*ceerr*/)
1097313284 {
10974- label = 693LLU; // jump to alternative
13285+ label = 851LLU; // jump to alternative
1097513286 break;
1097613287 }
1097713288
@@ -10979,7 +13290,7 @@
1097913290 fprintf(stderr, "%s", "in function ");
1098013291 // call reportid from ProcCall
1098113292 stack[base + 26LLU] = base;
10982- stack[base + 27LLU] = 695LLU;
13293+ stack[base + 27LLU] = 853LLU;
1098313294 // arguments for call to reportid
1098413295 stack[base + 28LLU] = stack[base + 7]/*fnid*/;
1098513296 // set stack-base & callee-address
@@ -10987,13 +13298,13 @@
1098713298 label = 18446744073709551586LLU; // reportid
1098813299 break;
1098913300 }
10990- case 695LLU: // return from reportid to ProcCall
13301+ case 853LLU: // return from reportid to ProcCall
1099113302 {
1099213303 // copy mutable arguments back from call to reportid
1099313304 fprintf(stderr, "%s", ": partial function ");
1099413305 // call reportid from ProcCall
1099513306 stack[base + 26LLU] = base;
10996- stack[base + 27LLU] = 696LLU;
13307+ stack[base + 27LLU] = 854LLU;
1099713308 // arguments for call to reportid
1099813309 stack[base + 28LLU] = stack[base + 23]/*ceid*/;
1099913310 // set stack-base & callee-address
@@ -11001,25 +13312,25 @@
1100113312 label = 18446744073709551586LLU; // reportid
1100213313 break;
1100313314 }
11004- case 696LLU: // return from reportid to ProcCall
13315+ case 854LLU: // return from reportid to ProcCall
1100513316 {
1100613317 // copy mutable arguments back from call to reportid
1100713318 fprintf(stderr, "%s", " cannot be called from total function - define caller-function as fallible: prefix return-type with '!'\n");
1100813319 exit(-1);
11009- label = 694LLU; // consequent complete
13320+ label = 852LLU; // consequent complete
1101013321 break;
1101113322 }
11012- case 693LLU: // alternative
13323+ case 851LLU: // alternative
1101313324 {
11014- label = 694LLU; // alternative complete
13325+ label = 852LLU; // alternative complete
1101513326 break;
1101613327 }
11017- case 694LLU: // completed if-then-else
13328+ case 852LLU: // completed if-then-else
1101813329 {
11019- label = 692LLU; // alternative complete
13330+ label = 850LLU; // alternative complete
1102013331 break;
1102113332 }
11022- case 692LLU: // completed if-then-else
13333+ case 850LLU: // completed if-then-else
1102313334 {
1102413335 stack[base + 26] = 0;
1102513336 stack[base + 26]/*cerescount*/ = list_size(((struct listnode *)(stack[base + 20]/*cerestypes*/)));
@@ -11027,22 +13338,22 @@
1102713338 stack[base + 27]/*ceargcount*/ = list_size(((struct listnode *)(stack[base + 21]/*ceargtypes*/)));
1102813339 if(!stack[base + 19]/*celabel*/)
1102913340 {
11030- label = 697LLU; // jump to alternative
13341+ label = 855LLU; // jump to alternative
1103113342 break;
1103213343 }
1103313344
1103413345 // consequent
11035- label = 698LLU; // consequent complete
13346+ label = 856LLU; // consequent complete
1103613347 break;
1103713348 }
11038- case 697LLU: // alternative
13349+ case 855LLU: // alternative
1103913350 {
1104013351 fprintf(stderr, "%s", " NULL-label!\n");
1104113352 exit(-1);
11042- label = 698LLU; // alternative complete
13353+ label = 856LLU; // alternative complete
1104313354 break;
1104413355 }
11045- case 698LLU: // completed if-then-else
13356+ case 856LLU: // completed if-then-else
1104613357 {
1104713358 stack[base + 28] = 0;
1104813359 stack[base + 29] = 0;
@@ -11049,7 +13360,7 @@
1104913360 stack[base + 30] = 0;
1105013361 if(!stack[base + 24]/*cerec*/)
1105113362 {
11052- label = 699LLU; // jump to alternative
13363+ label = 857LLU; // jump to alternative
1105313364 break;
1105413365 }
1105513366
@@ -11058,7 +13369,7 @@
1105813369 stack[base + 31]/*recsztotal*/ = 0;
1105913370 // call add from ProcCall
1106013371 stack[base + 32LLU] = base;
11061- stack[base + 33LLU] = 701LLU;
13372+ stack[base + 33LLU] = 859LLU;
1106213373 // arguments for call to add
1106313374 stack[base + 35LLU] = 3LLU;
1106413375 stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
@@ -11067,7 +13378,7 @@
1106713378 label = 18446744073709551605LLU; // add
1106813379 break;
1106913380 }
11070- case 701LLU: // return from add to ProcCall
13381+ case 859LLU: // return from add to ProcCall
1107113382 {
1107213383 // copy mutable arguments back from call to add
1107313384 // copy back results provided by call to add
@@ -11074,7 +13385,7 @@
1107413385 stack[base + 31] = stack[base + 34LLU];
1107513386 // call add from ProcCall
1107613387 stack[base + 32LLU] = base;
11077- stack[base + 33LLU] = 702LLU;
13388+ stack[base + 33LLU] = 860LLU;
1107813389 // arguments for call to add
1107913390 stack[base + 35LLU] = stack[base + 26]/*cerescount*/;
1108013391 stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
@@ -11083,7 +13394,7 @@
1108313394 label = 18446744073709551605LLU; // add
1108413395 break;
1108513396 }
11086- case 702LLU: // return from add to ProcCall
13397+ case 860LLU: // return from add to ProcCall
1108713398 {
1108813399 // copy mutable arguments back from call to add
1108913400 // copy back results provided by call to add
@@ -11090,7 +13401,7 @@
1109013401 stack[base + 31] = stack[base + 34LLU];
1109113402 // call add from ProcCall
1109213403 stack[base + 32LLU] = base;
11093- stack[base + 33LLU] = 703LLU;
13404+ stack[base + 33LLU] = 861LLU;
1109413405 // arguments for call to add
1109513406 stack[base + 35LLU] = stack[base + 27]/*ceargcount*/;
1109613407 stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
@@ -11099,7 +13410,7 @@
1109913410 label = 18446744073709551605LLU; // add
1110013411 break;
1110113412 }
11102- case 703LLU: // return from add to ProcCall
13413+ case 861LLU: // return from add to ProcCall
1110313414 {
1110413415 // copy mutable arguments back from call to add
1110513416 // copy back results provided by call to add
@@ -11106,7 +13417,7 @@
1110613417 stack[base + 31] = stack[base + 34LLU];
1110713418 // call add from ProcCall
1110813419 stack[base + 32LLU] = base;
11109- stack[base + 33LLU] = 704LLU;
13420+ stack[base + 33LLU] = 862LLU;
1111013421 // arguments for call to add
1111113422 stack[base + 35LLU] = stack[base + 22]/*cemaxcount*/;
1111213423 stack[base + 36LLU] = stack[base + 31]/*recsztotal*/;
@@ -11115,7 +13426,7 @@
1111513426 label = 18446744073709551605LLU; // add
1111613427 break;
1111713428 }
11118- case 704LLU: // return from add to ProcCall
13429+ case 862LLU: // return from add to ProcCall
1111913430 {
1112013431 // copy mutable arguments back from call to add
1112113432 // copy back results provided by call to add
@@ -11123,7 +13434,7 @@
1112313434 printf("%s", "\n uint64_t *newstack = (uint64_t *)Calloc(");
1112413435 // call printnr from ProcCall
1112513436 stack[base + 32LLU] = base;
11126- stack[base + 33LLU] = 705LLU;
13437+ stack[base + 33LLU] = 863LLU;
1112713438 // arguments for call to printnr
1112813439 stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
1112913440 // set stack-base & callee-address
@@ -11131,7 +13442,7 @@
1113113442 label = 18446744073709551590LLU; // printnr
1113213443 break;
1113313444 }
11134- case 705LLU: // return from printnr to ProcCall
13445+ case 863LLU: // return from printnr to ProcCall
1113513446 {
1113613447 // copy mutable arguments back from call to printnr
1113713448 printf("%s", "LLU + 1, sizeof(uint64_t));");
@@ -11140,7 +13451,7 @@
1114013451 printf("%s", "\n fprintf(stderr, \"in function ");
1114113452 // call printid from ProcCall
1114213453 stack[base + 32LLU] = base;
11143- stack[base + 33LLU] = 706LLU;
13454+ stack[base + 33LLU] = 864LLU;
1114413455 // arguments for call to printid
1114513456 stack[base + 34LLU] = stack[base + 7]/*fnid*/;
1114613457 // set stack-base & callee-address
@@ -11148,13 +13459,13 @@
1114813459 label = 18446744073709551587LLU; // printid
1114913460 break;
1115013461 }
11151- case 706LLU: // return from printid to ProcCall
13462+ case 864LLU: // return from printid to ProcCall
1115213463 {
1115313464 // copy mutable arguments back from call to printid
1115413465 printf("%s", " call to ");
1115513466 // call printid from ProcCall
1115613467 stack[base + 32LLU] = base;
11157- stack[base + 33LLU] = 707LLU;
13468+ stack[base + 33LLU] = 865LLU;
1115813469 // arguments for call to printid
1115913470 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1116013471 // set stack-base & callee-address
@@ -11162,7 +13473,7 @@
1116213473 label = 18446744073709551587LLU; // printid
1116313474 break;
1116413475 }
11165- case 707LLU: // return from printid to ProcCall
13476+ case 865LLU: // return from printid to ProcCall
1116613477 {
1116713478 // copy mutable arguments back from call to printid
1116813479 printf("%s", ": OUT OF MEMORY!\");");
@@ -11171,7 +13482,7 @@
1117113482 printf("%s", "\n newstack[");
1117213483 // call printnr from ProcCall
1117313484 stack[base + 32LLU] = base;
11174- stack[base + 33LLU] = 708LLU;
13485+ stack[base + 33LLU] = 866LLU;
1117513486 // arguments for call to printnr
1117613487 stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
1117713488 // set stack-base & callee-address
@@ -11179,7 +13490,7 @@
1117913490 label = 18446744073709551590LLU; // printnr
1118013491 break;
1118113492 }
11182- case 708LLU: // return from printnr to ProcCall
13493+ case 866LLU: // return from printnr to ProcCall
1118313494 {
1118413495 // copy mutable arguments back from call to printnr
1118513496 printf("%s", "LLU] = 9876543210LLU; // overflow-marker");
@@ -11186,7 +13497,7 @@
1118613497 printf("%s", "\n // call ");
1118713498 // call printid from ProcCall
1118813499 stack[base + 32LLU] = base;
11189- stack[base + 33LLU] = 709LLU;
13500+ stack[base + 33LLU] = 867LLU;
1119013501 // arguments for call to printid
1119113502 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1119213503 // set stack-base & callee-address
@@ -11194,13 +13505,13 @@
1119413505 label = 18446744073709551587LLU; // printid
1119513506 break;
1119613507 }
11197- case 709LLU: // return from printid to ProcCall
13508+ case 867LLU: // return from printid to ProcCall
1119813509 {
1119913510 // copy mutable arguments back from call to printid
1120013511 printf("%s", " from ");
1120113512 // call printid from ProcCall
1120213513 stack[base + 32LLU] = base;
11203- stack[base + 33LLU] = 710LLU;
13514+ stack[base + 33LLU] = 868LLU;
1120413515 // arguments for call to printid
1120513516 stack[base + 34LLU] = stack[base + 7]/*fnid*/;
1120613517 // set stack-base & callee-address
@@ -11208,7 +13519,7 @@
1120813519 label = 18446744073709551587LLU; // printid
1120913520 break;
1121013521 }
11211- case 710LLU: // return from printid to ProcCall
13522+ case 868LLU: // return from printid to ProcCall
1121213523 {
1121313524 // copy mutable arguments back from call to printid
1121413525 printf("%s", "\n newstack[0] = (uint64_t)stack; // backup stack location");
@@ -11215,7 +13526,7 @@
1121513526 printf("%s", "\n newstack[1] = base;");
1121613527 // call add from ProcCall
1121713528 stack[base + 32LLU] = base;
11218- stack[base + 33LLU] = 711LLU;
13529+ stack[base + 33LLU] = 869LLU;
1121913530 // arguments for call to add
1122013531 stack[base + 35LLU] = 1LLU;
1122113532 stack[base + 36LLU] = stack[base + 16]/*label*/;
@@ -11224,7 +13535,7 @@
1122413535 label = 18446744073709551605LLU; // add
1122513536 break;
1122613537 }
11227- case 711LLU: // return from add to ProcCall
13538+ case 869LLU: // return from add to ProcCall
1122813539 {
1122913540 // copy mutable arguments back from call to add
1123013541 // copy back results provided by call to add
@@ -11232,7 +13543,7 @@
1123213543 printf("%s", "\n newstack[2] = ");
1123313544 // call printnr from ProcCall
1123413545 stack[base + 32LLU] = base;
11235- stack[base + 33LLU] = 712LLU;
13546+ stack[base + 33LLU] = 870LLU;
1123613547 // arguments for call to printnr
1123713548 stack[base + 34LLU] = stack[base + 16]/*label*/;
1123813549 // set stack-base & callee-address
@@ -11240,7 +13551,7 @@
1124013551 label = 18446744073709551590LLU; // printnr
1124113552 break;
1124213553 }
11243- case 712LLU: // return from printnr to ProcCall
13554+ case 870LLU: // return from printnr to ProcCall
1124413555 {
1124513556 // copy mutable arguments back from call to printnr
1124613557 printf("%s", "LLU;");
@@ -11248,7 +13559,7 @@
1124813559 printf("%s", "\n // arguments for call to ");
1124913560 // call printid from ProcCall
1125013561 stack[base + 32LLU] = base;
11251- stack[base + 33LLU] = 713LLU;
13562+ stack[base + 33LLU] = 871LLU;
1125213563 // arguments for call to printid
1125313564 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1125413565 // set stack-base & callee-address
@@ -11256,19 +13567,19 @@
1125613567 label = 18446744073709551587LLU; // printid
1125713568 break;
1125813569 }
11259- case 713LLU: // return from printid to ProcCall
13570+ case 871LLU: // return from printid to ProcCall
1126013571 {
1126113572 // copy mutable arguments back from call to printid
1126213573 stack[base + 32] = 0;
1126313574 flippedassign(stack[base + 21]/*ceargtypes*/, &stack[base + 33]);
11264- label = 714LLU; // start to repeat
13575+ label = 872LLU; // start to repeat
1126513576 break;
1126613577 }
11267- case 714LLU: // repeat from here
13578+ case 872LLU: // repeat from here
1126813579 {
1126913580 if(!stack[base + 33])
1127013581 {
11271- label = 715LLU; // break loop
13582+ label = 873LLU; // break loop
1127213583 break;
1127313584 }
1127413585
@@ -11278,7 +13589,7 @@
1127813589 stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->next);
1127913590 // call sub from ProcCall
1128013591 stack[base + 36LLU] = base;
11281- stack[base + 37LLU] = 716LLU;
13592+ stack[base + 37LLU] = 874LLU;
1128213593 // arguments for call to sub
1128313594 stack[base + 39LLU] = stack[base + 27]/*ceargcount*/;
1128413595 stack[base + 40LLU] = stack[base + 29]/*n*/;
@@ -11287,7 +13598,7 @@
1128713598 label = 18446744073709551604LLU; // sub
1128813599 break;
1128913600 }
11290- case 716LLU: // return from sub to ProcCall
13601+ case 874LLU: // return from sub to ProcCall
1129113602 {
1129213603 // copy mutable arguments back from call to sub
1129313604 // copy back results provided by call to sub
@@ -11294,7 +13605,7 @@
1129413605 stack[base + 30] = stack[base + 38LLU];
1129513606 // call sub from ProcCall
1129613607 stack[base + 36LLU] = base;
11297- stack[base + 37LLU] = 717LLU;
13608+ stack[base + 37LLU] = 875LLU;
1129813609 // arguments for call to sub
1129913610 stack[base + 39LLU] = stack[base + 29]/*n*/;
1130013611 stack[base + 40LLU] = 1LLU;
@@ -11303,7 +13614,7 @@
1130313614 label = 18446744073709551604LLU; // sub
1130413615 break;
1130513616 }
11306- case 717LLU: // return from sub to ProcCall
13617+ case 875LLU: // return from sub to ProcCall
1130713618 {
1130813619 // copy mutable arguments back from call to sub
1130913620 // copy back results provided by call to sub
@@ -11310,7 +13621,7 @@
1131013621 stack[base + 29] = stack[base + 38LLU];
1131113622 if(!stack[base + 30]/*index*/)
1131213623 {
11313- label = 718LLU; // jump to alternative
13624+ label = 876LLU; // jump to alternative
1131413625 break;
1131513626 }
1131613627
@@ -11317,7 +13628,7 @@
1131713628 // consequent
1131813629 // call matchsym from ProcCall
1131913630 stack[base + 36LLU] = base;
11320- stack[base + 37LLU] = 720LLU;
13631+ stack[base + 37LLU] = 878LLU;
1132113632 // arguments for call to matchsym
1132213633 stack[base + 38LLU] = stack[base + 7]/*fnid*/;
1132313634 stack[base + 39LLU] = 44LLU;
@@ -11327,24 +13638,24 @@
1132713638 label = 110LLU; // matchsym
1132813639 break;
1132913640 }
11330- case 720LLU: // return from matchsym to ProcCall
13641+ case 878LLU: // return from matchsym to ProcCall
1133113642 {
1133213643 // copy mutable arguments back from call to matchsym
1133313644 stack[base + 13]/*lookahead*/ = stack[base + 40LLU];
11334- label = 719LLU; // consequent complete
13645+ label = 877LLU; // consequent complete
1133513646 break;
1133613647 }
11337- case 718LLU: // alternative
13648+ case 876LLU: // alternative
1133813649 {
11339- label = 719LLU; // alternative complete
13650+ label = 877LLU; // alternative complete
1134013651 break;
1134113652 }
11342- case 719LLU: // completed if-then-else
13653+ case 877LLU: // completed if-then-else
1134313654 {
1134413655 stack[base + 28]/*sum*/ = 0;
1134513656 // call add from ProcCall
1134613657 stack[base + 36LLU] = base;
11347- stack[base + 37LLU] = 721LLU;
13658+ stack[base + 37LLU] = 879LLU;
1134813659 // arguments for call to add
1134913660 stack[base + 39LLU] = 3LLU;
1135013661 stack[base + 40LLU] = stack[base + 28]/*sum*/;
@@ -11353,7 +13664,7 @@
1135313664 label = 18446744073709551605LLU; // add
1135413665 break;
1135513666 }
11356- case 721LLU: // return from add to ProcCall
13667+ case 879LLU: // return from add to ProcCall
1135713668 {
1135813669 // copy mutable arguments back from call to add
1135913670 // copy back results provided by call to add
@@ -11360,7 +13671,7 @@
1136013671 stack[base + 28] = stack[base + 38LLU];
1136113672 // call add from ProcCall
1136213673 stack[base + 36LLU] = base;
11363- stack[base + 37LLU] = 722LLU;
13674+ stack[base + 37LLU] = 880LLU;
1136413675 // arguments for call to add
1136513676 stack[base + 39LLU] = stack[base + 26]/*cerescount*/;
1136613677 stack[base + 40LLU] = stack[base + 28]/*sum*/;
@@ -11369,7 +13680,7 @@
1136913680 label = 18446744073709551605LLU; // add
1137013681 break;
1137113682 }
11372- case 722LLU: // return from add to ProcCall
13683+ case 880LLU: // return from add to ProcCall
1137313684 {
1137413685 // copy mutable arguments back from call to add
1137513686 // copy back results provided by call to add
@@ -11376,7 +13687,7 @@
1137613687 stack[base + 28] = stack[base + 38LLU];
1137713688 // call add from ProcCall
1137813689 stack[base + 36LLU] = base;
11379- stack[base + 37LLU] = 723LLU;
13690+ stack[base + 37LLU] = 881LLU;
1138013691 // arguments for call to add
1138113692 stack[base + 39LLU] = stack[base + 30]/*index*/;
1138213693 stack[base + 40LLU] = stack[base + 28]/*sum*/;
@@ -11385,7 +13696,7 @@
1138513696 label = 18446744073709551605LLU; // add
1138613697 break;
1138713698 }
11388- case 723LLU: // return from add to ProcCall
13699+ case 881LLU: // return from add to ProcCall
1138913700 {
1139013701 // copy mutable arguments back from call to add
1139113702 // copy back results provided by call to add
@@ -11392,7 +13703,7 @@
1139213703 stack[base + 28] = stack[base + 38LLU];
1139313704 // call ParseToken from ProcCall
1139413705 stack[base + 36LLU] = base;
11395- stack[base + 37LLU] = 724LLU;
13706+ stack[base + 37LLU] = 882LLU;
1139613707 // arguments for call to ParseToken
1139713708 stack[base + 40LLU] = stack[base + 13]/*lookahead*/;
1139813709 // set stack-base & callee-address
@@ -11400,7 +13711,7 @@
1140013711 label = 2LLU; // ParseToken
1140113712 break;
1140213713 }
11403- case 724LLU: // return from ParseToken to ProcCall
13714+ case 882LLU: // return from ParseToken to ProcCall
1140413715 {
1140513716 // copy mutable arguments back from call to ParseToken
1140613717 stack[base + 13]/*lookahead*/ = stack[base + 40LLU];
@@ -11409,7 +13720,7 @@
1140913720 stack[base + 15] = stack[base + 39LLU];
1141013721 // call isncs from ProcCall
1141113722 stack[base + 36LLU] = base;
11412- stack[base + 37LLU] = 725LLU;
13723+ stack[base + 37LLU] = 883LLU;
1141313724 // arguments for call to isncs
1141413725 stack[base + 39LLU] = stack[base + 14]/*variant*/;
1141513726 // set stack-base & callee-address
@@ -11417,7 +13728,7 @@
1141713728 label = 138LLU; // isncs
1141813729 break;
1141913730 }
11420- case 725LLU: // return from isncs to ProcCall
13731+ case 883LLU: // return from isncs to ProcCall
1142113732 {
1142213733 // copy mutable arguments back from call to isncs
1142313734 // copy back results provided by call to isncs
@@ -11424,7 +13735,7 @@
1142413735 stack[base + 17] = stack[base + 38LLU];
1142513736 if(!stack[base + 17]/*isequal*/)
1142613737 {
11427- label = 726LLU; // jump to alternative
13738+ label = 884LLU; // jump to alternative
1142813739 break;
1142913740 }
1143013741
@@ -11431,7 +13742,7 @@
1143113742 // consequent
1143213743 if(/*param*/0 != ((uint64_t *)(stack[base + 34]/*param*/))[0])
1143313744 {
11434- label = 729LLU; // jump to alternative
13745+ label = 887LLU; // jump to alternative
1143513746 break;
1143613747 }
1143713748
@@ -11441,7 +13752,7 @@
1144113752 // case
1144213753 if(/*typeid*/0 != ((uint64_t *)(stack[base + 36]/*typeid*/))[0])
1144313754 {
11444- label = 731LLU; // jump to alternative
13755+ label = 889LLU; // jump to alternative
1144513756 break;
1144613757 }
1144713758
@@ -11451,7 +13762,7 @@
1145113762 // case
1145213763 // call mktypename from ProcCall
1145313764 stack[base + 41LLU] = base;
11454- stack[base + 42LLU] = 732LLU;
13765+ stack[base + 42LLU] = 890LLU;
1145513766 // arguments for call to mktypename
1145613767 stack[base + 44LLU] = 881834713755418624LLU;
1145713768 // set stack-base & callee-address
@@ -11459,7 +13770,7 @@
1145913770 label = 152LLU; // mktypename
1146013771 break;
1146113772 }
11462- case 732LLU: // return from mktypename to ProcCall
13773+ case 890LLU: // return from mktypename to ProcCall
1146313774 {
1146413775 // copy mutable arguments back from call to mktypename
1146513776 // copy back results provided by call to mktypename
@@ -11474,7 +13785,7 @@
1147413785 // call equtype from ProcCall
1147513786 newstack[0] = (uint64_t)stack; // backup stack location
1147613787 newstack[1] = base;
11477- newstack[2] = 733LLU;
13788+ newstack[2] = 891LLU;
1147813789 // arguments for call to equtype
1147913790 newstack[4LLU] = stack[base + 40]/*type*/;
1148013791 newstack[5LLU] = stack[base + 38]/*expected*/;
@@ -11484,7 +13795,7 @@
1148413795 label = 170LLU; // equtype
1148513796 break;
1148613797 }
11487- case 733LLU: // return from equtype to ProcCall
13798+ case 891LLU: // return from equtype to ProcCall
1148813799 {
1148913800 uint64_t *oldstack = (uint64_t *)stack[0];
1149013801 // copy mutable arguments back from call to equtype
@@ -11499,20 +13810,20 @@
1149913810 stack = oldstack;
1150013811 if(!stack[base + 17]/*isequal*/)
1150113812 {
11502- label = 734LLU; // jump to alternative
13813+ label = 892LLU; // jump to alternative
1150313814 break;
1150413815 }
1150513816
1150613817 // consequent
11507- label = 735LLU; // consequent complete
13818+ label = 893LLU; // consequent complete
1150813819 break;
1150913820 }
11510- case 734LLU: // alternative
13821+ case 892LLU: // alternative
1151113822 {
1151213823 fprintf(stderr, "%s", "in function ");
1151313824 // call reportid from ProcCall
1151413825 stack[base + 41LLU] = base;
11515- stack[base + 42LLU] = 736LLU;
13826+ stack[base + 42LLU] = 894LLU;
1151613827 // arguments for call to reportid
1151713828 stack[base + 43LLU] = stack[base + 7]/*fnid*/;
1151813829 // set stack-base & callee-address
@@ -11520,13 +13831,13 @@
1152013831 label = 18446744073709551586LLU; // reportid
1152113832 break;
1152213833 }
11523- case 736LLU: // return from reportid to ProcCall
13834+ case 894LLU: // return from reportid to ProcCall
1152413835 {
1152513836 // copy mutable arguments back from call to reportid
1152613837 fprintf(stderr, "%s", " call to ");
1152713838 // call reportid from ProcCall
1152813839 stack[base + 41LLU] = base;
11529- stack[base + 42LLU] = 737LLU;
13840+ stack[base + 42LLU] = 895LLU;
1153013841 // arguments for call to reportid
1153113842 stack[base + 43LLU] = stack[base + 23]/*ceid*/;
1153213843 // set stack-base & callee-address
@@ -11534,13 +13845,13 @@
1153413845 label = 18446744073709551586LLU; // reportid
1153513846 break;
1153613847 }
11537- case 737LLU: // return from reportid to ProcCall
13848+ case 895LLU: // return from reportid to ProcCall
1153813849 {
1153913850 // copy mutable arguments back from call to reportid
1154013851 fprintf(stderr, "%s", " at position ");
1154113852 // call reportnr from ProcCall
1154213853 stack[base + 41LLU] = base;
11543- stack[base + 42LLU] = 738LLU;
13854+ stack[base + 42LLU] = 896LLU;
1154413855 // arguments for call to reportnr
1154513856 stack[base + 43LLU] = stack[base + 30]/*index*/;
1154613857 // set stack-base & callee-address
@@ -11548,7 +13859,7 @@
1154813859 label = 18446744073709551589LLU; // reportnr
1154913860 break;
1155013861 }
11551- case 738LLU: // return from reportnr to ProcCall
13862+ case 896LLU: // return from reportnr to ProcCall
1155213863 {
1155313864 // copy mutable arguments back from call to reportnr
1155413865 fprintf(stderr, "%s", " expected parameter of type ");
@@ -11562,7 +13873,7 @@
1156213873 // call reporttype from ProcCall
1156313874 newstack[0] = (uint64_t)stack; // backup stack location
1156413875 newstack[1] = base;
11565- newstack[2] = 739LLU;
13876+ newstack[2] = 897LLU;
1156613877 // arguments for call to reporttype
1156713878 newstack[3LLU] = stack[base + 38]/*expected*/;
1156813879 stack = newstack;
@@ -11571,7 +13882,7 @@
1157113882 label = 159LLU; // reporttype
1157213883 break;
1157313884 }
11574- case 739LLU: // return from reporttype to ProcCall
13885+ case 897LLU: // return from reporttype to ProcCall
1157513886 {
1157613887 uint64_t *oldstack = (uint64_t *)stack[0];
1157713888 // copy mutable arguments back from call to reporttype
@@ -11585,10 +13896,10 @@
1158513896 fprintf(stderr, "%s", " but found constant-argument of type u64");
1158613897 fprintf(stderr, "%s", "\n");
1158713898 exit(-1);
11588- label = 735LLU; // alternative complete
13899+ label = 893LLU; // alternative complete
1158913900 break;
1159013901 }
11591- case 735LLU: // completed if-then-else
13902+ case 893LLU: // completed if-then-else
1159213903 {
1159313904
1159413905 uint64_t *newstack = (uint64_t *)(stack[base + 40] - sizeof(uint64_t) * 3);
@@ -11595,7 +13906,7 @@
1159513906 // call ~type from ProcCall
1159613907 newstack[0] = (uint64_t)stack; // backup stack location
1159713908 newstack[1] = base;
11598- newstack[2] = 740LLU;
13909+ newstack[2] = 898LLU;
1159913910 stack = newstack;
1160013911 // set stack-base & callee-address
1160113912 base = 3;
@@ -11602,7 +13913,7 @@
1160213913 label = 148LLU; // ~type
1160313914 break;
1160413915 }
11605- case 740LLU: // return from ~type to ProcCall
13916+ case 898LLU: // return from ~type to ProcCall
1160613917 {
1160713918 stack = (uint64_t *)stack[0];
1160813919 // releasing toplevel container
@@ -11610,19 +13921,19 @@
1161013921
1161113922 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 39];
1161213923 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 38];
11613- label = 730LLU; // case complete
13924+ label = 888LLU; // case complete
1161413925 break;
1161513926 }
11616- case 731LLU: // try next case
13927+ case 889LLU: // try next case
1161713928 {
1161813929 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1161913930 exit(-1);
1162013931 }
11621- case 730LLU: // completed switch
13932+ case 888LLU: // completed switch
1162213933 {
1162313934 if(!stack[base + 37]/*mutable*/)
1162413935 {
11625- label = 741LLU; // jump to alternative
13936+ label = 899LLU; // jump to alternative
1162613937 break;
1162713938 }
1162813939
@@ -11630,7 +13941,7 @@
1163013941 fprintf(stderr, "%s", "in function ");
1163113942 // call reportid from ProcCall
1163213943 stack[base + 38LLU] = base;
11633- stack[base + 39LLU] = 743LLU;
13944+ stack[base + 39LLU] = 901LLU;
1163413945 // arguments for call to reportid
1163513946 stack[base + 40LLU] = stack[base + 7]/*fnid*/;
1163613947 // set stack-base & callee-address
@@ -11638,13 +13949,13 @@
1163813949 label = 18446744073709551586LLU; // reportid
1163913950 break;
1164013951 }
11641- case 743LLU: // return from reportid to ProcCall
13952+ case 901LLU: // return from reportid to ProcCall
1164213953 {
1164313954 // copy mutable arguments back from call to reportid
1164413955 fprintf(stderr, "%s", ", calling ");
1164513956 // call reportid from ProcCall
1164613957 stack[base + 38LLU] = base;
11647- stack[base + 39LLU] = 744LLU;
13958+ stack[base + 39LLU] = 902LLU;
1164813959 // arguments for call to reportid
1164913960 stack[base + 40LLU] = stack[base + 23]/*ceid*/;
1165013961 // set stack-base & callee-address
@@ -11652,7 +13963,7 @@
1165213963 label = 18446744073709551586LLU; // reportid
1165313964 break;
1165413965 }
11655- case 744LLU: // return from reportid to ProcCall
13966+ case 902LLU: // return from reportid to ProcCall
1165613967 {
1165713968 // copy mutable arguments back from call to reportid
1165813969 fprintf(stderr, "%s", ": ");
@@ -11659,7 +13970,7 @@
1165913970 fprintf(stderr, "%s", "can't use constant argument ");
1166013971 // call printnr from ProcCall
1166113972 stack[base + 38LLU] = base;
11662- stack[base + 39LLU] = 745LLU;
13973+ stack[base + 39LLU] = 903LLU;
1166313974 // arguments for call to printnr
1166413975 stack[base + 40LLU] = stack[base + 15]/*content*/;
1166513976 // set stack-base & callee-address
@@ -11667,13 +13978,13 @@
1166713978 label = 18446744073709551590LLU; // printnr
1166813979 break;
1166913980 }
11670- case 745LLU: // return from printnr to ProcCall
13981+ case 903LLU: // return from printnr to ProcCall
1167113982 {
1167213983 // copy mutable arguments back from call to printnr
1167313984 printf("%s", " for mutable parameter ");
1167413985 // call reportti from ProcCall
1167513986 stack[base + 38LLU] = base;
11676- stack[base + 39LLU] = 746LLU;
13987+ stack[base + 39LLU] = 904LLU;
1167713988 // arguments for call to reportti
1167813989 stack[base + 40LLU] = stack[base + 36]/*typeid*/;
1167913990 // set stack-base & callee-address
@@ -11681,37 +13992,37 @@
1168113992 label = 183LLU; // reportti
1168213993 break;
1168313994 }
11684- case 746LLU: // return from reportti to ProcCall
13995+ case 904LLU: // return from reportti to ProcCall
1168513996 {
1168613997 // copy mutable arguments back from call to reportti
1168713998 fprintf(stderr, "%s", "\n");
1168813999 exit(-1);
11689- label = 742LLU; // consequent complete
14000+ label = 900LLU; // consequent complete
1169014001 break;
1169114002 }
11692- case 741LLU: // alternative
14003+ case 899LLU: // alternative
1169314004 {
11694- label = 742LLU; // alternative complete
14005+ label = 900LLU; // alternative complete
1169514006 break;
1169614007 }
11697- case 742LLU: // completed if-then-else
14008+ case 900LLU: // completed if-then-else
1169814009 {
1169914010 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
1170014011 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
11701- label = 728LLU; // case complete
14012+ label = 886LLU; // case complete
1170214013 break;
1170314014 }
11704- case 729LLU: // try next case
14015+ case 887LLU: // try next case
1170514016 {
1170614017 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1170714018 exit(-1);
1170814019 }
11709- case 728LLU: // completed switch
14020+ case 886LLU: // completed switch
1171014021 {
1171114022 printf("%s", "\n newstack[");
1171214023 // call printnr from ProcCall
1171314024 stack[base + 36LLU] = base;
11714- stack[base + 37LLU] = 747LLU;
14025+ stack[base + 37LLU] = 905LLU;
1171514026 // arguments for call to printnr
1171614027 stack[base + 38LLU] = stack[base + 28]/*sum*/;
1171714028 // set stack-base & callee-address
@@ -11719,13 +14030,13 @@
1171914030 label = 18446744073709551590LLU; // printnr
1172014031 break;
1172114032 }
11722- case 747LLU: // return from printnr to ProcCall
14033+ case 905LLU: // return from printnr to ProcCall
1172314034 {
1172414035 // copy mutable arguments back from call to printnr
1172514036 printf("%s", "LLU] = ");
1172614037 // call printnr from ProcCall
1172714038 stack[base + 36LLU] = base;
11728- stack[base + 37LLU] = 748LLU;
14039+ stack[base + 37LLU] = 906LLU;
1172914040 // arguments for call to printnr
1173014041 stack[base + 38LLU] = stack[base + 15]/*content*/;
1173114042 // set stack-base & callee-address
@@ -11733,13 +14044,13 @@
1173314044 label = 18446744073709551590LLU; // printnr
1173414045 break;
1173514046 }
11736- case 748LLU: // return from printnr to ProcCall
14047+ case 906LLU: // return from printnr to ProcCall
1173714048 {
1173814049 // copy mutable arguments back from call to printnr
1173914050 printf("%s", "LLU; // ");
1174014051 // call printid from ProcCall
1174114052 stack[base + 36LLU] = base;
11742- stack[base + 37LLU] = 749LLU;
14053+ stack[base + 37LLU] = 907LLU;
1174314054 // arguments for call to printid
1174414055 stack[base + 38LLU] = stack[base + 15]/*content*/;
1174514056 // set stack-base & callee-address
@@ -11747,17 +14058,17 @@
1174714058 label = 18446744073709551587LLU; // printid
1174814059 break;
1174914060 }
11750- case 749LLU: // return from printid to ProcCall
14061+ case 907LLU: // return from printid to ProcCall
1175114062 {
1175214063 // copy mutable arguments back from call to printid
11753- label = 727LLU; // consequent complete
14064+ label = 885LLU; // consequent complete
1175414065 break;
1175514066 }
11756- case 726LLU: // alternative
14067+ case 884LLU: // alternative
1175714068 {
1175814069 // call equ from ProcCall
1175914070 stack[base + 36LLU] = base;
11760- stack[base + 37LLU] = 750LLU;
14071+ stack[base + 37LLU] = 908LLU;
1176114072 // arguments for call to equ
1176214073 stack[base + 39LLU] = stack[base + 14]/*variant*/;
1176314074 stack[base + 40LLU] = 4LLU;
@@ -11766,7 +14077,7 @@
1176614077 label = 18446744073709551600LLU; // equ
1176714078 break;
1176814079 }
11769- case 750LLU: // return from equ to ProcCall
14080+ case 908LLU: // return from equ to ProcCall
1177014081 {
1177114082 // copy mutable arguments back from call to equ
1177214083 // copy back results provided by call to equ
@@ -11773,7 +14084,7 @@
1177314084 stack[base + 17] = stack[base + 38LLU];
1177414085 if(!stack[base + 17]/*isequal*/)
1177514086 {
11776- label = 751LLU; // jump to alternative
14087+ label = 909LLU; // jump to alternative
1177714088 break;
1177814089 }
1177914090
@@ -11780,7 +14091,7 @@
1178014091 // consequent
1178114092 if(/*param*/0 != ((uint64_t *)(stack[base + 34]/*param*/))[0])
1178214093 {
11783- label = 754LLU; // jump to alternative
14094+ label = 912LLU; // jump to alternative
1178414095 break;
1178514096 }
1178614097
@@ -11790,7 +14101,7 @@
1179014101 // case
1179114102 if(/*typeid*/0 != ((uint64_t *)(stack[base + 36]/*typeid*/))[0])
1179214103 {
11793- label = 756LLU; // jump to alternative
14104+ label = 914LLU; // jump to alternative
1179414105 break;
1179514106 }
1179614107
@@ -11800,7 +14111,7 @@
1180014111 // case
1180114112 // call equ from ProcCall
1180214113 stack[base + 40LLU] = base;
11803- stack[base + 41LLU] = 757LLU;
14114+ stack[base + 41LLU] = 915LLU;
1180414115 // arguments for call to equ
1180514116 stack[base + 43LLU] = stack[base + 15]/*content*/;
1180614117 stack[base + 44LLU] = 621705506259468288LLU;
@@ -11809,7 +14120,7 @@
1180914120 label = 18446744073709551600LLU; // equ
1181014121 break;
1181114122 }
11812- case 757LLU: // return from equ to ProcCall
14123+ case 915LLU: // return from equ to ProcCall
1181314124 {
1181414125 // copy mutable arguments back from call to equ
1181514126 // copy back results provided by call to equ
@@ -11816,7 +14127,7 @@
1181614127 stack[base + 17] = stack[base + 42LLU];
1181714128 if(!stack[base + 17]/*isequal*/)
1181814129 {
11819- label = 758LLU; // jump to alternative
14130+ label = 916LLU; // jump to alternative
1182014131 break;
1182114132 }
1182214133
@@ -11823,7 +14134,7 @@
1182314134 // consequent
1182414135 // call matchsym from ProcCall
1182514136 stack[base + 40LLU] = base;
11826- stack[base + 41LLU] = 760LLU;
14137+ stack[base + 41LLU] = 918LLU;
1182714138 // arguments for call to matchsym
1182814139 stack[base + 42LLU] = stack[base + 7]/*fnid*/;
1182914140 stack[base + 43LLU] = 40LLU;
@@ -11833,13 +14144,13 @@
1183314144 label = 110LLU; // matchsym
1183414145 break;
1183514146 }
11836- case 760LLU: // return from matchsym to ProcCall
14147+ case 918LLU: // return from matchsym to ProcCall
1183714148 {
1183814149 // copy mutable arguments back from call to matchsym
1183914150 stack[base + 13]/*lookahead*/ = stack[base + 44LLU];
1184014151 // call matchsym from ProcCall
1184114152 stack[base + 40LLU] = base;
11842- stack[base + 41LLU] = 761LLU;
14153+ stack[base + 41LLU] = 919LLU;
1184314154 // arguments for call to matchsym
1184414155 stack[base + 42LLU] = stack[base + 7]/*fnid*/;
1184514156 stack[base + 43LLU] = 41LLU;
@@ -11849,13 +14160,13 @@
1184914160 label = 110LLU; // matchsym
1185014161 break;
1185114162 }
11852- case 761LLU: // return from matchsym to ProcCall
14163+ case 919LLU: // return from matchsym to ProcCall
1185314164 {
1185414165 // copy mutable arguments back from call to matchsym
1185514166 stack[base + 13]/*lookahead*/ = stack[base + 44LLU];
1185614167 if(/*typename*/0 != ((uint64_t *)(stack[base + 38]/*expected*/))[0])
1185714168 {
11858- label = 763LLU; // jump to alternative
14169+ label = 921LLU; // jump to alternative
1185914170 break;
1186014171 }
1186114172
@@ -11864,7 +14175,7 @@
1186414175 // case
1186514176 // call equ from ProcCall
1186614177 stack[base + 41LLU] = base;
11867- stack[base + 42LLU] = 764LLU;
14178+ stack[base + 42LLU] = 922LLU;
1186814179 // arguments for call to equ
1186914180 stack[base + 44LLU] = stack[base + 40]/*name*/;
1187014181 stack[base + 45LLU] = 881834713755418624LLU;
@@ -11873,7 +14184,7 @@
1187314184 label = 18446744073709551600LLU; // equ
1187414185 break;
1187514186 }
11876- case 764LLU: // return from equ to ProcCall
14187+ case 922LLU: // return from equ to ProcCall
1187714188 {
1187814189 // copy mutable arguments back from call to equ
1187914190 // copy back results provided by call to equ
@@ -11880,7 +14191,7 @@
1188014191 stack[base + 17] = stack[base + 43LLU];
1188114192 if(!stack[base + 17]/*isequal*/)
1188214193 {
11883- label = 765LLU; // jump to alternative
14194+ label = 923LLU; // jump to alternative
1188414195 break;
1188514196 }
1188614197
@@ -11887,7 +14198,7 @@
1188714198 // consequent
1188814199 if(!stack[base + 37]/*mutable*/)
1188914200 {
11890- label = 767LLU; // jump to alternative
14201+ label = 925LLU; // jump to alternative
1189114202 break;
1189214203 }
1189314204
@@ -11895,7 +14206,7 @@
1189514206 fprintf(stderr, "%s", "in function ");
1189614207 // call reportid from ProcCall
1189714208 stack[base + 41LLU] = base;
11898- stack[base + 42LLU] = 769LLU;
14209+ stack[base + 42LLU] = 927LLU;
1189914210 // arguments for call to reportid
1190014211 stack[base + 43LLU] = stack[base + 7]/*fnid*/;
1190114212 // set stack-base & callee-address
@@ -11903,13 +14214,13 @@
1190314214 label = 18446744073709551586LLU; // reportid
1190414215 break;
1190514216 }
11906- case 769LLU: // return from reportid to ProcCall
14217+ case 927LLU: // return from reportid to ProcCall
1190714218 {
1190814219 // copy mutable arguments back from call to reportid
1190914220 fprintf(stderr, "%s", ", call to ");
1191014221 // call reportid from ProcCall
1191114222 stack[base + 41LLU] = base;
11912- stack[base + 42LLU] = 770LLU;
14223+ stack[base + 42LLU] = 928LLU;
1191314224 // arguments for call to reportid
1191414225 stack[base + 43LLU] = stack[base + 23]/*ceid*/;
1191514226 // set stack-base & callee-address
@@ -11917,7 +14228,7 @@
1191714228 label = 18446744073709551586LLU; // reportid
1191814229 break;
1191914230 }
11920- case 770LLU: // return from reportid to ProcCall
14231+ case 928LLU: // return from reportid to ProcCall
1192114232 {
1192214233 // copy mutable arguments back from call to reportid
1192314234 fprintf(stderr, "%s", ": can't put constant argument u64 getbyte() into mutable parameter ");
@@ -11931,7 +14242,7 @@
1193114242 // call reporttype from ProcCall
1193214243 newstack[0] = (uint64_t)stack; // backup stack location
1193314244 newstack[1] = base;
11934- newstack[2] = 771LLU;
14245+ newstack[2] = 929LLU;
1193514246 // arguments for call to reporttype
1193614247 newstack[3LLU] = stack[base + 38]/*expected*/;
1193714248 stack = newstack;
@@ -11940,7 +14251,7 @@
1194014251 label = 159LLU; // reporttype
1194114252 break;
1194214253 }
11943- case 771LLU: // return from reporttype to ProcCall
14254+ case 929LLU: // return from reporttype to ProcCall
1194414255 {
1194514256 uint64_t *oldstack = (uint64_t *)stack[0];
1194614257 // copy mutable arguments back from call to reporttype
@@ -11953,7 +14264,7 @@
1195314264 stack = oldstack;
1195414265 // call reportid from ProcCall
1195514266 stack[base + 41LLU] = base;
11956- stack[base + 42LLU] = 772LLU;
14267+ stack[base + 42LLU] = 930LLU;
1195714268 // arguments for call to reportid
1195814269 stack[base + 43LLU] = stack[base + 39]/*paramname*/;
1195914270 // set stack-base & callee-address
@@ -11961,21 +14272,21 @@
1196114272 label = 18446744073709551586LLU; // reportid
1196214273 break;
1196314274 }
11964- case 772LLU: // return from reportid to ProcCall
14275+ case 930LLU: // return from reportid to ProcCall
1196514276 {
1196614277 // copy mutable arguments back from call to reportid
1196714278 fprintf(stderr, "%s", "\n");
1196814279 exit(-1);
11969- label = 768LLU; // consequent complete
14280+ label = 926LLU; // consequent complete
1197014281 break;
1197114282 }
11972- case 767LLU: // alternative
14283+ case 925LLU: // alternative
1197314284 {
1197414285 stack[base + 32]/*csubstruct*/ = 1;
1197514286 printf("%s", "\n newstack[");
1197614287 // call printnr from ProcCall
1197714288 stack[base + 41LLU] = base;
11978- stack[base + 42LLU] = 773LLU;
14289+ stack[base + 42LLU] = 931LLU;
1197914290 // arguments for call to printnr
1198014291 stack[base + 43LLU] = stack[base + 28]/*sum*/;
1198114292 // set stack-base & callee-address
@@ -11983,24 +14294,24 @@
1198314294 label = 18446744073709551590LLU; // printnr
1198414295 break;
1198514296 }
11986- case 773LLU: // return from printnr to ProcCall
14297+ case 931LLU: // return from printnr to ProcCall
1198714298 {
1198814299 // copy mutable arguments back from call to printnr
1198914300 printf("%s", "LLU] = getchar();");
11990- label = 768LLU; // alternative complete
14301+ label = 926LLU; // alternative complete
1199114302 break;
1199214303 }
11993- case 768LLU: // completed if-then-else
14304+ case 926LLU: // completed if-then-else
1199414305 {
11995- label = 766LLU; // consequent complete
14306+ label = 924LLU; // consequent complete
1199614307 break;
1199714308 }
11998- case 765LLU: // alternative
14309+ case 923LLU: // alternative
1199914310 {
1200014311 fprintf(stderr, "%s", "in function ");
1200114312 // call reportid from ProcCall
1200214313 stack[base + 41LLU] = base;
12003- stack[base + 42LLU] = 774LLU;
14314+ stack[base + 42LLU] = 932LLU;
1200414315 // arguments for call to reportid
1200514316 stack[base + 43LLU] = stack[base + 7]/*fnid*/;
1200614317 // set stack-base & callee-address
@@ -12008,13 +14319,13 @@
1200814319 label = 18446744073709551586LLU; // reportid
1200914320 break;
1201014321 }
12011- case 774LLU: // return from reportid to ProcCall
14322+ case 932LLU: // return from reportid to ProcCall
1201214323 {
1201314324 // copy mutable arguments back from call to reportid
1201414325 fprintf(stderr, "%s", " recursive call to ");
1201514326 // call reportid from ProcCall
1201614327 stack[base + 41LLU] = base;
12017- stack[base + 42LLU] = 775LLU;
14328+ stack[base + 42LLU] = 933LLU;
1201814329 // arguments for call to reportid
1201914330 stack[base + 43LLU] = stack[base + 23]/*ceid*/;
1202014331 // set stack-base & callee-address
@@ -12022,13 +14333,13 @@
1202214333 label = 18446744073709551586LLU; // reportid
1202314334 break;
1202414335 }
12025- case 775LLU: // return from reportid to ProcCall
14336+ case 933LLU: // return from reportid to ProcCall
1202614337 {
1202714338 // copy mutable arguments back from call to reportid
1202814339 fprintf(stderr, "%s", " at position ");
1202914340 // call reportnr from ProcCall
1203014341 stack[base + 41LLU] = base;
12031- stack[base + 42LLU] = 776LLU;
14342+ stack[base + 42LLU] = 934LLU;
1203214343 // arguments for call to reportnr
1203314344 stack[base + 43LLU] = stack[base + 30]/*index*/;
1203414345 // set stack-base & callee-address
@@ -12036,7 +14347,7 @@
1203614347 label = 18446744073709551589LLU; // reportnr
1203714348 break;
1203814349 }
12039- case 776LLU: // return from reportnr to ProcCall
14350+ case 934LLU: // return from reportnr to ProcCall
1204014351 {
1204114352 // copy mutable arguments back from call to reportnr
1204214353 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -12051,7 +14362,7 @@
1205114362 // call reporttype from ProcCall
1205214363 newstack[0] = (uint64_t)stack; // backup stack location
1205314364 newstack[1] = base;
12054- newstack[2] = 777LLU;
14365+ newstack[2] = 935LLU;
1205514366 // arguments for call to reporttype
1205614367 newstack[3LLU] = stack[base + 38]/*expected*/;
1205714368 stack = newstack;
@@ -12060,7 +14371,7 @@
1206014371 label = 159LLU; // reporttype
1206114372 break;
1206214373 }
12063- case 777LLU: // return from reporttype to ProcCall
14374+ case 935LLU: // return from reporttype to ProcCall
1206414375 {
1206514376 uint64_t *oldstack = (uint64_t *)stack[0];
1206614377 // copy mutable arguments back from call to reporttype
@@ -12073,22 +14384,22 @@
1207314384 stack = oldstack;
1207414385 fprintf(stderr, "%s", "\n");
1207514386 exit(-1);
12076- label = 766LLU; // alternative complete
14387+ label = 924LLU; // alternative complete
1207714388 break;
1207814389 }
12079- case 766LLU: // completed if-then-else
14390+ case 924LLU: // completed if-then-else
1208014391 {
1208114392 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
12082- label = 762LLU; // case complete
14393+ label = 920LLU; // case complete
1208314394 break;
1208414395 }
12085- case 763LLU: // try next case
14396+ case 921LLU: // try next case
1208614397 {
1208714398 // default
1208814399 fprintf(stderr, "%s", "in function ");
1208914400 // call reportid from ProcCall
1209014401 stack[base + 40LLU] = base;
12091- stack[base + 41LLU] = 778LLU;
14402+ stack[base + 41LLU] = 936LLU;
1209214403 // arguments for call to reportid
1209314404 stack[base + 42LLU] = stack[base + 7]/*fnid*/;
1209414405 // set stack-base & callee-address
@@ -12096,13 +14407,13 @@
1209614407 label = 18446744073709551586LLU; // reportid
1209714408 break;
1209814409 }
12099- case 778LLU: // return from reportid to ProcCall
14410+ case 936LLU: // return from reportid to ProcCall
1210014411 {
1210114412 // copy mutable arguments back from call to reportid
1210214413 fprintf(stderr, "%s", " recursive call to ");
1210314414 // call reportid from ProcCall
1210414415 stack[base + 40LLU] = base;
12105- stack[base + 41LLU] = 779LLU;
14416+ stack[base + 41LLU] = 937LLU;
1210614417 // arguments for call to reportid
1210714418 stack[base + 42LLU] = stack[base + 23]/*ceid*/;
1210814419 // set stack-base & callee-address
@@ -12110,13 +14421,13 @@
1211014421 label = 18446744073709551586LLU; // reportid
1211114422 break;
1211214423 }
12113- case 779LLU: // return from reportid to ProcCall
14424+ case 937LLU: // return from reportid to ProcCall
1211414425 {
1211514426 // copy mutable arguments back from call to reportid
1211614427 fprintf(stderr, "%s", " at position ");
1211714428 // call reportnr from ProcCall
1211814429 stack[base + 40LLU] = base;
12119- stack[base + 41LLU] = 780LLU;
14430+ stack[base + 41LLU] = 938LLU;
1212014431 // arguments for call to reportnr
1212114432 stack[base + 42LLU] = stack[base + 30]/*index*/;
1212214433 // set stack-base & callee-address
@@ -12124,7 +14435,7 @@
1212414435 label = 18446744073709551589LLU; // reportnr
1212514436 break;
1212614437 }
12127- case 780LLU: // return from reportnr to ProcCall
14438+ case 938LLU: // return from reportnr to ProcCall
1212814439 {
1212914440 // copy mutable arguments back from call to reportnr
1213014441 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -12139,7 +14450,7 @@
1213914450 // call reporttype from ProcCall
1214014451 newstack[0] = (uint64_t)stack; // backup stack location
1214114452 newstack[1] = base;
12142- newstack[2] = 781LLU;
14453+ newstack[2] = 939LLU;
1214314454 // arguments for call to reporttype
1214414455 newstack[3LLU] = stack[base + 38]/*expected*/;
1214514456 stack = newstack;
@@ -12148,7 +14459,7 @@
1214814459 label = 159LLU; // reporttype
1214914460 break;
1215014461 }
12151- case 781LLU: // return from reporttype to ProcCall
14462+ case 939LLU: // return from reporttype to ProcCall
1215214463 {
1215314464 uint64_t *oldstack = (uint64_t *)stack[0];
1215414465 // copy mutable arguments back from call to reporttype
@@ -12161,19 +14472,19 @@
1216114472 stack = oldstack;
1216214473 fprintf(stderr, "%s", "\n");
1216314474 exit(-1);
12164- label = 762LLU; // default complete
14475+ label = 920LLU; // default complete
1216514476 break;
1216614477 }
12167- case 762LLU: // completed switch
14478+ case 920LLU: // completed switch
1216814479 {
12169- label = 759LLU; // consequent complete
14480+ label = 917LLU; // consequent complete
1217014481 break;
1217114482 }
12172- case 758LLU: // alternative
14483+ case 916LLU: // alternative
1217314484 {
1217414485 // call FindLetNew from ProcCall
1217514486 stack[base + 41LLU] = base;
12176- stack[base + 42LLU] = 782LLU;
14487+ stack[base + 42LLU] = 940LLU;
1217714488 // arguments for call to FindLetNew
1217814489 stack[base + 44LLU] = stack[base + 7]/*fnid*/;
1217914490 stack[base + 45LLU] = stack[base + 15]/*content*/;
@@ -12184,7 +14495,7 @@
1218414495 label = 290LLU; // FindLetNew
1218514496 break;
1218614497 }
12187- case 782LLU: // return from FindLetNew to ProcCall
14498+ case 940LLU: // return from FindLetNew to ProcCall
1218814499 {
1218914500 // copy mutable arguments back from call to FindLetNew
1219014501 // copy back results provided by call to FindLetNew
@@ -12191,7 +14502,7 @@
1219114502 stack[base + 40] = stack[base + 43LLU];
1219214503 if(/*letdef*/0 != ((uint64_t *)(stack[base + 40]/*letdef*/))[0])
1219314504 {
12194- label = 784LLU; // jump to alternative
14505+ label = 942LLU; // jump to alternative
1219514506 break;
1219614507 }
1219714508
@@ -12204,7 +14515,7 @@
1220414515 // case
1220514516 // call or from ProcCall
1220614517 stack[base + 46LLU] = base;
12207- stack[base + 47LLU] = 785LLU;
14518+ stack[base + 47LLU] = 943LLU;
1220814519 // arguments for call to or
1220914520 stack[base + 49LLU] = stack[base + 32]/*csubstruct*/;
1221014521 stack[base + 50LLU] = stack[base + 45]/*substruct*/;
@@ -12213,7 +14524,7 @@
1221314524 label = 18446744073709551611LLU; // or
1221414525 break;
1221514526 }
12216- case 785LLU: // return from or to ProcCall
14527+ case 943LLU: // return from or to ProcCall
1221714528 {
1221814529 // copy mutable arguments back from call to or
1221914530 // copy back results provided by call to or
@@ -12228,7 +14539,7 @@
1222814539 // call equtype from ProcCall
1222914540 newstack[0] = (uint64_t)stack; // backup stack location
1223014541 newstack[1] = base;
12231- newstack[2] = 786LLU;
14542+ newstack[2] = 944LLU;
1223214543 // arguments for call to equtype
1223314544 newstack[4LLU] = stack[base + 41]/*type*/;
1223414545 newstack[5LLU] = stack[base + 38]/*expected*/;
@@ -12238,7 +14549,7 @@
1223814549 label = 170LLU; // equtype
1223914550 break;
1224014551 }
12241- case 786LLU: // return from equtype to ProcCall
14552+ case 944LLU: // return from equtype to ProcCall
1224214553 {
1224314554 uint64_t *oldstack = (uint64_t *)stack[0];
1224414555 // copy mutable arguments back from call to equtype
@@ -12253,20 +14564,20 @@
1225314564 stack = oldstack;
1225414565 if(!stack[base + 17]/*isequal*/)
1225514566 {
12256- label = 787LLU; // jump to alternative
14567+ label = 945LLU; // jump to alternative
1225714568 break;
1225814569 }
1225914570
1226014571 // consequent
12261- label = 788LLU; // consequent complete
14572+ label = 946LLU; // consequent complete
1226214573 break;
1226314574 }
12264- case 787LLU: // alternative
14575+ case 945LLU: // alternative
1226514576 {
1226614577 fprintf(stderr, "%s", "in function ");
1226714578 // call reportid from ProcCall
1226814579 stack[base + 46LLU] = base;
12269- stack[base + 47LLU] = 789LLU;
14580+ stack[base + 47LLU] = 947LLU;
1227014581 // arguments for call to reportid
1227114582 stack[base + 48LLU] = stack[base + 7]/*fnid*/;
1227214583 // set stack-base & callee-address
@@ -12274,13 +14585,13 @@
1227414585 label = 18446744073709551586LLU; // reportid
1227514586 break;
1227614587 }
12277- case 789LLU: // return from reportid to ProcCall
14588+ case 947LLU: // return from reportid to ProcCall
1227814589 {
1227914590 // copy mutable arguments back from call to reportid
1228014591 fprintf(stderr, "%s", " call to ");
1228114592 // call reportid from ProcCall
1228214593 stack[base + 46LLU] = base;
12283- stack[base + 47LLU] = 790LLU;
14594+ stack[base + 47LLU] = 948LLU;
1228414595 // arguments for call to reportid
1228514596 stack[base + 48LLU] = stack[base + 23]/*ceid*/;
1228614597 // set stack-base & callee-address
@@ -12288,13 +14599,13 @@
1228814599 label = 18446744073709551586LLU; // reportid
1228914600 break;
1229014601 }
12291- case 790LLU: // return from reportid to ProcCall
14602+ case 948LLU: // return from reportid to ProcCall
1229214603 {
1229314604 // copy mutable arguments back from call to reportid
1229414605 fprintf(stderr, "%s", " at position ");
1229514606 // call reportnr from ProcCall
1229614607 stack[base + 46LLU] = base;
12297- stack[base + 47LLU] = 791LLU;
14608+ stack[base + 47LLU] = 949LLU;
1229814609 // arguments for call to reportnr
1229914610 stack[base + 48LLU] = stack[base + 30]/*index*/;
1230014611 // set stack-base & callee-address
@@ -12302,7 +14613,7 @@
1230214613 label = 18446744073709551589LLU; // reportnr
1230314614 break;
1230414615 }
12305- case 791LLU: // return from reportnr to ProcCall
14616+ case 949LLU: // return from reportnr to ProcCall
1230614617 {
1230714618 // copy mutable arguments back from call to reportnr
1230814619 fprintf(stderr, "%s", " parameter type ");
@@ -12316,7 +14627,7 @@
1231614627 // call reporttype from ProcCall
1231714628 newstack[0] = (uint64_t)stack; // backup stack location
1231814629 newstack[1] = base;
12319- newstack[2] = 792LLU;
14630+ newstack[2] = 950LLU;
1232014631 // arguments for call to reporttype
1232114632 newstack[3LLU] = stack[base + 38]/*expected*/;
1232214633 stack = newstack;
@@ -12325,7 +14636,7 @@
1232514636 label = 159LLU; // reporttype
1232614637 break;
1232714638 }
12328- case 792LLU: // return from reporttype to ProcCall
14639+ case 950LLU: // return from reporttype to ProcCall
1232914640 {
1233014641 uint64_t *oldstack = (uint64_t *)stack[0];
1233114642 // copy mutable arguments back from call to reporttype
@@ -12347,7 +14658,7 @@
1234714658 // call reporttype from ProcCall
1234814659 newstack[0] = (uint64_t)stack; // backup stack location
1234914660 newstack[1] = base;
12350- newstack[2] = 793LLU;
14661+ newstack[2] = 951LLU;
1235114662 // arguments for call to reporttype
1235214663 newstack[3LLU] = stack[base + 41]/*type*/;
1235314664 stack = newstack;
@@ -12356,7 +14667,7 @@
1235614667 label = 159LLU; // reporttype
1235714668 break;
1235814669 }
12359- case 793LLU: // return from reporttype to ProcCall
14670+ case 951LLU: // return from reporttype to ProcCall
1236014671 {
1236114672 uint64_t *oldstack = (uint64_t *)stack[0];
1236214673 // copy mutable arguments back from call to reporttype
@@ -12369,14 +14680,14 @@
1236914680 stack = oldstack;
1237014681 fprintf(stderr, "%s", "\n");
1237114682 exit(-1);
12372- label = 788LLU; // alternative complete
14683+ label = 946LLU; // alternative complete
1237314684 break;
1237414685 }
12375- case 788LLU: // completed if-then-else
14686+ case 946LLU: // completed if-then-else
1237614687 {
1237714688 if(!stack[base + 37]/*mutable*/)
1237814689 {
12379- label = 794LLU; // jump to alternative
14690+ label = 952LLU; // jump to alternative
1238014691 break;
1238114692 }
1238214693
@@ -12383,7 +14694,7 @@
1238314694 // consequent
1238414695 if(!stack[base + 44]/*mutarg*/)
1238514696 {
12386- label = 796LLU; // jump to alternative
14697+ label = 954LLU; // jump to alternative
1238714698 break;
1238814699 }
1238914700
@@ -12390,7 +14701,7 @@
1239014701 // consequent
1239114702 // call lookidnr from ProcCall
1239214703 stack[base + 47LLU] = base;
12393- stack[base + 48LLU] = 798LLU;
14704+ stack[base + 48LLU] = 956LLU;
1239414705 // arguments for call to lookidnr
1239514706 stack[base + 50LLU] = stack[base + 18]/*copyback*/;
1239614707 stack[base + 51LLU] = stack[base + 15]/*content*/;
@@ -12399,7 +14710,7 @@
1239914710 label = 373LLU; // lookidnr
1240014711 break;
1240114712 }
12402- case 798LLU: // return from lookidnr to ProcCall
14713+ case 956LLU: // return from lookidnr to ProcCall
1240314714 {
1240414715 // copy mutable arguments back from call to lookidnr
1240514716 // copy back results provided by call to lookidnr
@@ -12406,7 +14717,7 @@
1240614717 stack[base + 46] = stack[base + 49LLU];
1240714718 if(!stack[base + 46]/*found*/)
1240814719 {
12409- label = 799LLU; // jump to alternative
14720+ label = 957LLU; // jump to alternative
1241014721 break;
1241114722 }
1241214723
@@ -12414,7 +14725,7 @@
1241414725 fprintf(stderr, "%s", "in function ");
1241514726 // call reportid from ProcCall
1241614727 stack[base + 47LLU] = base;
12417- stack[base + 48LLU] = 801LLU;
14728+ stack[base + 48LLU] = 959LLU;
1241814729 // arguments for call to reportid
1241914730 stack[base + 49LLU] = stack[base + 7]/*fnid*/;
1242014731 // set stack-base & callee-address
@@ -12422,13 +14733,13 @@
1242214733 label = 18446744073709551586LLU; // reportid
1242314734 break;
1242414735 }
12425- case 801LLU: // return from reportid to ProcCall
14736+ case 959LLU: // return from reportid to ProcCall
1242614737 {
1242714738 // copy mutable arguments back from call to reportid
1242814739 fprintf(stderr, "%s", " call to ");
1242914740 // call reportid from ProcCall
1243014741 stack[base + 47LLU] = base;
12431- stack[base + 48LLU] = 802LLU;
14742+ stack[base + 48LLU] = 960LLU;
1243214743 // arguments for call to reportid
1243314744 stack[base + 49LLU] = stack[base + 23]/*ceid*/;
1243414745 // set stack-base & callee-address
@@ -12436,13 +14747,13 @@
1243614747 label = 18446744073709551586LLU; // reportid
1243714748 break;
1243814749 }
12439- case 802LLU: // return from reportid to ProcCall
14750+ case 960LLU: // return from reportid to ProcCall
1244014751 {
1244114752 // copy mutable arguments back from call to reportid
1244214753 fprintf(stderr, "%s", " - duplicate mutable argument ");
1244314754 // call reportid from ProcCall
1244414755 stack[base + 47LLU] = base;
12445- stack[base + 48LLU] = 803LLU;
14756+ stack[base + 48LLU] = 961LLU;
1244614757 // arguments for call to reportid
1244714758 stack[base + 49LLU] = stack[base + 15]/*content*/;
1244814759 // set stack-base & callee-address
@@ -12450,20 +14761,20 @@
1245014761 label = 18446744073709551586LLU; // reportid
1245114762 break;
1245214763 }
12453- case 803LLU: // return from reportid to ProcCall
14764+ case 961LLU: // return from reportid to ProcCall
1245414765 {
1245514766 // copy mutable arguments back from call to reportid
1245614767 fprintf(stderr, "%s", "\n");
1245714768 exit(-1);
12458- label = 800LLU; // consequent complete
14769+ label = 958LLU; // consequent complete
1245914770 break;
1246014771 }
12461- case 799LLU: // alternative
14772+ case 957LLU: // alternative
1246214773 {
12463- label = 800LLU; // alternative complete
14774+ label = 958LLU; // alternative complete
1246414775 break;
1246514776 }
12466- case 800LLU: // completed if-then-else
14777+ case 958LLU: // completed if-then-else
1246714778 {
1246814779 // construct idnr.idnr
1246914780 if(!(stack[base + 46] = (uint64_t)Calloc(2 + 3, sizeof(uint64_t)) + sizeof(uint64_t) * 3))
@@ -12491,15 +14802,15 @@
1249114802 stack[base + 18]/*copyback*/ = (uint64_t)list;
1249214803 MOVE(&list->data, &stack[base + 46]/*idnr*/);
1249314804 }
12494- label = 797LLU; // consequent complete
14805+ label = 955LLU; // consequent complete
1249514806 break;
1249614807 }
12497- case 796LLU: // alternative
14808+ case 954LLU: // alternative
1249814809 {
1249914810 fprintf(stderr, "%s", "in function ");
1250014811 // call reportid from ProcCall
1250114812 stack[base + 46LLU] = base;
12502- stack[base + 47LLU] = 804LLU;
14813+ stack[base + 47LLU] = 962LLU;
1250314814 // arguments for call to reportid
1250414815 stack[base + 48LLU] = stack[base + 7]/*fnid*/;
1250514816 // set stack-base & callee-address
@@ -12507,13 +14818,13 @@
1250714818 label = 18446744073709551586LLU; // reportid
1250814819 break;
1250914820 }
12510- case 804LLU: // return from reportid to ProcCall
14821+ case 962LLU: // return from reportid to ProcCall
1251114822 {
1251214823 // copy mutable arguments back from call to reportid
1251314824 fprintf(stderr, "%s", ", call to ");
1251414825 // call reportid from ProcCall
1251514826 stack[base + 46LLU] = base;
12516- stack[base + 47LLU] = 805LLU;
14827+ stack[base + 47LLU] = 963LLU;
1251714828 // arguments for call to reportid
1251814829 stack[base + 48LLU] = stack[base + 23]/*ceid*/;
1251914830 // set stack-base & callee-address
@@ -12521,7 +14832,7 @@
1252114832 label = 18446744073709551586LLU; // reportid
1252214833 break;
1252314834 }
12524- case 805LLU: // return from reportid to ProcCall
14835+ case 963LLU: // return from reportid to ProcCall
1252514836 {
1252614837 // copy mutable arguments back from call to reportid
1252714838 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -12535,7 +14846,7 @@
1253514846 // call reporttype from ProcCall
1253614847 newstack[0] = (uint64_t)stack; // backup stack location
1253714848 newstack[1] = base;
12538- newstack[2] = 806LLU;
14849+ newstack[2] = 964LLU;
1253914850 // arguments for call to reporttype
1254014851 newstack[3LLU] = stack[base + 41]/*type*/;
1254114852 stack = newstack;
@@ -12544,7 +14855,7 @@
1254414855 label = 159LLU; // reporttype
1254514856 break;
1254614857 }
12547- case 806LLU: // return from reporttype to ProcCall
14858+ case 964LLU: // return from reporttype to ProcCall
1254814859 {
1254914860 uint64_t *oldstack = (uint64_t *)stack[0];
1255014861 // copy mutable arguments back from call to reporttype
@@ -12558,7 +14869,7 @@
1255814869 fprintf(stderr, "%s", " ");
1255914870 // call reportid from ProcCall
1256014871 stack[base + 46LLU] = base;
12561- stack[base + 47LLU] = 807LLU;
14872+ stack[base + 47LLU] = 965LLU;
1256214873 // arguments for call to reportid
1256314874 stack[base + 48LLU] = stack[base + 15]/*content*/;
1256414875 // set stack-base & callee-address
@@ -12566,7 +14877,7 @@
1256614877 label = 18446744073709551586LLU; // reportid
1256714878 break;
1256814879 }
12569- case 807LLU: // return from reportid to ProcCall
14880+ case 965LLU: // return from reportid to ProcCall
1257014881 {
1257114882 // copy mutable arguments back from call to reportid
1257214883 fprintf(stderr, "%s", " into mutable parameter ");
@@ -12580,7 +14891,7 @@
1258014891 // call reporttype from ProcCall
1258114892 newstack[0] = (uint64_t)stack; // backup stack location
1258214893 newstack[1] = base;
12583- newstack[2] = 808LLU;
14894+ newstack[2] = 966LLU;
1258414895 // arguments for call to reporttype
1258514896 newstack[3LLU] = stack[base + 38]/*expected*/;
1258614897 stack = newstack;
@@ -12589,7 +14900,7 @@
1258914900 label = 159LLU; // reporttype
1259014901 break;
1259114902 }
12592- case 808LLU: // return from reporttype to ProcCall
14903+ case 966LLU: // return from reporttype to ProcCall
1259314904 {
1259414905 uint64_t *oldstack = (uint64_t *)stack[0];
1259514906 // copy mutable arguments back from call to reporttype
@@ -12602,7 +14913,7 @@
1260214913 stack = oldstack;
1260314914 // call reportid from ProcCall
1260414915 stack[base + 46LLU] = base;
12605- stack[base + 47LLU] = 809LLU;
14916+ stack[base + 47LLU] = 967LLU;
1260614917 // arguments for call to reportid
1260714918 stack[base + 48LLU] = stack[base + 39]/*paramname*/;
1260814919 // set stack-base & callee-address
@@ -12610,25 +14921,25 @@
1261014921 label = 18446744073709551586LLU; // reportid
1261114922 break;
1261214923 }
12613- case 809LLU: // return from reportid to ProcCall
14924+ case 967LLU: // return from reportid to ProcCall
1261414925 {
1261514926 // copy mutable arguments back from call to reportid
1261614927 fprintf(stderr, "%s", "\n");
1261714928 exit(-1);
12618- label = 797LLU; // alternative complete
14929+ label = 955LLU; // alternative complete
1261914930 break;
1262014931 }
12621- case 797LLU: // completed if-then-else
14932+ case 955LLU: // completed if-then-else
1262214933 {
12623- label = 795LLU; // consequent complete
14934+ label = 953LLU; // consequent complete
1262414935 break;
1262514936 }
12626- case 794LLU: // alternative
14937+ case 952LLU: // alternative
1262714938 {
12628- label = 795LLU; // alternative complete
14939+ label = 953LLU; // alternative complete
1262914940 break;
1263014941 }
12631- case 795LLU: // completed if-then-else
14942+ case 953LLU: // completed if-then-else
1263214943 {
1263314944 ((uint64_t **)(stack[base + 40]))[1][4] = stack[base + 45];
1263414945 ((uint64_t **)(stack[base + 40]))[1][3] = stack[base + 44];
@@ -12635,20 +14946,20 @@
1263514946 ((uint64_t **)(stack[base + 40]))[1][2] = stack[base + 43];
1263614947 ((uint64_t **)(stack[base + 40]))[1][1] = stack[base + 42];
1263714948 ((uint64_t **)(stack[base + 40]))[1][0] = stack[base + 41];
12638- label = 783LLU; // case complete
14949+ label = 941LLU; // case complete
1263914950 break;
1264014951 }
12641- case 784LLU: // try next case
14952+ case 942LLU: // try next case
1264214953 {
1264314954 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1264414955 exit(-1);
1264514956 }
12646- case 783LLU: // completed switch
14957+ case 941LLU: // completed switch
1264714958 {
1264814959 printf("%s", "\n newstack[");
1264914960 // call printnr from ProcCall
1265014961 stack[base + 41LLU] = base;
12651- stack[base + 42LLU] = 810LLU;
14962+ stack[base + 42LLU] = 968LLU;
1265214963 // arguments for call to printnr
1265314964 stack[base + 43LLU] = stack[base + 28]/*sum*/;
1265414965 // set stack-base & callee-address
@@ -12656,13 +14967,13 @@
1265614967 label = 18446744073709551590LLU; // printnr
1265714968 break;
1265814969 }
12659- case 810LLU: // return from printnr to ProcCall
14970+ case 968LLU: // return from printnr to ProcCall
1266014971 {
1266114972 // copy mutable arguments back from call to printnr
1266214973 printf("%s", "LLU] = ");
1266314974 // call emitvar from ProcCall
1266414975 stack[base + 41LLU] = base;
12665- stack[base + 42LLU] = 811LLU;
14976+ stack[base + 42LLU] = 969LLU;
1266614977 // arguments for call to emitvar
1266714978 stack[base + 43LLU] = stack[base + 7]/*fnid*/;
1266814979 stack[base + 44LLU] = stack[base + 15]/*content*/;
@@ -12673,7 +14984,7 @@
1267314984 label = 349LLU; // emitvar
1267414985 break;
1267514986 }
12676- case 811LLU: // return from emitvar to ProcCall
14987+ case 969LLU: // return from emitvar to ProcCall
1267714988 {
1267814989 // copy mutable arguments back from call to emitvar
1267914990 printf("%s", ";");
@@ -12682,7 +14993,7 @@
1268214993 // call ~letdef from ProcCall
1268314994 newstack[0] = (uint64_t)stack; // backup stack location
1268414995 newstack[1] = base;
12685- newstack[2] = 812LLU;
14996+ newstack[2] = 970LLU;
1268614997 stack = newstack;
1268714998 // set stack-base & callee-address
1268814999 base = 3;
@@ -12689,50 +15000,50 @@
1268915000 label = 229LLU; // ~letdef
1269015001 break;
1269115002 }
12692- case 812LLU: // return from ~letdef to ProcCall
15003+ case 970LLU: // return from ~letdef to ProcCall
1269315004 {
1269415005 stack = (uint64_t *)stack[0];
1269515006 // releasing toplevel container
1269615007 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 40] - sizeof(uint64_t) * 3));
1269715008
12698- label = 759LLU; // alternative complete
15009+ label = 917LLU; // alternative complete
1269915010 break;
1270015011 }
12701- case 759LLU: // completed if-then-else
15012+ case 917LLU: // completed if-then-else
1270215013 {
1270315014 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 39];
1270415015 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 38];
12705- label = 755LLU; // case complete
15016+ label = 913LLU; // case complete
1270615017 break;
1270715018 }
12708- case 756LLU: // try next case
15019+ case 914LLU: // try next case
1270915020 {
1271015021 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1271115022 exit(-1);
1271215023 }
12713- case 755LLU: // completed switch
15024+ case 913LLU: // completed switch
1271415025 {
1271515026 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
1271615027 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
12717- label = 753LLU; // case complete
15028+ label = 911LLU; // case complete
1271815029 break;
1271915030 }
12720- case 754LLU: // try next case
15031+ case 912LLU: // try next case
1272115032 {
1272215033 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1272315034 exit(-1);
1272415035 }
12725- case 753LLU: // completed switch
15036+ case 911LLU: // completed switch
1272615037 {
12727- label = 752LLU; // consequent complete
15038+ label = 910LLU; // consequent complete
1272815039 break;
1272915040 }
12730- case 751LLU: // alternative
15041+ case 909LLU: // alternative
1273115042 {
1273215043 fprintf(stderr, "%s", "in function ");
1273315044 // call reportid from ProcCall
1273415045 stack[base + 36LLU] = base;
12735- stack[base + 37LLU] = 813LLU;
15046+ stack[base + 37LLU] = 971LLU;
1273615047 // arguments for call to reportid
1273715048 stack[base + 38LLU] = stack[base + 7]/*fnid*/;
1273815049 // set stack-base & callee-address
@@ -12740,13 +15051,13 @@
1274015051 label = 18446744073709551586LLU; // reportid
1274115052 break;
1274215053 }
12743- case 813LLU: // return from reportid to ProcCall
15054+ case 971LLU: // return from reportid to ProcCall
1274415055 {
1274515056 // copy mutable arguments back from call to reportid
1274615057 fprintf(stderr, "%s", " call to ");
1274715058 // call reportid from ProcCall
1274815059 stack[base + 36LLU] = base;
12749- stack[base + 37LLU] = 814LLU;
15060+ stack[base + 37LLU] = 972LLU;
1275015061 // arguments for call to reportid
1275115062 stack[base + 38LLU] = stack[base + 23]/*ceid*/;
1275215063 // set stack-base & callee-address
@@ -12754,13 +15065,13 @@
1275415065 label = 18446744073709551586LLU; // reportid
1275515066 break;
1275615067 }
12757- case 814LLU: // return from reportid to ProcCall
15068+ case 972LLU: // return from reportid to ProcCall
1275815069 {
1275915070 // copy mutable arguments back from call to reportid
1276015071 fprintf(stderr, "%s", ": expected identifier or constant argument but found ");
1276115072 // call printtoken from ProcCall
1276215073 stack[base + 36LLU] = base;
12763- stack[base + 37LLU] = 815LLU;
15074+ stack[base + 37LLU] = 973LLU;
1276415075 // arguments for call to printtoken
1276515076 stack[base + 38LLU] = stack[base + 14]/*variant*/;
1276615077 stack[base + 39LLU] = stack[base + 15]/*content*/;
@@ -12769,30 +15080,30 @@
1276915080 label = 18446744073709551583LLU; // printtoken
1277015081 break;
1277115082 }
12772- case 815LLU: // return from printtoken to ProcCall
15083+ case 973LLU: // return from printtoken to ProcCall
1277315084 {
1277415085 // copy mutable arguments back from call to printtoken
1277515086 fprintf(stderr, "%s", "\n");
1277615087 exit(-1);
12777- label = 752LLU; // alternative complete
15088+ label = 910LLU; // alternative complete
1277815089 break;
1277915090 }
12780- case 752LLU: // completed if-then-else
15091+ case 910LLU: // completed if-then-else
1278115092 {
12782- label = 727LLU; // alternative complete
15093+ label = 885LLU; // alternative complete
1278315094 break;
1278415095 }
12785- case 727LLU: // completed if-then-else
15096+ case 885LLU: // completed if-then-else
1278615097 {
1278715098 ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34];
12788- label = 714LLU; // repeat
15099+ label = 872LLU; // repeat
1278915100 break;
1279015101 }
12791- case 715LLU: // loop finished
15102+ case 873LLU: // loop finished
1279215103 {
1279315104 // call equ from ProcCall
1279415105 stack[base + 36LLU] = base;
12795- stack[base + 37LLU] = 816LLU;
15106+ stack[base + 37LLU] = 974LLU;
1279615107 // arguments for call to equ
1279715108 stack[base + 39LLU] = stack[base + 7]/*fnid*/;
1279815109 stack[base + 40LLU] = stack[base + 23]/*ceid*/;
@@ -12801,7 +15112,7 @@
1280115112 label = 18446744073709551600LLU; // equ
1280215113 break;
1280315114 }
12804- case 816LLU: // return from equ to ProcCall
15115+ case 974LLU: // return from equ to ProcCall
1280515116 {
1280615117 // copy mutable arguments back from call to equ
1280715118 // copy back results provided by call to equ
@@ -12808,7 +15119,7 @@
1280815119 stack[base + 17] = stack[base + 38LLU];
1280915120 if(!stack[base + 17]/*isequal*/)
1281015121 {
12811- label = 817LLU; // jump to alternative
15122+ label = 975LLU; // jump to alternative
1281215123 break;
1281315124 }
1281415125
@@ -12815,20 +15126,20 @@
1281515126 // consequent
1281615127 if(!stack[base + 32]/*csubstruct*/)
1281715128 {
12818- label = 819LLU; // jump to alternative
15129+ label = 977LLU; // jump to alternative
1281915130 break;
1282015131 }
1282115132
1282215133 // consequent
12823- label = 820LLU; // consequent complete
15134+ label = 978LLU; // consequent complete
1282415135 break;
1282515136 }
12826- case 819LLU: // alternative
15137+ case 977LLU: // alternative
1282715138 {
1282815139 fprintf(stderr, "%s", "in function ");
1282915140 // call reportid from ProcCall
1283015141 stack[base + 36LLU] = base;
12831- stack[base + 37LLU] = 821LLU;
15142+ stack[base + 37LLU] = 979LLU;
1283215143 // arguments for call to reportid
1283315144 stack[base + 38LLU] = stack[base + 7]/*fnid*/;
1283415145 // set stack-base & callee-address
@@ -12836,13 +15147,13 @@
1283615147 label = 18446744073709551586LLU; // reportid
1283715148 break;
1283815149 }
12839- case 821LLU: // return from reportid to ProcCall
15150+ case 979LLU: // return from reportid to ProcCall
1284015151 {
1284115152 // copy mutable arguments back from call to reportid
1284215153 fprintf(stderr, "%s", " recursive call to ");
1284315154 // call reportid from ProcCall
1284415155 stack[base + 36LLU] = base;
12845- stack[base + 37LLU] = 822LLU;
15156+ stack[base + 37LLU] = 980LLU;
1284615157 // arguments for call to reportid
1284715158 stack[base + 38LLU] = stack[base + 23]/*ceid*/;
1284815159 // set stack-base & callee-address
@@ -12850,25 +15161,25 @@
1285015161 label = 18446744073709551586LLU; // reportid
1285115162 break;
1285215163 }
12853- case 822LLU: // return from reportid to ProcCall
15164+ case 980LLU: // return from reportid to ProcCall
1285415165 {
1285515166 // copy mutable arguments back from call to reportid
1285615167 fprintf(stderr, "%s", ": at least one argument must be a substructure (i.e. part of parameter obtained by switch)\n");
1285715168 exit(-1);
12858- label = 820LLU; // alternative complete
15169+ label = 978LLU; // alternative complete
1285915170 break;
1286015171 }
12861- case 820LLU: // completed if-then-else
15172+ case 978LLU: // completed if-then-else
1286215173 {
12863- label = 818LLU; // consequent complete
15174+ label = 976LLU; // consequent complete
1286415175 break;
1286515176 }
12866- case 817LLU: // alternative
15177+ case 975LLU: // alternative
1286715178 {
12868- label = 818LLU; // alternative complete
15179+ label = 976LLU; // alternative complete
1286915180 break;
1287015181 }
12871- case 818LLU: // completed if-then-else
15182+ case 976LLU: // completed if-then-else
1287215183 {
1287315184 printf("%s", "\n stack = newstack;");
1287415185 printf("%s", "\n // set stack-base & callee-address");
@@ -12876,7 +15187,7 @@
1287615187 printf("%s", "\n label = ");
1287715188 // call printnr from ProcCall
1287815189 stack[base + 32LLU] = base;
12879- stack[base + 33LLU] = 823LLU;
15190+ stack[base + 33LLU] = 981LLU;
1288015191 // arguments for call to printnr
1288115192 stack[base + 34LLU] = stack[base + 19]/*celabel*/;
1288215193 // set stack-base & callee-address
@@ -12884,13 +15195,13 @@
1288415195 label = 18446744073709551590LLU; // printnr
1288515196 break;
1288615197 }
12887- case 823LLU: // return from printnr to ProcCall
15198+ case 981LLU: // return from printnr to ProcCall
1288815199 {
1288915200 // copy mutable arguments back from call to printnr
1289015201 printf("%s", "LLU; // ");
1289115202 // call printid from ProcCall
1289215203 stack[base + 32LLU] = base;
12893- stack[base + 33LLU] = 824LLU;
15204+ stack[base + 33LLU] = 982LLU;
1289415205 // arguments for call to printid
1289515206 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1289615207 // set stack-base & callee-address
@@ -12898,7 +15209,7 @@
1289815209 label = 18446744073709551587LLU; // printid
1289915210 break;
1290015211 }
12901- case 824LLU: // return from printid to ProcCall
15212+ case 982LLU: // return from printid to ProcCall
1290215213 {
1290315214 // copy mutable arguments back from call to printid
1290415215 printf("%s", "\n break;");
@@ -12906,7 +15217,7 @@
1290615217 printf("%s", "\n case ");
1290715218 // call printnr from ProcCall
1290815219 stack[base + 32LLU] = base;
12909- stack[base + 33LLU] = 825LLU;
15220+ stack[base + 33LLU] = 983LLU;
1291015221 // arguments for call to printnr
1291115222 stack[base + 34LLU] = stack[base + 16]/*label*/;
1291215223 // set stack-base & callee-address
@@ -12914,13 +15225,13 @@
1291415225 label = 18446744073709551590LLU; // printnr
1291515226 break;
1291615227 }
12917- case 825LLU: // return from printnr to ProcCall
15228+ case 983LLU: // return from printnr to ProcCall
1291815229 {
1291915230 // copy mutable arguments back from call to printnr
1292015231 printf("%s", "LLU: // return from ");
1292115232 // call printid from ProcCall
1292215233 stack[base + 32LLU] = base;
12923- stack[base + 33LLU] = 826LLU;
15234+ stack[base + 33LLU] = 984LLU;
1292415235 // arguments for call to printid
1292515236 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1292615237 // set stack-base & callee-address
@@ -12928,13 +15239,13 @@
1292815239 label = 18446744073709551587LLU; // printid
1292915240 break;
1293015241 }
12931- case 826LLU: // return from printid to ProcCall
15242+ case 984LLU: // return from printid to ProcCall
1293215243 {
1293315244 // copy mutable arguments back from call to printid
1293415245 printf("%s", " to ");
1293515246 // call printid from ProcCall
1293615247 stack[base + 32LLU] = base;
12937- stack[base + 33LLU] = 827LLU;
15248+ stack[base + 33LLU] = 985LLU;
1293815249 // arguments for call to printid
1293915250 stack[base + 34LLU] = stack[base + 7]/*fnid*/;
1294015251 // set stack-base & callee-address
@@ -12942,7 +15253,7 @@
1294215253 label = 18446744073709551587LLU; // printid
1294315254 break;
1294415255 }
12945- case 827LLU: // return from printid to ProcCall
15256+ case 985LLU: // return from printid to ProcCall
1294615257 {
1294715258 // copy mutable arguments back from call to printid
1294815259 printf("%s", "\n {");
@@ -12950,7 +15261,7 @@
1295015261 printf("%s", "\n // copy mutable arguments back from call to ");
1295115262 // call printid from ProcCall
1295215263 stack[base + 32LLU] = base;
12953- stack[base + 33LLU] = 828LLU;
15264+ stack[base + 33LLU] = 986LLU;
1295415265 // arguments for call to printid
1295515266 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1295615267 // set stack-base & callee-address
@@ -12958,17 +15269,17 @@
1295815269 label = 18446744073709551587LLU; // printid
1295915270 break;
1296015271 }
12961- case 828LLU: // return from printid to ProcCall
15272+ case 986LLU: // return from printid to ProcCall
1296215273 {
1296315274 // copy mutable arguments back from call to printid
12964- label = 829LLU; // start to repeat
15275+ label = 987LLU; // start to repeat
1296515276 break;
1296615277 }
12967- case 829LLU: // repeat from here
15278+ case 987LLU: // repeat from here
1296815279 {
1296915280 if(!stack[base + 18])
1297015281 {
12971- label = 830LLU; // break loop
15282+ label = 988LLU; // break loop
1297215283 break;
1297315284 }
1297415285
@@ -12981,7 +15292,7 @@
1298115292 }
1298215293 if(/*idnr*/0 != ((uint64_t *)(stack[base + 32]/*idnr*/))[0])
1298315294 {
12984- label = 832LLU; // jump to alternative
15295+ label = 990LLU; // jump to alternative
1298515296 break;
1298615297 }
1298715298
@@ -12992,7 +15303,7 @@
1299215303 printf("%s", "\n old");
1299315304 // call emitvar from ProcCall
1299415305 stack[base + 35LLU] = base;
12995- stack[base + 36LLU] = 833LLU;
15306+ stack[base + 36LLU] = 991LLU;
1299615307 // arguments for call to emitvar
1299715308 stack[base + 37LLU] = stack[base + 7]/*fnid*/;
1299815309 stack[base + 38LLU] = stack[base + 33]/*content*/;
@@ -13003,13 +15314,13 @@
1300315314 label = 349LLU; // emitvar
1300415315 break;
1300515316 }
13006- case 833LLU: // return from emitvar to ProcCall
15317+ case 991LLU: // return from emitvar to ProcCall
1300715318 {
1300815319 // copy mutable arguments back from call to emitvar
1300915320 printf("%s", " = stack[");
1301015321 // call printnr from ProcCall
1301115322 stack[base + 35LLU] = base;
13012- stack[base + 36LLU] = 834LLU;
15323+ stack[base + 36LLU] = 992LLU;
1301315324 // arguments for call to printnr
1301415325 stack[base + 37LLU] = stack[base + 34]/*sum*/;
1301515326 // set stack-base & callee-address
@@ -13017,21 +15328,21 @@
1301715328 label = 18446744073709551590LLU; // printnr
1301815329 break;
1301915330 }
13020- case 834LLU: // return from printnr to ProcCall
15331+ case 992LLU: // return from printnr to ProcCall
1302115332 {
1302215333 // copy mutable arguments back from call to printnr
1302315334 printf("%s", "LLU];");
1302415335 ((uint64_t **)(stack[base + 32]))[1][1] = stack[base + 34];
1302515336 ((uint64_t **)(stack[base + 32]))[1][0] = stack[base + 33];
13026- label = 831LLU; // case complete
15337+ label = 989LLU; // case complete
1302715338 break;
1302815339 }
13029- case 832LLU: // try next case
15340+ case 990LLU: // try next case
1303015341 {
1303115342 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1303215343 exit(-1);
1303315344 }
13034- case 831LLU: // completed switch
15345+ case 989LLU: // completed switch
1303515346 {
1303615347
1303715348 uint64_t *newstack = (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 3);
@@ -13038,7 +15349,7 @@
1303815349 // call ~idnr from ProcCall
1303915350 newstack[0] = (uint64_t)stack; // backup stack location
1304015351 newstack[1] = base;
13041- newstack[2] = 835LLU;
15352+ newstack[2] = 993LLU;
1304215353 stack = newstack;
1304315354 // set stack-base & callee-address
1304415355 base = 3;
@@ -13045,20 +15356,20 @@
1304515356 label = 371LLU; // ~idnr
1304615357 break;
1304715358 }
13048- case 835LLU: // return from ~idnr to ProcCall
15359+ case 993LLU: // return from ~idnr to ProcCall
1304915360 {
1305015361 stack = (uint64_t *)stack[0];
1305115362 // releasing toplevel container
1305215363 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 3));
1305315364
13054- label = 829LLU; // repeat
15365+ label = 987LLU; // repeat
1305515366 break;
1305615367 }
13057- case 830LLU: // loop finished
15368+ case 988LLU: // loop finished
1305815369 {
1305915370 if(!stack[base + 26]/*cerescount*/)
1306015371 {
13061- label = 836LLU; // jump to alternative
15372+ label = 994LLU; // jump to alternative
1306215373 break;
1306315374 }
1306415375
@@ -13066,7 +15377,7 @@
1306615377 printf("%s", "\n // copy back results provided by call to ");
1306715378 // call printid from ProcCall
1306815379 stack[base + 32LLU] = base;
13069- stack[base + 33LLU] = 838LLU;
15380+ stack[base + 33LLU] = 996LLU;
1307015381 // arguments for call to printid
1307115382 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1307215383 // set stack-base & callee-address
@@ -13074,19 +15385,19 @@
1307415385 label = 18446744073709551587LLU; // printid
1307515386 break;
1307615387 }
13077- case 838LLU: // return from printid to ProcCall
15388+ case 996LLU: // return from printid to ProcCall
1307815389 {
1307915390 // copy mutable arguments back from call to printid
1308015391 stack[base + 29]/*n*/ = stack[base + 26]/*cerescount*/;
1308115392 flippedassign(stack[base + 20]/*cerestypes*/, &stack[base + 32]);
13082- label = 839LLU; // start to repeat
15393+ label = 997LLU; // start to repeat
1308315394 break;
1308415395 }
13085- case 839LLU: // repeat from here
15396+ case 997LLU: // repeat from here
1308615397 {
1308715398 if(!stack[base + 32])
1308815399 {
13089- label = 840LLU; // break loop
15400+ label = 998LLU; // break loop
1309015401 break;
1309115402 }
1309215403
@@ -13096,7 +15407,7 @@
1309615407 stack[base + 32] = (uint64_t)(((const struct listnode *)(stack[base + 32]))->next);
1309715408 // call sub from ProcCall
1309815409 stack[base + 35LLU] = base;
13099- stack[base + 36LLU] = 841LLU;
15410+ stack[base + 36LLU] = 999LLU;
1310015411 // arguments for call to sub
1310115412 stack[base + 38LLU] = stack[base + 26]/*cerescount*/;
1310215413 stack[base + 39LLU] = stack[base + 29]/*n*/;
@@ -13105,7 +15416,7 @@
1310515416 label = 18446744073709551604LLU; // sub
1310615417 break;
1310715418 }
13108- case 841LLU: // return from sub to ProcCall
15419+ case 999LLU: // return from sub to ProcCall
1310915420 {
1311015421 // copy mutable arguments back from call to sub
1311115422 // copy back results provided by call to sub
@@ -13112,7 +15423,7 @@
1311215423 stack[base + 30] = stack[base + 37LLU];
1311315424 // call sub from ProcCall
1311415425 stack[base + 35LLU] = base;
13115- stack[base + 36LLU] = 842LLU;
15426+ stack[base + 36LLU] = 1000LLU;
1311615427 // arguments for call to sub
1311715428 stack[base + 38LLU] = stack[base + 29]/*n*/;
1311815429 stack[base + 39LLU] = 1LLU;
@@ -13121,7 +15432,7 @@
1312115432 label = 18446744073709551604LLU; // sub
1312215433 break;
1312315434 }
13124- case 842LLU: // return from sub to ProcCall
15435+ case 1000LLU: // return from sub to ProcCall
1312515436 {
1312615437 // copy mutable arguments back from call to sub
1312715438 // copy back results provided by call to sub
@@ -13130,7 +15441,7 @@
1313015441 struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/;
1313115442 if(!list)
1313215443 {
13133- label = 843LLU; // jump to alternative
15444+ label = 1001LLU; // jump to alternative
1313415445 break;
1313515446 }
1313615447
@@ -13142,7 +15453,7 @@
1314215453 }
1314315454 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 35]/*typeidx*/))[0])
1314415455 {
13145- label = 846LLU; // jump to alternative
15456+ label = 1004LLU; // jump to alternative
1314615457 break;
1314715458 }
1314815459
@@ -13152,7 +15463,7 @@
1315215463 // case
1315315464 if(/*result*/0 != ((uint64_t *)(stack[base + 33]/*result*/))[0])
1315415465 {
13155- label = 848LLU; // jump to alternative
15466+ label = 1006LLU; // jump to alternative
1315615467 break;
1315715468 }
1315815469
@@ -13170,7 +15481,7 @@
1317015481 // call equtype from ProcCall
1317115482 newstack[0] = (uint64_t)stack; // backup stack location
1317215483 newstack[1] = base;
13173- newstack[2] = 849LLU;
15484+ newstack[2] = 1007LLU;
1317415485 // arguments for call to equtype
1317515486 newstack[4LLU] = stack[base + 36]/*dsttype*/;
1317615487 newstack[5LLU] = stack[base + 38]/*srctype*/;
@@ -13180,7 +15491,7 @@
1318015491 label = 170LLU; // equtype
1318115492 break;
1318215493 }
13183- case 849LLU: // return from equtype to ProcCall
15494+ case 1007LLU: // return from equtype to ProcCall
1318415495 {
1318515496 uint64_t *oldstack = (uint64_t *)stack[0];
1318615497 // copy mutable arguments back from call to equtype
@@ -13195,20 +15506,20 @@
1319515506 stack = oldstack;
1319615507 if(!stack[base + 17]/*isequal*/)
1319715508 {
13198- label = 850LLU; // jump to alternative
15509+ label = 1008LLU; // jump to alternative
1319915510 break;
1320015511 }
1320115512
1320215513 // consequent
13203- label = 851LLU; // consequent complete
15514+ label = 1009LLU; // consequent complete
1320415515 break;
1320515516 }
13206- case 850LLU: // alternative
15517+ case 1008LLU: // alternative
1320715518 {
1320815519 fprintf(stderr, "%s", "in function ");
1320915520 // call reportid from ProcCall
1321015521 stack[base + 40LLU] = base;
13211- stack[base + 41LLU] = 852LLU;
15522+ stack[base + 41LLU] = 1010LLU;
1321215523 // arguments for call to reportid
1321315524 stack[base + 42LLU] = stack[base + 7]/*fnid*/;
1321415525 // set stack-base & callee-address
@@ -13216,13 +15527,13 @@
1321615527 label = 18446744073709551586LLU; // reportid
1321715528 break;
1321815529 }
13219- case 852LLU: // return from reportid to ProcCall
15530+ case 1010LLU: // return from reportid to ProcCall
1322015531 {
1322115532 // copy mutable arguments back from call to reportid
1322215533 fprintf(stderr, "%s", " call to ");
1322315534 // call reportid from ProcCall
1322415535 stack[base + 40LLU] = base;
13225- stack[base + 41LLU] = 853LLU;
15536+ stack[base + 41LLU] = 1011LLU;
1322615537 // arguments for call to reportid
1322715538 stack[base + 42LLU] = stack[base + 23]/*ceid*/;
1322815539 // set stack-base & callee-address
@@ -13230,13 +15541,13 @@
1323015541 label = 18446744073709551586LLU; // reportid
1323115542 break;
1323215543 }
13233- case 853LLU: // return from reportid to ProcCall
15544+ case 1011LLU: // return from reportid to ProcCall
1323415545 {
1323515546 // copy mutable arguments back from call to reportid
1323615547 fprintf(stderr, "%s", " at position ");
1323715548 // call reportnr from ProcCall
1323815549 stack[base + 40LLU] = base;
13239- stack[base + 41LLU] = 854LLU;
15550+ stack[base + 41LLU] = 1012LLU;
1324015551 // arguments for call to reportnr
1324115552 stack[base + 42LLU] = stack[base + 30]/*index*/;
1324215553 // set stack-base & callee-address
@@ -13244,7 +15555,7 @@
1324415555 label = 18446744073709551589LLU; // reportnr
1324515556 break;
1324615557 }
13247- case 854LLU: // return from reportnr to ProcCall
15558+ case 1012LLU: // return from reportnr to ProcCall
1324815559 {
1324915560 // copy mutable arguments back from call to reportnr
1325015561 fprintf(stderr, "%s", " cannot return source of type ");
@@ -13258,7 +15569,7 @@
1325815569 // call reporttype from ProcCall
1325915570 newstack[0] = (uint64_t)stack; // backup stack location
1326015571 newstack[1] = base;
13261- newstack[2] = 855LLU;
15572+ newstack[2] = 1013LLU;
1326215573 // arguments for call to reporttype
1326315574 newstack[3LLU] = stack[base + 38]/*srctype*/;
1326415575 stack = newstack;
@@ -13267,7 +15578,7 @@
1326715578 label = 159LLU; // reporttype
1326815579 break;
1326915580 }
13270- case 855LLU: // return from reporttype to ProcCall
15581+ case 1013LLU: // return from reporttype to ProcCall
1327115582 {
1327215583 uint64_t *oldstack = (uint64_t *)stack[0];
1327315584 // copy mutable arguments back from call to reporttype
@@ -13289,7 +15600,7 @@
1328915600 // call reporttype from ProcCall
1329015601 newstack[0] = (uint64_t)stack; // backup stack location
1329115602 newstack[1] = base;
13292- newstack[2] = 856LLU;
15603+ newstack[2] = 1014LLU;
1329315604 // arguments for call to reporttype
1329415605 newstack[3LLU] = stack[base + 36]/*dsttype*/;
1329515606 stack = newstack;
@@ -13298,7 +15609,7 @@
1329815609 label = 159LLU; // reporttype
1329915610 break;
1330015611 }
13301- case 856LLU: // return from reporttype to ProcCall
15612+ case 1014LLU: // return from reporttype to ProcCall
1330215613 {
1330315614 uint64_t *oldstack = (uint64_t *)stack[0];
1330415615 // copy mutable arguments back from call to reporttype
@@ -13311,15 +15622,15 @@
1331115622 stack = oldstack;
1331215623 fprintf(stderr, "%s", "\n");
1331315624 exit(-1);
13314- label = 851LLU; // alternative complete
15625+ label = 1009LLU; // alternative complete
1331515626 break;
1331615627 }
13317- case 851LLU: // completed if-then-else
15628+ case 1009LLU: // completed if-then-else
1331815629 {
1331915630 stack[base + 28]/*sum*/ = 0;
1332015631 // call add from ProcCall
1332115632 stack[base + 40LLU] = base;
13322- stack[base + 41LLU] = 857LLU;
15633+ stack[base + 41LLU] = 1015LLU;
1332315634 // arguments for call to add
1332415635 stack[base + 43LLU] = 3LLU;
1332515636 stack[base + 44LLU] = stack[base + 28]/*sum*/;
@@ -13328,7 +15639,7 @@
1332815639 label = 18446744073709551605LLU; // add
1332915640 break;
1333015641 }
13331- case 857LLU: // return from add to ProcCall
15642+ case 1015LLU: // return from add to ProcCall
1333215643 {
1333315644 // copy mutable arguments back from call to add
1333415645 // copy back results provided by call to add
@@ -13335,7 +15646,7 @@
1333515646 stack[base + 28] = stack[base + 42LLU];
1333615647 // call add from ProcCall
1333715648 stack[base + 40LLU] = base;
13338- stack[base + 41LLU] = 858LLU;
15649+ stack[base + 41LLU] = 1016LLU;
1333915650 // arguments for call to add
1334015651 stack[base + 43LLU] = stack[base + 30]/*index*/;
1334115652 stack[base + 44LLU] = stack[base + 28]/*sum*/;
@@ -13344,7 +15655,7 @@
1334415655 label = 18446744073709551605LLU; // add
1334515656 break;
1334615657 }
13347- case 858LLU: // return from add to ProcCall
15658+ case 1016LLU: // return from add to ProcCall
1334815659 {
1334915660 // copy mutable arguments back from call to add
1335015661 // copy back results provided by call to add
@@ -13352,7 +15663,7 @@
1335215663 printf("%s", "\n old");
1335315664 // call emitvaridx from ProcCall
1335415665 stack[base + 40LLU] = base;
13355- stack[base + 41LLU] = 859LLU;
15666+ stack[base + 41LLU] = 1017LLU;
1335615667 // arguments for call to emitvaridx
1335715668 stack[base + 42LLU] = stack[base + 37]/*INDEX*/;
1335815669 // set stack-base & callee-address
@@ -13360,13 +15671,13 @@
1336015671 label = 347LLU; // emitvaridx
1336115672 break;
1336215673 }
13363- case 859LLU: // return from emitvaridx to ProcCall
15674+ case 1017LLU: // return from emitvaridx to ProcCall
1336415675 {
1336515676 // copy mutable arguments back from call to emitvaridx
1336615677 printf("%s", " = stack[");
1336715678 // call printnr from ProcCall
1336815679 stack[base + 40LLU] = base;
13369- stack[base + 41LLU] = 860LLU;
15680+ stack[base + 41LLU] = 1018LLU;
1337015681 // arguments for call to printnr
1337115682 stack[base + 42LLU] = stack[base + 28]/*sum*/;
1337215683 // set stack-base & callee-address
@@ -13374,33 +15685,33 @@
1337415685 label = 18446744073709551590LLU; // printnr
1337515686 break;
1337615687 }
13377- case 860LLU: // return from printnr to ProcCall
15688+ case 1018LLU: // return from printnr to ProcCall
1337815689 {
1337915690 // copy mutable arguments back from call to printnr
1338015691 printf("%s", "LLU];");
1338115692 ((uint64_t **)(stack[base + 33]))[1][1] = stack[base + 39];
1338215693 ((uint64_t **)(stack[base + 33]))[1][0] = stack[base + 38];
13383- label = 847LLU; // case complete
15694+ label = 1005LLU; // case complete
1338415695 break;
1338515696 }
13386- case 848LLU: // try next case
15697+ case 1006LLU: // try next case
1338715698 {
1338815699 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1338915700 exit(-1);
1339015701 }
13391- case 847LLU: // completed switch
15702+ case 1005LLU: // completed switch
1339215703 {
1339315704 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
1339415705 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
13395- label = 845LLU; // case complete
15706+ label = 1003LLU; // case complete
1339615707 break;
1339715708 }
13398- case 846LLU: // try next case
15709+ case 1004LLU: // try next case
1339915710 {
1340015711 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1340115712 exit(-1);
1340215713 }
13403- case 845LLU: // completed switch
15714+ case 1003LLU: // completed switch
1340415715 {
1340515716
1340615717 uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 3);
@@ -13407,7 +15718,7 @@
1340715718 // call ~typeidx from ProcCall
1340815719 newstack[0] = (uint64_t)stack; // backup stack location
1340915720 newstack[1] = base;
13410- newstack[2] = 861LLU;
15721+ newstack[2] = 1019LLU;
1341115722 stack = newstack;
1341215723 // set stack-base & callee-address
1341315724 base = 3;
@@ -13414,21 +15725,21 @@
1341415725 label = 188LLU; // ~typeidx
1341515726 break;
1341615727 }
13417- case 861LLU: // return from ~typeidx to ProcCall
15728+ case 1019LLU: // return from ~typeidx to ProcCall
1341815729 {
1341915730 stack = (uint64_t *)stack[0];
1342015731 // releasing toplevel container
1342115732 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 3));
1342215733
13423- label = 844LLU; // consequent complete
15734+ label = 1002LLU; // consequent complete
1342415735 break;
1342515736 }
13426- case 843LLU: // alternative
15737+ case 1001LLU: // alternative
1342715738 {
1342815739 fprintf(stderr, "%s", "in function ");
1342915740 // call reportid from ProcCall
1343015741 stack[base + 36LLU] = base;
13431- stack[base + 37LLU] = 862LLU;
15742+ stack[base + 37LLU] = 1020LLU;
1343215743 // arguments for call to reportid
1343315744 stack[base + 38LLU] = stack[base + 7]/*fnid*/;
1343415745 // set stack-base & callee-address
@@ -13436,13 +15747,13 @@
1343615747 label = 18446744073709551586LLU; // reportid
1343715748 break;
1343815749 }
13439- case 862LLU: // return from reportid to ProcCall
15750+ case 1020LLU: // return from reportid to ProcCall
1344015751 {
1344115752 // copy mutable arguments back from call to reportid
1344215753 fprintf(stderr, "%s", " call to ");
1344315754 // call reportid from ProcCall
1344415755 stack[base + 36LLU] = base;
13445- stack[base + 37LLU] = 863LLU;
15756+ stack[base + 37LLU] = 1021LLU;
1344615757 // arguments for call to reportid
1344715758 stack[base + 38LLU] = stack[base + 23]/*ceid*/;
1344815759 // set stack-base & callee-address
@@ -13450,13 +15761,13 @@
1345015761 label = 18446744073709551586LLU; // reportid
1345115762 break;
1345215763 }
13453- case 863LLU: // return from reportid to ProcCall
15764+ case 1021LLU: // return from reportid to ProcCall
1345415765 {
1345515766 // copy mutable arguments back from call to reportid
1345615767 fprintf(stderr, "%s", " at position ");
1345715768 // call reportnr from ProcCall
1345815769 stack[base + 36LLU] = base;
13459- stack[base + 37LLU] = 864LLU;
15770+ stack[base + 37LLU] = 1022LLU;
1346015771 // arguments for call to reportnr
1346115772 stack[base + 38LLU] = stack[base + 30]/*index*/;
1346215773 // set stack-base & callee-address
@@ -13464,37 +15775,37 @@
1346415775 label = 18446744073709551589LLU; // reportnr
1346515776 break;
1346615777 }
13467- case 864LLU: // return from reportnr to ProcCall
15778+ case 1022LLU: // return from reportnr to ProcCall
1346815779 {
1346915780 // copy mutable arguments back from call to reportnr
1347015781 fprintf(stderr, "%s", " not enough destination-variables for results");
1347115782 fprintf(stderr, "%s", "\n");
1347215783 exit(-1);
13473- label = 844LLU; // alternative complete
15784+ label = 1002LLU; // alternative complete
1347415785 break;
1347515786 }
13476- case 844LLU: // completed if-then-else
15787+ case 1002LLU: // completed if-then-else
1347715788 {
1347815789 ((struct listnode *)(stack[base + 34]/*previous*/))->data = stack[base + 33];
13479- label = 839LLU; // repeat
15790+ label = 997LLU; // repeat
1348015791 break;
1348115792 }
13482- case 840LLU: // loop finished
15793+ case 998LLU: // loop finished
1348315794 {
13484- label = 837LLU; // consequent complete
15795+ label = 995LLU; // consequent complete
1348515796 break;
1348615797 }
13487- case 836LLU: // alternative
15798+ case 994LLU: // alternative
1348815799 {
13489- label = 837LLU; // alternative complete
15800+ label = 995LLU; // alternative complete
1349015801 break;
1349115802 }
13492- case 837LLU: // completed if-then-else
15803+ case 995LLU: // completed if-then-else
1349315804 {
1349415805 printf("%s", "\n if(stack[");
1349515806 // call printnr from ProcCall
1349615807 stack[base + 32LLU] = base;
13497- stack[base + 33LLU] = 865LLU;
15808+ stack[base + 33LLU] = 1023LLU;
1349815809 // arguments for call to printnr
1349915810 stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
1350015811 // set stack-base & callee-address
@@ -13502,7 +15813,7 @@
1350215813 label = 18446744073709551590LLU; // printnr
1350315814 break;
1350415815 }
13505- case 865LLU: // return from printnr to ProcCall
15816+ case 1023LLU: // return from printnr to ProcCall
1350615817 {
1350715818 // copy mutable arguments back from call to printnr
1350815819 printf("%s", "LLU] != 9876543210LLU)");
@@ -13510,7 +15821,7 @@
1351015821 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
1351115822 // call printid from ProcCall
1351215823 stack[base + 32LLU] = base;
13513- stack[base + 33LLU] = 866LLU;
15824+ stack[base + 33LLU] = 1024LLU;
1351415825 // arguments for call to printid
1351515826 stack[base + 34LLU] = stack[base + 23]/*ceid*/;
1351615827 // set stack-base & callee-address
@@ -13518,7 +15829,7 @@
1351815829 label = 18446744073709551587LLU; // printid
1351915830 break;
1352015831 }
13521- case 866LLU: // return from printid to ProcCall
15832+ case 1024LLU: // return from printid to ProcCall
1352215833 {
1352315834 // copy mutable arguments back from call to printid
1352415835 printf("%s", ")!\");");
@@ -13527,7 +15838,7 @@
1352715838 printf("%s", "\n Free(");
1352815839 // call printnr from ProcCall
1352915840 stack[base + 32LLU] = base;
13530- stack[base + 33LLU] = 867LLU;
15841+ stack[base + 33LLU] = 1025LLU;
1353115842 // arguments for call to printnr
1353215843 stack[base + 34LLU] = stack[base + 31]/*recsztotal*/;
1353315844 // set stack-base & callee-address
@@ -13535,20 +15846,20 @@
1353515846 label = 18446744073709551590LLU; // printnr
1353615847 break;
1353715848 }
13538- case 867LLU: // return from printnr to ProcCall
15849+ case 1025LLU: // return from printnr to ProcCall
1353915850 {
1354015851 // copy mutable arguments back from call to printnr
1354115852 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
1354215853 printf("%s", "\n stack = oldstack;");
13543- label = 700LLU; // consequent complete
15854+ label = 858LLU; // consequent complete
1354415855 break;
1354515856 }
13546- case 699LLU: // alternative
15857+ case 857LLU: // alternative
1354715858 {
1354815859 printf("%s", "\n // call ");
1354915860 // call printid from ProcCall
1355015861 stack[base + 31LLU] = base;
13551- stack[base + 32LLU] = 868LLU;
15862+ stack[base + 32LLU] = 1026LLU;
1355215863 // arguments for call to printid
1355315864 stack[base + 33LLU] = stack[base + 23]/*ceid*/;
1355415865 // set stack-base & callee-address
@@ -13556,13 +15867,13 @@
1355615867 label = 18446744073709551587LLU; // printid
1355715868 break;
1355815869 }
13559- case 868LLU: // return from printid to ProcCall
15870+ case 1026LLU: // return from printid to ProcCall
1356015871 {
1356115872 // copy mutable arguments back from call to printid
1356215873 printf("%s", " from ");
1356315874 // call printid from ProcCall
1356415875 stack[base + 31LLU] = base;
13565- stack[base + 32LLU] = 869LLU;
15876+ stack[base + 32LLU] = 1027LLU;
1356615877 // arguments for call to printid
1356715878 stack[base + 33LLU] = stack[base + 7]/*fnid*/;
1356815879 // set stack-base & callee-address
@@ -13570,13 +15881,13 @@
1357015881 label = 18446744073709551587LLU; // printid
1357115882 break;
1357215883 }
13573- case 869LLU: // return from printid to ProcCall
15884+ case 1027LLU: // return from printid to ProcCall
1357415885 {
1357515886 // copy mutable arguments back from call to printid
1357615887 stack[base + 28]/*sum*/ = 0;
1357715888 // call add from ProcCall
1357815889 stack[base + 31LLU] = base;
13579- stack[base + 32LLU] = 870LLU;
15890+ stack[base + 32LLU] = 1028LLU;
1358015891 // arguments for call to add
1358115892 stack[base + 34LLU] = stack[base + 4]/*offset*/;
1358215893 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13585,7 +15896,7 @@
1358515896 label = 18446744073709551605LLU; // add
1358615897 break;
1358715898 }
13588- case 870LLU: // return from add to ProcCall
15899+ case 1028LLU: // return from add to ProcCall
1358915900 {
1359015901 // copy mutable arguments back from call to add
1359115902 // copy back results provided by call to add
@@ -13592,7 +15903,7 @@
1359215903 stack[base + 28] = stack[base + 33LLU];
1359315904 // call add from ProcCall
1359415905 stack[base + 31LLU] = base;
13595- stack[base + 32LLU] = 871LLU;
15906+ stack[base + 32LLU] = 1029LLU;
1359615907 // arguments for call to add
1359715908 stack[base + 34LLU] = stack[base + 9]/*fnrescount*/;
1359815909 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13601,7 +15912,7 @@
1360115912 label = 18446744073709551605LLU; // add
1360215913 break;
1360315914 }
13604- case 871LLU: // return from add to ProcCall
15915+ case 1029LLU: // return from add to ProcCall
1360515916 {
1360615917 // copy mutable arguments back from call to add
1360715918 // copy back results provided by call to add
@@ -13608,7 +15919,7 @@
1360815919 stack[base + 28] = stack[base + 33LLU];
1360915920 // call add from ProcCall
1361015921 stack[base + 31LLU] = base;
13611- stack[base + 32LLU] = 872LLU;
15922+ stack[base + 32LLU] = 1030LLU;
1361215923 // arguments for call to add
1361315924 stack[base + 34LLU] = stack[base + 10]/*fnargcount*/;
1361415925 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13617,7 +15928,7 @@
1361715928 label = 18446744073709551605LLU; // add
1361815929 break;
1361915930 }
13620- case 872LLU: // return from add to ProcCall
15931+ case 1030LLU: // return from add to ProcCall
1362115932 {
1362215933 // copy mutable arguments back from call to add
1362315934 // copy back results provided by call to add
@@ -13624,7 +15935,7 @@
1362415935 stack[base + 28] = stack[base + 33LLU];
1362515936 // call add from ProcCall
1362615937 stack[base + 31LLU] = base;
13627- stack[base + 32LLU] = 873LLU;
15938+ stack[base + 32LLU] = 1031LLU;
1362815939 // arguments for call to add
1362915940 stack[base + 34LLU] = 0LLU;
1363015941 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13633,7 +15944,7 @@
1363315944 label = 18446744073709551605LLU; // add
1363415945 break;
1363515946 }
13636- case 873LLU: // return from add to ProcCall
15947+ case 1031LLU: // return from add to ProcCall
1363715948 {
1363815949 // copy mutable arguments back from call to add
1363915950 // copy back results provided by call to add
@@ -13641,7 +15952,7 @@
1364115952 printf("%s", "\n stack[base + ");
1364215953 // call printnr from ProcCall
1364315954 stack[base + 31LLU] = base;
13644- stack[base + 32LLU] = 874LLU;
15955+ stack[base + 32LLU] = 1032LLU;
1364515956 // arguments for call to printnr
1364615957 stack[base + 33LLU] = stack[base + 28]/*sum*/;
1364715958 // set stack-base & callee-address
@@ -13649,7 +15960,7 @@
1364915960 label = 18446744073709551590LLU; // printnr
1365015961 break;
1365115962 }
13652- case 874LLU: // return from printnr to ProcCall
15963+ case 1032LLU: // return from printnr to ProcCall
1365315964 {
1365415965 // copy mutable arguments back from call to printnr
1365515966 printf("%s", "LLU] = base;");
@@ -13656,7 +15967,7 @@
1365615967 stack[base + 28]/*sum*/ = 0;
1365715968 // call add from ProcCall
1365815969 stack[base + 31LLU] = base;
13659- stack[base + 32LLU] = 875LLU;
15970+ stack[base + 32LLU] = 1033LLU;
1366015971 // arguments for call to add
1366115972 stack[base + 34LLU] = stack[base + 4]/*offset*/;
1366215973 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13665,7 +15976,7 @@
1366515976 label = 18446744073709551605LLU; // add
1366615977 break;
1366715978 }
13668- case 875LLU: // return from add to ProcCall
15979+ case 1033LLU: // return from add to ProcCall
1366915980 {
1367015981 // copy mutable arguments back from call to add
1367115982 // copy back results provided by call to add
@@ -13672,7 +15983,7 @@
1367215983 stack[base + 28] = stack[base + 33LLU];
1367315984 // call add from ProcCall
1367415985 stack[base + 31LLU] = base;
13675- stack[base + 32LLU] = 876LLU;
15986+ stack[base + 32LLU] = 1034LLU;
1367615987 // arguments for call to add
1367715988 stack[base + 34LLU] = stack[base + 9]/*fnrescount*/;
1367815989 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13681,7 +15992,7 @@
1368115992 label = 18446744073709551605LLU; // add
1368215993 break;
1368315994 }
13684- case 876LLU: // return from add to ProcCall
15995+ case 1034LLU: // return from add to ProcCall
1368515996 {
1368615997 // copy mutable arguments back from call to add
1368715998 // copy back results provided by call to add
@@ -13688,7 +15999,7 @@
1368815999 stack[base + 28] = stack[base + 33LLU];
1368916000 // call add from ProcCall
1369016001 stack[base + 31LLU] = base;
13691- stack[base + 32LLU] = 877LLU;
16002+ stack[base + 32LLU] = 1035LLU;
1369216003 // arguments for call to add
1369316004 stack[base + 34LLU] = stack[base + 10]/*fnargcount*/;
1369416005 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13697,7 +16008,7 @@
1369716008 label = 18446744073709551605LLU; // add
1369816009 break;
1369916010 }
13700- case 877LLU: // return from add to ProcCall
16011+ case 1035LLU: // return from add to ProcCall
1370116012 {
1370216013 // copy mutable arguments back from call to add
1370316014 // copy back results provided by call to add
@@ -13704,7 +16015,7 @@
1370416015 stack[base + 28] = stack[base + 33LLU];
1370516016 // call add from ProcCall
1370616017 stack[base + 31LLU] = base;
13707- stack[base + 32LLU] = 878LLU;
16018+ stack[base + 32LLU] = 1036LLU;
1370816019 // arguments for call to add
1370916020 stack[base + 34LLU] = 1LLU;
1371016021 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -13713,7 +16024,7 @@
1371316024 label = 18446744073709551605LLU; // add
1371416025 break;
1371516026 }
13716- case 878LLU: // return from add to ProcCall
16027+ case 1036LLU: // return from add to ProcCall
1371716028 {
1371816029 // copy mutable arguments back from call to add
1371916030 // copy back results provided by call to add
@@ -13720,7 +16031,7 @@
1372016031 stack[base + 28] = stack[base + 33LLU];
1372116032 // call add from ProcCall
1372216033 stack[base + 31LLU] = base;
13723- stack[base + 32LLU] = 879LLU;
16034+ stack[base + 32LLU] = 1037LLU;
1372416035 // arguments for call to add
1372516036 stack[base + 34LLU] = 1LLU;
1372616037 stack[base + 35LLU] = stack[base + 16]/*label*/;
@@ -13729,7 +16040,7 @@
1372916040 label = 18446744073709551605LLU; // add
1373016041 break;
1373116042 }
13732- case 879LLU: // return from add to ProcCall
16043+ case 1037LLU: // return from add to ProcCall
1373316044 {
1373416045 // copy mutable arguments back from call to add
1373516046 // copy back results provided by call to add
@@ -13737,7 +16048,7 @@
1373716048 printf("%s", "\n stack[base + ");
1373816049 // call printnr from ProcCall
1373916050 stack[base + 31LLU] = base;
13740- stack[base + 32LLU] = 880LLU;
16051+ stack[base + 32LLU] = 1038LLU;
1374116052 // arguments for call to printnr
1374216053 stack[base + 33LLU] = stack[base + 28]/*sum*/;
1374316054 // set stack-base & callee-address
@@ -13745,13 +16056,13 @@
1374516056 label = 18446744073709551590LLU; // printnr
1374616057 break;
1374716058 }
13748- case 880LLU: // return from printnr to ProcCall
16059+ case 1038LLU: // return from printnr to ProcCall
1374916060 {
1375016061 // copy mutable arguments back from call to printnr
1375116062 printf("%s", "LLU] = ");
1375216063 // call printnr from ProcCall
1375316064 stack[base + 31LLU] = base;
13754- stack[base + 32LLU] = 881LLU;
16065+ stack[base + 32LLU] = 1039LLU;
1375516066 // arguments for call to printnr
1375616067 stack[base + 33LLU] = stack[base + 16]/*label*/;
1375716068 // set stack-base & callee-address
@@ -13759,7 +16070,7 @@
1375916070 label = 18446744073709551590LLU; // printnr
1376016071 break;
1376116072 }
13762- case 881LLU: // return from printnr to ProcCall
16073+ case 1039LLU: // return from printnr to ProcCall
1376316074 {
1376416075 // copy mutable arguments back from call to printnr
1376516076 printf("%s", "LLU;");
@@ -13767,7 +16078,7 @@
1376716078 printf("%s", "\n // arguments for call to ");
1376816079 // call printid from ProcCall
1376916080 stack[base + 31LLU] = base;
13770- stack[base + 32LLU] = 882LLU;
16081+ stack[base + 32LLU] = 1040LLU;
1377116082 // arguments for call to printid
1377216083 stack[base + 33LLU] = stack[base + 23]/*ceid*/;
1377316084 // set stack-base & callee-address
@@ -13775,18 +16086,18 @@
1377516086 label = 18446744073709551587LLU; // printid
1377616087 break;
1377716088 }
13778- case 882LLU: // return from printid to ProcCall
16089+ case 1040LLU: // return from printid to ProcCall
1377916090 {
1378016091 // copy mutable arguments back from call to printid
1378116092 flippedassign(stack[base + 21]/*ceargtypes*/, &stack[base + 31]);
13782- label = 883LLU; // start to repeat
16093+ label = 1041LLU; // start to repeat
1378316094 break;
1378416095 }
13785- case 883LLU: // repeat from here
16096+ case 1041LLU: // repeat from here
1378616097 {
1378716098 if(!stack[base + 31])
1378816099 {
13789- label = 884LLU; // break loop
16100+ label = 1042LLU; // break loop
1379016101 break;
1379116102 }
1379216103
@@ -13796,7 +16107,7 @@
1379616107 stack[base + 31] = (uint64_t)(((const struct listnode *)(stack[base + 31]))->next);
1379716108 // call sub from ProcCall
1379816109 stack[base + 34LLU] = base;
13799- stack[base + 35LLU] = 885LLU;
16110+ stack[base + 35LLU] = 1043LLU;
1380016111 // arguments for call to sub
1380116112 stack[base + 37LLU] = stack[base + 27]/*ceargcount*/;
1380216113 stack[base + 38LLU] = stack[base + 29]/*n*/;
@@ -13805,7 +16116,7 @@
1380516116 label = 18446744073709551604LLU; // sub
1380616117 break;
1380716118 }
13808- case 885LLU: // return from sub to ProcCall
16119+ case 1043LLU: // return from sub to ProcCall
1380916120 {
1381016121 // copy mutable arguments back from call to sub
1381116122 // copy back results provided by call to sub
@@ -13812,7 +16123,7 @@
1381216123 stack[base + 30] = stack[base + 36LLU];
1381316124 // call sub from ProcCall
1381416125 stack[base + 34LLU] = base;
13815- stack[base + 35LLU] = 886LLU;
16126+ stack[base + 35LLU] = 1044LLU;
1381616127 // arguments for call to sub
1381716128 stack[base + 37LLU] = stack[base + 29]/*n*/;
1381816129 stack[base + 38LLU] = 1LLU;
@@ -13821,7 +16132,7 @@
1382116132 label = 18446744073709551604LLU; // sub
1382216133 break;
1382316134 }
13824- case 886LLU: // return from sub to ProcCall
16135+ case 1044LLU: // return from sub to ProcCall
1382516136 {
1382616137 // copy mutable arguments back from call to sub
1382716138 // copy back results provided by call to sub
@@ -13828,7 +16139,7 @@
1382816139 stack[base + 29] = stack[base + 36LLU];
1382916140 if(!stack[base + 30]/*index*/)
1383016141 {
13831- label = 887LLU; // jump to alternative
16142+ label = 1045LLU; // jump to alternative
1383216143 break;
1383316144 }
1383416145
@@ -13835,7 +16146,7 @@
1383516146 // consequent
1383616147 // call matchsym from ProcCall
1383716148 stack[base + 34LLU] = base;
13838- stack[base + 35LLU] = 889LLU;
16149+ stack[base + 35LLU] = 1047LLU;
1383916150 // arguments for call to matchsym
1384016151 stack[base + 36LLU] = stack[base + 7]/*fnid*/;
1384116152 stack[base + 37LLU] = 44LLU;
@@ -13845,24 +16156,24 @@
1384516156 label = 110LLU; // matchsym
1384616157 break;
1384716158 }
13848- case 889LLU: // return from matchsym to ProcCall
16159+ case 1047LLU: // return from matchsym to ProcCall
1384916160 {
1385016161 // copy mutable arguments back from call to matchsym
1385116162 stack[base + 13]/*lookahead*/ = stack[base + 38LLU];
13852- label = 888LLU; // consequent complete
16163+ label = 1046LLU; // consequent complete
1385316164 break;
1385416165 }
13855- case 887LLU: // alternative
16166+ case 1045LLU: // alternative
1385616167 {
13857- label = 888LLU; // alternative complete
16168+ label = 1046LLU; // alternative complete
1385816169 break;
1385916170 }
13860- case 888LLU: // completed if-then-else
16171+ case 1046LLU: // completed if-then-else
1386116172 {
1386216173 stack[base + 28]/*sum*/ = 0;
1386316174 // call add from ProcCall
1386416175 stack[base + 34LLU] = base;
13865- stack[base + 35LLU] = 890LLU;
16176+ stack[base + 35LLU] = 1048LLU;
1386616177 // arguments for call to add
1386716178 stack[base + 37LLU] = stack[base + 4]/*offset*/;
1386816179 stack[base + 38LLU] = stack[base + 28]/*sum*/;
@@ -13871,7 +16182,7 @@
1387116182 label = 18446744073709551605LLU; // add
1387216183 break;
1387316184 }
13874- case 890LLU: // return from add to ProcCall
16185+ case 1048LLU: // return from add to ProcCall
1387516186 {
1387616187 // copy mutable arguments back from call to add
1387716188 // copy back results provided by call to add
@@ -13878,7 +16189,7 @@
1387816189 stack[base + 28] = stack[base + 36LLU];
1387916190 // call add from ProcCall
1388016191 stack[base + 34LLU] = base;
13881- stack[base + 35LLU] = 891LLU;
16192+ stack[base + 35LLU] = 1049LLU;
1388216193 // arguments for call to add
1388316194 stack[base + 37LLU] = 2LLU;
1388416195 stack[base + 38LLU] = stack[base + 28]/*sum*/;
@@ -13887,7 +16198,7 @@
1388716198 label = 18446744073709551605LLU; // add
1388816199 break;
1388916200 }
13890- case 891LLU: // return from add to ProcCall
16201+ case 1049LLU: // return from add to ProcCall
1389116202 {
1389216203 // copy mutable arguments back from call to add
1389316204 // copy back results provided by call to add
@@ -13894,7 +16205,7 @@
1389416205 stack[base + 28] = stack[base + 36LLU];
1389516206 // call add from ProcCall
1389616207 stack[base + 34LLU] = base;
13897- stack[base + 35LLU] = 892LLU;
16208+ stack[base + 35LLU] = 1050LLU;
1389816209 // arguments for call to add
1389916210 stack[base + 37LLU] = stack[base + 9]/*fnrescount*/;
1390016211 stack[base + 38LLU] = stack[base + 28]/*sum*/;
@@ -13903,7 +16214,7 @@
1390316214 label = 18446744073709551605LLU; // add
1390416215 break;
1390516216 }
13906- case 892LLU: // return from add to ProcCall
16217+ case 1050LLU: // return from add to ProcCall
1390716218 {
1390816219 // copy mutable arguments back from call to add
1390916220 // copy back results provided by call to add
@@ -13910,7 +16221,7 @@
1391016221 stack[base + 28] = stack[base + 36LLU];
1391116222 // call add from ProcCall
1391216223 stack[base + 34LLU] = base;
13913- stack[base + 35LLU] = 893LLU;
16224+ stack[base + 35LLU] = 1051LLU;
1391416225 // arguments for call to add
1391516226 stack[base + 37LLU] = stack[base + 10]/*fnargcount*/;
1391616227 stack[base + 38LLU] = stack[base + 28]/*sum*/;
@@ -13919,7 +16230,7 @@
1391916230 label = 18446744073709551605LLU; // add
1392016231 break;
1392116232 }
13922- case 893LLU: // return from add to ProcCall
16233+ case 1051LLU: // return from add to ProcCall
1392316234 {
1392416235 // copy mutable arguments back from call to add
1392516236 // copy back results provided by call to add
@@ -13926,7 +16237,7 @@
1392616237 stack[base + 28] = stack[base + 36LLU];
1392716238 // call add from ProcCall
1392816239 stack[base + 34LLU] = base;
13929- stack[base + 35LLU] = 894LLU;
16240+ stack[base + 35LLU] = 1052LLU;
1393016241 // arguments for call to add
1393116242 stack[base + 37LLU] = stack[base + 26]/*cerescount*/;
1393216243 stack[base + 38LLU] = stack[base + 28]/*sum*/;
@@ -13935,7 +16246,7 @@
1393516246 label = 18446744073709551605LLU; // add
1393616247 break;
1393716248 }
13938- case 894LLU: // return from add to ProcCall
16249+ case 1052LLU: // return from add to ProcCall
1393916250 {
1394016251 // copy mutable arguments back from call to add
1394116252 // copy back results provided by call to add
@@ -13942,7 +16253,7 @@
1394216253 stack[base + 28] = stack[base + 36LLU];
1394316254 // call add from ProcCall
1394416255 stack[base + 34LLU] = base;
13945- stack[base + 35LLU] = 895LLU;
16256+ stack[base + 35LLU] = 1053LLU;
1394616257 // arguments for call to add
1394716258 stack[base + 37LLU] = stack[base + 30]/*index*/;
1394816259 stack[base + 38LLU] = stack[base + 28]/*sum*/;
@@ -13951,7 +16262,7 @@
1395116262 label = 18446744073709551605LLU; // add
1395216263 break;
1395316264 }
13954- case 895LLU: // return from add to ProcCall
16265+ case 1053LLU: // return from add to ProcCall
1395516266 {
1395616267 // copy mutable arguments back from call to add
1395716268 // copy back results provided by call to add
@@ -13958,7 +16269,7 @@
1395816269 stack[base + 28] = stack[base + 36LLU];
1395916270 // call ParseToken from ProcCall
1396016271 stack[base + 34LLU] = base;
13961- stack[base + 35LLU] = 896LLU;
16272+ stack[base + 35LLU] = 1054LLU;
1396216273 // arguments for call to ParseToken
1396316274 stack[base + 38LLU] = stack[base + 13]/*lookahead*/;
1396416275 // set stack-base & callee-address
@@ -13966,7 +16277,7 @@
1396616277 label = 2LLU; // ParseToken
1396716278 break;
1396816279 }
13969- case 896LLU: // return from ParseToken to ProcCall
16280+ case 1054LLU: // return from ParseToken to ProcCall
1397016281 {
1397116282 // copy mutable arguments back from call to ParseToken
1397216283 stack[base + 13]/*lookahead*/ = stack[base + 38LLU];
@@ -13975,7 +16286,7 @@
1397516286 stack[base + 15] = stack[base + 37LLU];
1397616287 // call isncs from ProcCall
1397716288 stack[base + 34LLU] = base;
13978- stack[base + 35LLU] = 897LLU;
16289+ stack[base + 35LLU] = 1055LLU;
1397916290 // arguments for call to isncs
1398016291 stack[base + 37LLU] = stack[base + 14]/*variant*/;
1398116292 // set stack-base & callee-address
@@ -13983,7 +16294,7 @@
1398316294 label = 138LLU; // isncs
1398416295 break;
1398516296 }
13986- case 897LLU: // return from isncs to ProcCall
16297+ case 1055LLU: // return from isncs to ProcCall
1398716298 {
1398816299 // copy mutable arguments back from call to isncs
1398916300 // copy back results provided by call to isncs
@@ -13990,7 +16301,7 @@
1399016301 stack[base + 17] = stack[base + 36LLU];
1399116302 if(!stack[base + 17]/*isequal*/)
1399216303 {
13993- label = 898LLU; // jump to alternative
16304+ label = 1056LLU; // jump to alternative
1399416305 break;
1399516306 }
1399616307
@@ -13997,7 +16308,7 @@
1399716308 // consequent
1399816309 if(/*param*/0 != ((uint64_t *)(stack[base + 32]/*param*/))[0])
1399916310 {
14000- label = 901LLU; // jump to alternative
16311+ label = 1059LLU; // jump to alternative
1400116312 break;
1400216313 }
1400316314
@@ -14007,7 +16318,7 @@
1400716318 // case
1400816319 if(/*typeid*/0 != ((uint64_t *)(stack[base + 34]/*typeid*/))[0])
1400916320 {
14010- label = 903LLU; // jump to alternative
16321+ label = 1061LLU; // jump to alternative
1401116322 break;
1401216323 }
1401316324
@@ -14017,7 +16328,7 @@
1401716328 // case
1401816329 // call mktypename from ProcCall
1401916330 stack[base + 39LLU] = base;
14020- stack[base + 40LLU] = 904LLU;
16331+ stack[base + 40LLU] = 1062LLU;
1402116332 // arguments for call to mktypename
1402216333 stack[base + 42LLU] = 881834713755418624LLU;
1402316334 // set stack-base & callee-address
@@ -14025,7 +16336,7 @@
1402516336 label = 152LLU; // mktypename
1402616337 break;
1402716338 }
14028- case 904LLU: // return from mktypename to ProcCall
16339+ case 1062LLU: // return from mktypename to ProcCall
1402916340 {
1403016341 // copy mutable arguments back from call to mktypename
1403116342 // copy back results provided by call to mktypename
@@ -14040,7 +16351,7 @@
1404016351 // call equtype from ProcCall
1404116352 newstack[0] = (uint64_t)stack; // backup stack location
1404216353 newstack[1] = base;
14043- newstack[2] = 905LLU;
16354+ newstack[2] = 1063LLU;
1404416355 // arguments for call to equtype
1404516356 newstack[4LLU] = stack[base + 38]/*type*/;
1404616357 newstack[5LLU] = stack[base + 36]/*expected*/;
@@ -14050,7 +16361,7 @@
1405016361 label = 170LLU; // equtype
1405116362 break;
1405216363 }
14053- case 905LLU: // return from equtype to ProcCall
16364+ case 1063LLU: // return from equtype to ProcCall
1405416365 {
1405516366 uint64_t *oldstack = (uint64_t *)stack[0];
1405616367 // copy mutable arguments back from call to equtype
@@ -14065,20 +16376,20 @@
1406516376 stack = oldstack;
1406616377 if(!stack[base + 17]/*isequal*/)
1406716378 {
14068- label = 906LLU; // jump to alternative
16379+ label = 1064LLU; // jump to alternative
1406916380 break;
1407016381 }
1407116382
1407216383 // consequent
14073- label = 907LLU; // consequent complete
16384+ label = 1065LLU; // consequent complete
1407416385 break;
1407516386 }
14076- case 906LLU: // alternative
16387+ case 1064LLU: // alternative
1407716388 {
1407816389 fprintf(stderr, "%s", "in function ");
1407916390 // call reportid from ProcCall
1408016391 stack[base + 39LLU] = base;
14081- stack[base + 40LLU] = 908LLU;
16392+ stack[base + 40LLU] = 1066LLU;
1408216393 // arguments for call to reportid
1408316394 stack[base + 41LLU] = stack[base + 7]/*fnid*/;
1408416395 // set stack-base & callee-address
@@ -14086,13 +16397,13 @@
1408616397 label = 18446744073709551586LLU; // reportid
1408716398 break;
1408816399 }
14089- case 908LLU: // return from reportid to ProcCall
16400+ case 1066LLU: // return from reportid to ProcCall
1409016401 {
1409116402 // copy mutable arguments back from call to reportid
1409216403 fprintf(stderr, "%s", " call to ");
1409316404 // call reportid from ProcCall
1409416405 stack[base + 39LLU] = base;
14095- stack[base + 40LLU] = 909LLU;
16406+ stack[base + 40LLU] = 1067LLU;
1409616407 // arguments for call to reportid
1409716408 stack[base + 41LLU] = stack[base + 23]/*ceid*/;
1409816409 // set stack-base & callee-address
@@ -14100,13 +16411,13 @@
1410016411 label = 18446744073709551586LLU; // reportid
1410116412 break;
1410216413 }
14103- case 909LLU: // return from reportid to ProcCall
16414+ case 1067LLU: // return from reportid to ProcCall
1410416415 {
1410516416 // copy mutable arguments back from call to reportid
1410616417 fprintf(stderr, "%s", " at position ");
1410716418 // call reportnr from ProcCall
1410816419 stack[base + 39LLU] = base;
14109- stack[base + 40LLU] = 910LLU;
16420+ stack[base + 40LLU] = 1068LLU;
1411016421 // arguments for call to reportnr
1411116422 stack[base + 41LLU] = stack[base + 30]/*index*/;
1411216423 // set stack-base & callee-address
@@ -14114,7 +16425,7 @@
1411416425 label = 18446744073709551589LLU; // reportnr
1411516426 break;
1411616427 }
14117- case 910LLU: // return from reportnr to ProcCall
16428+ case 1068LLU: // return from reportnr to ProcCall
1411816429 {
1411916430 // copy mutable arguments back from call to reportnr
1412016431 fprintf(stderr, "%s", " expected parameter of type ");
@@ -14128,7 +16439,7 @@
1412816439 // call reporttype from ProcCall
1412916440 newstack[0] = (uint64_t)stack; // backup stack location
1413016441 newstack[1] = base;
14131- newstack[2] = 911LLU;
16442+ newstack[2] = 1069LLU;
1413216443 // arguments for call to reporttype
1413316444 newstack[3LLU] = stack[base + 36]/*expected*/;
1413416445 stack = newstack;
@@ -14137,7 +16448,7 @@
1413716448 label = 159LLU; // reporttype
1413816449 break;
1413916450 }
14140- case 911LLU: // return from reporttype to ProcCall
16451+ case 1069LLU: // return from reporttype to ProcCall
1414116452 {
1414216453 uint64_t *oldstack = (uint64_t *)stack[0];
1414316454 // copy mutable arguments back from call to reporttype
@@ -14151,10 +16462,10 @@
1415116462 fprintf(stderr, "%s", " but found constant-argument of type u64");
1415216463 fprintf(stderr, "%s", "\n");
1415316464 exit(-1);
14154- label = 907LLU; // alternative complete
16465+ label = 1065LLU; // alternative complete
1415516466 break;
1415616467 }
14157- case 907LLU: // completed if-then-else
16468+ case 1065LLU: // completed if-then-else
1415816469 {
1415916470
1416016471 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 3);
@@ -14161,7 +16472,7 @@
1416116472 // call ~type from ProcCall
1416216473 newstack[0] = (uint64_t)stack; // backup stack location
1416316474 newstack[1] = base;
14164- newstack[2] = 912LLU;
16475+ newstack[2] = 1070LLU;
1416516476 stack = newstack;
1416616477 // set stack-base & callee-address
1416716478 base = 3;
@@ -14168,7 +16479,7 @@
1416816479 label = 148LLU; // ~type
1416916480 break;
1417016481 }
14171- case 912LLU: // return from ~type to ProcCall
16482+ case 1070LLU: // return from ~type to ProcCall
1417216483 {
1417316484 stack = (uint64_t *)stack[0];
1417416485 // releasing toplevel container
@@ -14176,19 +16487,19 @@
1417616487
1417716488 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
1417816489 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
14179- label = 902LLU; // case complete
16490+ label = 1060LLU; // case complete
1418016491 break;
1418116492 }
14182- case 903LLU: // try next case
16493+ case 1061LLU: // try next case
1418316494 {
1418416495 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1418516496 exit(-1);
1418616497 }
14187- case 902LLU: // completed switch
16498+ case 1060LLU: // completed switch
1418816499 {
1418916500 if(!stack[base + 35]/*mutable*/)
1419016501 {
14191- label = 913LLU; // jump to alternative
16502+ label = 1071LLU; // jump to alternative
1419216503 break;
1419316504 }
1419416505
@@ -14196,7 +16507,7 @@
1419616507 fprintf(stderr, "%s", "in function ");
1419716508 // call reportid from ProcCall
1419816509 stack[base + 36LLU] = base;
14199- stack[base + 37LLU] = 915LLU;
16510+ stack[base + 37LLU] = 1073LLU;
1420016511 // arguments for call to reportid
1420116512 stack[base + 38LLU] = stack[base + 7]/*fnid*/;
1420216513 // set stack-base & callee-address
@@ -14204,13 +16515,13 @@
1420416515 label = 18446744073709551586LLU; // reportid
1420516516 break;
1420616517 }
14207- case 915LLU: // return from reportid to ProcCall
16518+ case 1073LLU: // return from reportid to ProcCall
1420816519 {
1420916520 // copy mutable arguments back from call to reportid
1421016521 fprintf(stderr, "%s", ", calling ");
1421116522 // call reportid from ProcCall
1421216523 stack[base + 36LLU] = base;
14213- stack[base + 37LLU] = 916LLU;
16524+ stack[base + 37LLU] = 1074LLU;
1421416525 // arguments for call to reportid
1421516526 stack[base + 38LLU] = stack[base + 23]/*ceid*/;
1421616527 // set stack-base & callee-address
@@ -14218,7 +16529,7 @@
1421816529 label = 18446744073709551586LLU; // reportid
1421916530 break;
1422016531 }
14221- case 916LLU: // return from reportid to ProcCall
16532+ case 1074LLU: // return from reportid to ProcCall
1422216533 {
1422316534 // copy mutable arguments back from call to reportid
1422416535 fprintf(stderr, "%s", ": ");
@@ -14225,7 +16536,7 @@
1422516536 fprintf(stderr, "%s", "can't use constant argument ");
1422616537 // call printnr from ProcCall
1422716538 stack[base + 36LLU] = base;
14228- stack[base + 37LLU] = 917LLU;
16539+ stack[base + 37LLU] = 1075LLU;
1422916540 // arguments for call to printnr
1423016541 stack[base + 38LLU] = stack[base + 15]/*content*/;
1423116542 // set stack-base & callee-address
@@ -14233,13 +16544,13 @@
1423316544 label = 18446744073709551590LLU; // printnr
1423416545 break;
1423516546 }
14236- case 917LLU: // return from printnr to ProcCall
16547+ case 1075LLU: // return from printnr to ProcCall
1423716548 {
1423816549 // copy mutable arguments back from call to printnr
1423916550 printf("%s", " for mutable parameter ");
1424016551 // call reportti from ProcCall
1424116552 stack[base + 36LLU] = base;
14242- stack[base + 37LLU] = 918LLU;
16553+ stack[base + 37LLU] = 1076LLU;
1424316554 // arguments for call to reportti
1424416555 stack[base + 38LLU] = stack[base + 34]/*typeid*/;
1424516556 // set stack-base & callee-address
@@ -14247,37 +16558,37 @@
1424716558 label = 183LLU; // reportti
1424816559 break;
1424916560 }
14250- case 918LLU: // return from reportti to ProcCall
16561+ case 1076LLU: // return from reportti to ProcCall
1425116562 {
1425216563 // copy mutable arguments back from call to reportti
1425316564 fprintf(stderr, "%s", "\n");
1425416565 exit(-1);
14255- label = 914LLU; // consequent complete
16566+ label = 1072LLU; // consequent complete
1425616567 break;
1425716568 }
14258- case 913LLU: // alternative
16569+ case 1071LLU: // alternative
1425916570 {
14260- label = 914LLU; // alternative complete
16571+ label = 1072LLU; // alternative complete
1426116572 break;
1426216573 }
14263- case 914LLU: // completed if-then-else
16574+ case 1072LLU: // completed if-then-else
1426416575 {
1426516576 ((uint64_t **)(stack[base + 32]))[1][1] = stack[base + 35];
1426616577 ((uint64_t **)(stack[base + 32]))[1][0] = stack[base + 34];
14267- label = 900LLU; // case complete
16578+ label = 1058LLU; // case complete
1426816579 break;
1426916580 }
14270- case 901LLU: // try next case
16581+ case 1059LLU: // try next case
1427116582 {
1427216583 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1427316584 exit(-1);
1427416585 }
14275- case 900LLU: // completed switch
16586+ case 1058LLU: // completed switch
1427616587 {
1427716588 printf("%s", "\n stack[base + ");
1427816589 // call printnr from ProcCall
1427916590 stack[base + 34LLU] = base;
14280- stack[base + 35LLU] = 919LLU;
16591+ stack[base + 35LLU] = 1077LLU;
1428116592 // arguments for call to printnr
1428216593 stack[base + 36LLU] = stack[base + 28]/*sum*/;
1428316594 // set stack-base & callee-address
@@ -14285,13 +16596,13 @@
1428516596 label = 18446744073709551590LLU; // printnr
1428616597 break;
1428716598 }
14288- case 919LLU: // return from printnr to ProcCall
16599+ case 1077LLU: // return from printnr to ProcCall
1428916600 {
1429016601 // copy mutable arguments back from call to printnr
1429116602 printf("%s", "LLU] = ");
1429216603 // call printnr from ProcCall
1429316604 stack[base + 34LLU] = base;
14294- stack[base + 35LLU] = 920LLU;
16605+ stack[base + 35LLU] = 1078LLU;
1429516606 // arguments for call to printnr
1429616607 stack[base + 36LLU] = stack[base + 15]/*content*/;
1429716608 // set stack-base & callee-address
@@ -14299,18 +16610,18 @@
1429916610 label = 18446744073709551590LLU; // printnr
1430016611 break;
1430116612 }
14302- case 920LLU: // return from printnr to ProcCall
16613+ case 1078LLU: // return from printnr to ProcCall
1430316614 {
1430416615 // copy mutable arguments back from call to printnr
1430516616 printf("%s", "LLU;");
14306- label = 899LLU; // consequent complete
16617+ label = 1057LLU; // consequent complete
1430716618 break;
1430816619 }
14309- case 898LLU: // alternative
16620+ case 1056LLU: // alternative
1431016621 {
1431116622 // call equ from ProcCall
1431216623 stack[base + 34LLU] = base;
14313- stack[base + 35LLU] = 921LLU;
16624+ stack[base + 35LLU] = 1079LLU;
1431416625 // arguments for call to equ
1431516626 stack[base + 37LLU] = stack[base + 14]/*variant*/;
1431616627 stack[base + 38LLU] = 4LLU;
@@ -14319,7 +16630,7 @@
1431916630 label = 18446744073709551600LLU; // equ
1432016631 break;
1432116632 }
14322- case 921LLU: // return from equ to ProcCall
16633+ case 1079LLU: // return from equ to ProcCall
1432316634 {
1432416635 // copy mutable arguments back from call to equ
1432516636 // copy back results provided by call to equ
@@ -14326,7 +16637,7 @@
1432616637 stack[base + 17] = stack[base + 36LLU];
1432716638 if(!stack[base + 17]/*isequal*/)
1432816639 {
14329- label = 922LLU; // jump to alternative
16640+ label = 1080LLU; // jump to alternative
1433016641 break;
1433116642 }
1433216643
@@ -14333,7 +16644,7 @@
1433316644 // consequent
1433416645 if(/*param*/0 != ((uint64_t *)(stack[base + 32]/*param*/))[0])
1433516646 {
14336- label = 925LLU; // jump to alternative
16647+ label = 1083LLU; // jump to alternative
1433716648 break;
1433816649 }
1433916650
@@ -14343,7 +16654,7 @@
1434316654 // case
1434416655 if(/*typeid*/0 != ((uint64_t *)(stack[base + 34]/*typeid*/))[0])
1434516656 {
14346- label = 927LLU; // jump to alternative
16657+ label = 1085LLU; // jump to alternative
1434716658 break;
1434816659 }
1434916660
@@ -14353,7 +16664,7 @@
1435316664 // case
1435416665 // call getlettype from ProcCall
1435516666 stack[base + 39LLU] = base;
14356- stack[base + 40LLU] = 928LLU;
16667+ stack[base + 40LLU] = 1086LLU;
1435716668 // arguments for call to getlettype
1435816669 stack[base + 42LLU] = stack[base + 7]/*fnid*/;
1435916670 stack[base + 43LLU] = stack[base + 15]/*content*/;
@@ -14364,7 +16675,7 @@
1436416675 label = 326LLU; // getlettype
1436516676 break;
1436616677 }
14367- case 928LLU: // return from getlettype to ProcCall
16678+ case 1086LLU: // return from getlettype to ProcCall
1436816679 {
1436916680 // copy mutable arguments back from call to getlettype
1437016681 // copy back results provided by call to getlettype
@@ -14371,7 +16682,7 @@
1437116682 stack[base + 38] = stack[base + 41LLU];
1437216683 // call findletmut from ProcCall
1437316684 stack[base + 40LLU] = base;
14374- stack[base + 41LLU] = 929LLU;
16685+ stack[base + 41LLU] = 1087LLU;
1437516686 // arguments for call to findletmut
1437616687 stack[base + 43LLU] = stack[base + 7]/*fnid*/;
1437716688 stack[base + 44LLU] = stack[base + 15]/*content*/;
@@ -14382,7 +16693,7 @@
1438216693 label = 337LLU; // findletmut
1438316694 break;
1438416695 }
14385- case 929LLU: // return from findletmut to ProcCall
16696+ case 1087LLU: // return from findletmut to ProcCall
1438616697 {
1438716698 // copy mutable arguments back from call to findletmut
1438816699 // copy back results provided by call to findletmut
@@ -14397,7 +16708,7 @@
1439716708 // call equtype from ProcCall
1439816709 newstack[0] = (uint64_t)stack; // backup stack location
1439916710 newstack[1] = base;
14400- newstack[2] = 930LLU;
16711+ newstack[2] = 1088LLU;
1440116712 // arguments for call to equtype
1440216713 newstack[4LLU] = stack[base + 38]/*type*/;
1440316714 newstack[5LLU] = stack[base + 36]/*expected*/;
@@ -14407,7 +16718,7 @@
1440716718 label = 170LLU; // equtype
1440816719 break;
1440916720 }
14410- case 930LLU: // return from equtype to ProcCall
16721+ case 1088LLU: // return from equtype to ProcCall
1441116722 {
1441216723 uint64_t *oldstack = (uint64_t *)stack[0];
1441316724 // copy mutable arguments back from call to equtype
@@ -14422,20 +16733,20 @@
1442216733 stack = oldstack;
1442316734 if(!stack[base + 17]/*isequal*/)
1442416735 {
14425- label = 931LLU; // jump to alternative
16736+ label = 1089LLU; // jump to alternative
1442616737 break;
1442716738 }
1442816739
1442916740 // consequent
14430- label = 932LLU; // consequent complete
16741+ label = 1090LLU; // consequent complete
1443116742 break;
1443216743 }
14433- case 931LLU: // alternative
16744+ case 1089LLU: // alternative
1443416745 {
1443516746 fprintf(stderr, "%s", "in function ");
1443616747 // call reportid from ProcCall
1443716748 stack[base + 40LLU] = base;
14438- stack[base + 41LLU] = 933LLU;
16749+ stack[base + 41LLU] = 1091LLU;
1443916750 // arguments for call to reportid
1444016751 stack[base + 42LLU] = stack[base + 7]/*fnid*/;
1444116752 // set stack-base & callee-address
@@ -14443,13 +16754,13 @@
1444316754 label = 18446744073709551586LLU; // reportid
1444416755 break;
1444516756 }
14446- case 933LLU: // return from reportid to ProcCall
16757+ case 1091LLU: // return from reportid to ProcCall
1444716758 {
1444816759 // copy mutable arguments back from call to reportid
1444916760 fprintf(stderr, "%s", " call to ");
1445016761 // call reportid from ProcCall
1445116762 stack[base + 40LLU] = base;
14452- stack[base + 41LLU] = 934LLU;
16763+ stack[base + 41LLU] = 1092LLU;
1445316764 // arguments for call to reportid
1445416765 stack[base + 42LLU] = stack[base + 23]/*ceid*/;
1445516766 // set stack-base & callee-address
@@ -14457,13 +16768,13 @@
1445716768 label = 18446744073709551586LLU; // reportid
1445816769 break;
1445916770 }
14460- case 934LLU: // return from reportid to ProcCall
16771+ case 1092LLU: // return from reportid to ProcCall
1446116772 {
1446216773 // copy mutable arguments back from call to reportid
1446316774 fprintf(stderr, "%s", " at position ");
1446416775 // call reportnr from ProcCall
1446516776 stack[base + 40LLU] = base;
14466- stack[base + 41LLU] = 935LLU;
16777+ stack[base + 41LLU] = 1093LLU;
1446716778 // arguments for call to reportnr
1446816779 stack[base + 42LLU] = stack[base + 30]/*index*/;
1446916780 // set stack-base & callee-address
@@ -14471,7 +16782,7 @@
1447116782 label = 18446744073709551589LLU; // reportnr
1447216783 break;
1447316784 }
14474- case 935LLU: // return from reportnr to ProcCall
16785+ case 1093LLU: // return from reportnr to ProcCall
1447516786 {
1447616787 // copy mutable arguments back from call to reportnr
1447716788 fprintf(stderr, "%s", " parameter type ");
@@ -14485,7 +16796,7 @@
1448516796 // call reporttype from ProcCall
1448616797 newstack[0] = (uint64_t)stack; // backup stack location
1448716798 newstack[1] = base;
14488- newstack[2] = 936LLU;
16799+ newstack[2] = 1094LLU;
1448916800 // arguments for call to reporttype
1449016801 newstack[3LLU] = stack[base + 36]/*expected*/;
1449116802 stack = newstack;
@@ -14494,7 +16805,7 @@
1449416805 label = 159LLU; // reporttype
1449516806 break;
1449616807 }
14497- case 936LLU: // return from reporttype to ProcCall
16808+ case 1094LLU: // return from reporttype to ProcCall
1449816809 {
1449916810 uint64_t *oldstack = (uint64_t *)stack[0];
1450016811 // copy mutable arguments back from call to reporttype
@@ -14516,7 +16827,7 @@
1451616827 // call reporttype from ProcCall
1451716828 newstack[0] = (uint64_t)stack; // backup stack location
1451816829 newstack[1] = base;
14519- newstack[2] = 937LLU;
16830+ newstack[2] = 1095LLU;
1452016831 // arguments for call to reporttype
1452116832 newstack[3LLU] = stack[base + 38]/*type*/;
1452216833 stack = newstack;
@@ -14525,7 +16836,7 @@
1452516836 label = 159LLU; // reporttype
1452616837 break;
1452716838 }
14528- case 937LLU: // return from reporttype to ProcCall
16839+ case 1095LLU: // return from reporttype to ProcCall
1452916840 {
1453016841 uint64_t *oldstack = (uint64_t *)stack[0];
1453116842 // copy mutable arguments back from call to reporttype
@@ -14538,14 +16849,14 @@
1453816849 stack = oldstack;
1453916850 fprintf(stderr, "%s", "\n");
1454016851 exit(-1);
14541- label = 932LLU; // alternative complete
16852+ label = 1090LLU; // alternative complete
1454216853 break;
1454316854 }
14544- case 932LLU: // completed if-then-else
16855+ case 1090LLU: // completed if-then-else
1454516856 {
1454616857 if(!stack[base + 35]/*mutable*/)
1454716858 {
14548- label = 938LLU; // jump to alternative
16859+ label = 1096LLU; // jump to alternative
1454916860 break;
1455016861 }
1455116862
@@ -14552,7 +16863,7 @@
1455216863 // consequent
1455316864 if(!stack[base + 39]/*mutarg*/)
1455416865 {
14555- label = 940LLU; // jump to alternative
16866+ label = 1098LLU; // jump to alternative
1455616867 break;
1455716868 }
1455816869
@@ -14559,7 +16870,7 @@
1455916870 // consequent
1456016871 // call lookidnr from ProcCall
1456116872 stack[base + 41LLU] = base;
14562- stack[base + 42LLU] = 942LLU;
16873+ stack[base + 42LLU] = 1100LLU;
1456316874 // arguments for call to lookidnr
1456416875 stack[base + 44LLU] = stack[base + 18]/*copyback*/;
1456516876 stack[base + 45LLU] = stack[base + 15]/*content*/;
@@ -14568,7 +16879,7 @@
1456816879 label = 373LLU; // lookidnr
1456916880 break;
1457016881 }
14571- case 942LLU: // return from lookidnr to ProcCall
16882+ case 1100LLU: // return from lookidnr to ProcCall
1457216883 {
1457316884 // copy mutable arguments back from call to lookidnr
1457416885 // copy back results provided by call to lookidnr
@@ -14575,7 +16886,7 @@
1457516886 stack[base + 40] = stack[base + 43LLU];
1457616887 if(!stack[base + 40]/*found*/)
1457716888 {
14578- label = 943LLU; // jump to alternative
16889+ label = 1101LLU; // jump to alternative
1457916890 break;
1458016891 }
1458116892
@@ -14583,7 +16894,7 @@
1458316894 fprintf(stderr, "%s", "in function ");
1458416895 // call reportid from ProcCall
1458516896 stack[base + 41LLU] = base;
14586- stack[base + 42LLU] = 945LLU;
16897+ stack[base + 42LLU] = 1103LLU;
1458716898 // arguments for call to reportid
1458816899 stack[base + 43LLU] = stack[base + 7]/*fnid*/;
1458916900 // set stack-base & callee-address
@@ -14591,13 +16902,13 @@
1459116902 label = 18446744073709551586LLU; // reportid
1459216903 break;
1459316904 }
14594- case 945LLU: // return from reportid to ProcCall
16905+ case 1103LLU: // return from reportid to ProcCall
1459516906 {
1459616907 // copy mutable arguments back from call to reportid
1459716908 fprintf(stderr, "%s", " call to ");
1459816909 // call reportid from ProcCall
1459916910 stack[base + 41LLU] = base;
14600- stack[base + 42LLU] = 946LLU;
16911+ stack[base + 42LLU] = 1104LLU;
1460116912 // arguments for call to reportid
1460216913 stack[base + 43LLU] = stack[base + 23]/*ceid*/;
1460316914 // set stack-base & callee-address
@@ -14605,13 +16916,13 @@
1460516916 label = 18446744073709551586LLU; // reportid
1460616917 break;
1460716918 }
14608- case 946LLU: // return from reportid to ProcCall
16919+ case 1104LLU: // return from reportid to ProcCall
1460916920 {
1461016921 // copy mutable arguments back from call to reportid
1461116922 fprintf(stderr, "%s", " - duplicate mutable argument ");
1461216923 // call reportid from ProcCall
1461316924 stack[base + 41LLU] = base;
14614- stack[base + 42LLU] = 947LLU;
16925+ stack[base + 42LLU] = 1105LLU;
1461516926 // arguments for call to reportid
1461616927 stack[base + 43LLU] = stack[base + 15]/*content*/;
1461716928 // set stack-base & callee-address
@@ -14619,20 +16930,20 @@
1461916930 label = 18446744073709551586LLU; // reportid
1462016931 break;
1462116932 }
14622- case 947LLU: // return from reportid to ProcCall
16933+ case 1105LLU: // return from reportid to ProcCall
1462316934 {
1462416935 // copy mutable arguments back from call to reportid
1462516936 fprintf(stderr, "%s", "\n");
1462616937 exit(-1);
14627- label = 944LLU; // consequent complete
16938+ label = 1102LLU; // consequent complete
1462816939 break;
1462916940 }
14630- case 943LLU: // alternative
16941+ case 1101LLU: // alternative
1463116942 {
14632- label = 944LLU; // alternative complete
16943+ label = 1102LLU; // alternative complete
1463316944 break;
1463416945 }
14635- case 944LLU: // completed if-then-else
16946+ case 1102LLU: // completed if-then-else
1463616947 {
1463716948 // construct idnr.idnr
1463816949 if(!(stack[base + 40] = (uint64_t)Calloc(2 + 3, sizeof(uint64_t)) + sizeof(uint64_t) * 3))
@@ -14660,15 +16971,15 @@
1466016971 stack[base + 18]/*copyback*/ = (uint64_t)list;
1466116972 MOVE(&list->data, &stack[base + 40]/*idnr*/);
1466216973 }
14663- label = 941LLU; // consequent complete
16974+ label = 1099LLU; // consequent complete
1466416975 break;
1466516976 }
14666- case 940LLU: // alternative
16977+ case 1098LLU: // alternative
1466716978 {
1466816979 fprintf(stderr, "%s", "in function ");
1466916980 // call reportid from ProcCall
1467016981 stack[base + 40LLU] = base;
14671- stack[base + 41LLU] = 948LLU;
16982+ stack[base + 41LLU] = 1106LLU;
1467216983 // arguments for call to reportid
1467316984 stack[base + 42LLU] = stack[base + 7]/*fnid*/;
1467416985 // set stack-base & callee-address
@@ -14676,13 +16987,13 @@
1467616987 label = 18446744073709551586LLU; // reportid
1467716988 break;
1467816989 }
14679- case 948LLU: // return from reportid to ProcCall
16990+ case 1106LLU: // return from reportid to ProcCall
1468016991 {
1468116992 // copy mutable arguments back from call to reportid
1468216993 fprintf(stderr, "%s", ", call to ");
1468316994 // call reportid from ProcCall
1468416995 stack[base + 40LLU] = base;
14685- stack[base + 41LLU] = 949LLU;
16996+ stack[base + 41LLU] = 1107LLU;
1468616997 // arguments for call to reportid
1468716998 stack[base + 42LLU] = stack[base + 23]/*ceid*/;
1468816999 // set stack-base & callee-address
@@ -14690,7 +17001,7 @@
1469017001 label = 18446744073709551586LLU; // reportid
1469117002 break;
1469217003 }
14693- case 949LLU: // return from reportid to ProcCall
17004+ case 1107LLU: // return from reportid to ProcCall
1469417005 {
1469517006 // copy mutable arguments back from call to reportid
1469617007 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -14704,7 +17015,7 @@
1470417015 // call reporttype from ProcCall
1470517016 newstack[0] = (uint64_t)stack; // backup stack location
1470617017 newstack[1] = base;
14707- newstack[2] = 950LLU;
17018+ newstack[2] = 1108LLU;
1470817019 // arguments for call to reporttype
1470917020 newstack[3LLU] = stack[base + 38]/*type*/;
1471017021 stack = newstack;
@@ -14713,7 +17024,7 @@
1471317024 label = 159LLU; // reporttype
1471417025 break;
1471517026 }
14716- case 950LLU: // return from reporttype to ProcCall
17027+ case 1108LLU: // return from reporttype to ProcCall
1471717028 {
1471817029 uint64_t *oldstack = (uint64_t *)stack[0];
1471917030 // copy mutable arguments back from call to reporttype
@@ -14727,7 +17038,7 @@
1472717038 fprintf(stderr, "%s", " ");
1472817039 // call reportid from ProcCall
1472917040 stack[base + 40LLU] = base;
14730- stack[base + 41LLU] = 951LLU;
17041+ stack[base + 41LLU] = 1109LLU;
1473117042 // arguments for call to reportid
1473217043 stack[base + 42LLU] = stack[base + 15]/*content*/;
1473317044 // set stack-base & callee-address
@@ -14735,7 +17046,7 @@
1473517046 label = 18446744073709551586LLU; // reportid
1473617047 break;
1473717048 }
14738- case 951LLU: // return from reportid to ProcCall
17049+ case 1109LLU: // return from reportid to ProcCall
1473917050 {
1474017051 // copy mutable arguments back from call to reportid
1474117052 fprintf(stderr, "%s", " into mutable parameter ");
@@ -14749,7 +17060,7 @@
1474917060 // call reporttype from ProcCall
1475017061 newstack[0] = (uint64_t)stack; // backup stack location
1475117062 newstack[1] = base;
14752- newstack[2] = 952LLU;
17063+ newstack[2] = 1110LLU;
1475317064 // arguments for call to reporttype
1475417065 newstack[3LLU] = stack[base + 36]/*expected*/;
1475517066 stack = newstack;
@@ -14758,7 +17069,7 @@
1475817069 label = 159LLU; // reporttype
1475917070 break;
1476017071 }
14761- case 952LLU: // return from reporttype to ProcCall
17072+ case 1110LLU: // return from reporttype to ProcCall
1476217073 {
1476317074 uint64_t *oldstack = (uint64_t *)stack[0];
1476417075 // copy mutable arguments back from call to reporttype
@@ -14771,7 +17082,7 @@
1477117082 stack = oldstack;
1477217083 // call reportid from ProcCall
1477317084 stack[base + 40LLU] = base;
14774- stack[base + 41LLU] = 953LLU;
17085+ stack[base + 41LLU] = 1111LLU;
1477517086 // arguments for call to reportid
1477617087 stack[base + 42LLU] = stack[base + 37]/*paramname*/;
1477717088 // set stack-base & callee-address
@@ -14779,25 +17090,25 @@
1477917090 label = 18446744073709551586LLU; // reportid
1478017091 break;
1478117092 }
14782- case 953LLU: // return from reportid to ProcCall
17093+ case 1111LLU: // return from reportid to ProcCall
1478317094 {
1478417095 // copy mutable arguments back from call to reportid
1478517096 fprintf(stderr, "%s", "\n");
1478617097 exit(-1);
14787- label = 941LLU; // alternative complete
17098+ label = 1099LLU; // alternative complete
1478817099 break;
1478917100 }
14790- case 941LLU: // completed if-then-else
17101+ case 1099LLU: // completed if-then-else
1479117102 {
14792- label = 939LLU; // consequent complete
17103+ label = 1097LLU; // consequent complete
1479317104 break;
1479417105 }
14795- case 938LLU: // alternative
17106+ case 1096LLU: // alternative
1479617107 {
14797- label = 939LLU; // alternative complete
17108+ label = 1097LLU; // alternative complete
1479817109 break;
1479917110 }
14800- case 939LLU: // completed if-then-else
17111+ case 1097LLU: // completed if-then-else
1480117112 {
1480217113
1480317114 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 3);
@@ -14804,7 +17115,7 @@
1480417115 // call ~type from ProcCall
1480517116 newstack[0] = (uint64_t)stack; // backup stack location
1480617117 newstack[1] = base;
14807- newstack[2] = 954LLU;
17118+ newstack[2] = 1112LLU;
1480817119 stack = newstack;
1480917120 // set stack-base & callee-address
1481017121 base = 3;
@@ -14811,7 +17122,7 @@
1481117122 label = 148LLU; // ~type
1481217123 break;
1481317124 }
14814- case 954LLU: // return from ~type to ProcCall
17125+ case 1112LLU: // return from ~type to ProcCall
1481517126 {
1481617127 stack = (uint64_t *)stack[0];
1481717128 // releasing toplevel container
@@ -14819,20 +17130,20 @@
1481917130
1482017131 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
1482117132 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
14822- label = 926LLU; // case complete
17133+ label = 1084LLU; // case complete
1482317134 break;
1482417135 }
14825- case 927LLU: // try next case
17136+ case 1085LLU: // try next case
1482617137 {
1482717138 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1482817139 exit(-1);
1482917140 }
14830- case 926LLU: // completed switch
17141+ case 1084LLU: // completed switch
1483117142 {
1483217143 printf("%s", "\n stack[base + ");
1483317144 // call printnr from ProcCall
1483417145 stack[base + 36LLU] = base;
14835- stack[base + 37LLU] = 955LLU;
17146+ stack[base + 37LLU] = 1113LLU;
1483617147 // arguments for call to printnr
1483717148 stack[base + 38LLU] = stack[base + 28]/*sum*/;
1483817149 // set stack-base & callee-address
@@ -14840,13 +17151,13 @@
1484017151 label = 18446744073709551590LLU; // printnr
1484117152 break;
1484217153 }
14843- case 955LLU: // return from printnr to ProcCall
17154+ case 1113LLU: // return from printnr to ProcCall
1484417155 {
1484517156 // copy mutable arguments back from call to printnr
1484617157 printf("%s", "LLU] = ");
1484717158 // call emitvar from ProcCall
1484817159 stack[base + 36LLU] = base;
14849- stack[base + 37LLU] = 956LLU;
17160+ stack[base + 37LLU] = 1114LLU;
1485017161 // arguments for call to emitvar
1485117162 stack[base + 38LLU] = stack[base + 7]/*fnid*/;
1485217163 stack[base + 39LLU] = stack[base + 15]/*content*/;
@@ -14857,31 +17168,31 @@
1485717168 label = 349LLU; // emitvar
1485817169 break;
1485917170 }
14860- case 956LLU: // return from emitvar to ProcCall
17171+ case 1114LLU: // return from emitvar to ProcCall
1486117172 {
1486217173 // copy mutable arguments back from call to emitvar
1486317174 printf("%s", ";");
1486417175 ((uint64_t **)(stack[base + 32]))[1][1] = stack[base + 35];
1486517176 ((uint64_t **)(stack[base + 32]))[1][0] = stack[base + 34];
14866- label = 924LLU; // case complete
17177+ label = 1082LLU; // case complete
1486717178 break;
1486817179 }
14869- case 925LLU: // try next case
17180+ case 1083LLU: // try next case
1487017181 {
1487117182 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1487217183 exit(-1);
1487317184 }
14874- case 924LLU: // completed switch
17185+ case 1082LLU: // completed switch
1487517186 {
14876- label = 923LLU; // consequent complete
17187+ label = 1081LLU; // consequent complete
1487717188 break;
1487817189 }
14879- case 922LLU: // alternative
17190+ case 1080LLU: // alternative
1488017191 {
1488117192 fprintf(stderr, "%s", "expected identifier or constant argument but found ");
1488217193 // call printtoken from ProcCall
1488317194 stack[base + 34LLU] = base;
14884- stack[base + 35LLU] = 957LLU;
17195+ stack[base + 35LLU] = 1115LLU;
1488517196 // arguments for call to printtoken
1488617197 stack[base + 36LLU] = stack[base + 14]/*variant*/;
1488717198 stack[base + 37LLU] = stack[base + 15]/*content*/;
@@ -14890,32 +17201,32 @@
1489017201 label = 18446744073709551583LLU; // printtoken
1489117202 break;
1489217203 }
14893- case 957LLU: // return from printtoken to ProcCall
17204+ case 1115LLU: // return from printtoken to ProcCall
1489417205 {
1489517206 // copy mutable arguments back from call to printtoken
1489617207 fprintf(stderr, "%s", "\n");
1489717208 exit(-1);
14898- label = 923LLU; // alternative complete
17209+ label = 1081LLU; // alternative complete
1489917210 break;
1490017211 }
14901- case 923LLU: // completed if-then-else
17212+ case 1081LLU: // completed if-then-else
1490217213 {
14903- label = 899LLU; // alternative complete
17214+ label = 1057LLU; // alternative complete
1490417215 break;
1490517216 }
14906- case 899LLU: // completed if-then-else
17217+ case 1057LLU: // completed if-then-else
1490717218 {
1490817219 ((struct listnode *)(stack[base + 33]/*previous*/))->data = stack[base + 32];
14909- label = 883LLU; // repeat
17220+ label = 1041LLU; // repeat
1491017221 break;
1491117222 }
14912- case 884LLU: // loop finished
17223+ case 1042LLU: // loop finished
1491317224 {
1491417225 printf("%s", "\n // set stack-base & callee-address");
1491517226 stack[base + 28]/*sum*/ = 0;
1491617227 // call add from ProcCall
1491717228 stack[base + 31LLU] = base;
14918- stack[base + 32LLU] = 958LLU;
17229+ stack[base + 32LLU] = 1116LLU;
1491917230 // arguments for call to add
1492017231 stack[base + 34LLU] = stack[base + 4]/*offset*/;
1492117232 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -14924,7 +17235,7 @@
1492417235 label = 18446744073709551605LLU; // add
1492517236 break;
1492617237 }
14927- case 958LLU: // return from add to ProcCall
17238+ case 1116LLU: // return from add to ProcCall
1492817239 {
1492917240 // copy mutable arguments back from call to add
1493017241 // copy back results provided by call to add
@@ -14931,7 +17242,7 @@
1493117242 stack[base + 28] = stack[base + 33LLU];
1493217243 // call add from ProcCall
1493317244 stack[base + 31LLU] = base;
14934- stack[base + 32LLU] = 959LLU;
17245+ stack[base + 32LLU] = 1117LLU;
1493517246 // arguments for call to add
1493617247 stack[base + 34LLU] = 2LLU;
1493717248 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -14940,7 +17251,7 @@
1494017251 label = 18446744073709551605LLU; // add
1494117252 break;
1494217253 }
14943- case 959LLU: // return from add to ProcCall
17254+ case 1117LLU: // return from add to ProcCall
1494417255 {
1494517256 // copy mutable arguments back from call to add
1494617257 // copy back results provided by call to add
@@ -14947,7 +17258,7 @@
1494717258 stack[base + 28] = stack[base + 33LLU];
1494817259 // call add from ProcCall
1494917260 stack[base + 31LLU] = base;
14950- stack[base + 32LLU] = 960LLU;
17261+ stack[base + 32LLU] = 1118LLU;
1495117262 // arguments for call to add
1495217263 stack[base + 34LLU] = stack[base + 9]/*fnrescount*/;
1495317264 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -14956,7 +17267,7 @@
1495617267 label = 18446744073709551605LLU; // add
1495717268 break;
1495817269 }
14959- case 960LLU: // return from add to ProcCall
17270+ case 1118LLU: // return from add to ProcCall
1496017271 {
1496117272 // copy mutable arguments back from call to add
1496217273 // copy back results provided by call to add
@@ -14963,7 +17274,7 @@
1496317274 stack[base + 28] = stack[base + 33LLU];
1496417275 // call add from ProcCall
1496517276 stack[base + 31LLU] = base;
14966- stack[base + 32LLU] = 961LLU;
17277+ stack[base + 32LLU] = 1119LLU;
1496717278 // arguments for call to add
1496817279 stack[base + 34LLU] = stack[base + 10]/*fnargcount*/;
1496917280 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -14972,7 +17283,7 @@
1497217283 label = 18446744073709551605LLU; // add
1497317284 break;
1497417285 }
14975- case 961LLU: // return from add to ProcCall
17286+ case 1119LLU: // return from add to ProcCall
1497617287 {
1497717288 // copy mutable arguments back from call to add
1497817289 // copy back results provided by call to add
@@ -14980,7 +17291,7 @@
1498017291 printf("%s", "\n base += ");
1498117292 // call printnr from ProcCall
1498217293 stack[base + 31LLU] = base;
14983- stack[base + 32LLU] = 962LLU;
17294+ stack[base + 32LLU] = 1120LLU;
1498417295 // arguments for call to printnr
1498517296 stack[base + 33LLU] = stack[base + 28]/*sum*/;
1498617297 // set stack-base & callee-address
@@ -14988,7 +17299,7 @@
1498817299 label = 18446744073709551590LLU; // printnr
1498917300 break;
1499017301 }
14991- case 962LLU: // return from printnr to ProcCall
17302+ case 1120LLU: // return from printnr to ProcCall
1499217303 {
1499317304 // copy mutable arguments back from call to printnr
1499417305 printf("%s", "LLU;");
@@ -14995,7 +17306,7 @@
1499517306 printf("%s", "\n label = ");
1499617307 // call printnr from ProcCall
1499717308 stack[base + 31LLU] = base;
14998- stack[base + 32LLU] = 963LLU;
17309+ stack[base + 32LLU] = 1121LLU;
1499917310 // arguments for call to printnr
1500017311 stack[base + 33LLU] = stack[base + 19]/*celabel*/;
1500117312 // set stack-base & callee-address
@@ -15003,13 +17314,13 @@
1500317314 label = 18446744073709551590LLU; // printnr
1500417315 break;
1500517316 }
15006- case 963LLU: // return from printnr to ProcCall
17317+ case 1121LLU: // return from printnr to ProcCall
1500717318 {
1500817319 // copy mutable arguments back from call to printnr
1500917320 printf("%s", "LLU; // ");
1501017321 // call printid from ProcCall
1501117322 stack[base + 31LLU] = base;
15012- stack[base + 32LLU] = 964LLU;
17323+ stack[base + 32LLU] = 1122LLU;
1501317324 // arguments for call to printid
1501417325 stack[base + 33LLU] = stack[base + 23]/*ceid*/;
1501517326 // set stack-base & callee-address
@@ -15017,7 +17328,7 @@
1501717328 label = 18446744073709551587LLU; // printid
1501817329 break;
1501917330 }
15020- case 964LLU: // return from printid to ProcCall
17331+ case 1122LLU: // return from printid to ProcCall
1502117332 {
1502217333 // copy mutable arguments back from call to printid
1502317334 printf("%s", "\n break;");
@@ -15025,7 +17336,7 @@
1502517336 printf("%s", "\n case ");
1502617337 // call printnr from ProcCall
1502717338 stack[base + 31LLU] = base;
15028- stack[base + 32LLU] = 965LLU;
17339+ stack[base + 32LLU] = 1123LLU;
1502917340 // arguments for call to printnr
1503017341 stack[base + 33LLU] = stack[base + 16]/*label*/;
1503117342 // set stack-base & callee-address
@@ -15033,13 +17344,13 @@
1503317344 label = 18446744073709551590LLU; // printnr
1503417345 break;
1503517346 }
15036- case 965LLU: // return from printnr to ProcCall
17347+ case 1123LLU: // return from printnr to ProcCall
1503717348 {
1503817349 // copy mutable arguments back from call to printnr
1503917350 printf("%s", "LLU: // return from ");
1504017351 // call printid from ProcCall
1504117352 stack[base + 31LLU] = base;
15042- stack[base + 32LLU] = 966LLU;
17353+ stack[base + 32LLU] = 1124LLU;
1504317354 // arguments for call to printid
1504417355 stack[base + 33LLU] = stack[base + 23]/*ceid*/;
1504517356 // set stack-base & callee-address
@@ -15047,13 +17358,13 @@
1504717358 label = 18446744073709551587LLU; // printid
1504817359 break;
1504917360 }
15050- case 966LLU: // return from printid to ProcCall
17361+ case 1124LLU: // return from printid to ProcCall
1505117362 {
1505217363 // copy mutable arguments back from call to printid
1505317364 printf("%s", " to ");
1505417365 // call printid from ProcCall
1505517366 stack[base + 31LLU] = base;
15056- stack[base + 32LLU] = 967LLU;
17367+ stack[base + 32LLU] = 1125LLU;
1505717368 // arguments for call to printid
1505817369 stack[base + 33LLU] = stack[base + 7]/*fnid*/;
1505917370 // set stack-base & callee-address
@@ -15061,7 +17372,7 @@
1506117372 label = 18446744073709551587LLU; // printid
1506217373 break;
1506317374 }
15064- case 967LLU: // return from printid to ProcCall
17375+ case 1125LLU: // return from printid to ProcCall
1506517376 {
1506617377 // copy mutable arguments back from call to printid
1506717378 printf("%s", "\n {");
@@ -15068,7 +17379,7 @@
1506817379 printf("%s", "\n // copy mutable arguments back from call to ");
1506917380 // call printid from ProcCall
1507017381 stack[base + 31LLU] = base;
15071- stack[base + 32LLU] = 968LLU;
17382+ stack[base + 32LLU] = 1126LLU;
1507217383 // arguments for call to printid
1507317384 stack[base + 33LLU] = stack[base + 23]/*ceid*/;
1507417385 // set stack-base & callee-address
@@ -15076,17 +17387,17 @@
1507617387 label = 18446744073709551587LLU; // printid
1507717388 break;
1507817389 }
15079- case 968LLU: // return from printid to ProcCall
17390+ case 1126LLU: // return from printid to ProcCall
1508017391 {
1508117392 // copy mutable arguments back from call to printid
15082- label = 969LLU; // start to repeat
17393+ label = 1127LLU; // start to repeat
1508317394 break;
1508417395 }
15085- case 969LLU: // repeat from here
17396+ case 1127LLU: // repeat from here
1508617397 {
1508717398 if(!stack[base + 18])
1508817399 {
15089- label = 970LLU; // break loop
17400+ label = 1128LLU; // break loop
1509017401 break;
1509117402 }
1509217403
@@ -15099,7 +17410,7 @@
1509917410 }
1510017411 if(/*idnr*/0 != ((uint64_t *)(stack[base + 31]/*idnr*/))[0])
1510117412 {
15102- label = 972LLU; // jump to alternative
17413+ label = 1130LLU; // jump to alternative
1510317414 break;
1510417415 }
1510517416
@@ -15110,7 +17421,7 @@
1511017421 printf("%s", "\n ");
1511117422 // call emitvar from ProcCall
1511217423 stack[base + 34LLU] = base;
15113- stack[base + 35LLU] = 973LLU;
17424+ stack[base + 35LLU] = 1131LLU;
1511417425 // arguments for call to emitvar
1511517426 stack[base + 36LLU] = stack[base + 7]/*fnid*/;
1511617427 stack[base + 37LLU] = stack[base + 32]/*content*/;
@@ -15121,13 +17432,13 @@
1512117432 label = 349LLU; // emitvar
1512217433 break;
1512317434 }
15124- case 973LLU: // return from emitvar to ProcCall
17435+ case 1131LLU: // return from emitvar to ProcCall
1512517436 {
1512617437 // copy mutable arguments back from call to emitvar
1512717438 printf("%s", " = stack[base + ");
1512817439 // call printnr from ProcCall
1512917440 stack[base + 34LLU] = base;
15130- stack[base + 35LLU] = 974LLU;
17441+ stack[base + 35LLU] = 1132LLU;
1513117442 // arguments for call to printnr
1513217443 stack[base + 36LLU] = stack[base + 33]/*sum*/;
1513317444 // set stack-base & callee-address
@@ -15135,21 +17446,21 @@
1513517446 label = 18446744073709551590LLU; // printnr
1513617447 break;
1513717448 }
15138- case 974LLU: // return from printnr to ProcCall
17449+ case 1132LLU: // return from printnr to ProcCall
1513917450 {
1514017451 // copy mutable arguments back from call to printnr
1514117452 printf("%s", "LLU];");
1514217453 ((uint64_t **)(stack[base + 31]))[1][1] = stack[base + 33];
1514317454 ((uint64_t **)(stack[base + 31]))[1][0] = stack[base + 32];
15144- label = 971LLU; // case complete
17455+ label = 1129LLU; // case complete
1514517456 break;
1514617457 }
15147- case 972LLU: // try next case
17458+ case 1130LLU: // try next case
1514817459 {
1514917460 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1515017461 exit(-1);
1515117462 }
15152- case 971LLU: // completed switch
17463+ case 1129LLU: // completed switch
1515317464 {
1515417465
1515517466 uint64_t *newstack = (uint64_t *)(stack[base + 31] - sizeof(uint64_t) * 3);
@@ -15156,7 +17467,7 @@
1515617467 // call ~idnr from ProcCall
1515717468 newstack[0] = (uint64_t)stack; // backup stack location
1515817469 newstack[1] = base;
15159- newstack[2] = 975LLU;
17470+ newstack[2] = 1133LLU;
1516017471 stack = newstack;
1516117472 // set stack-base & callee-address
1516217473 base = 3;
@@ -15163,20 +17474,20 @@
1516317474 label = 371LLU; // ~idnr
1516417475 break;
1516517476 }
15166- case 975LLU: // return from ~idnr to ProcCall
17477+ case 1133LLU: // return from ~idnr to ProcCall
1516717478 {
1516817479 stack = (uint64_t *)stack[0];
1516917480 // releasing toplevel container
1517017481 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 31] - sizeof(uint64_t) * 3));
1517117482
15172- label = 969LLU; // repeat
17483+ label = 1127LLU; // repeat
1517317484 break;
1517417485 }
15175- case 970LLU: // loop finished
17486+ case 1128LLU: // loop finished
1517617487 {
1517717488 if(!stack[base + 26]/*cerescount*/)
1517817489 {
15179- label = 976LLU; // jump to alternative
17490+ label = 1134LLU; // jump to alternative
1518017491 break;
1518117492 }
1518217493
@@ -15184,7 +17495,7 @@
1518417495 printf("%s", "\n // copy back results provided by call to ");
1518517496 // call printid from ProcCall
1518617497 stack[base + 31LLU] = base;
15187- stack[base + 32LLU] = 978LLU;
17498+ stack[base + 32LLU] = 1136LLU;
1518817499 // arguments for call to printid
1518917500 stack[base + 33LLU] = stack[base + 23]/*ceid*/;
1519017501 // set stack-base & callee-address
@@ -15192,19 +17503,19 @@
1519217503 label = 18446744073709551587LLU; // printid
1519317504 break;
1519417505 }
15195- case 978LLU: // return from printid to ProcCall
17506+ case 1136LLU: // return from printid to ProcCall
1519617507 {
1519717508 // copy mutable arguments back from call to printid
1519817509 stack[base + 29]/*n*/ = stack[base + 26]/*cerescount*/;
1519917510 flippedassign(stack[base + 20]/*cerestypes*/, &stack[base + 31]);
15200- label = 979LLU; // start to repeat
17511+ label = 1137LLU; // start to repeat
1520117512 break;
1520217513 }
15203- case 979LLU: // repeat from here
17514+ case 1137LLU: // repeat from here
1520417515 {
1520517516 if(!stack[base + 31])
1520617517 {
15207- label = 980LLU; // break loop
17518+ label = 1138LLU; // break loop
1520817519 break;
1520917520 }
1521017521
@@ -15214,7 +17525,7 @@
1521417525 stack[base + 31] = (uint64_t)(((const struct listnode *)(stack[base + 31]))->next);
1521517526 // call sub from ProcCall
1521617527 stack[base + 34LLU] = base;
15217- stack[base + 35LLU] = 981LLU;
17528+ stack[base + 35LLU] = 1139LLU;
1521817529 // arguments for call to sub
1521917530 stack[base + 37LLU] = stack[base + 26]/*cerescount*/;
1522017531 stack[base + 38LLU] = stack[base + 29]/*n*/;
@@ -15223,7 +17534,7 @@
1522317534 label = 18446744073709551604LLU; // sub
1522417535 break;
1522517536 }
15226- case 981LLU: // return from sub to ProcCall
17537+ case 1139LLU: // return from sub to ProcCall
1522717538 {
1522817539 // copy mutable arguments back from call to sub
1522917540 // copy back results provided by call to sub
@@ -15230,7 +17541,7 @@
1523017541 stack[base + 30] = stack[base + 36LLU];
1523117542 // call sub from ProcCall
1523217543 stack[base + 34LLU] = base;
15233- stack[base + 35LLU] = 982LLU;
17544+ stack[base + 35LLU] = 1140LLU;
1523417545 // arguments for call to sub
1523517546 stack[base + 37LLU] = stack[base + 29]/*n*/;
1523617547 stack[base + 38LLU] = 1LLU;
@@ -15239,7 +17550,7 @@
1523917550 label = 18446744073709551604LLU; // sub
1524017551 break;
1524117552 }
15242- case 982LLU: // return from sub to ProcCall
17553+ case 1140LLU: // return from sub to ProcCall
1524317554 {
1524417555 // copy mutable arguments back from call to sub
1524517556 // copy back results provided by call to sub
@@ -15248,7 +17559,7 @@
1524817559 struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/;
1524917560 if(!list)
1525017561 {
15251- label = 983LLU; // jump to alternative
17562+ label = 1141LLU; // jump to alternative
1525217563 break;
1525317564 }
1525417565
@@ -15260,7 +17571,7 @@
1526017571 }
1526117572 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 34]/*typeidx*/))[0])
1526217573 {
15263- label = 986LLU; // jump to alternative
17574+ label = 1144LLU; // jump to alternative
1526417575 break;
1526517576 }
1526617577
@@ -15270,7 +17581,7 @@
1527017581 // case
1527117582 if(/*result*/0 != ((uint64_t *)(stack[base + 32]/*result*/))[0])
1527217583 {
15273- label = 988LLU; // jump to alternative
17584+ label = 1146LLU; // jump to alternative
1527417585 break;
1527517586 }
1527617587
@@ -15288,7 +17599,7 @@
1528817599 // call equtype from ProcCall
1528917600 newstack[0] = (uint64_t)stack; // backup stack location
1529017601 newstack[1] = base;
15291- newstack[2] = 989LLU;
17602+ newstack[2] = 1147LLU;
1529217603 // arguments for call to equtype
1529317604 newstack[4LLU] = stack[base + 35]/*dsttype*/;
1529417605 newstack[5LLU] = stack[base + 37]/*srctype*/;
@@ -15298,7 +17609,7 @@
1529817609 label = 170LLU; // equtype
1529917610 break;
1530017611 }
15301- case 989LLU: // return from equtype to ProcCall
17612+ case 1147LLU: // return from equtype to ProcCall
1530217613 {
1530317614 uint64_t *oldstack = (uint64_t *)stack[0];
1530417615 // copy mutable arguments back from call to equtype
@@ -15313,20 +17624,20 @@
1531317624 stack = oldstack;
1531417625 if(!stack[base + 17]/*isequal*/)
1531517626 {
15316- label = 990LLU; // jump to alternative
17627+ label = 1148LLU; // jump to alternative
1531717628 break;
1531817629 }
1531917630
1532017631 // consequent
15321- label = 991LLU; // consequent complete
17632+ label = 1149LLU; // consequent complete
1532217633 break;
1532317634 }
15324- case 990LLU: // alternative
17635+ case 1148LLU: // alternative
1532517636 {
1532617637 fprintf(stderr, "%s", "in function ");
1532717638 // call reportid from ProcCall
1532817639 stack[base + 39LLU] = base;
15329- stack[base + 40LLU] = 992LLU;
17640+ stack[base + 40LLU] = 1150LLU;
1533017641 // arguments for call to reportid
1533117642 stack[base + 41LLU] = stack[base + 7]/*fnid*/;
1533217643 // set stack-base & callee-address
@@ -15334,13 +17645,13 @@
1533417645 label = 18446744073709551586LLU; // reportid
1533517646 break;
1533617647 }
15337- case 992LLU: // return from reportid to ProcCall
17648+ case 1150LLU: // return from reportid to ProcCall
1533817649 {
1533917650 // copy mutable arguments back from call to reportid
1534017651 fprintf(stderr, "%s", " call to ");
1534117652 // call reportid from ProcCall
1534217653 stack[base + 39LLU] = base;
15343- stack[base + 40LLU] = 993LLU;
17654+ stack[base + 40LLU] = 1151LLU;
1534417655 // arguments for call to reportid
1534517656 stack[base + 41LLU] = stack[base + 23]/*ceid*/;
1534617657 // set stack-base & callee-address
@@ -15348,13 +17659,13 @@
1534817659 label = 18446744073709551586LLU; // reportid
1534917660 break;
1535017661 }
15351- case 993LLU: // return from reportid to ProcCall
17662+ case 1151LLU: // return from reportid to ProcCall
1535217663 {
1535317664 // copy mutable arguments back from call to reportid
1535417665 fprintf(stderr, "%s", " at position ");
1535517666 // call reportnr from ProcCall
1535617667 stack[base + 39LLU] = base;
15357- stack[base + 40LLU] = 994LLU;
17668+ stack[base + 40LLU] = 1152LLU;
1535817669 // arguments for call to reportnr
1535917670 stack[base + 41LLU] = stack[base + 30]/*index*/;
1536017671 // set stack-base & callee-address
@@ -15362,7 +17673,7 @@
1536217673 label = 18446744073709551589LLU; // reportnr
1536317674 break;
1536417675 }
15365- case 994LLU: // return from reportnr to ProcCall
17676+ case 1152LLU: // return from reportnr to ProcCall
1536617677 {
1536717678 // copy mutable arguments back from call to reportnr
1536817679 fprintf(stderr, "%s", " cannot return source of type ");
@@ -15376,7 +17687,7 @@
1537617687 // call reporttype from ProcCall
1537717688 newstack[0] = (uint64_t)stack; // backup stack location
1537817689 newstack[1] = base;
15379- newstack[2] = 995LLU;
17690+ newstack[2] = 1153LLU;
1538017691 // arguments for call to reporttype
1538117692 newstack[3LLU] = stack[base + 37]/*srctype*/;
1538217693 stack = newstack;
@@ -15385,7 +17696,7 @@
1538517696 label = 159LLU; // reporttype
1538617697 break;
1538717698 }
15388- case 995LLU: // return from reporttype to ProcCall
17699+ case 1153LLU: // return from reporttype to ProcCall
1538917700 {
1539017701 uint64_t *oldstack = (uint64_t *)stack[0];
1539117702 // copy mutable arguments back from call to reporttype
@@ -15407,7 +17718,7 @@
1540717718 // call reporttype from ProcCall
1540817719 newstack[0] = (uint64_t)stack; // backup stack location
1540917720 newstack[1] = base;
15410- newstack[2] = 996LLU;
17721+ newstack[2] = 1154LLU;
1541117722 // arguments for call to reporttype
1541217723 newstack[3LLU] = stack[base + 35]/*dsttype*/;
1541317724 stack = newstack;
@@ -15416,7 +17727,7 @@
1541617727 label = 159LLU; // reporttype
1541717728 break;
1541817729 }
15419- case 996LLU: // return from reporttype to ProcCall
17730+ case 1154LLU: // return from reporttype to ProcCall
1542017731 {
1542117732 uint64_t *oldstack = (uint64_t *)stack[0];
1542217733 // copy mutable arguments back from call to reporttype
@@ -15429,15 +17740,15 @@
1542917740 stack = oldstack;
1543017741 fprintf(stderr, "%s", "\n");
1543117742 exit(-1);
15432- label = 991LLU; // alternative complete
17743+ label = 1149LLU; // alternative complete
1543317744 break;
1543417745 }
15435- case 991LLU: // completed if-then-else
17746+ case 1149LLU: // completed if-then-else
1543617747 {
1543717748 stack[base + 28]/*sum*/ = 0;
1543817749 // call add from ProcCall
1543917750 stack[base + 39LLU] = base;
15440- stack[base + 40LLU] = 997LLU;
17751+ stack[base + 40LLU] = 1155LLU;
1544117752 // arguments for call to add
1544217753 stack[base + 42LLU] = stack[base + 9]/*fnrescount*/;
1544317754 stack[base + 43LLU] = stack[base + 28]/*sum*/;
@@ -15446,7 +17757,7 @@
1544617757 label = 18446744073709551605LLU; // add
1544717758 break;
1544817759 }
15449- case 997LLU: // return from add to ProcCall
17760+ case 1155LLU: // return from add to ProcCall
1545017761 {
1545117762 // copy mutable arguments back from call to add
1545217763 // copy back results provided by call to add
@@ -15453,7 +17764,7 @@
1545317764 stack[base + 28] = stack[base + 41LLU];
1545417765 // call add from ProcCall
1545517766 stack[base + 39LLU] = base;
15456- stack[base + 40LLU] = 998LLU;
17767+ stack[base + 40LLU] = 1156LLU;
1545717768 // arguments for call to add
1545817769 stack[base + 42LLU] = stack[base + 10]/*fnargcount*/;
1545917770 stack[base + 43LLU] = stack[base + 28]/*sum*/;
@@ -15462,7 +17773,7 @@
1546217773 label = 18446744073709551605LLU; // add
1546317774 break;
1546417775 }
15465- case 998LLU: // return from add to ProcCall
17776+ case 1156LLU: // return from add to ProcCall
1546617777 {
1546717778 // copy mutable arguments back from call to add
1546817779 // copy back results provided by call to add
@@ -15469,7 +17780,7 @@
1546917780 stack[base + 28] = stack[base + 41LLU];
1547017781 // call add from ProcCall
1547117782 stack[base + 39LLU] = base;
15472- stack[base + 40LLU] = 999LLU;
17783+ stack[base + 40LLU] = 1157LLU;
1547317784 // arguments for call to add
1547417785 stack[base + 42LLU] = stack[base + 4]/*offset*/;
1547517786 stack[base + 43LLU] = stack[base + 28]/*sum*/;
@@ -15478,7 +17789,7 @@
1547817789 label = 18446744073709551605LLU; // add
1547917790 break;
1548017791 }
15481- case 999LLU: // return from add to ProcCall
17792+ case 1157LLU: // return from add to ProcCall
1548217793 {
1548317794 // copy mutable arguments back from call to add
1548417795 // copy back results provided by call to add
@@ -15485,7 +17796,7 @@
1548517796 stack[base + 28] = stack[base + 41LLU];
1548617797 // call add from ProcCall
1548717798 stack[base + 39LLU] = base;
15488- stack[base + 40LLU] = 1000LLU;
17799+ stack[base + 40LLU] = 1158LLU;
1548917800 // arguments for call to add
1549017801 stack[base + 42LLU] = 2LLU;
1549117802 stack[base + 43LLU] = stack[base + 28]/*sum*/;
@@ -15494,7 +17805,7 @@
1549417805 label = 18446744073709551605LLU; // add
1549517806 break;
1549617807 }
15497- case 1000LLU: // return from add to ProcCall
17808+ case 1158LLU: // return from add to ProcCall
1549817809 {
1549917810 // copy mutable arguments back from call to add
1550017811 // copy back results provided by call to add
@@ -15501,7 +17812,7 @@
1550117812 stack[base + 28] = stack[base + 41LLU];
1550217813 // call add from ProcCall
1550317814 stack[base + 39LLU] = base;
15504- stack[base + 40LLU] = 1001LLU;
17815+ stack[base + 40LLU] = 1159LLU;
1550517816 // arguments for call to add
1550617817 stack[base + 42LLU] = stack[base + 30]/*index*/;
1550717818 stack[base + 43LLU] = stack[base + 28]/*sum*/;
@@ -15510,7 +17821,7 @@
1551017821 label = 18446744073709551605LLU; // add
1551117822 break;
1551217823 }
15513- case 1001LLU: // return from add to ProcCall
17824+ case 1159LLU: // return from add to ProcCall
1551417825 {
1551517826 // copy mutable arguments back from call to add
1551617827 // copy back results provided by call to add
@@ -15518,7 +17829,7 @@
1551817829 printf("%s", "\n ");
1551917830 // call emitvaridx from ProcCall
1552017831 stack[base + 39LLU] = base;
15521- stack[base + 40LLU] = 1002LLU;
17832+ stack[base + 40LLU] = 1160LLU;
1552217833 // arguments for call to emitvaridx
1552317834 stack[base + 41LLU] = stack[base + 36]/*INDEX*/;
1552417835 // set stack-base & callee-address
@@ -15526,13 +17837,13 @@
1552617837 label = 347LLU; // emitvaridx
1552717838 break;
1552817839 }
15529- case 1002LLU: // return from emitvaridx to ProcCall
17840+ case 1160LLU: // return from emitvaridx to ProcCall
1553017841 {
1553117842 // copy mutable arguments back from call to emitvaridx
1553217843 printf("%s", " = stack[base + ");
1553317844 // call printnr from ProcCall
1553417845 stack[base + 39LLU] = base;
15535- stack[base + 40LLU] = 1003LLU;
17846+ stack[base + 40LLU] = 1161LLU;
1553617847 // arguments for call to printnr
1553717848 stack[base + 41LLU] = stack[base + 28]/*sum*/;
1553817849 // set stack-base & callee-address
@@ -15540,33 +17851,33 @@
1554017851 label = 18446744073709551590LLU; // printnr
1554117852 break;
1554217853 }
15543- case 1003LLU: // return from printnr to ProcCall
17854+ case 1161LLU: // return from printnr to ProcCall
1554417855 {
1554517856 // copy mutable arguments back from call to printnr
1554617857 printf("%s", "LLU];");
1554717858 ((uint64_t **)(stack[base + 32]))[1][1] = stack[base + 38];
1554817859 ((uint64_t **)(stack[base + 32]))[1][0] = stack[base + 37];
15549- label = 987LLU; // case complete
17860+ label = 1145LLU; // case complete
1555017861 break;
1555117862 }
15552- case 988LLU: // try next case
17863+ case 1146LLU: // try next case
1555317864 {
1555417865 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1555517866 exit(-1);
1555617867 }
15557- case 987LLU: // completed switch
17868+ case 1145LLU: // completed switch
1555817869 {
1555917870 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 36];
1556017871 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 35];
15561- label = 985LLU; // case complete
17872+ label = 1143LLU; // case complete
1556217873 break;
1556317874 }
15564- case 986LLU: // try next case
17875+ case 1144LLU: // try next case
1556517876 {
1556617877 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1556717878 exit(-1);
1556817879 }
15569- case 985LLU: // completed switch
17880+ case 1143LLU: // completed switch
1557017881 {
1557117882
1557217883 uint64_t *newstack = (uint64_t *)(stack[base + 34] - sizeof(uint64_t) * 3);
@@ -15573,7 +17884,7 @@
1557317884 // call ~typeidx from ProcCall
1557417885 newstack[0] = (uint64_t)stack; // backup stack location
1557517886 newstack[1] = base;
15576- newstack[2] = 1004LLU;
17887+ newstack[2] = 1162LLU;
1557717888 stack = newstack;
1557817889 // set stack-base & callee-address
1557917890 base = 3;
@@ -15580,21 +17891,21 @@
1558017891 label = 188LLU; // ~typeidx
1558117892 break;
1558217893 }
15583- case 1004LLU: // return from ~typeidx to ProcCall
17894+ case 1162LLU: // return from ~typeidx to ProcCall
1558417895 {
1558517896 stack = (uint64_t *)stack[0];
1558617897 // releasing toplevel container
1558717898 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 34] - sizeof(uint64_t) * 3));
1558817899
15589- label = 984LLU; // consequent complete
17900+ label = 1142LLU; // consequent complete
1559017901 break;
1559117902 }
15592- case 983LLU: // alternative
17903+ case 1141LLU: // alternative
1559317904 {
1559417905 fprintf(stderr, "%s", "in function ");
1559517906 // call reportid from ProcCall
1559617907 stack[base + 35LLU] = base;
15597- stack[base + 36LLU] = 1005LLU;
17908+ stack[base + 36LLU] = 1163LLU;
1559817909 // arguments for call to reportid
1559917910 stack[base + 37LLU] = stack[base + 7]/*fnid*/;
1560017911 // set stack-base & callee-address
@@ -15602,13 +17913,13 @@
1560217913 label = 18446744073709551586LLU; // reportid
1560317914 break;
1560417915 }
15605- case 1005LLU: // return from reportid to ProcCall
17916+ case 1163LLU: // return from reportid to ProcCall
1560617917 {
1560717918 // copy mutable arguments back from call to reportid
1560817919 fprintf(stderr, "%s", " call to ");
1560917920 // call reportid from ProcCall
1561017921 stack[base + 35LLU] = base;
15611- stack[base + 36LLU] = 1006LLU;
17922+ stack[base + 36LLU] = 1164LLU;
1561217923 // arguments for call to reportid
1561317924 stack[base + 37LLU] = stack[base + 23]/*ceid*/;
1561417925 // set stack-base & callee-address
@@ -15616,13 +17927,13 @@
1561617927 label = 18446744073709551586LLU; // reportid
1561717928 break;
1561817929 }
15619- case 1006LLU: // return from reportid to ProcCall
17930+ case 1164LLU: // return from reportid to ProcCall
1562017931 {
1562117932 // copy mutable arguments back from call to reportid
1562217933 fprintf(stderr, "%s", " at position ");
1562317934 // call reportnr from ProcCall
1562417935 stack[base + 35LLU] = base;
15625- stack[base + 36LLU] = 1007LLU;
17936+ stack[base + 36LLU] = 1165LLU;
1562617937 // arguments for call to reportnr
1562717938 stack[base + 37LLU] = stack[base + 30]/*index*/;
1562817939 // set stack-base & callee-address
@@ -15630,37 +17941,37 @@
1563017941 label = 18446744073709551589LLU; // reportnr
1563117942 break;
1563217943 }
15633- case 1007LLU: // return from reportnr to ProcCall
17944+ case 1165LLU: // return from reportnr to ProcCall
1563417945 {
1563517946 // copy mutable arguments back from call to reportnr
1563617947 fprintf(stderr, "%s", " not enough destination-variables for results");
1563717948 fprintf(stderr, "%s", "\n");
1563817949 exit(-1);
15639- label = 984LLU; // alternative complete
17950+ label = 1142LLU; // alternative complete
1564017951 break;
1564117952 }
15642- case 984LLU: // completed if-then-else
17953+ case 1142LLU: // completed if-then-else
1564317954 {
1564417955 ((struct listnode *)(stack[base + 33]/*previous*/))->data = stack[base + 32];
15645- label = 979LLU; // repeat
17956+ label = 1137LLU; // repeat
1564617957 break;
1564717958 }
15648- case 980LLU: // loop finished
17959+ case 1138LLU: // loop finished
1564917960 {
15650- label = 977LLU; // consequent complete
17961+ label = 1135LLU; // consequent complete
1565117962 break;
1565217963 }
15653- case 976LLU: // alternative
17964+ case 1134LLU: // alternative
1565417965 {
15655- label = 977LLU; // alternative complete
17966+ label = 1135LLU; // alternative complete
1565617967 break;
1565717968 }
15658- case 977LLU: // completed if-then-else
17969+ case 1135LLU: // completed if-then-else
1565917970 {
1566017971 stack[base + 28]/*sum*/ = 0;
1566117972 // call add from ProcCall
1566217973 stack[base + 31LLU] = base;
15663- stack[base + 32LLU] = 1008LLU;
17974+ stack[base + 32LLU] = 1166LLU;
1566417975 // arguments for call to add
1566517976 stack[base + 34LLU] = stack[base + 4]/*offset*/;
1566617977 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -15669,7 +17980,7 @@
1566917980 label = 18446744073709551605LLU; // add
1567017981 break;
1567117982 }
15672- case 1008LLU: // return from add to ProcCall
17983+ case 1166LLU: // return from add to ProcCall
1567317984 {
1567417985 // copy mutable arguments back from call to add
1567517986 // copy back results provided by call to add
@@ -15676,7 +17987,7 @@
1567617987 stack[base + 28] = stack[base + 33LLU];
1567717988 // call add from ProcCall
1567817989 stack[base + 31LLU] = base;
15679- stack[base + 32LLU] = 1009LLU;
17990+ stack[base + 32LLU] = 1167LLU;
1568017991 // arguments for call to add
1568117992 stack[base + 34LLU] = 2LLU;
1568217993 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -15685,7 +17996,7 @@
1568517996 label = 18446744073709551605LLU; // add
1568617997 break;
1568717998 }
15688- case 1009LLU: // return from add to ProcCall
17999+ case 1167LLU: // return from add to ProcCall
1568918000 {
1569018001 // copy mutable arguments back from call to add
1569118002 // copy back results provided by call to add
@@ -15692,7 +18003,7 @@
1569218003 stack[base + 28] = stack[base + 33LLU];
1569318004 // call add from ProcCall
1569418005 stack[base + 31LLU] = base;
15695- stack[base + 32LLU] = 1010LLU;
18006+ stack[base + 32LLU] = 1168LLU;
1569618007 // arguments for call to add
1569718008 stack[base + 34LLU] = stack[base + 26]/*cerescount*/;
1569818009 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -15701,7 +18012,7 @@
1570118012 label = 18446744073709551605LLU; // add
1570218013 break;
1570318014 }
15704- case 1010LLU: // return from add to ProcCall
18015+ case 1168LLU: // return from add to ProcCall
1570518016 {
1570618017 // copy mutable arguments back from call to add
1570718018 // copy back results provided by call to add
@@ -15708,7 +18019,7 @@
1570818019 stack[base + 28] = stack[base + 33LLU];
1570918020 // call add from ProcCall
1571018021 stack[base + 31LLU] = base;
15711- stack[base + 32LLU] = 1011LLU;
18022+ stack[base + 32LLU] = 1169LLU;
1571218023 // arguments for call to add
1571318024 stack[base + 34LLU] = stack[base + 27]/*ceargcount*/;
1571418025 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -15717,7 +18028,7 @@
1571718028 label = 18446744073709551605LLU; // add
1571818029 break;
1571918030 }
15720- case 1011LLU: // return from add to ProcCall
18031+ case 1169LLU: // return from add to ProcCall
1572118032 {
1572218033 // copy mutable arguments back from call to add
1572318034 // copy back results provided by call to add
@@ -15724,7 +18035,7 @@
1572418035 stack[base + 28] = stack[base + 33LLU];
1572518036 // call add from ProcCall
1572618037 stack[base + 31LLU] = base;
15727- stack[base + 32LLU] = 1012LLU;
18038+ stack[base + 32LLU] = 1170LLU;
1572818039 // arguments for call to add
1572918040 stack[base + 34LLU] = stack[base + 22]/*cemaxcount*/;
1573018041 stack[base + 35LLU] = stack[base + 28]/*sum*/;
@@ -15733,7 +18044,7 @@
1573318044 label = 18446744073709551605LLU; // add
1573418045 break;
1573518046 }
15736- case 1012LLU: // return from add to ProcCall
18047+ case 1170LLU: // return from add to ProcCall
1573718048 {
1573818049 // copy mutable arguments back from call to add
1573918050 // copy back results provided by call to add
@@ -15740,7 +18051,7 @@
1574018051 stack[base + 28] = stack[base + 33LLU];
1574118052 // call max from ProcCall
1574218053 stack[base + 31LLU] = base;
15743- stack[base + 32LLU] = 1013LLU;
18054+ stack[base + 32LLU] = 1171LLU;
1574418055 // arguments for call to max
1574518056 stack[base + 34LLU] = stack[base + 28]/*sum*/;
1574618057 stack[base + 35LLU] = stack[base + 11]/*fnmaxcount*/;
@@ -15749,19 +18060,19 @@
1574918060 label = 18446744073709551606LLU; // max
1575018061 break;
1575118062 }
15752- case 1013LLU: // return from max to ProcCall
18063+ case 1171LLU: // return from max to ProcCall
1575318064 {
1575418065 // copy mutable arguments back from call to max
1575518066 // copy back results provided by call to max
1575618067 stack[base + 11] = stack[base + 33LLU];
15757- label = 700LLU; // alternative complete
18068+ label = 858LLU; // alternative complete
1575818069 break;
1575918070 }
15760- case 700LLU: // completed if-then-else
18071+ case 858LLU: // completed if-then-else
1576118072 {
1576218073 if(!stack[base + 0]/*dsttypeids*/)
1576318074 {
15764- label = 1014LLU; // jump to alternative
18075+ label = 1172LLU; // jump to alternative
1576518076 break;
1576618077 }
1576718078
@@ -15769,7 +18080,7 @@
1576918080 fprintf(stderr, "%s", "in function ");
1577018081 // call reportid from ProcCall
1577118082 stack[base + 28LLU] = base;
15772- stack[base + 29LLU] = 1016LLU;
18083+ stack[base + 29LLU] = 1174LLU;
1577318084 // arguments for call to reportid
1577418085 stack[base + 30LLU] = stack[base + 7]/*fnid*/;
1577518086 // set stack-base & callee-address
@@ -15777,13 +18088,13 @@
1577718088 label = 18446744073709551586LLU; // reportid
1577818089 break;
1577918090 }
15780- case 1016LLU: // return from reportid to ProcCall
18091+ case 1174LLU: // return from reportid to ProcCall
1578118092 {
1578218093 // copy mutable arguments back from call to reportid
1578318094 fprintf(stderr, "%s", " call to ");
1578418095 // call reportid from ProcCall
1578518096 stack[base + 28LLU] = base;
15786- stack[base + 29LLU] = 1017LLU;
18097+ stack[base + 29LLU] = 1175LLU;
1578718098 // arguments for call to reportid
1578818099 stack[base + 30LLU] = stack[base + 23]/*ceid*/;
1578918100 // set stack-base & callee-address
@@ -15791,21 +18102,21 @@
1579118102 label = 18446744073709551586LLU; // reportid
1579218103 break;
1579318104 }
15794- case 1017LLU: // return from reportid to ProcCall
18105+ case 1175LLU: // return from reportid to ProcCall
1579518106 {
1579618107 // copy mutable arguments back from call to reportid
1579718108 fprintf(stderr, "%s", " not enough results to fill all destination-variables");
1579818109 fprintf(stderr, "%s", "\n");
1579918110 exit(-1);
15800- label = 1015LLU; // consequent complete
18111+ label = 1173LLU; // consequent complete
1580118112 break;
1580218113 }
15803- case 1014LLU: // alternative
18114+ case 1172LLU: // alternative
1580418115 {
15805- label = 1015LLU; // alternative complete
18116+ label = 1173LLU; // alternative complete
1580618117 break;
1580718118 }
15808- case 1015LLU: // completed if-then-else
18119+ case 1173LLU: // completed if-then-else
1580918120 {
1581018121 ((uint64_t **)(stack[base + 12]))[1][6] = stack[base + 25];
1581118122 ((uint64_t **)(stack[base + 12]))[1][5] = stack[base + 24];
@@ -15814,25 +18125,25 @@
1581418125 ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 21];
1581518126 ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 20];
1581618127 ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 19];
15817- label = 689LLU; // case complete
18128+ label = 847LLU; // case complete
1581818129 break;
1581918130 }
15820- case 690LLU: // try next case
18131+ case 848LLU: // try next case
1582118132 {
1582218133 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1582318134 exit(-1);
1582418135 }
15825- case 689LLU: // completed switch
18136+ case 847LLU: // completed switch
1582618137 {
1582718138 // delete list
15828- label = 1018LLU; // start to repeat
18139+ label = 1176LLU; // start to repeat
1582918140 break;
1583018141 }
15831- case 1018LLU: // repeat from here
18142+ case 1176LLU: // repeat from here
1583218143 {
1583318144 if(!stack[base + 18])
1583418145 {
15835- label = 1019LLU; // break loop
18146+ label = 1177LLU; // break loop
1583618147 break;
1583718148 }
1583818149
@@ -15842,7 +18153,7 @@
1584218153 // call ~idnr from ProcCall
1584318154 newstack[0] = (uint64_t)stack; // backup stack location
1584418155 newstack[1] = base;
15845- newstack[2] = 1020LLU;
18156+ newstack[2] = 1178LLU;
1584618157 stack = newstack;
1584718158 // set stack-base & callee-address
1584818159 base = 3;
@@ -15849,7 +18160,7 @@
1584918160 label = 371LLU; // ~idnr
1585018161 break;
1585118162 }
15852- case 1020LLU: // return from ~idnr to ProcCall
18163+ case 1178LLU: // return from ~idnr to ProcCall
1585318164 {
1585418165 stack = (uint64_t *)stack[0];
1585518166 // releasing toplevel container
@@ -15860,14 +18171,14 @@
1586018171 stack[base + 18] = (uint64_t)list->next;
1586118172 Free(1, sizeof(struct listnode), list);
1586218173 }
15863- label = 1018LLU; // repeat
18174+ label = 1176LLU; // repeat
1586418175 break;
1586518176 }
15866- case 1019LLU: // loop finished
18177+ case 1177LLU: // loop finished
1586718178 {
1586818179 // call MATCHPEEK from ProcCall
1586918180 stack[base + 18LLU] = base;
15870- stack[base + 19LLU] = 1021LLU;
18181+ stack[base + 19LLU] = 1179LLU;
1587118182 // arguments for call to MATCHPEEK
1587218183 stack[base + 20LLU] = stack[base + 7]/*fnid*/;
1587318184 stack[base + 21LLU] = 41LLU;
@@ -15877,7 +18188,7 @@
1587718188 label = 102LLU; // MATCHPEEK
1587818189 break;
1587918190 }
15880- case 1021LLU: // return from MATCHPEEK to ProcCall
18191+ case 1179LLU: // return from MATCHPEEK to ProcCall
1588118192 {
1588218193 // copy mutable arguments back from call to MATCHPEEK
1588318194 stack[base + 13]/*lookahead*/ = stack[base + 22LLU];
@@ -15886,7 +18197,7 @@
1588618197 base = stack[base - 2];
1588718198 break;
1588818199 }
15889- case 1022LLU: // initfrom
18200+ case 1180LLU: // initfrom
1589018201 {
1589118202 //#define arg0 0
1589218203 //#define arg1 1
@@ -15898,7 +18209,7 @@
1589818209 stack[base + 7] = 0;
1589918210 // call ParseToken from initfrom
1590018211 stack[base + 10LLU] = base;
15901- stack[base + 11LLU] = 1023LLU;
18212+ stack[base + 11LLU] = 1181LLU;
1590218213 // arguments for call to ParseToken
1590318214 stack[base + 14LLU] = stack[base + 6]/*lookahead*/;
1590418215 // set stack-base & callee-address
@@ -15906,7 +18217,7 @@
1590618217 label = 2LLU; // ParseToken
1590718218 break;
1590818219 }
15909- case 1023LLU: // return from ParseToken to initfrom
18220+ case 1181LLU: // return from ParseToken to initfrom
1591018221 {
1591118222 // copy mutable arguments back from call to ParseToken
1591218223 stack[base + 6]/*lookahead*/ = stack[base + 14LLU];
@@ -15915,7 +18226,7 @@
1591518226 stack[base + 9] = stack[base + 13LLU];
1591618227 // call equ from initfrom
1591718228 stack[base + 10LLU] = base;
15918- stack[base + 11LLU] = 1024LLU;
18229+ stack[base + 11LLU] = 1182LLU;
1591918230 // arguments for call to equ
1592018231 stack[base + 13LLU] = stack[base + 8]/*variant*/;
1592118232 stack[base + 14LLU] = 4LLU;
@@ -15924,7 +18235,7 @@
1592418235 label = 18446744073709551600LLU; // equ
1592518236 break;
1592618237 }
15927- case 1024LLU: // return from equ to initfrom
18238+ case 1182LLU: // return from equ to initfrom
1592818239 {
1592918240 // copy mutable arguments back from call to equ
1593018241 // copy back results provided by call to equ
@@ -15931,7 +18242,7 @@
1593118242 stack[base + 7] = stack[base + 12LLU];
1593218243 if(!stack[base + 7]/*isequal*/)
1593318244 {
15934- label = 1025LLU; // jump to alternative
18245+ label = 1183LLU; // jump to alternative
1593518246 break;
1593618247 }
1593718248
@@ -15938,7 +18249,7 @@
1593818249 // consequent
1593918250 // call skipwscmnt from initfrom
1594018251 stack[base + 10LLU] = base;
15941- stack[base + 11LLU] = 1027LLU;
18252+ stack[base + 11LLU] = 1185LLU;
1594218253 // arguments for call to skipwscmnt
1594318254 stack[base + 13LLU] = stack[base + 6]/*lookahead*/;
1594418255 // set stack-base & callee-address
@@ -15946,7 +18257,7 @@
1594618257 label = 18446744073709551580LLU; // skipwscmnt
1594718258 break;
1594818259 }
15949- case 1027LLU: // return from skipwscmnt to initfrom
18260+ case 1185LLU: // return from skipwscmnt to initfrom
1595018261 {
1595118262 // copy mutable arguments back from call to skipwscmnt
1595218263 // copy back results provided by call to skipwscmnt
@@ -15953,7 +18264,7 @@
1595318264 stack[base + 6] = stack[base + 12LLU];
1595418265 // call equ from initfrom
1595518266 stack[base + 11LLU] = base;
15956- stack[base + 12LLU] = 1028LLU;
18267+ stack[base + 12LLU] = 1186LLU;
1595718268 // arguments for call to equ
1595818269 stack[base + 14LLU] = stack[base + 6]/*lookahead*/;
1595918270 stack[base + 15LLU] = 46LLU;
@@ -15962,7 +18273,7 @@
1596218273 label = 18446744073709551600LLU; // equ
1596318274 break;
1596418275 }
15965- case 1028LLU: // return from equ to initfrom
18276+ case 1186LLU: // return from equ to initfrom
1596618277 {
1596718278 // copy mutable arguments back from call to equ
1596818279 // copy back results provided by call to equ
@@ -15969,7 +18280,7 @@
1596918280 stack[base + 10] = stack[base + 13LLU];
1597018281 if(!stack[base + 10]/*namespace*/)
1597118282 {
15972- label = 1029LLU; // jump to alternative
18283+ label = 1187LLU; // jump to alternative
1597318284 break;
1597418285 }
1597518286
@@ -15977,7 +18288,7 @@
1597718288 stack[base + 11] = stack[base + 9]/*content*/;
1597818289 // call matchsym from initfrom
1597918290 stack[base + 12LLU] = base;
15980- stack[base + 13LLU] = 1031LLU;
18291+ stack[base + 13LLU] = 1189LLU;
1598118292 // arguments for call to matchsym
1598218293 stack[base + 14LLU] = stack[base + 0]/*fnid*/;
1598318294 stack[base + 15LLU] = 46LLU;
@@ -15987,13 +18298,13 @@
1598718298 label = 110LLU; // matchsym
1598818299 break;
1598918300 }
15990- case 1031LLU: // return from matchsym to initfrom
18301+ case 1189LLU: // return from matchsym to initfrom
1599118302 {
1599218303 // copy mutable arguments back from call to matchsym
1599318304 stack[base + 6]/*lookahead*/ = stack[base + 16LLU];
1599418305 // call FindData from initfrom
1599518306 stack[base + 13LLU] = base;
15996- stack[base + 14LLU] = 1032LLU;
18307+ stack[base + 14LLU] = 1190LLU;
1599718308 // arguments for call to FindData
1599818309 stack[base + 16LLU] = stack[base + 3]/*typedefs*/;
1599918310 stack[base + 17LLU] = stack[base + 11]/*typename*/;
@@ -16002,7 +18313,7 @@
1600218313 label = 457LLU; // FindData
1600318314 break;
1600418315 }
16005- case 1032LLU: // return from FindData to initfrom
18316+ case 1190LLU: // return from FindData to initfrom
1600618317 {
1600718318 // copy mutable arguments back from call to FindData
1600818319 // copy back results provided by call to FindData
@@ -16009,7 +18320,7 @@
1600918320 stack[base + 12] = stack[base + 15LLU];
1601018321 if(/*datadef*/0 != ((uint64_t *)(stack[base + 12]/*reftypedef*/))[0])
1601118322 {
16012- label = 1034LLU; // jump to alternative
18323+ label = 1192LLU; // jump to alternative
1601318324 break;
1601418325 }
1601518326
@@ -16020,7 +18331,7 @@
1602018331 // case
1602118332 // call ParseToken from initfrom
1602218333 stack[base + 16LLU] = base;
16023- stack[base + 17LLU] = 1035LLU;
18334+ stack[base + 17LLU] = 1193LLU;
1602418335 // arguments for call to ParseToken
1602518336 stack[base + 20LLU] = stack[base + 6]/*lookahead*/;
1602618337 // set stack-base & callee-address
@@ -16028,7 +18339,7 @@
1602818339 label = 2LLU; // ParseToken
1602918340 break;
1603018341 }
16031- case 1035LLU: // return from ParseToken to initfrom
18342+ case 1193LLU: // return from ParseToken to initfrom
1603218343 {
1603318344 // copy mutable arguments back from call to ParseToken
1603418345 stack[base + 6]/*lookahead*/ = stack[base + 20LLU];
@@ -16037,7 +18348,7 @@
1603718348 stack[base + 9] = stack[base + 19LLU];
1603818349 // call equ from initfrom
1603918350 stack[base + 16LLU] = base;
16040- stack[base + 17LLU] = 1036LLU;
18351+ stack[base + 17LLU] = 1194LLU;
1604118352 // arguments for call to equ
1604218353 stack[base + 19LLU] = stack[base + 8]/*variant*/;
1604318354 stack[base + 20LLU] = 4LLU;
@@ -16046,7 +18357,7 @@
1604618357 label = 18446744073709551600LLU; // equ
1604718358 break;
1604818359 }
16049- case 1036LLU: // return from equ to initfrom
18360+ case 1194LLU: // return from equ to initfrom
1605018361 {
1605118362 // copy mutable arguments back from call to equ
1605218363 // copy back results provided by call to equ
@@ -16053,20 +18364,20 @@
1605318364 stack[base + 7] = stack[base + 18LLU];
1605418365 if(!stack[base + 7]/*isequal*/)
1605518366 {
16056- label = 1037LLU; // jump to alternative
18367+ label = 1195LLU; // jump to alternative
1605718368 break;
1605818369 }
1605918370
1606018371 // consequent
16061- label = 1038LLU; // consequent complete
18372+ label = 1196LLU; // consequent complete
1606218373 break;
1606318374 }
16064- case 1037LLU: // alternative
18375+ case 1195LLU: // alternative
1606518376 {
1606618377 fprintf(stderr, "%s", "construct requires constructor but found ");
1606718378 // call reporttok from initfrom
1606818379 stack[base + 16LLU] = base;
16069- stack[base + 17LLU] = 1039LLU;
18380+ stack[base + 17LLU] = 1197LLU;
1607018381 // arguments for call to reporttok
1607118382 stack[base + 18LLU] = stack[base + 8]/*variant*/;
1607218383 stack[base + 19LLU] = stack[base + 9]/*content*/;
@@ -16075,20 +18386,20 @@
1607518386 label = 18446744073709551582LLU; // reporttok
1607618387 break;
1607718388 }
16078- case 1039LLU: // return from reporttok to initfrom
18389+ case 1197LLU: // return from reporttok to initfrom
1607918390 {
1608018391 // copy mutable arguments back from call to reporttok
1608118392 fprintf(stderr, "%s", "\n");
1608218393 exit(-1);
16083- label = 1038LLU; // alternative complete
18394+ label = 1196LLU; // alternative complete
1608418395 break;
1608518396 }
16086- case 1038LLU: // completed if-then-else
18397+ case 1196LLU: // completed if-then-else
1608718398 {
1608818399 printf("%s", "\n // construct ");
1608918400 // call printid from initfrom
1609018401 stack[base + 16LLU] = base;
16091- stack[base + 17LLU] = 1040LLU;
18402+ stack[base + 17LLU] = 1198LLU;
1609218403 // arguments for call to printid
1609318404 stack[base + 18LLU] = stack[base + 11]/*typename*/;
1609418405 // set stack-base & callee-address
@@ -16096,13 +18407,13 @@
1609618407 label = 18446744073709551587LLU; // printid
1609718408 break;
1609818409 }
16099- case 1040LLU: // return from printid to initfrom
18410+ case 1198LLU: // return from printid to initfrom
1610018411 {
1610118412 // copy mutable arguments back from call to printid
1610218413 printf("%s", ".");
1610318414 // call printid from initfrom
1610418415 stack[base + 16LLU] = base;
16105- stack[base + 17LLU] = 1041LLU;
18416+ stack[base + 17LLU] = 1199LLU;
1610618417 // arguments for call to printid
1610718418 stack[base + 18LLU] = stack[base + 9]/*content*/;
1610818419 // set stack-base & callee-address
@@ -16110,12 +18421,12 @@
1611018421 label = 18446744073709551587LLU; // printid
1611118422 break;
1611218423 }
16113- case 1041LLU: // return from printid to initfrom
18424+ case 1199LLU: // return from printid to initfrom
1611418425 {
1611518426 // copy mutable arguments back from call to printid
1611618427 // call GetVariant from initfrom
1611718428 stack[base + 18LLU] = base;
16118- stack[base + 19LLU] = 1042LLU;
18429+ stack[base + 19LLU] = 1200LLU;
1611918430 // arguments for call to GetVariant
1612018431 stack[base + 22LLU] = stack[base + 0]/*fnid*/;
1612118432 stack[base + 23LLU] = stack[base + 14]/*variants*/;
@@ -16125,7 +18436,7 @@
1612518436 label = 417LLU; // GetVariant
1612618437 break;
1612718438 }
16128- case 1042LLU: // return from GetVariant to initfrom
18439+ case 1200LLU: // return from GetVariant to initfrom
1612918440 {
1613018441 // copy mutable arguments back from call to GetVariant
1613118442 // copy back results provided by call to GetVariant
@@ -16133,7 +18444,7 @@
1613318444 stack[base + 17] = stack[base + 21LLU];
1613418445 if(/*variant*/0 != ((uint64_t *)(stack[base + 17]/*constr*/))[0])
1613518446 {
16136- label = 1044LLU; // jump to alternative
18447+ label = 1202LLU; // jump to alternative
1613718448 break;
1613818449 }
1613918450
@@ -16144,7 +18455,7 @@
1614418455 printf("%s", "\n if(!(");
1614518456 // call emitvaridx from initfrom
1614618457 stack[base + 20LLU] = base;
16147- stack[base + 21LLU] = 1045LLU;
18458+ stack[base + 21LLU] = 1203LLU;
1614818459 // arguments for call to emitvaridx
1614918460 stack[base + 22LLU] = stack[base + 2]/*dstindex*/;
1615018461 // set stack-base & callee-address
@@ -16152,13 +18463,13 @@
1615218463 label = 347LLU; // emitvaridx
1615318464 break;
1615418465 }
16155- case 1045LLU: // return from emitvaridx to initfrom
18466+ case 1203LLU: // return from emitvaridx to initfrom
1615618467 {
1615718468 // copy mutable arguments back from call to emitvaridx
1615818469 printf("%s", " = (uint64_t)Calloc(2 + ");
1615918470 // call deloffset from initfrom
1616018471 stack[base + 20LLU] = base;
16161- stack[base + 21LLU] = 1046LLU;
18472+ stack[base + 21LLU] = 1204LLU;
1616218473 // arguments for call to deloffset
1616318474 // set stack-base & callee-address
1616418475 base += 22LLU;
@@ -16165,13 +18476,13 @@
1616518476 label = 74LLU; // deloffset
1616618477 break;
1616718478 }
16168- case 1046LLU: // return from deloffset to initfrom
18479+ case 1204LLU: // return from deloffset to initfrom
1616918480 {
1617018481 // copy mutable arguments back from call to deloffset
1617118482 printf("%s", ", sizeof(uint64_t)) + sizeof(uint64_t) * ");
1617218483 // call deloffset from initfrom
1617318484 stack[base + 20LLU] = base;
16174- stack[base + 21LLU] = 1047LLU;
18485+ stack[base + 21LLU] = 1205LLU;
1617518486 // arguments for call to deloffset
1617618487 // set stack-base & callee-address
1617718488 base += 22LLU;
@@ -16178,7 +18489,7 @@
1617818489 label = 74LLU; // deloffset
1617918490 break;
1618018491 }
16181- case 1047LLU: // return from deloffset to initfrom
18492+ case 1205LLU: // return from deloffset to initfrom
1618218493 {
1618318494 // copy mutable arguments back from call to deloffset
1618418495 printf("%s", "))");
@@ -16186,7 +18497,7 @@
1618618497 printf("%s", "\n fprintf(stderr, \"%s\", \"ERROR: failed to construct ");
1618718498 // call printid from initfrom
1618818499 stack[base + 20LLU] = base;
16189- stack[base + 21LLU] = 1048LLU;
18500+ stack[base + 21LLU] = 1206LLU;
1619018501 // arguments for call to printid
1619118502 stack[base + 22LLU] = stack[base + 11]/*typename*/;
1619218503 // set stack-base & callee-address
@@ -16194,13 +18505,13 @@
1619418505 label = 18446744073709551587LLU; // printid
1619518506 break;
1619618507 }
16197- case 1048LLU: // return from printid to initfrom
18508+ case 1206LLU: // return from printid to initfrom
1619818509 {
1619918510 // copy mutable arguments back from call to printid
1620018511 printf("%s", ".");
1620118512 // call printid from initfrom
1620218513 stack[base + 20LLU] = base;
16203- stack[base + 21LLU] = 1049LLU;
18514+ stack[base + 21LLU] = 1207LLU;
1620418515 // arguments for call to printid
1620518516 stack[base + 22LLU] = stack[base + 9]/*content*/;
1620618517 // set stack-base & callee-address
@@ -16208,7 +18519,7 @@
1620818519 label = 18446744073709551587LLU; // printid
1620918520 break;
1621018521 }
16211- case 1049LLU: // return from printid to initfrom
18522+ case 1207LLU: // return from printid to initfrom
1621218523 {
1621318524 // copy mutable arguments back from call to printid
1621418525 printf("%s", "\\n\");");
@@ -16219,7 +18530,7 @@
1621918530 printf("%s", "\n ((uint64_t *)");
1622018531 // call emitvaridx from initfrom
1622118532 stack[base + 21LLU] = base;
16222- stack[base + 22LLU] = 1050LLU;
18533+ stack[base + 22LLU] = 1208LLU;
1622318534 // arguments for call to emitvaridx
1622418535 stack[base + 23LLU] = stack[base + 2]/*dstindex*/;
1622518536 // set stack-base & callee-address
@@ -16227,13 +18538,13 @@
1622718538 label = 347LLU; // emitvaridx
1622818539 break;
1622918540 }
16230- case 1050LLU: // return from emitvaridx to initfrom
18541+ case 1208LLU: // return from emitvaridx to initfrom
1623118542 {
1623218543 // copy mutable arguments back from call to emitvaridx
1623318544 printf("%s", ")[0] = ");
1623418545 // call printnr from initfrom
1623518546 stack[base + 21LLU] = base;
16236- stack[base + 22LLU] = 1051LLU;
18547+ stack[base + 22LLU] = 1209LLU;
1623718548 // arguments for call to printnr
1623818549 stack[base + 23LLU] = stack[base + 16]/*varnr*/;
1623918550 // set stack-base & callee-address
@@ -16241,7 +18552,7 @@
1624118552 label = 18446744073709551590LLU; // printnr
1624218553 break;
1624318554 }
16244- case 1051LLU: // return from printnr to initfrom
18555+ case 1209LLU: // return from printnr to initfrom
1624518556 {
1624618557 // copy mutable arguments back from call to printnr
1624718558 printf("%s", ";");
@@ -16248,7 +18559,7 @@
1624818559 printf("%s", "\n if(!(((uint64_t *)");
1624918560 // call emitvaridx from initfrom
1625018561 stack[base + 21LLU] = base;
16251- stack[base + 22LLU] = 1052LLU;
18562+ stack[base + 22LLU] = 1210LLU;
1625218563 // arguments for call to emitvaridx
1625318564 stack[base + 23LLU] = stack[base + 2]/*dstindex*/;
1625418565 // set stack-base & callee-address
@@ -16256,13 +18567,13 @@
1625618567 label = 347LLU; // emitvaridx
1625718568 break;
1625818569 }
16259- case 1052LLU: // return from emitvaridx to initfrom
18570+ case 1210LLU: // return from emitvaridx to initfrom
1626018571 {
1626118572 // copy mutable arguments back from call to emitvaridx
1626218573 printf("%s", ")[1] = (uint64_t)Calloc(");
1626318574 // call printnr from initfrom
1626418575 stack[base + 21LLU] = base;
16265- stack[base + 22LLU] = 1053LLU;
18576+ stack[base + 22LLU] = 1211LLU;
1626618577 // arguments for call to printnr
1626718578 stack[base + 23LLU] = stack[base + 20]/*size*/;
1626818579 // set stack-base & callee-address
@@ -16270,7 +18581,7 @@
1627018581 label = 18446744073709551590LLU; // printnr
1627118582 break;
1627218583 }
16273- case 1053LLU: // return from printnr to initfrom
18584+ case 1211LLU: // return from printnr to initfrom
1627418585 {
1627518586 // copy mutable arguments back from call to printnr
1627618587 printf("%s", ", sizeof(uint64_t))))");
@@ -16278,7 +18589,7 @@
1627818589 printf("%s", "\n Free(");
1627918590 // call printnr from initfrom
1628018591 stack[base + 21LLU] = base;
16281- stack[base + 22LLU] = 1054LLU;
18592+ stack[base + 22LLU] = 1212LLU;
1628218593 // arguments for call to printnr
1628318594 stack[base + 23LLU] = stack[base + 20]/*size*/;
1628418595 // set stack-base & callee-address
@@ -16286,13 +18597,13 @@
1628618597 label = 18446744073709551590LLU; // printnr
1628718598 break;
1628818599 }
16289- case 1054LLU: // return from printnr to initfrom
18600+ case 1212LLU: // return from printnr to initfrom
1629018601 {
1629118602 // copy mutable arguments back from call to printnr
1629218603 printf("%s", ", sizeof(uint64_t), ((uint64_t **)");
1629318604 // call emitvaridx from initfrom
1629418605 stack[base + 21LLU] = base;
16295- stack[base + 22LLU] = 1055LLU;
18606+ stack[base + 22LLU] = 1213LLU;
1629618607 // arguments for call to emitvaridx
1629718608 stack[base + 23LLU] = stack[base + 2]/*dstindex*/;
1629818609 // set stack-base & callee-address
@@ -16300,7 +18611,7 @@
1630018611 label = 347LLU; // emitvaridx
1630118612 break;
1630218613 }
16303- case 1055LLU: // return from emitvaridx to initfrom
18614+ case 1213LLU: // return from emitvaridx to initfrom
1630418615 {
1630518616 // copy mutable arguments back from call to emitvaridx
1630618617 printf("%s", ")[1]);");
@@ -16307,7 +18618,7 @@
1630718618 printf("%s", "\n fprintf(stderr, \"%s\", \"ERROR: failed to construct ");
1630818619 // call printid from initfrom
1630918620 stack[base + 21LLU] = base;
16310- stack[base + 22LLU] = 1056LLU;
18621+ stack[base + 22LLU] = 1214LLU;
1631118622 // arguments for call to printid
1631218623 stack[base + 23LLU] = stack[base + 11]/*typename*/;
1631318624 // set stack-base & callee-address
@@ -16315,13 +18626,13 @@
1631518626 label = 18446744073709551587LLU; // printid
1631618627 break;
1631718628 }
16318- case 1056LLU: // return from printid to initfrom
18629+ case 1214LLU: // return from printid to initfrom
1631918630 {
1632018631 // copy mutable arguments back from call to printid
1632118632 printf("%s", ".");
1632218633 // call printid from initfrom
1632318634 stack[base + 21LLU] = base;
16324- stack[base + 22LLU] = 1057LLU;
18635+ stack[base + 22LLU] = 1215LLU;
1632518636 // arguments for call to printid
1632618637 stack[base + 23LLU] = stack[base + 9]/*content*/;
1632718638 // set stack-base & callee-address
@@ -16329,7 +18640,7 @@
1632918640 label = 18446744073709551587LLU; // printid
1633018641 break;
1633118642 }
16332- case 1057LLU: // return from printid to initfrom
18643+ case 1215LLU: // return from printid to initfrom
1633318644 {
1633418645 // copy mutable arguments back from call to printid
1633518646 printf("%s", "\\n\");");
@@ -16337,7 +18648,7 @@
1633718648 printf("%s", "\n }");
1633818649 // call matchsym from initfrom
1633918650 stack[base + 21LLU] = base;
16340- stack[base + 22LLU] = 1058LLU;
18651+ stack[base + 22LLU] = 1216LLU;
1634118652 // arguments for call to matchsym
1634218653 stack[base + 23LLU] = stack[base + 0]/*fnid*/;
1634318654 stack[base + 24LLU] = 40LLU;
@@ -16347,20 +18658,20 @@
1634718658 label = 110LLU; // matchsym
1634818659 break;
1634918660 }
16350- case 1058LLU: // return from matchsym to initfrom
18661+ case 1216LLU: // return from matchsym to initfrom
1635118662 {
1635218663 // copy mutable arguments back from call to matchsym
1635318664 stack[base + 6]/*lookahead*/ = stack[base + 25LLU];
1635418665 stack[base + 21] = 0;
1635518666 flippedassign(stack[base + 19]/*TYPEIDS*/, &stack[base + 22]);
16356- label = 1059LLU; // start to repeat
18667+ label = 1217LLU; // start to repeat
1635718668 break;
1635818669 }
16359- case 1059LLU: // repeat from here
18670+ case 1217LLU: // repeat from here
1636018671 {
1636118672 if(!stack[base + 22])
1636218673 {
16363- label = 1060LLU; // break loop
18674+ label = 1218LLU; // break loop
1636418675 break;
1636518676 }
1636618677
@@ -16370,7 +18681,7 @@
1637018681 stack[base + 22] = (uint64_t)(((const struct listnode *)(stack[base + 22]))->next);
1637118682 if(/*typeid*/0 != ((uint64_t *)(stack[base + 23]/*typeid*/))[0])
1637218683 {
16373- label = 1062LLU; // jump to alternative
18684+ label = 1220LLU; // jump to alternative
1637418685 break;
1637518686 }
1637618687
@@ -16380,7 +18691,7 @@
1638018691 // case
1638118692 if(!stack[base + 21]/*elemindex*/)
1638218693 {
16383- label = 1063LLU; // jump to alternative
18694+ label = 1221LLU; // jump to alternative
1638418695 break;
1638518696 }
1638618697
@@ -16387,7 +18698,7 @@
1638718698 // consequent
1638818699 // call matchsym from initfrom
1638918700 stack[base + 27LLU] = base;
16390- stack[base + 28LLU] = 1065LLU;
18701+ stack[base + 28LLU] = 1223LLU;
1639118702 // arguments for call to matchsym
1639218703 stack[base + 29LLU] = stack[base + 0]/*fnid*/;
1639318704 stack[base + 30LLU] = 44LLU;
@@ -16397,23 +18708,23 @@
1639718708 label = 110LLU; // matchsym
1639818709 break;
1639918710 }
16400- case 1065LLU: // return from matchsym to initfrom
18711+ case 1223LLU: // return from matchsym to initfrom
1640118712 {
1640218713 // copy mutable arguments back from call to matchsym
1640318714 stack[base + 6]/*lookahead*/ = stack[base + 31LLU];
16404- label = 1064LLU; // consequent complete
18715+ label = 1222LLU; // consequent complete
1640518716 break;
1640618717 }
16407- case 1063LLU: // alternative
18718+ case 1221LLU: // alternative
1640818719 {
16409- label = 1064LLU; // alternative complete
18720+ label = 1222LLU; // alternative complete
1641018721 break;
1641118722 }
16412- case 1064LLU: // completed if-then-else
18723+ case 1222LLU: // completed if-then-else
1641318724 {
1641418725 // call ParseToken from initfrom
1641518726 stack[base + 27LLU] = base;
16416- stack[base + 28LLU] = 1066LLU;
18727+ stack[base + 28LLU] = 1224LLU;
1641718728 // arguments for call to ParseToken
1641818729 stack[base + 31LLU] = stack[base + 6]/*lookahead*/;
1641918730 // set stack-base & callee-address
@@ -16421,7 +18732,7 @@
1642118732 label = 2LLU; // ParseToken
1642218733 break;
1642318734 }
16424- case 1066LLU: // return from ParseToken to initfrom
18735+ case 1224LLU: // return from ParseToken to initfrom
1642518736 {
1642618737 // copy mutable arguments back from call to ParseToken
1642718738 stack[base + 6]/*lookahead*/ = stack[base + 31LLU];
@@ -16430,7 +18741,7 @@
1643018741 stack[base + 9] = stack[base + 30LLU];
1643118742 // call equ from initfrom
1643218743 stack[base + 27LLU] = base;
16433- stack[base + 28LLU] = 1067LLU;
18744+ stack[base + 28LLU] = 1225LLU;
1643418745 // arguments for call to equ
1643518746 stack[base + 30LLU] = stack[base + 8]/*variant*/;
1643618747 stack[base + 31LLU] = 4LLU;
@@ -16439,7 +18750,7 @@
1643918750 label = 18446744073709551600LLU; // equ
1644018751 break;
1644118752 }
16442- case 1067LLU: // return from equ to initfrom
18753+ case 1225LLU: // return from equ to initfrom
1644318754 {
1644418755 // copy mutable arguments back from call to equ
1644518756 // copy back results provided by call to equ
@@ -16446,20 +18757,20 @@
1644618757 stack[base + 7] = stack[base + 29LLU];
1644718758 if(!stack[base + 7]/*isequal*/)
1644818759 {
16449- label = 1068LLU; // jump to alternative
18760+ label = 1226LLU; // jump to alternative
1645018761 break;
1645118762 }
1645218763
1645318764 // consequent
16454- label = 1069LLU; // consequent complete
18765+ label = 1227LLU; // consequent complete
1645518766 break;
1645618767 }
16457- case 1068LLU: // alternative
18768+ case 1226LLU: // alternative
1645818769 {
1645918770 fprintf(stderr, "%s", "constructor requires variables but found ");
1646018771 // call reporttok from initfrom
1646118772 stack[base + 27LLU] = base;
16462- stack[base + 28LLU] = 1070LLU;
18773+ stack[base + 28LLU] = 1228LLU;
1646318774 // arguments for call to reporttok
1646418775 stack[base + 29LLU] = stack[base + 8]/*variant*/;
1646518776 stack[base + 30LLU] = stack[base + 9]/*content*/;
@@ -16468,19 +18779,19 @@
1646818779 label = 18446744073709551582LLU; // reporttok
1646918780 break;
1647018781 }
16471- case 1070LLU: // return from reporttok to initfrom
18782+ case 1228LLU: // return from reporttok to initfrom
1647218783 {
1647318784 // copy mutable arguments back from call to reporttok
1647418785 fprintf(stderr, "%s", "\n");
1647518786 exit(-1);
16476- label = 1069LLU; // alternative complete
18787+ label = 1227LLU; // alternative complete
1647718788 break;
1647818789 }
16479- case 1069LLU: // completed if-then-else
18790+ case 1227LLU: // completed if-then-else
1648018791 {
1648118792 // call getlettype from initfrom
1648218793 stack[base + 28LLU] = base;
16483- stack[base + 29LLU] = 1071LLU;
18794+ stack[base + 29LLU] = 1229LLU;
1648418795 // arguments for call to getlettype
1648518796 stack[base + 31LLU] = stack[base + 0]/*fnid*/;
1648618797 stack[base + 32LLU] = stack[base + 9]/*content*/;
@@ -16491,7 +18802,7 @@
1649118802 label = 326LLU; // getlettype
1649218803 break;
1649318804 }
16494- case 1071LLU: // return from getlettype to initfrom
18805+ case 1229LLU: // return from getlettype to initfrom
1649518806 {
1649618807 // copy mutable arguments back from call to getlettype
1649718808 // copy back results provided by call to getlettype
@@ -16506,7 +18817,7 @@
1650618817 // call equtype from initfrom
1650718818 newstack[0] = (uint64_t)stack; // backup stack location
1650818819 newstack[1] = base;
16509- newstack[2] = 1072LLU;
18820+ newstack[2] = 1230LLU;
1651018821 // arguments for call to equtype
1651118822 newstack[4LLU] = stack[base + 25]/*dsttype*/;
1651218823 newstack[5LLU] = stack[base + 27]/*srctype*/;
@@ -16516,7 +18827,7 @@
1651618827 label = 170LLU; // equtype
1651718828 break;
1651818829 }
16519- case 1072LLU: // return from equtype to initfrom
18830+ case 1230LLU: // return from equtype to initfrom
1652018831 {
1652118832 uint64_t *oldstack = (uint64_t *)stack[0];
1652218833 // copy mutable arguments back from call to equtype
@@ -16531,7 +18842,7 @@
1653118842 stack = oldstack;
1653218843 if(!stack[base + 7]/*isequal*/)
1653318844 {
16534- label = 1073LLU; // jump to alternative
18845+ label = 1231LLU; // jump to alternative
1653518846 break;
1653618847 }
1653718848
@@ -16538,7 +18849,7 @@
1653818849 // consequent
1653918850 if(/*typename*/0 != ((uint64_t *)(stack[base + 25]/*dsttype*/))[0])
1654018851 {
16541- label = 1076LLU; // jump to alternative
18852+ label = 1234LLU; // jump to alternative
1654218853 break;
1654318854 }
1654418855
@@ -16547,7 +18858,7 @@
1654718858 // case
1654818859 // call equ from initfrom
1654918860 stack[base + 29LLU] = base;
16550- stack[base + 30LLU] = 1077LLU;
18861+ stack[base + 30LLU] = 1235LLU;
1655118862 // arguments for call to equ
1655218863 stack[base + 32LLU] = 881834713755418624LLU;
1655318864 stack[base + 33LLU] = stack[base + 28]/*name*/;
@@ -16556,7 +18867,7 @@
1655618867 label = 18446744073709551600LLU; // equ
1655718868 break;
1655818869 }
16559- case 1077LLU: // return from equ to initfrom
18870+ case 1235LLU: // return from equ to initfrom
1656018871 {
1656118872 // copy mutable arguments back from call to equ
1656218873 // copy back results provided by call to equ
@@ -16563,7 +18874,7 @@
1656318874 stack[base + 7] = stack[base + 31LLU];
1656418875 if(!stack[base + 7]/*isequal*/)
1656518876 {
16566- label = 1078LLU; // jump to alternative
18877+ label = 1236LLU; // jump to alternative
1656718878 break;
1656818879 }
1656918880
@@ -16571,7 +18882,7 @@
1657118882 printf("%s", "\n (((uint64_t **)(");
1657218883 // call emitvaridx from initfrom
1657318884 stack[base + 29LLU] = base;
16574- stack[base + 30LLU] = 1080LLU;
18885+ stack[base + 30LLU] = 1238LLU;
1657518886 // arguments for call to emitvaridx
1657618887 stack[base + 31LLU] = stack[base + 2]/*dstindex*/;
1657718888 // set stack-base & callee-address
@@ -16579,13 +18890,13 @@
1657918890 label = 347LLU; // emitvaridx
1658018891 break;
1658118892 }
16582- case 1080LLU: // return from emitvaridx to initfrom
18893+ case 1238LLU: // return from emitvaridx to initfrom
1658318894 {
1658418895 // copy mutable arguments back from call to emitvaridx
1658518896 printf("%s", "))[1][");
1658618897 // call printnr from initfrom
1658718898 stack[base + 29LLU] = base;
16588- stack[base + 30LLU] = 1081LLU;
18899+ stack[base + 30LLU] = 1239LLU;
1658918900 // arguments for call to printnr
1659018901 stack[base + 31LLU] = stack[base + 21]/*elemindex*/;
1659118902 // set stack-base & callee-address
@@ -16593,13 +18904,13 @@
1659318904 label = 18446744073709551590LLU; // printnr
1659418905 break;
1659518906 }
16596- case 1081LLU: // return from printnr to initfrom
18907+ case 1239LLU: // return from printnr to initfrom
1659718908 {
1659818909 // copy mutable arguments back from call to printnr
1659918910 printf("%s", "]) = ");
1660018911 // call emitvar from initfrom
1660118912 stack[base + 29LLU] = base;
16602- stack[base + 30LLU] = 1082LLU;
18913+ stack[base + 30LLU] = 1240LLU;
1660318914 // arguments for call to emitvar
1660418915 stack[base + 31LLU] = stack[base + 0]/*fnid*/;
1660518916 stack[base + 32LLU] = stack[base + 9]/*content*/;
@@ -16610,19 +18921,19 @@
1661018921 label = 349LLU; // emitvar
1661118922 break;
1661218923 }
16613- case 1082LLU: // return from emitvar to initfrom
18924+ case 1240LLU: // return from emitvar to initfrom
1661418925 {
1661518926 // copy mutable arguments back from call to emitvar
1661618927 printf("%s", ";");
16617- label = 1079LLU; // consequent complete
18928+ label = 1237LLU; // consequent complete
1661818929 break;
1661918930 }
16620- case 1078LLU: // alternative
18931+ case 1236LLU: // alternative
1662118932 {
1662218933 printf("%s", "\n INIT(&(((uint64_t **)(");
1662318934 // call emitvaridx from initfrom
1662418935 stack[base + 29LLU] = base;
16625- stack[base + 30LLU] = 1083LLU;
18936+ stack[base + 30LLU] = 1241LLU;
1662618937 // arguments for call to emitvaridx
1662718938 stack[base + 31LLU] = stack[base + 2]/*dstindex*/;
1662818939 // set stack-base & callee-address
@@ -16630,13 +18941,13 @@
1663018941 label = 347LLU; // emitvaridx
1663118942 break;
1663218943 }
16633- case 1083LLU: // return from emitvaridx to initfrom
18944+ case 1241LLU: // return from emitvaridx to initfrom
1663418945 {
1663518946 // copy mutable arguments back from call to emitvaridx
1663618947 printf("%s", "))[1][");
1663718948 // call printnr from initfrom
1663818949 stack[base + 29LLU] = base;
16639- stack[base + 30LLU] = 1084LLU;
18950+ stack[base + 30LLU] = 1242LLU;
1664018951 // arguments for call to printnr
1664118952 stack[base + 31LLU] = stack[base + 21]/*elemindex*/;
1664218953 // set stack-base & callee-address
@@ -16644,13 +18955,13 @@
1664418955 label = 18446744073709551590LLU; // printnr
1664518956 break;
1664618957 }
16647- case 1084LLU: // return from printnr to initfrom
18958+ case 1242LLU: // return from printnr to initfrom
1664818959 {
1664918960 // copy mutable arguments back from call to printnr
1665018961 printf("%s", "]), &");
1665118962 // call emitvar from initfrom
1665218963 stack[base + 29LLU] = base;
16653- stack[base + 30LLU] = 1085LLU;
18964+ stack[base + 30LLU] = 1243LLU;
1665418965 // arguments for call to emitvar
1665518966 stack[base + 31LLU] = stack[base + 0]/*fnid*/;
1665618967 stack[base + 32LLU] = stack[base + 9]/*content*/;
@@ -16661,13 +18972,13 @@
1666118972 label = 349LLU; // emitvar
1666218973 break;
1666318974 }
16664- case 1085LLU: // return from emitvar to initfrom
18975+ case 1243LLU: // return from emitvar to initfrom
1666518976 {
1666618977 // copy mutable arguments back from call to emitvar
1666718978 printf("%s", ");");
1666818979 // call unscopelet from initfrom
1666918980 stack[base + 29LLU] = base;
16670- stack[base + 30LLU] = 1086LLU;
18981+ stack[base + 30LLU] = 1244LLU;
1667118982 // arguments for call to unscopelet
1667218983 stack[base + 31LLU] = stack[base + 0]/*fnid*/;
1667318984 stack[base + 32LLU] = stack[base + 5]/*scope*/;
@@ -16677,26 +18988,26 @@
1667718988 label = 270LLU; // unscopelet
1667818989 break;
1667918990 }
16680- case 1086LLU: // return from unscopelet to initfrom
18991+ case 1244LLU: // return from unscopelet to initfrom
1668118992 {
1668218993 // copy mutable arguments back from call to unscopelet
1668318994 stack[base + 5]/*scope*/ = stack[base + 32LLU];
16684- label = 1079LLU; // alternative complete
18995+ label = 1237LLU; // alternative complete
1668518996 break;
1668618997 }
16687- case 1079LLU: // completed if-then-else
18998+ case 1237LLU: // completed if-then-else
1668818999 {
1668919000 ((uint64_t **)(stack[base + 25]))[1][0] = stack[base + 28];
16690- label = 1075LLU; // case complete
19001+ label = 1233LLU; // case complete
1669119002 break;
1669219003 }
16693- case 1076LLU: // try next case
19004+ case 1234LLU: // try next case
1669419005 {
1669519006 // default
1669619007 printf("%s", "\n INIT(&(((uint64_t **)(");
1669719008 // call emitvaridx from initfrom
1669819009 stack[base + 28LLU] = base;
16699- stack[base + 29LLU] = 1087LLU;
19010+ stack[base + 29LLU] = 1245LLU;
1670019011 // arguments for call to emitvaridx
1670119012 stack[base + 30LLU] = stack[base + 2]/*dstindex*/;
1670219013 // set stack-base & callee-address
@@ -16704,13 +19015,13 @@
1670419015 label = 347LLU; // emitvaridx
1670519016 break;
1670619017 }
16707- case 1087LLU: // return from emitvaridx to initfrom
19018+ case 1245LLU: // return from emitvaridx to initfrom
1670819019 {
1670919020 // copy mutable arguments back from call to emitvaridx
1671019021 printf("%s", "))[1][");
1671119022 // call printnr from initfrom
1671219023 stack[base + 28LLU] = base;
16713- stack[base + 29LLU] = 1088LLU;
19024+ stack[base + 29LLU] = 1246LLU;
1671419025 // arguments for call to printnr
1671519026 stack[base + 30LLU] = stack[base + 21]/*elemindex*/;
1671619027 // set stack-base & callee-address
@@ -16718,13 +19029,13 @@
1671819029 label = 18446744073709551590LLU; // printnr
1671919030 break;
1672019031 }
16721- case 1088LLU: // return from printnr to initfrom
19032+ case 1246LLU: // return from printnr to initfrom
1672219033 {
1672319034 // copy mutable arguments back from call to printnr
1672419035 printf("%s", "]), &");
1672519036 // call emitvar from initfrom
1672619037 stack[base + 28LLU] = base;
16727- stack[base + 29LLU] = 1089LLU;
19038+ stack[base + 29LLU] = 1247LLU;
1672819039 // arguments for call to emitvar
1672919040 stack[base + 30LLU] = stack[base + 0]/*fnid*/;
1673019041 stack[base + 31LLU] = stack[base + 9]/*content*/;
@@ -16735,13 +19046,13 @@
1673519046 label = 349LLU; // emitvar
1673619047 break;
1673719048 }
16738- case 1089LLU: // return from emitvar to initfrom
19049+ case 1247LLU: // return from emitvar to initfrom
1673919050 {
1674019051 // copy mutable arguments back from call to emitvar
1674119052 printf("%s", ");");
1674219053 // call unscopelet from initfrom
1674319054 stack[base + 28LLU] = base;
16744- stack[base + 29LLU] = 1090LLU;
19055+ stack[base + 29LLU] = 1248LLU;
1674519056 // arguments for call to unscopelet
1674619057 stack[base + 30LLU] = stack[base + 0]/*fnid*/;
1674719058 stack[base + 31LLU] = stack[base + 5]/*scope*/;
@@ -16751,24 +19062,24 @@
1675119062 label = 270LLU; // unscopelet
1675219063 break;
1675319064 }
16754- case 1090LLU: // return from unscopelet to initfrom
19065+ case 1248LLU: // return from unscopelet to initfrom
1675519066 {
1675619067 // copy mutable arguments back from call to unscopelet
1675719068 stack[base + 5]/*scope*/ = stack[base + 31LLU];
16758- label = 1075LLU; // default complete
19069+ label = 1233LLU; // default complete
1675919070 break;
1676019071 }
16761- case 1075LLU: // completed switch
19072+ case 1233LLU: // completed switch
1676219073 {
16763- label = 1074LLU; // consequent complete
19074+ label = 1232LLU; // consequent complete
1676419075 break;
1676519076 }
16766- case 1073LLU: // alternative
19077+ case 1231LLU: // alternative
1676719078 {
1676819079 fprintf(stderr, "%s", "in function ");
1676919080 // call reportid from initfrom
1677019081 stack[base + 28LLU] = base;
16771- stack[base + 29LLU] = 1091LLU;
19082+ stack[base + 29LLU] = 1249LLU;
1677219083 // arguments for call to reportid
1677319084 stack[base + 30LLU] = stack[base + 0]/*fnid*/;
1677419085 // set stack-base & callee-address
@@ -16776,7 +19087,7 @@
1677619087 label = 18446744073709551586LLU; // reportid
1677719088 break;
1677819089 }
16779- case 1091LLU: // return from reportid to initfrom
19090+ case 1249LLU: // return from reportid to initfrom
1678019091 {
1678119092 // copy mutable arguments back from call to reportid
1678219093 fprintf(stderr, "%s", ": constructor of type ");
@@ -16790,7 +19101,7 @@
1679019101 // call reporttype from initfrom
1679119102 newstack[0] = (uint64_t)stack; // backup stack location
1679219103 newstack[1] = base;
16793- newstack[2] = 1092LLU;
19104+ newstack[2] = 1250LLU;
1679419105 // arguments for call to reporttype
1679519106 newstack[3LLU] = stack[base + 1]/*type*/;
1679619107 stack = newstack;
@@ -16799,7 +19110,7 @@
1679919110 label = 159LLU; // reporttype
1680019111 break;
1680119112 }
16802- case 1092LLU: // return from reporttype to initfrom
19113+ case 1250LLU: // return from reporttype to initfrom
1680319114 {
1680419115 uint64_t *oldstack = (uint64_t *)stack[0];
1680519116 // copy mutable arguments back from call to reporttype
@@ -16821,7 +19132,7 @@
1682119132 // call reporttype from initfrom
1682219133 newstack[0] = (uint64_t)stack; // backup stack location
1682319134 newstack[1] = base;
16824- newstack[2] = 1093LLU;
19135+ newstack[2] = 1251LLU;
1682519136 // arguments for call to reporttype
1682619137 newstack[3LLU] = stack[base + 25]/*dsttype*/;
1682719138 stack = newstack;
@@ -16830,7 +19141,7 @@
1683019141 label = 159LLU; // reporttype
1683119142 break;
1683219143 }
16833- case 1093LLU: // return from reporttype to initfrom
19144+ case 1251LLU: // return from reporttype to initfrom
1683419145 {
1683519146 uint64_t *oldstack = (uint64_t *)stack[0];
1683619147 // copy mutable arguments back from call to reporttype
@@ -16852,7 +19163,7 @@
1685219163 // call reporttype from initfrom
1685319164 newstack[0] = (uint64_t)stack; // backup stack location
1685419165 newstack[1] = base;
16855- newstack[2] = 1094LLU;
19166+ newstack[2] = 1252LLU;
1685619167 // arguments for call to reporttype
1685719168 newstack[3LLU] = stack[base + 27]/*srctype*/;
1685819169 stack = newstack;
@@ -16861,7 +19172,7 @@
1686119172 label = 159LLU; // reporttype
1686219173 break;
1686319174 }
16864- case 1094LLU: // return from reporttype to initfrom
19175+ case 1252LLU: // return from reporttype to initfrom
1686519176 {
1686619177 uint64_t *oldstack = (uint64_t *)stack[0];
1686719178 // copy mutable arguments back from call to reporttype
@@ -16875,7 +19186,7 @@
1687519186 fprintf(stderr, "%s", " ");
1687619187 // call reportid from initfrom
1687719188 stack[base + 28LLU] = base;
16878- stack[base + 29LLU] = 1095LLU;
19189+ stack[base + 29LLU] = 1253LLU;
1687919190 // arguments for call to reportid
1688019191 stack[base + 30LLU] = stack[base + 9]/*content*/;
1688119192 // set stack-base & callee-address
@@ -16883,15 +19194,15 @@
1688319194 label = 18446744073709551586LLU; // reportid
1688419195 break;
1688519196 }
16886- case 1095LLU: // return from reportid to initfrom
19197+ case 1253LLU: // return from reportid to initfrom
1688719198 {
1688819199 // copy mutable arguments back from call to reportid
1688919200 fprintf(stderr, "%s", "\n");
1689019201 exit(-1);
16891- label = 1074LLU; // alternative complete
19202+ label = 1232LLU; // alternative complete
1689219203 break;
1689319204 }
16894- case 1074LLU: // completed if-then-else
19205+ case 1232LLU: // completed if-then-else
1689519206 {
1689619207
1689719208 uint64_t *newstack = (uint64_t *)(stack[base + 27] - sizeof(uint64_t) * 3);
@@ -16898,7 +19209,7 @@
1689819209 // call ~type from initfrom
1689919210 newstack[0] = (uint64_t)stack; // backup stack location
1690019211 newstack[1] = base;
16901- newstack[2] = 1096LLU;
19212+ newstack[2] = 1254LLU;
1690219213 stack = newstack;
1690319214 // set stack-base & callee-address
1690419215 base = 3;
@@ -16905,7 +19216,7 @@
1690519216 label = 148LLU; // ~type
1690619217 break;
1690719218 }
16908- case 1096LLU: // return from ~type to initfrom
19219+ case 1254LLU: // return from ~type to initfrom
1690919220 {
1691019221 stack = (uint64_t *)stack[0];
1691119222 // releasing toplevel container
@@ -16913,19 +19224,19 @@
1691319224
1691419225 ((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 26];
1691519226 ((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 25];
16916- label = 1061LLU; // case complete
19227+ label = 1219LLU; // case complete
1691719228 break;
1691819229 }
16919- case 1062LLU: // try next case
19230+ case 1220LLU: // try next case
1692019231 {
1692119232 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1692219233 exit(-1);
1692319234 }
16924- case 1061LLU: // completed switch
19235+ case 1219LLU: // completed switch
1692519236 {
1692619237 // call add from initfrom
1692719238 stack[base + 25LLU] = base;
16928- stack[base + 26LLU] = 1097LLU;
19239+ stack[base + 26LLU] = 1255LLU;
1692919240 // arguments for call to add
1693019241 stack[base + 28LLU] = stack[base + 21]/*elemindex*/;
1693119242 stack[base + 29LLU] = 1LLU;
@@ -16934,20 +19245,20 @@
1693419245 label = 18446744073709551605LLU; // add
1693519246 break;
1693619247 }
16937- case 1097LLU: // return from add to initfrom
19248+ case 1255LLU: // return from add to initfrom
1693819249 {
1693919250 // copy mutable arguments back from call to add
1694019251 // copy back results provided by call to add
1694119252 stack[base + 21] = stack[base + 27LLU];
1694219253 ((struct listnode *)(stack[base + 24]/*previous*/))->data = stack[base + 23];
16943- label = 1059LLU; // repeat
19254+ label = 1217LLU; // repeat
1694419255 break;
1694519256 }
16946- case 1060LLU: // loop finished
19257+ case 1218LLU: // loop finished
1694719258 {
1694819259 // call matchsym from initfrom
1694919260 stack[base + 25LLU] = base;
16950- stack[base + 26LLU] = 1098LLU;
19261+ stack[base + 26LLU] = 1256LLU;
1695119262 // arguments for call to matchsym
1695219263 stack[base + 27LLU] = stack[base + 0]/*fnid*/;
1695319264 stack[base + 28LLU] = 41LLU;
@@ -16957,21 +19268,21 @@
1695719268 label = 110LLU; // matchsym
1695819269 break;
1695919270 }
16960- case 1098LLU: // return from matchsym to initfrom
19271+ case 1256LLU: // return from matchsym to initfrom
1696119272 {
1696219273 // copy mutable arguments back from call to matchsym
1696319274 stack[base + 6]/*lookahead*/ = stack[base + 29LLU];
1696419275 ((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
1696519276 ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
16966- label = 1043LLU; // case complete
19277+ label = 1201LLU; // case complete
1696719278 break;
1696819279 }
16969- case 1044LLU: // try next case
19280+ case 1202LLU: // try next case
1697019281 {
1697119282 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1697219283 exit(-1);
1697319284 }
16974- case 1043LLU: // completed switch
19285+ case 1201LLU: // completed switch
1697519286 {
1697619287
1697719288 uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 3);
@@ -16978,7 +19289,7 @@
1697819289 // call ~variant from initfrom
1697919290 newstack[0] = (uint64_t)stack; // backup stack location
1698019291 newstack[1] = base;
16981- newstack[2] = 1099LLU;
19292+ newstack[2] = 1257LLU;
1698219293 stack = newstack;
1698319294 // set stack-base & callee-address
1698419295 base = 3;
@@ -16985,7 +19296,7 @@
1698519296 label = 405LLU; // ~variant
1698619297 break;
1698719298 }
16988- case 1099LLU: // return from ~variant to initfrom
19299+ case 1257LLU: // return from ~variant to initfrom
1698919300 {
1699019301 stack = (uint64_t *)stack[0];
1699119302 // releasing toplevel container
@@ -16994,15 +19305,15 @@
1699419305 ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 15];
1699519306 ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 14];
1699619307 ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 13];
16997- label = 1033LLU; // case complete
19308+ label = 1191LLU; // case complete
1699819309 break;
1699919310 }
17000- case 1034LLU: // try next case
19311+ case 1192LLU: // try next case
1700119312 {
1700219313 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1700319314 exit(-1);
1700419315 }
17005- case 1033LLU: // completed switch
19316+ case 1191LLU: // completed switch
1700619317 {
1700719318
1700819319 uint64_t *newstack = (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 3);
@@ -17009,7 +19320,7 @@
1700919320 // call ~datadef from initfrom
1701019321 newstack[0] = (uint64_t)stack; // backup stack location
1701119322 newstack[1] = base;
17012- newstack[2] = 1100LLU;
19323+ newstack[2] = 1258LLU;
1701319324 stack = newstack;
1701419325 // set stack-base & callee-address
1701519326 base = 3;
@@ -17016,20 +19327,20 @@
1701619327 label = 435LLU; // ~datadef
1701719328 break;
1701819329 }
17019- case 1100LLU: // return from ~datadef to initfrom
19330+ case 1258LLU: // return from ~datadef to initfrom
1702019331 {
1702119332 stack = (uint64_t *)stack[0];
1702219333 // releasing toplevel container
1702319334 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 3));
1702419335
17025- label = 1030LLU; // consequent complete
19336+ label = 1188LLU; // consequent complete
1702619337 break;
1702719338 }
17028- case 1029LLU: // alternative
19339+ case 1187LLU: // alternative
1702919340 {
1703019341 // call getlettype from initfrom
1703119342 stack[base + 12LLU] = base;
17032- stack[base + 13LLU] = 1101LLU;
19343+ stack[base + 13LLU] = 1259LLU;
1703319344 // arguments for call to getlettype
1703419345 stack[base + 15LLU] = stack[base + 0]/*fnid*/;
1703519346 stack[base + 16LLU] = stack[base + 9]/*content*/;
@@ -17040,7 +19351,7 @@
1704019351 label = 326LLU; // getlettype
1704119352 break;
1704219353 }
17043- case 1101LLU: // return from getlettype to initfrom
19354+ case 1259LLU: // return from getlettype to initfrom
1704419355 {
1704519356 // copy mutable arguments back from call to getlettype
1704619357 // copy back results provided by call to getlettype
@@ -17047,7 +19358,7 @@
1704719358 stack[base + 11] = stack[base + 14LLU];
1704819359 if(/*typename*/0 != ((uint64_t *)(stack[base + 11]/*type*/))[0])
1704919360 {
17050- label = 1103LLU; // jump to alternative
19361+ label = 1261LLU; // jump to alternative
1705119362 break;
1705219363 }
1705319364
@@ -17056,7 +19367,7 @@
1705619367 // case
1705719368 // call equ from initfrom
1705819369 stack[base + 13LLU] = base;
17059- stack[base + 14LLU] = 1104LLU;
19370+ stack[base + 14LLU] = 1262LLU;
1706019371 // arguments for call to equ
1706119372 stack[base + 16LLU] = stack[base + 12]/*name*/;
1706219373 stack[base + 17LLU] = 881834713755418624LLU;
@@ -17065,7 +19376,7 @@
1706519376 label = 18446744073709551600LLU; // equ
1706619377 break;
1706719378 }
17068- case 1104LLU: // return from equ to initfrom
19379+ case 1262LLU: // return from equ to initfrom
1706919380 {
1707019381 // copy mutable arguments back from call to equ
1707119382 // copy back results provided by call to equ
@@ -17072,7 +19383,7 @@
1707219383 stack[base + 7] = stack[base + 15LLU];
1707319384 if(!stack[base + 7]/*isequal*/)
1707419385 {
17075- label = 1105LLU; // jump to alternative
19386+ label = 1263LLU; // jump to alternative
1707619387 break;
1707719388 }
1707819389
@@ -17080,7 +19391,7 @@
1708019391 printf("%s", "\n ");
1708119392 // call emitvaridx from initfrom
1708219393 stack[base + 13LLU] = base;
17083- stack[base + 14LLU] = 1107LLU;
19394+ stack[base + 14LLU] = 1265LLU;
1708419395 // arguments for call to emitvaridx
1708519396 stack[base + 15LLU] = stack[base + 2]/*dstindex*/;
1708619397 // set stack-base & callee-address
@@ -17088,13 +19399,13 @@
1708819399 label = 347LLU; // emitvaridx
1708919400 break;
1709019401 }
17091- case 1107LLU: // return from emitvaridx to initfrom
19402+ case 1265LLU: // return from emitvaridx to initfrom
1709219403 {
1709319404 // copy mutable arguments back from call to emitvaridx
1709419405 printf("%s", " = ");
1709519406 // call emitvar from initfrom
1709619407 stack[base + 13LLU] = base;
17097- stack[base + 14LLU] = 1108LLU;
19408+ stack[base + 14LLU] = 1266LLU;
1709819409 // arguments for call to emitvar
1709919410 stack[base + 15LLU] = stack[base + 0]/*fnid*/;
1710019411 stack[base + 16LLU] = stack[base + 9]/*content*/;
@@ -17105,19 +19416,19 @@
1710519416 label = 349LLU; // emitvar
1710619417 break;
1710719418 }
17108- case 1108LLU: // return from emitvar to initfrom
19419+ case 1266LLU: // return from emitvar to initfrom
1710919420 {
1711019421 // copy mutable arguments back from call to emitvar
1711119422 printf("%s", ";");
17112- label = 1106LLU; // consequent complete
19423+ label = 1264LLU; // consequent complete
1711319424 break;
1711419425 }
17115- case 1105LLU: // alternative
19426+ case 1263LLU: // alternative
1711619427 {
1711719428 printf("%s", "\n INIT(&");
1711819429 // call emitvaridx from initfrom
1711919430 stack[base + 13LLU] = base;
17120- stack[base + 14LLU] = 1109LLU;
19431+ stack[base + 14LLU] = 1267LLU;
1712119432 // arguments for call to emitvaridx
1712219433 stack[base + 15LLU] = stack[base + 2]/*dstindex*/;
1712319434 // set stack-base & callee-address
@@ -17125,13 +19436,13 @@
1712519436 label = 347LLU; // emitvaridx
1712619437 break;
1712719438 }
17128- case 1109LLU: // return from emitvaridx to initfrom
19439+ case 1267LLU: // return from emitvaridx to initfrom
1712919440 {
1713019441 // copy mutable arguments back from call to emitvaridx
1713119442 printf("%s", ", &");
1713219443 // call emitvar from initfrom
1713319444 stack[base + 13LLU] = base;
17134- stack[base + 14LLU] = 1110LLU;
19445+ stack[base + 14LLU] = 1268LLU;
1713519446 // arguments for call to emitvar
1713619447 stack[base + 15LLU] = stack[base + 0]/*fnid*/;
1713719448 stack[base + 16LLU] = stack[base + 9]/*content*/;
@@ -17142,13 +19453,13 @@
1714219453 label = 349LLU; // emitvar
1714319454 break;
1714419455 }
17145- case 1110LLU: // return from emitvar to initfrom
19456+ case 1268LLU: // return from emitvar to initfrom
1714619457 {
1714719458 // copy mutable arguments back from call to emitvar
1714819459 printf("%s", ");");
1714919460 // call unscopelet from initfrom
1715019461 stack[base + 13LLU] = base;
17151- stack[base + 14LLU] = 1111LLU;
19462+ stack[base + 14LLU] = 1269LLU;
1715219463 // arguments for call to unscopelet
1715319464 stack[base + 15LLU] = stack[base + 0]/*fnid*/;
1715419465 stack[base + 16LLU] = stack[base + 5]/*scope*/;
@@ -17158,26 +19469,26 @@
1715819469 label = 270LLU; // unscopelet
1715919470 break;
1716019471 }
17161- case 1111LLU: // return from unscopelet to initfrom
19472+ case 1269LLU: // return from unscopelet to initfrom
1716219473 {
1716319474 // copy mutable arguments back from call to unscopelet
1716419475 stack[base + 5]/*scope*/ = stack[base + 16LLU];
17165- label = 1106LLU; // alternative complete
19476+ label = 1264LLU; // alternative complete
1716619477 break;
1716719478 }
17168- case 1106LLU: // completed if-then-else
19479+ case 1264LLU: // completed if-then-else
1716919480 {
1717019481 ((uint64_t **)(stack[base + 11]))[1][0] = stack[base + 12];
17171- label = 1102LLU; // case complete
19482+ label = 1260LLU; // case complete
1717219483 break;
1717319484 }
17174- case 1103LLU: // try next case
19485+ case 1261LLU: // try next case
1717519486 {
1717619487 // default
1717719488 printf("%s", "\n INIT(&");
1717819489 // call emitvaridx from initfrom
1717919490 stack[base + 12LLU] = base;
17180- stack[base + 13LLU] = 1112LLU;
19491+ stack[base + 13LLU] = 1270LLU;
1718119492 // arguments for call to emitvaridx
1718219493 stack[base + 14LLU] = stack[base + 2]/*dstindex*/;
1718319494 // set stack-base & callee-address
@@ -17185,13 +19496,13 @@
1718519496 label = 347LLU; // emitvaridx
1718619497 break;
1718719498 }
17188- case 1112LLU: // return from emitvaridx to initfrom
19499+ case 1270LLU: // return from emitvaridx to initfrom
1718919500 {
1719019501 // copy mutable arguments back from call to emitvaridx
1719119502 printf("%s", ", &");
1719219503 // call emitvar from initfrom
1719319504 stack[base + 12LLU] = base;
17194- stack[base + 13LLU] = 1113LLU;
19505+ stack[base + 13LLU] = 1271LLU;
1719519506 // arguments for call to emitvar
1719619507 stack[base + 14LLU] = stack[base + 0]/*fnid*/;
1719719508 stack[base + 15LLU] = stack[base + 9]/*content*/;
@@ -17202,13 +19513,13 @@
1720219513 label = 349LLU; // emitvar
1720319514 break;
1720419515 }
17205- case 1113LLU: // return from emitvar to initfrom
19516+ case 1271LLU: // return from emitvar to initfrom
1720619517 {
1720719518 // copy mutable arguments back from call to emitvar
1720819519 printf("%s", ");");
1720919520 // call unscopelet from initfrom
1721019521 stack[base + 12LLU] = base;
17211- stack[base + 13LLU] = 1114LLU;
19522+ stack[base + 13LLU] = 1272LLU;
1721219523 // arguments for call to unscopelet
1721319524 stack[base + 14LLU] = stack[base + 0]/*fnid*/;
1721419525 stack[base + 15LLU] = stack[base + 5]/*scope*/;
@@ -17218,14 +19529,14 @@
1721819529 label = 270LLU; // unscopelet
1721919530 break;
1722019531 }
17221- case 1114LLU: // return from unscopelet to initfrom
19532+ case 1272LLU: // return from unscopelet to initfrom
1722219533 {
1722319534 // copy mutable arguments back from call to unscopelet
1722419535 stack[base + 5]/*scope*/ = stack[base + 15LLU];
17225- label = 1102LLU; // default complete
19536+ label = 1260LLU; // default complete
1722619537 break;
1722719538 }
17228- case 1102LLU: // completed switch
19539+ case 1260LLU: // completed switch
1722919540 {
1723019541
1723119542 uint64_t *newstack = (uint64_t *)(stack[base + 11] - sizeof(uint64_t) * 3);
@@ -17232,7 +19543,7 @@
1723219543 // call ~type from initfrom
1723319544 newstack[0] = (uint64_t)stack; // backup stack location
1723419545 newstack[1] = base;
17235- newstack[2] = 1115LLU;
19546+ newstack[2] = 1273LLU;
1723619547 stack = newstack;
1723719548 // set stack-base & callee-address
1723819549 base = 3;
@@ -17239,25 +19550,25 @@
1723919550 label = 148LLU; // ~type
1724019551 break;
1724119552 }
17242- case 1115LLU: // return from ~type to initfrom
19553+ case 1273LLU: // return from ~type to initfrom
1724319554 {
1724419555 stack = (uint64_t *)stack[0];
1724519556 // releasing toplevel container
1724619557 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 11] - sizeof(uint64_t) * 3));
1724719558
17248- label = 1030LLU; // alternative complete
19559+ label = 1188LLU; // alternative complete
1724919560 break;
1725019561 }
17251- case 1030LLU: // completed if-then-else
19562+ case 1188LLU: // completed if-then-else
1725219563 {
17253- label = 1026LLU; // consequent complete
19564+ label = 1184LLU; // consequent complete
1725419565 break;
1725519566 }
17256- case 1025LLU: // alternative
19567+ case 1183LLU: // alternative
1725719568 {
1725819569 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
1725919570 {
17260- label = 1117LLU; // jump to alternative
19571+ label = 1275LLU; // jump to alternative
1726119572 break;
1726219573 }
1726319574
@@ -17266,7 +19577,7 @@
1726619577 // case
1726719578 // call equ from initfrom
1726819579 stack[base + 11LLU] = base;
17269- stack[base + 12LLU] = 1118LLU;
19580+ stack[base + 12LLU] = 1276LLU;
1727019581 // arguments for call to equ
1727119582 stack[base + 14LLU] = 881834713755418624LLU;
1727219583 stack[base + 15LLU] = stack[base + 10]/*name*/;
@@ -17275,7 +19586,7 @@
1727519586 label = 18446744073709551600LLU; // equ
1727619587 break;
1727719588 }
17278- case 1118LLU: // return from equ to initfrom
19589+ case 1276LLU: // return from equ to initfrom
1727919590 {
1728019591 // copy mutable arguments back from call to equ
1728119592 // copy back results provided by call to equ
@@ -17282,7 +19593,7 @@
1728219593 stack[base + 7] = stack[base + 13LLU];
1728319594 if(!stack[base + 7]/*isequal*/)
1728419595 {
17285- label = 1119LLU; // jump to alternative
19596+ label = 1277LLU; // jump to alternative
1728619597 break;
1728719598 }
1728819599
@@ -17289,7 +19600,7 @@
1728919600 // consequent
1729019601 // call isncs from initfrom
1729119602 stack[base + 11LLU] = base;
17292- stack[base + 12LLU] = 1121LLU;
19603+ stack[base + 12LLU] = 1279LLU;
1729319604 // arguments for call to isncs
1729419605 stack[base + 14LLU] = stack[base + 8]/*variant*/;
1729519606 // set stack-base & callee-address
@@ -17297,7 +19608,7 @@
1729719608 label = 138LLU; // isncs
1729819609 break;
1729919610 }
17300- case 1121LLU: // return from isncs to initfrom
19611+ case 1279LLU: // return from isncs to initfrom
1730119612 {
1730219613 // copy mutable arguments back from call to isncs
1730319614 // copy back results provided by call to isncs
@@ -17304,7 +19615,7 @@
1730419615 stack[base + 7] = stack[base + 13LLU];
1730519616 if(!stack[base + 7]/*isequal*/)
1730619617 {
17307- label = 1122LLU; // jump to alternative
19618+ label = 1280LLU; // jump to alternative
1730819619 break;
1730919620 }
1731019621
@@ -17312,7 +19623,7 @@
1731219623 printf("%s", "\n ");
1731319624 // call emitvaridx from initfrom
1731419625 stack[base + 11LLU] = base;
17315- stack[base + 12LLU] = 1124LLU;
19626+ stack[base + 12LLU] = 1282LLU;
1731619627 // arguments for call to emitvaridx
1731719628 stack[base + 13LLU] = stack[base + 2]/*dstindex*/;
1731819629 // set stack-base & callee-address
@@ -17320,13 +19631,13 @@
1732019631 label = 347LLU; // emitvaridx
1732119632 break;
1732219633 }
17323- case 1124LLU: // return from emitvaridx to initfrom
19634+ case 1282LLU: // return from emitvaridx to initfrom
1732419635 {
1732519636 // copy mutable arguments back from call to emitvaridx
1732619637 printf("%s", " = ");
1732719638 // call printnr from initfrom
1732819639 stack[base + 11LLU] = base;
17329- stack[base + 12LLU] = 1125LLU;
19640+ stack[base + 12LLU] = 1283LLU;
1733019641 // arguments for call to printnr
1733119642 stack[base + 13LLU] = stack[base + 9]/*content*/;
1733219643 // set stack-base & callee-address
@@ -17334,14 +19645,14 @@
1733419645 label = 18446744073709551590LLU; // printnr
1733519646 break;
1733619647 }
17337- case 1125LLU: // return from printnr to initfrom
19648+ case 1283LLU: // return from printnr to initfrom
1733819649 {
1733919650 // copy mutable arguments back from call to printnr
1734019651 printf("%s", ";");
17341- label = 1123LLU; // consequent complete
19652+ label = 1281LLU; // consequent complete
1734219653 break;
1734319654 }
17344- case 1122LLU: // alternative
19655+ case 1280LLU: // alternative
1734519656 {
1734619657 fprintf(stderr, "%s", "expected number/character/string or identifier (u64 variable) in ");
1734719658 fprintf(stderr, "%s", "initializing type ");
@@ -17355,7 +19666,7 @@
1735519666 // call reporttype from initfrom
1735619667 newstack[0] = (uint64_t)stack; // backup stack location
1735719668 newstack[1] = base;
17358- newstack[2] = 1126LLU;
19669+ newstack[2] = 1284LLU;
1735919670 // arguments for call to reporttype
1736019671 newstack[3LLU] = stack[base + 1]/*type*/;
1736119672 stack = newstack;
@@ -17364,7 +19675,7 @@
1736419675 label = 159LLU; // reporttype
1736519676 break;
1736619677 }
17367- case 1126LLU: // return from reporttype to initfrom
19678+ case 1284LLU: // return from reporttype to initfrom
1736819679 {
1736919680 uint64_t *oldstack = (uint64_t *)stack[0];
1737019681 // copy mutable arguments back from call to reporttype
@@ -17378,7 +19689,7 @@
1737819689 fprintf(stderr, "%s", " with ");
1737919690 // call reporttok from initfrom
1738019691 stack[base + 11LLU] = base;
17381- stack[base + 12LLU] = 1127LLU;
19692+ stack[base + 12LLU] = 1285LLU;
1738219693 // arguments for call to reporttok
1738319694 stack[base + 13LLU] = stack[base + 8]/*variant*/;
1738419695 stack[base + 14LLU] = stack[base + 9]/*content*/;
@@ -17387,25 +19698,25 @@
1738719698 label = 18446744073709551582LLU; // reporttok
1738819699 break;
1738919700 }
17390- case 1127LLU: // return from reporttok to initfrom
19701+ case 1285LLU: // return from reporttok to initfrom
1739119702 {
1739219703 // copy mutable arguments back from call to reporttok
1739319704 fprintf(stderr, "%s", "\n");
1739419705 exit(-1);
17395- label = 1123LLU; // alternative complete
19706+ label = 1281LLU; // alternative complete
1739619707 break;
1739719708 }
17398- case 1123LLU: // completed if-then-else
19709+ case 1281LLU: // completed if-then-else
1739919710 {
17400- label = 1120LLU; // consequent complete
19711+ label = 1278LLU; // consequent complete
1740119712 break;
1740219713 }
17403- case 1119LLU: // alternative
19714+ case 1277LLU: // alternative
1740419715 {
1740519716 fprintf(stderr, "%s", "in function ");
1740619717 // call reportid from initfrom
1740719718 stack[base + 11LLU] = base;
17408- stack[base + 12LLU] = 1128LLU;
19719+ stack[base + 12LLU] = 1286LLU;
1740919720 // arguments for call to reportid
1741019721 stack[base + 13LLU] = stack[base + 0]/*fnid*/;
1741119722 // set stack-base & callee-address
@@ -17413,7 +19724,7 @@
1741319724 label = 18446744073709551586LLU; // reportid
1741419725 break;
1741519726 }
17416- case 1128LLU: // return from reportid to initfrom
19727+ case 1286LLU: // return from reportid to initfrom
1741719728 {
1741819729 // copy mutable arguments back from call to reportid
1741919730 fprintf(stderr, "%s", ": can't initialize type ");
@@ -17427,7 +19738,7 @@
1742719738 // call reporttype from initfrom
1742819739 newstack[0] = (uint64_t)stack; // backup stack location
1742919740 newstack[1] = base;
17430- newstack[2] = 1129LLU;
19741+ newstack[2] = 1287LLU;
1743119742 // arguments for call to reporttype
1743219743 newstack[3LLU] = stack[base + 1]/*type*/;
1743319744 stack = newstack;
@@ -17436,7 +19747,7 @@
1743619747 label = 159LLU; // reporttype
1743719748 break;
1743819749 }
17439- case 1129LLU: // return from reporttype to initfrom
19750+ case 1287LLU: // return from reporttype to initfrom
1744019751 {
1744119752 uint64_t *oldstack = (uint64_t *)stack[0];
1744219753 // copy mutable arguments back from call to reporttype
@@ -17450,7 +19761,7 @@
1745019761 fprintf(stderr, "%s", " with literal ");
1745119762 // call reporttok from initfrom
1745219763 stack[base + 11LLU] = base;
17453- stack[base + 12LLU] = 1130LLU;
19764+ stack[base + 12LLU] = 1288LLU;
1745419765 // arguments for call to reporttok
1745519766 stack[base + 13LLU] = stack[base + 8]/*variant*/;
1745619767 stack[base + 14LLU] = stack[base + 9]/*content*/;
@@ -17459,25 +19770,25 @@
1745919770 label = 18446744073709551582LLU; // reporttok
1746019771 break;
1746119772 }
17462- case 1130LLU: // return from reporttok to initfrom
19773+ case 1288LLU: // return from reporttok to initfrom
1746319774 {
1746419775 // copy mutable arguments back from call to reporttok
1746519776 fprintf(stderr, "%s", " - use constructor instead\n");
1746619777 exit(-1);
17467- label = 1120LLU; // alternative complete
19778+ label = 1278LLU; // alternative complete
1746819779 break;
1746919780 }
17470- case 1120LLU: // completed if-then-else
19781+ case 1278LLU: // completed if-then-else
1747119782 {
1747219783 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 10];
17473- label = 1116LLU; // case complete
19784+ label = 1274LLU; // case complete
1747419785 break;
1747519786 }
17476- case 1117LLU: // try next case
19787+ case 1275LLU: // try next case
1747719788 {
1747819789 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
1747919790 {
17480- label = 1131LLU; // jump to alternative
19791+ label = 1289LLU; // jump to alternative
1748119792 break;
1748219793 }
1748319794
@@ -17486,7 +19797,7 @@
1748619797 // case
1748719798 // call issimple from initfrom
1748819799 stack[base + 11LLU] = base;
17489- stack[base + 12LLU] = 1132LLU;
19800+ stack[base + 12LLU] = 1290LLU;
1749019801 // arguments for call to issimple
1749119802 stack[base + 14LLU] = stack[base + 8]/*variant*/;
1749219803 stack[base + 15LLU] = stack[base + 9]/*content*/;
@@ -17496,7 +19807,7 @@
1749619807 label = 86LLU; // issimple
1749719808 break;
1749819809 }
17499- case 1132LLU: // return from issimple to initfrom
19810+ case 1290LLU: // return from issimple to initfrom
1750019811 {
1750119812 // copy mutable arguments back from call to issimple
1750219813 // copy back results provided by call to issimple
@@ -17503,7 +19814,7 @@
1750319814 stack[base + 7] = stack[base + 13LLU];
1750419815 if(!stack[base + 7]/*isequal*/)
1750519816 {
17506- label = 1133LLU; // jump to alternative
19817+ label = 1291LLU; // jump to alternative
1750719818 break;
1750819819 }
1750919820
@@ -17510,7 +19821,7 @@
1751019821 // consequent
1751119822 // call matchsym from initfrom
1751219823 stack[base + 11LLU] = base;
17513- stack[base + 12LLU] = 1135LLU;
19824+ stack[base + 12LLU] = 1293LLU;
1751419825 // arguments for call to matchsym
1751519826 stack[base + 13LLU] = stack[base + 0]/*fnid*/;
1751619827 stack[base + 14LLU] = 93LLU;
@@ -17520,7 +19831,7 @@
1752019831 label = 110LLU; // matchsym
1752119832 break;
1752219833 }
17523- case 1135LLU: // return from matchsym to initfrom
19834+ case 1293LLU: // return from matchsym to initfrom
1752419835 {
1752519836 // copy mutable arguments back from call to matchsym
1752619837 stack[base + 6]/*lookahead*/ = stack[base + 15LLU];
@@ -17527,7 +19838,7 @@
1752719838 printf("%s", "\n ");
1752819839 // call emitvaridx from initfrom
1752919840 stack[base + 11LLU] = base;
17530- stack[base + 12LLU] = 1136LLU;
19841+ stack[base + 12LLU] = 1294LLU;
1753119842 // arguments for call to emitvaridx
1753219843 stack[base + 13LLU] = stack[base + 2]/*dstindex*/;
1753319844 // set stack-base & callee-address
@@ -17535,19 +19846,19 @@
1753519846 label = 347LLU; // emitvaridx
1753619847 break;
1753719848 }
17538- case 1136LLU: // return from emitvaridx to initfrom
19849+ case 1294LLU: // return from emitvaridx to initfrom
1753919850 {
1754019851 // copy mutable arguments back from call to emitvaridx
1754119852 printf("%s", " = 0;");
17542- label = 1134LLU; // consequent complete
19853+ label = 1292LLU; // consequent complete
1754319854 break;
1754419855 }
17545- case 1133LLU: // alternative
19856+ case 1291LLU: // alternative
1754619857 {
1754719858 fprintf(stderr, "%s", "in function ");
1754819859 // call reportid from initfrom
1754919860 stack[base + 11LLU] = base;
17550- stack[base + 12LLU] = 1137LLU;
19861+ stack[base + 12LLU] = 1295LLU;
1755119862 // arguments for call to reportid
1755219863 stack[base + 13LLU] = stack[base + 0]/*fnid*/;
1755319864 // set stack-base & callee-address
@@ -17555,7 +19866,7 @@
1755519866 label = 18446744073709551586LLU; // reportid
1755619867 break;
1755719868 }
17558- case 1137LLU: // return from reportid to initfrom
19869+ case 1295LLU: // return from reportid to initfrom
1755919870 {
1756019871 // copy mutable arguments back from call to reportid
1756119872 fprintf(stderr, "%s", ": can't initialize type ");
@@ -17569,7 +19880,7 @@
1756919880 // call reporttype from initfrom
1757019881 newstack[0] = (uint64_t)stack; // backup stack location
1757119882 newstack[1] = base;
17572- newstack[2] = 1138LLU;
19883+ newstack[2] = 1296LLU;
1757319884 // arguments for call to reporttype
1757419885 newstack[3LLU] = stack[base + 1]/*type*/;
1757519886 stack = newstack;
@@ -17578,7 +19889,7 @@
1757819889 label = 159LLU; // reporttype
1757919890 break;
1758019891 }
17581- case 1138LLU: // return from reporttype to initfrom
19892+ case 1296LLU: // return from reporttype to initfrom
1758219893 {
1758319894 uint64_t *oldstack = (uint64_t *)stack[0];
1758419895 // copy mutable arguments back from call to reporttype
@@ -17592,7 +19903,7 @@
1759219903 fprintf(stderr, "%s", " with ");
1759319904 // call reporttok from initfrom
1759419905 stack[base + 11LLU] = base;
17595- stack[base + 12LLU] = 1139LLU;
19906+ stack[base + 12LLU] = 1297LLU;
1759619907 // arguments for call to reporttok
1759719908 stack[base + 13LLU] = stack[base + 8]/*variant*/;
1759819909 stack[base + 14LLU] = stack[base + 9]/*content*/;
@@ -17601,31 +19912,31 @@
1760119912 label = 18446744073709551582LLU; // reporttok
1760219913 break;
1760319914 }
17604- case 1139LLU: // return from reporttok to initfrom
19915+ case 1297LLU: // return from reporttok to initfrom
1760519916 {
1760619917 // copy mutable arguments back from call to reporttok
1760719918 fprintf(stderr, "%s", "\n");
1760819919 exit(-1);
17609- label = 1134LLU; // alternative complete
19920+ label = 1292LLU; // alternative complete
1761019921 break;
1761119922 }
17612- case 1134LLU: // completed if-then-else
19923+ case 1292LLU: // completed if-then-else
1761319924 {
1761419925 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 10];
17615- label = 1116LLU; // case complete
19926+ label = 1274LLU; // case complete
1761619927 break;
1761719928 }
17618- case 1131LLU: // try next case
19929+ case 1289LLU: // try next case
1761919930 {
1762019931 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1762119932 exit(-1);
1762219933 }
17623- case 1116LLU: // completed switch
19934+ case 1274LLU: // completed switch
1762419935 {
17625- label = 1026LLU; // alternative complete
19936+ label = 1184LLU; // alternative complete
1762619937 break;
1762719938 }
17628- case 1026LLU: // completed if-then-else
19939+ case 1184LLU: // completed if-then-else
1762919940 {
1763019941 // return from initfrom
1763119942 label = stack[base - 1];
@@ -17632,7 +19943,7 @@
1763219943 base = stack[base - 2];
1763319944 break;
1763419945 }
17635- case 1140LLU: // PROCRETURN
19946+ case 1298LLU: // PROCRETURN
1763619947 {
1763719948 //#define arg0 0
1763819949 //#define arg1 1
@@ -17654,7 +19965,7 @@
1765419965 stack[base + 17] = 0;
1765519966 // call issimple from PROCRETURN
1765619967 stack[base + 18LLU] = base;
17657- stack[base + 19LLU] = 1141LLU;
19968+ stack[base + 19LLU] = 1299LLU;
1765819969 // arguments for call to issimple
1765919970 stack[base + 21LLU] = stack[base + 14]/*variant*/;
1766019971 stack[base + 22LLU] = stack[base + 15]/*content*/;
@@ -17664,7 +19975,7 @@
1766419975 label = 86LLU; // issimple
1766519976 break;
1766619977 }
17667- case 1141LLU: // return from issimple to PROCRETURN
19978+ case 1299LLU: // return from issimple to PROCRETURN
1766819979 {
1766919980 // copy mutable arguments back from call to issimple
1767019981 // copy back results provided by call to issimple
@@ -17671,20 +19982,20 @@
1767119982 stack[base + 17] = stack[base + 20LLU];
1767219983 if(!stack[base + 17]/*isequal*/)
1767319984 {
17674- label = 1142LLU; // jump to alternative
19985+ label = 1300LLU; // jump to alternative
1767519986 break;
1767619987 }
1767719988
1767819989 // consequent
1767919990 flippedassign(stack[base + 4]/*blkresults*/, &stack[base + 18]);
17680- label = 1144LLU; // start to repeat
19991+ label = 1302LLU; // start to repeat
1768119992 break;
1768219993 }
17683- case 1144LLU: // repeat from here
19994+ case 1302LLU: // repeat from here
1768419995 {
1768519996 if(!stack[base + 18])
1768619997 {
17687- label = 1145LLU; // break loop
19998+ label = 1303LLU; // break loop
1768819999 break;
1768920000 }
1769020001
@@ -17694,7 +20005,7 @@
1769420005 stack[base + 18] = (uint64_t)(((const struct listnode *)(stack[base + 18]))->next);
1769520006 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 19]/*typeidx*/))[0])
1769620007 {
17697- label = 1147LLU; // jump to alternative
20008+ label = 1305LLU; // jump to alternative
1769820009 break;
1769920010 }
1770020011
@@ -17704,7 +20015,7 @@
1770420015 // case
1770520016 // call initfrom from PROCRETURN
1770620017 stack[base + 23LLU] = base;
17707- stack[base + 24LLU] = 1148LLU;
20018+ stack[base + 24LLU] = 1306LLU;
1770820019 // arguments for call to initfrom
1770920020 stack[base + 25LLU] = stack[base + 8]/*fnid*/;
1771020021 stack[base + 26LLU] = stack[base + 21]/*type*/;
@@ -17715,10 +20026,10 @@
1771520026 stack[base + 31LLU] = stack[base + 13]/*lookahead*/;
1771620027 // set stack-base & callee-address
1771720028 base += 25LLU;
17718- label = 1022LLU; // initfrom
20029+ label = 1180LLU; // initfrom
1771920030 break;
1772020031 }
17721- case 1148LLU: // return from initfrom to PROCRETURN
20032+ case 1306LLU: // return from initfrom to PROCRETURN
1772220033 {
1772320034 // copy mutable arguments back from call to initfrom
1772420035 stack[base + 13]/*lookahead*/ = stack[base + 31LLU];
@@ -17725,7 +20036,7 @@
1772520036 stack[base + 3]/*scope*/ = stack[base + 30LLU];
1772620037 if(!stack[base + 18]/*blkresults*/)
1772720038 {
17728- label = 1149LLU; // jump to alternative
20039+ label = 1307LLU; // jump to alternative
1772920040 break;
1773020041 }
1773120042
@@ -17732,7 +20043,7 @@
1773220043 // consequent
1773320044 // call matchsym from PROCRETURN
1773420045 stack[base + 23LLU] = base;
17735- stack[base + 24LLU] = 1151LLU;
20046+ stack[base + 24LLU] = 1309LLU;
1773620047 // arguments for call to matchsym
1773720048 stack[base + 25LLU] = stack[base + 8]/*fnid*/;
1773820049 stack[base + 26LLU] = 44LLU;
@@ -17742,41 +20053,41 @@
1774220053 label = 110LLU; // matchsym
1774320054 break;
1774420055 }
17745- case 1151LLU: // return from matchsym to PROCRETURN
20056+ case 1309LLU: // return from matchsym to PROCRETURN
1774620057 {
1774720058 // copy mutable arguments back from call to matchsym
1774820059 stack[base + 13]/*lookahead*/ = stack[base + 27LLU];
17749- label = 1150LLU; // consequent complete
20060+ label = 1308LLU; // consequent complete
1775020061 break;
1775120062 }
17752- case 1149LLU: // alternative
20063+ case 1307LLU: // alternative
1775320064 {
17754- label = 1150LLU; // alternative complete
20065+ label = 1308LLU; // alternative complete
1775520066 break;
1775620067 }
17757- case 1150LLU: // completed if-then-else
20068+ case 1308LLU: // completed if-then-else
1775820069 {
1775920070 ((uint64_t **)(stack[base + 19]))[1][1] = stack[base + 22];
1776020071 ((uint64_t **)(stack[base + 19]))[1][0] = stack[base + 21];
17761- label = 1146LLU; // case complete
20072+ label = 1304LLU; // case complete
1776220073 break;
1776320074 }
17764- case 1147LLU: // try next case
20075+ case 1305LLU: // try next case
1776520076 {
1776620077 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1776720078 exit(-1);
1776820079 }
17769- case 1146LLU: // completed switch
20080+ case 1304LLU: // completed switch
1777020081 {
1777120082 ((struct listnode *)(stack[base + 20]/*previous*/))->data = stack[base + 19];
17772- label = 1144LLU; // repeat
20083+ label = 1302LLU; // repeat
1777320084 break;
1777420085 }
17775- case 1145LLU: // loop finished
20086+ case 1303LLU: // loop finished
1777620087 {
1777720088 // call matchsym from PROCRETURN
1777820089 stack[base + 21LLU] = base;
17779- stack[base + 22LLU] = 1152LLU;
20090+ stack[base + 22LLU] = 1310LLU;
1778020091 // arguments for call to matchsym
1778120092 stack[base + 23LLU] = stack[base + 8]/*fnid*/;
1778220093 stack[base + 24LLU] = 41LLU;
@@ -17786,26 +20097,26 @@
1778620097 label = 110LLU; // matchsym
1778720098 break;
1778820099 }
17789- case 1152LLU: // return from matchsym to PROCRETURN
20100+ case 1310LLU: // return from matchsym to PROCRETURN
1779020101 {
1779120102 // copy mutable arguments back from call to matchsym
1779220103 stack[base + 13]/*lookahead*/ = stack[base + 25LLU];
17793- label = 1143LLU; // consequent complete
20104+ label = 1301LLU; // consequent complete
1779420105 break;
1779520106 }
17796- case 1142LLU: // alternative
20107+ case 1300LLU: // alternative
1779720108 {
1779820109 stack[base + 18] = 0;
1779920110 stack[base + 19] = 0;
1780020111 flippedassign(stack[base + 4]/*blkresults*/, &stack[base + 20]);
17801- label = 1153LLU; // start to repeat
20112+ label = 1311LLU; // start to repeat
1780220113 break;
1780320114 }
17804- case 1153LLU: // repeat from here
20115+ case 1311LLU: // repeat from here
1780520116 {
1780620117 if(!stack[base + 20])
1780720118 {
17808- label = 1154LLU; // break loop
20119+ label = 1312LLU; // break loop
1780920120 break;
1781020121 }
1781120122
@@ -17815,7 +20126,7 @@
1781520126 stack[base + 20] = (uint64_t)(((const struct listnode *)(stack[base + 20]))->next);
1781620127 // call cptypeidx from PROCRETURN
1781720128 stack[base + 24LLU] = base;
17818- stack[base + 25LLU] = 1155LLU;
20129+ stack[base + 25LLU] = 1313LLU;
1781920130 // arguments for call to cptypeidx
1782020131 stack[base + 27LLU] = stack[base + 21]/*typeidx*/;
1782120132 // set stack-base & callee-address
@@ -17823,7 +20134,7 @@
1782320134 label = 191LLU; // cptypeidx
1782420135 break;
1782520136 }
17826- case 1155LLU: // return from cptypeidx to PROCRETURN
20137+ case 1313LLU: // return from cptypeidx to PROCRETURN
1782720138 {
1782820139 // copy mutable arguments back from call to cptypeidx
1782920140 // copy back results provided by call to cptypeidx
@@ -17840,15 +20151,15 @@
1784020151 MOVE(&list->data, &stack[base + 23]/*copy*/);
1784120152 }
1784220153 ((struct listnode *)(stack[base + 22]/*previous*/))->data = stack[base + 21];
17843- label = 1153LLU; // repeat
20154+ label = 1311LLU; // repeat
1784420155 break;
1784520156 }
17846- case 1154LLU: // loop finished
20157+ case 1312LLU: // loop finished
1784720158 {
1784820159 list_reverse(((struct listnode **)(&stack[base + 19]/*BLKRESULTS*/)));
1784920160 // call equ from PROCRETURN
1785020161 stack[base + 23LLU] = base;
17851- stack[base + 24LLU] = 1156LLU;
20162+ stack[base + 24LLU] = 1314LLU;
1785220163 // arguments for call to equ
1785320164 stack[base + 26LLU] = stack[base + 14]/*variant*/;
1785420165 stack[base + 27LLU] = 4LLU;
@@ -17857,7 +20168,7 @@
1785720168 label = 18446744073709551600LLU; // equ
1785820169 break;
1785920170 }
17860- case 1156LLU: // return from equ to PROCRETURN
20171+ case 1314LLU: // return from equ to PROCRETURN
1786120172 {
1786220173 // copy mutable arguments back from call to equ
1786320174 // copy back results provided by call to equ
@@ -17864,20 +20175,20 @@
1786420175 stack[base + 17] = stack[base + 25LLU];
1786520176 if(!stack[base + 17]/*isequal*/)
1786620177 {
17867- label = 1157LLU; // jump to alternative
20178+ label = 1315LLU; // jump to alternative
1786820179 break;
1786920180 }
1787020181
1787120182 // consequent
17872- label = 1158LLU; // consequent complete
20183+ label = 1316LLU; // consequent complete
1787320184 break;
1787420185 }
17875- case 1157LLU: // alternative
20186+ case 1315LLU: // alternative
1787620187 {
1787720188 fprintf(stderr, "%s", "parsing function call expected identifier but found ");
1787820189 // call reporttok from PROCRETURN
1787920190 stack[base + 23LLU] = base;
17880- stack[base + 24LLU] = 1159LLU;
20191+ stack[base + 24LLU] = 1317LLU;
1788120192 // arguments for call to reporttok
1788220193 stack[base + 25LLU] = stack[base + 14]/*variant*/;
1788320194 stack[base + 26LLU] = stack[base + 15]/*content*/;
@@ -17886,18 +20197,18 @@
1788620197 label = 18446744073709551582LLU; // reporttok
1788720198 break;
1788820199 }
17889- case 1159LLU: // return from reporttok to PROCRETURN
20200+ case 1317LLU: // return from reporttok to PROCRETURN
1789020201 {
1789120202 // copy mutable arguments back from call to reporttok
1789220203 exit(-1);
17893- label = 1158LLU; // alternative complete
20204+ label = 1316LLU; // alternative complete
1789420205 break;
1789520206 }
17896- case 1158LLU: // completed if-then-else
20207+ case 1316LLU: // completed if-then-else
1789720208 {
1789820209 // call FindFn from PROCRETURN
1789920210 stack[base + 24LLU] = base;
17900- stack[base + 25LLU] = 1160LLU;
20211+ stack[base + 25LLU] = 1318LLU;
1790120212 // arguments for call to FindFn
1790220213 stack[base + 27LLU] = stack[base + 8]/*fnid*/;
1790320214 stack[base + 28LLU] = stack[base + 0]/*fndefs*/;
@@ -17907,7 +20218,7 @@
1790720218 label = 628LLU; // FindFn
1790820219 break;
1790920220 }
17910- case 1160LLU: // return from FindFn to PROCRETURN
20221+ case 1318LLU: // return from FindFn to PROCRETURN
1791120222 {
1791220223 // copy mutable arguments back from call to FindFn
1791320224 // copy back results provided by call to FindFn
@@ -17914,7 +20225,7 @@
1791420225 stack[base + 23] = stack[base + 26LLU];
1791520226 if(/*fndef*/0 != ((uint64_t *)(stack[base + 23]/*calleedef*/))[0])
1791620227 {
17917- label = 1162LLU; // jump to alternative
20228+ label = 1320LLU; // jump to alternative
1791820229 break;
1791920230 }
1792020231
@@ -17928,14 +20239,14 @@
1792820239
1792920240 // case
1793020241 flippedassign(stack[base + 25]/*cerestypes*/, &stack[base + 31]);
17931- label = 1163LLU; // start to repeat
20242+ label = 1321LLU; // start to repeat
1793220243 break;
1793320244 }
17934- case 1163LLU: // repeat from here
20245+ case 1321LLU: // repeat from here
1793520246 {
1793620247 if(!stack[base + 31])
1793720248 {
17938- label = 1164LLU; // break loop
20249+ label = 1322LLU; // break loop
1793920250 break;
1794020251 }
1794120252
@@ -17947,7 +20258,7 @@
1794720258 struct listnode *list = (struct listnode *)stack[base + 19]/*BLKRESULTS*/;
1794820259 if(!list)
1794920260 {
17950- label = 1165LLU; // jump to alternative
20261+ label = 1323LLU; // jump to alternative
1795120262 break;
1795220263 }
1795320264
@@ -17959,7 +20270,7 @@
1795920270 }
1796020271 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 34]/*typeidx*/))[0])
1796120272 {
17962- label = 1168LLU; // jump to alternative
20273+ label = 1326LLU; // jump to alternative
1796320274 break;
1796420275 }
1796520276
@@ -17969,7 +20280,7 @@
1796920280 // case
1797020281 if(/*result*/0 != ((uint64_t *)(stack[base + 32]/*result*/))[0])
1797120282 {
17972- label = 1170LLU; // jump to alternative
20283+ label = 1328LLU; // jump to alternative
1797320284 break;
1797420285 }
1797520286
@@ -17987,7 +20298,7 @@
1798720298 // call equtype from PROCRETURN
1798820299 newstack[0] = (uint64_t)stack; // backup stack location
1798920300 newstack[1] = base;
17990- newstack[2] = 1171LLU;
20301+ newstack[2] = 1329LLU;
1799120302 // arguments for call to equtype
1799220303 newstack[4LLU] = stack[base + 35]/*dsttype*/;
1799320304 newstack[5LLU] = stack[base + 37]/*srctype*/;
@@ -17997,7 +20308,7 @@
1799720308 label = 170LLU; // equtype
1799820309 break;
1799920310 }
18000- case 1171LLU: // return from equtype to PROCRETURN
20311+ case 1329LLU: // return from equtype to PROCRETURN
1800120312 {
1800220313 uint64_t *oldstack = (uint64_t *)stack[0];
1800320314 // copy mutable arguments back from call to equtype
@@ -18012,20 +20323,20 @@
1801220323 stack = oldstack;
1801320324 if(!stack[base + 17]/*isequal*/)
1801420325 {
18015- label = 1172LLU; // jump to alternative
20326+ label = 1330LLU; // jump to alternative
1801620327 break;
1801720328 }
1801820329
1801920330 // consequent
18020- label = 1173LLU; // consequent complete
20331+ label = 1331LLU; // consequent complete
1802120332 break;
1802220333 }
18023- case 1172LLU: // alternative
20334+ case 1330LLU: // alternative
1802420335 {
1802520336 fprintf(stderr, "%s", "in function ");
1802620337 // call reportid from PROCRETURN
1802720338 stack[base + 39LLU] = base;
18028- stack[base + 40LLU] = 1174LLU;
20339+ stack[base + 40LLU] = 1332LLU;
1802920340 // arguments for call to reportid
1803020341 stack[base + 41LLU] = stack[base + 8]/*fnid*/;
1803120342 // set stack-base & callee-address
@@ -18033,13 +20344,13 @@
1803320344 label = 18446744073709551586LLU; // reportid
1803420345 break;
1803520346 }
18036- case 1174LLU: // return from reportid to PROCRETURN
20347+ case 1332LLU: // return from reportid to PROCRETURN
1803720348 {
1803820349 // copy mutable arguments back from call to reportid
1803920350 fprintf(stderr, "%s", " call to ");
1804020351 // call reportid from PROCRETURN
1804120352 stack[base + 39LLU] = base;
18042- stack[base + 40LLU] = 1175LLU;
20353+ stack[base + 40LLU] = 1333LLU;
1804320354 // arguments for call to reportid
1804420355 stack[base + 41LLU] = stack[base + 28]/*ceid*/;
1804520356 // set stack-base & callee-address
@@ -18047,7 +20358,7 @@
1804720358 label = 18446744073709551586LLU; // reportid
1804820359 break;
1804920360 }
18050- case 1175LLU: // return from reportid to PROCRETURN
20361+ case 1333LLU: // return from reportid to PROCRETURN
1805120362 {
1805220363 // copy mutable arguments back from call to reportid
1805320364 fprintf(stderr, "%s", " can't return result of type ");
@@ -18061,7 +20372,7 @@
1806120372 // call reporttype from PROCRETURN
1806220373 newstack[0] = (uint64_t)stack; // backup stack location
1806320374 newstack[1] = base;
18064- newstack[2] = 1176LLU;
20375+ newstack[2] = 1334LLU;
1806520376 // arguments for call to reporttype
1806620377 newstack[3LLU] = stack[base + 37]/*srctype*/;
1806720378 stack = newstack;
@@ -18070,7 +20381,7 @@
1807020381 label = 159LLU; // reporttype
1807120382 break;
1807220383 }
18073- case 1176LLU: // return from reporttype to PROCRETURN
20384+ case 1334LLU: // return from reporttype to PROCRETURN
1807420385 {
1807520386 uint64_t *oldstack = (uint64_t *)stack[0];
1807620387 // copy mutable arguments back from call to reporttype
@@ -18092,7 +20403,7 @@
1809220403 // call reporttype from PROCRETURN
1809320404 newstack[0] = (uint64_t)stack; // backup stack location
1809420405 newstack[1] = base;
18095- newstack[2] = 1177LLU;
20406+ newstack[2] = 1335LLU;
1809620407 // arguments for call to reporttype
1809720408 newstack[3LLU] = stack[base + 35]/*dsttype*/;
1809820409 stack = newstack;
@@ -18101,7 +20412,7 @@
1810120412 label = 159LLU; // reporttype
1810220413 break;
1810320414 }
18104- case 1177LLU: // return from reporttype to PROCRETURN
20415+ case 1335LLU: // return from reporttype to PROCRETURN
1810520416 {
1810620417 uint64_t *oldstack = (uint64_t *)stack[0];
1810720418 // copy mutable arguments back from call to reporttype
@@ -18114,38 +20425,38 @@
1811420425 stack = oldstack;
1811520426 fprintf(stderr, "%s", "\n");
1811620427 exit(-1);
18117- label = 1173LLU; // alternative complete
20428+ label = 1331LLU; // alternative complete
1811820429 break;
1811920430 }
18120- case 1173LLU: // completed if-then-else
20431+ case 1331LLU: // completed if-then-else
1812120432 {
1812220433 ((uint64_t **)(stack[base + 32]))[1][1] = stack[base + 38];
1812320434 ((uint64_t **)(stack[base + 32]))[1][0] = stack[base + 37];
18124- label = 1169LLU; // case complete
20435+ label = 1327LLU; // case complete
1812520436 break;
1812620437 }
18127- case 1170LLU: // try next case
20438+ case 1328LLU: // try next case
1812820439 {
1812920440 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1813020441 exit(-1);
1813120442 }
18132- case 1169LLU: // completed switch
20443+ case 1327LLU: // completed switch
1813320444 {
1813420445 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 36];
1813520446 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 35];
18136- label = 1167LLU; // case complete
20447+ label = 1325LLU; // case complete
1813720448 break;
1813820449 }
18139- case 1168LLU: // try next case
20450+ case 1326LLU: // try next case
1814020451 {
1814120452 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1814220453 exit(-1);
1814320454 }
18144- case 1167LLU: // completed switch
20455+ case 1325LLU: // completed switch
1814520456 {
1814620457 // call cptypeidx from PROCRETURN
1814720458 stack[base + 36LLU] = base;
18148- stack[base + 37LLU] = 1178LLU;
20459+ stack[base + 37LLU] = 1336LLU;
1814920460 // arguments for call to cptypeidx
1815020461 stack[base + 39LLU] = stack[base + 34]/*typeidx*/;
1815120462 // set stack-base & callee-address
@@ -18153,7 +20464,7 @@
1815320464 label = 191LLU; // cptypeidx
1815420465 break;
1815520466 }
18156- case 1178LLU: // return from cptypeidx to PROCRETURN
20467+ case 1336LLU: // return from cptypeidx to PROCRETURN
1815720468 {
1815820469 // copy mutable arguments back from call to cptypeidx
1815920470 // copy back results provided by call to cptypeidx
@@ -18174,7 +20485,7 @@
1817420485 // call ~typeidx from PROCRETURN
1817520486 newstack[0] = (uint64_t)stack; // backup stack location
1817620487 newstack[1] = base;
18177- newstack[2] = 1179LLU;
20488+ newstack[2] = 1337LLU;
1817820489 stack = newstack;
1817920490 // set stack-base & callee-address
1818020491 base = 3;
@@ -18181,21 +20492,21 @@
1818120492 label = 188LLU; // ~typeidx
1818220493 break;
1818320494 }
18184- case 1179LLU: // return from ~typeidx to PROCRETURN
20495+ case 1337LLU: // return from ~typeidx to PROCRETURN
1818520496 {
1818620497 stack = (uint64_t *)stack[0];
1818720498 // releasing toplevel container
1818820499 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 34] - sizeof(uint64_t) * 3));
1818920500
18190- label = 1166LLU; // consequent complete
20501+ label = 1324LLU; // consequent complete
1819120502 break;
1819220503 }
18193- case 1165LLU: // alternative
20504+ case 1323LLU: // alternative
1819420505 {
1819520506 fprintf(stderr, "%s", "in function ");
1819620507 // call reportid from PROCRETURN
1819720508 stack[base + 35LLU] = base;
18198- stack[base + 36LLU] = 1180LLU;
20509+ stack[base + 36LLU] = 1338LLU;
1819920510 // arguments for call to reportid
1820020511 stack[base + 37LLU] = stack[base + 8]/*fnid*/;
1820120512 // set stack-base & callee-address
@@ -18203,13 +20514,13 @@
1820320514 label = 18446744073709551586LLU; // reportid
1820420515 break;
1820520516 }
18206- case 1180LLU: // return from reportid to PROCRETURN
20517+ case 1338LLU: // return from reportid to PROCRETURN
1820720518 {
1820820519 // copy mutable arguments back from call to reportid
1820920520 fprintf(stderr, "%s", " call to ");
1821020521 // call reportid from PROCRETURN
1821120522 stack[base + 35LLU] = base;
18212- stack[base + 36LLU] = 1181LLU;
20523+ stack[base + 36LLU] = 1339LLU;
1821320524 // arguments for call to reportid
1821420525 stack[base + 37LLU] = stack[base + 28]/*ceid*/;
1821520526 // set stack-base & callee-address
@@ -18217,22 +20528,22 @@
1821720528 label = 18446744073709551586LLU; // reportid
1821820529 break;
1821920530 }
18220- case 1181LLU: // return from reportid to PROCRETURN
20531+ case 1339LLU: // return from reportid to PROCRETURN
1822120532 {
1822220533 // copy mutable arguments back from call to reportid
1822320534 fprintf(stderr, "%s", " not enough destination-variables for results");
1822420535 fprintf(stderr, "%s", "\n");
1822520536 exit(-1);
18226- label = 1166LLU; // alternative complete
20537+ label = 1324LLU; // alternative complete
1822720538 break;
1822820539 }
18229- case 1166LLU: // completed if-then-else
20540+ case 1324LLU: // completed if-then-else
1823020541 {
1823120542 ((struct listnode *)(stack[base + 33]/*previous*/))->data = stack[base + 32];
18232- label = 1163LLU; // repeat
20543+ label = 1321LLU; // repeat
1823320544 break;
1823420545 }
18235- case 1164LLU: // loop finished
20546+ case 1322LLU: // loop finished
1823620547 {
1823720548 ((uint64_t **)(stack[base + 23]))[1][6] = stack[base + 30];
1823820549 ((uint64_t **)(stack[base + 23]))[1][5] = stack[base + 29];
@@ -18241,20 +20552,20 @@
1824120552 ((uint64_t **)(stack[base + 23]))[1][2] = stack[base + 26];
1824220553 ((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
1824320554 ((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
18244- label = 1161LLU; // case complete
20555+ label = 1319LLU; // case complete
1824520556 break;
1824620557 }
18247- case 1162LLU: // try next case
20558+ case 1320LLU: // try next case
1824820559 {
1824920560 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1825020561 exit(-1);
1825120562 }
18252- case 1161LLU: // completed switch
20563+ case 1319LLU: // completed switch
1825320564 {
1825420565 list_reverse(((struct listnode **)(&stack[base + 18]/*dsttypeidx*/)));
1825520566 // call matchsym from PROCRETURN
1825620567 stack[base + 24LLU] = base;
18257- stack[base + 25LLU] = 1182LLU;
20568+ stack[base + 25LLU] = 1340LLU;
1825820569 // arguments for call to matchsym
1825920570 stack[base + 26LLU] = stack[base + 8]/*fnid*/;
1826020571 stack[base + 27LLU] = 40LLU;
@@ -18264,13 +20575,13 @@
1826420575 label = 110LLU; // matchsym
1826520576 break;
1826620577 }
18267- case 1182LLU: // return from matchsym to PROCRETURN
20578+ case 1340LLU: // return from matchsym to PROCRETURN
1826820579 {
1826920580 // copy mutable arguments back from call to matchsym
1827020581 stack[base + 13]/*lookahead*/ = stack[base + 28LLU];
1827120582 // call ProcCall from PROCRETURN
1827220583 stack[base + 24LLU] = base;
18273- stack[base + 25LLU] = 1183LLU;
20584+ stack[base + 25LLU] = 1341LLU;
1827420585 // arguments for call to ProcCall
1827520586 stack[base + 26LLU] = stack[base + 18]/*dsttypeidx*/;
1827620587 stack[base + 27LLU] = stack[base + 0]/*fndefs*/;
@@ -18291,10 +20602,10 @@
1829120602 stack[base + 42LLU] = stack[base + 16]/*label*/;
1829220603 // set stack-base & callee-address
1829320604 base += 26LLU;
18294- label = 688LLU; // ProcCall
20605+ label = 846LLU; // ProcCall
1829520606 break;
1829620607 }
18297- case 1183LLU: // return from ProcCall to PROCRETURN
20608+ case 1341LLU: // return from ProcCall to PROCRETURN
1829820609 {
1829920610 // copy mutable arguments back from call to ProcCall
1830020611 stack[base + 16]/*label*/ = stack[base + 42LLU];
@@ -18305,7 +20616,7 @@
1830520616 stack[base + 18]/*dsttypeidx*/ = stack[base + 26LLU];
1830620617 // call matchsym from PROCRETURN
1830720618 stack[base + 24LLU] = base;
18308- stack[base + 25LLU] = 1184LLU;
20619+ stack[base + 25LLU] = 1342LLU;
1830920620 // arguments for call to matchsym
1831020621 stack[base + 26LLU] = stack[base + 8]/*fnid*/;
1831120622 stack[base + 27LLU] = 41LLU;
@@ -18315,13 +20626,13 @@
1831520626 label = 110LLU; // matchsym
1831620627 break;
1831720628 }
18318- case 1184LLU: // return from matchsym to PROCRETURN
20629+ case 1342LLU: // return from matchsym to PROCRETURN
1831920630 {
1832020631 // copy mutable arguments back from call to matchsym
1832120632 stack[base + 13]/*lookahead*/ = stack[base + 28LLU];
1832220633 // call skipwscmnt from PROCRETURN
1832320634 stack[base + 24LLU] = base;
18324- stack[base + 25LLU] = 1185LLU;
20635+ stack[base + 25LLU] = 1343LLU;
1832520636 // arguments for call to skipwscmnt
1832620637 stack[base + 27LLU] = stack[base + 13]/*lookahead*/;
1832720638 // set stack-base & callee-address
@@ -18329,7 +20640,7 @@
1832920640 label = 18446744073709551580LLU; // skipwscmnt
1833020641 break;
1833120642 }
18332- case 1185LLU: // return from skipwscmnt to PROCRETURN
20643+ case 1343LLU: // return from skipwscmnt to PROCRETURN
1833320644 {
1833420645 // copy mutable arguments back from call to skipwscmnt
1833520646 // copy back results provided by call to skipwscmnt
@@ -18336,7 +20647,7 @@
1833620647 stack[base + 13] = stack[base + 26LLU];
1833720648 // call equ from PROCRETURN
1833820649 stack[base + 24LLU] = base;
18339- stack[base + 25LLU] = 1186LLU;
20650+ stack[base + 25LLU] = 1344LLU;
1834020651 // arguments for call to equ
1834120652 stack[base + 27LLU] = stack[base + 13]/*lookahead*/;
1834220653 stack[base + 28LLU] = 125LLU;
@@ -18345,7 +20656,7 @@
1834520656 label = 18446744073709551600LLU; // equ
1834620657 break;
1834720658 }
18348- case 1186LLU: // return from equ to PROCRETURN
20659+ case 1344LLU: // return from equ to PROCRETURN
1834920660 {
1835020661 // copy mutable arguments back from call to equ
1835120662 // copy back results provided by call to equ
@@ -18352,20 +20663,20 @@
1835220663 stack[base + 17] = stack[base + 26LLU];
1835320664 if(!stack[base + 17]/*isequal*/)
1835420665 {
18355- label = 1187LLU; // jump to alternative
20666+ label = 1345LLU; // jump to alternative
1835620667 break;
1835720668 }
1835820669
1835920670 // consequent
18360- label = 1188LLU; // consequent complete
20671+ label = 1346LLU; // consequent complete
1836120672 break;
1836220673 }
18363- case 1187LLU: // alternative
20674+ case 1345LLU: // alternative
1836420675 {
1836520676 fprintf(stderr, "%s", "in function ");
1836620677 // call reportid from PROCRETURN
1836720678 stack[base + 24LLU] = base;
18368- stack[base + 25LLU] = 1189LLU;
20679+ stack[base + 25LLU] = 1347LLU;
1836920680 // arguments for call to reportid
1837020681 stack[base + 26LLU] = stack[base + 8]/*fnid*/;
1837120682 // set stack-base & callee-address
@@ -18373,13 +20684,13 @@
1837320684 label = 18446744073709551586LLU; // reportid
1837420685 break;
1837520686 }
18376- case 1189LLU: // return from reportid to PROCRETURN
20687+ case 1347LLU: // return from reportid to PROCRETURN
1837720688 {
1837820689 // copy mutable arguments back from call to reportid
1837920690 fprintf(stderr, "%s", ": return must be last statement in function - expected '}' but found '");
1838020691 // call reportbyte from PROCRETURN
1838120692 stack[base + 24LLU] = base;
18382- stack[base + 25LLU] = 1190LLU;
20693+ stack[base + 25LLU] = 1348LLU;
1838320694 // arguments for call to reportbyte
1838420695 stack[base + 26LLU] = stack[base + 13]/*lookahead*/;
1838520696 // set stack-base & callee-address
@@ -18387,15 +20698,15 @@
1838720698 label = 18446744073709551591LLU; // reportbyte
1838820699 break;
1838920700 }
18390- case 1190LLU: // return from reportbyte to PROCRETURN
20701+ case 1348LLU: // return from reportbyte to PROCRETURN
1839120702 {
1839220703 // copy mutable arguments back from call to reportbyte
1839320704 fprintf(stderr, "%s", "'\n");
1839420705 exit(-1);
18395- label = 1188LLU; // alternative complete
20706+ label = 1346LLU; // alternative complete
1839620707 break;
1839720708 }
18398- case 1188LLU: // completed if-then-else
20709+ case 1346LLU: // completed if-then-else
1839920710 {
1840020711
1840120712 uint64_t *newstack = (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 3);
@@ -18402,7 +20713,7 @@
1840220713 // call ~fndef from PROCRETURN
1840320714 newstack[0] = (uint64_t)stack; // backup stack location
1840420715 newstack[1] = base;
18405- newstack[2] = 1191LLU;
20716+ newstack[2] = 1349LLU;
1840620717 stack = newstack;
1840720718 // set stack-base & callee-address
1840820719 base = 3;
@@ -18409,7 +20720,7 @@
1840920720 label = 610LLU; // ~fndef
1841020721 break;
1841120722 }
18412- case 1191LLU: // return from ~fndef to PROCRETURN
20723+ case 1349LLU: // return from ~fndef to PROCRETURN
1841320724 {
1841420725 stack = (uint64_t *)stack[0];
1841520726 // releasing toplevel container
@@ -18416,14 +20727,14 @@
1841620727 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 3));
1841720728
1841820729 // delete list
18419- label = 1192LLU; // start to repeat
20730+ label = 1350LLU; // start to repeat
1842020731 break;
1842120732 }
18422- case 1192LLU: // repeat from here
20733+ case 1350LLU: // repeat from here
1842320734 {
1842420735 if(!stack[base + 19])
1842520736 {
18426- label = 1193LLU; // break loop
20737+ label = 1351LLU; // break loop
1842720738 break;
1842820739 }
1842920740
@@ -18433,7 +20744,7 @@
1843320744 // call ~typeidx from PROCRETURN
1843420745 newstack[0] = (uint64_t)stack; // backup stack location
1843520746 newstack[1] = base;
18436- newstack[2] = 1194LLU;
20747+ newstack[2] = 1352LLU;
1843720748 stack = newstack;
1843820749 // set stack-base & callee-address
1843920750 base = 3;
@@ -18440,7 +20751,7 @@
1844020751 label = 188LLU; // ~typeidx
1844120752 break;
1844220753 }
18443- case 1194LLU: // return from ~typeidx to PROCRETURN
20754+ case 1352LLU: // return from ~typeidx to PROCRETURN
1844420755 {
1844520756 stack = (uint64_t *)stack[0];
1844620757 // releasing toplevel container
@@ -18451,20 +20762,20 @@
1845120762 stack[base + 19] = (uint64_t)list->next;
1845220763 Free(1, sizeof(struct listnode), list);
1845320764 }
18454- label = 1192LLU; // repeat
20765+ label = 1350LLU; // repeat
1845520766 break;
1845620767 }
18457- case 1193LLU: // loop finished
20768+ case 1351LLU: // loop finished
1845820769 {
1845920770 // delete list
18460- label = 1195LLU; // start to repeat
20771+ label = 1353LLU; // start to repeat
1846120772 break;
1846220773 }
18463- case 1195LLU: // repeat from here
20774+ case 1353LLU: // repeat from here
1846420775 {
1846520776 if(!stack[base + 18])
1846620777 {
18467- label = 1196LLU; // break loop
20778+ label = 1354LLU; // break loop
1846820779 break;
1846920780 }
1847020781
@@ -18474,7 +20785,7 @@
1847420785 // call ~typeidx from PROCRETURN
1847520786 newstack[0] = (uint64_t)stack; // backup stack location
1847620787 newstack[1] = base;
18477- newstack[2] = 1197LLU;
20788+ newstack[2] = 1355LLU;
1847820789 stack = newstack;
1847920790 // set stack-base & callee-address
1848020791 base = 3;
@@ -18481,7 +20792,7 @@
1848120792 label = 188LLU; // ~typeidx
1848220793 break;
1848320794 }
18484- case 1197LLU: // return from ~typeidx to PROCRETURN
20795+ case 1355LLU: // return from ~typeidx to PROCRETURN
1848520796 {
1848620797 stack = (uint64_t *)stack[0];
1848720798 // releasing toplevel container
@@ -18492,15 +20803,15 @@
1849220803 stack[base + 18] = (uint64_t)list->next;
1849320804 Free(1, sizeof(struct listnode), list);
1849420805 }
18495- label = 1195LLU; // repeat
20806+ label = 1353LLU; // repeat
1849620807 break;
1849720808 }
18498- case 1196LLU: // loop finished
20809+ case 1354LLU: // loop finished
1849920810 {
18500- label = 1143LLU; // alternative complete
20811+ label = 1301LLU; // alternative complete
1850120812 break;
1850220813 }
18503- case 1143LLU: // completed if-then-else
20814+ case 1301LLU: // completed if-then-else
1850420815 {
1850520816 // return from PROCRETURN
1850620817 label = stack[base - 1];
@@ -18507,7 +20818,7 @@
1850720818 base = stack[base - 2];
1850820819 break;
1850920820 }
18510- case 1198LLU: // PROCCALL
20821+ case 1356LLU: // PROCCALL
1851120822 {
1851220823 //#define arg0 0
1851320824 //#define arg1 1
@@ -18529,7 +20840,7 @@
1852920840 stack[base + 17] = 0;
1853020841 // call equ from PROCCALL
1853120842 stack[base + 18LLU] = base;
18532- stack[base + 19LLU] = 1199LLU;
20843+ stack[base + 19LLU] = 1357LLU;
1853320844 // arguments for call to equ
1853420845 stack[base + 21LLU] = 40LLU;
1853520846 stack[base + 22LLU] = stack[base + 13]/*content*/;
@@ -18538,7 +20849,7 @@
1853820849 label = 18446744073709551600LLU; // equ
1853920850 break;
1854020851 }
18541- case 1199LLU: // return from equ to PROCCALL
20852+ case 1357LLU: // return from equ to PROCCALL
1854220853 {
1854320854 // copy mutable arguments back from call to equ
1854420855 // copy back results provided by call to equ
@@ -18545,20 +20856,20 @@
1854520856 stack[base + 17] = stack[base + 20LLU];
1854620857 if(!stack[base + 17]/*isequal*/)
1854720858 {
18548- label = 1200LLU; // jump to alternative
20859+ label = 1358LLU; // jump to alternative
1854920860 break;
1855020861 }
1855120862
1855220863 // consequent
18553- label = 1201LLU; // consequent complete
20864+ label = 1359LLU; // consequent complete
1855420865 break;
1855520866 }
18556- case 1200LLU: // alternative
20867+ case 1358LLU: // alternative
1855720868 {
1855820869 fprintf(stderr, "%s", "expected '(' but found token ");
1855920870 // call reporttok from PROCCALL
1856020871 stack[base + 18LLU] = base;
18561- stack[base + 19LLU] = 1202LLU;
20872+ stack[base + 19LLU] = 1360LLU;
1856220873 // arguments for call to reporttok
1856320874 stack[base + 20LLU] = stack[base + 12]/*variant*/;
1856420875 stack[base + 21LLU] = stack[base + 13]/*content*/;
@@ -18567,19 +20878,19 @@
1856720878 label = 18446744073709551582LLU; // reporttok
1856820879 break;
1856920880 }
18570- case 1202LLU: // return from reporttok to PROCCALL
20881+ case 1360LLU: // return from reporttok to PROCCALL
1857120882 {
1857220883 // copy mutable arguments back from call to reporttok
1857320884 fprintf(stderr, "%s", "\n");
1857420885 exit(-1);
18575- label = 1201LLU; // alternative complete
20886+ label = 1359LLU; // alternative complete
1857620887 break;
1857720888 }
18578- case 1201LLU: // completed if-then-else
20889+ case 1359LLU: // completed if-then-else
1857920890 {
1858020891 // call skipwscmnt from PROCCALL
1858120892 stack[base + 18LLU] = base;
18582- stack[base + 19LLU] = 1203LLU;
20893+ stack[base + 19LLU] = 1361LLU;
1858320894 // arguments for call to skipwscmnt
1858420895 stack[base + 21LLU] = stack[base + 11]/*lookahead*/;
1858520896 // set stack-base & callee-address
@@ -18587,7 +20898,7 @@
1858720898 label = 18446744073709551580LLU; // skipwscmnt
1858820899 break;
1858920900 }
18590- case 1203LLU: // return from skipwscmnt to PROCCALL
20901+ case 1361LLU: // return from skipwscmnt to PROCCALL
1859120902 {
1859220903 // copy mutable arguments back from call to skipwscmnt
1859320904 // copy back results provided by call to skipwscmnt
@@ -18594,7 +20905,7 @@
1859420905 stack[base + 11] = stack[base + 20LLU];
1859520906 // call equ from PROCCALL
1859620907 stack[base + 18LLU] = base;
18597- stack[base + 19LLU] = 1204LLU;
20908+ stack[base + 19LLU] = 1362LLU;
1859820909 // arguments for call to equ
1859920910 stack[base + 21LLU] = stack[base + 11]/*lookahead*/;
1860020911 stack[base + 22LLU] = 41LLU;
@@ -18603,7 +20914,7 @@
1860320914 label = 18446744073709551600LLU; // equ
1860420915 break;
1860520916 }
18606- case 1204LLU: // return from equ to PROCCALL
20917+ case 1362LLU: // return from equ to PROCCALL
1860720918 {
1860820919 // copy mutable arguments back from call to equ
1860920920 // copy back results provided by call to equ
@@ -18610,24 +20921,24 @@
1861020921 stack[base + 17] = stack[base + 20LLU];
1861120922 if(!stack[base + 17]/*isequal*/)
1861220923 {
18613- label = 1205LLU; // jump to alternative
20924+ label = 1363LLU; // jump to alternative
1861420925 break;
1861520926 }
1861620927
1861720928 // consequent
18618- label = 1206LLU; // consequent complete
20929+ label = 1364LLU; // consequent complete
1861920930 break;
1862020931 }
18621- case 1205LLU: // alternative
20932+ case 1363LLU: // alternative
1862220933 {
18623- label = 1207LLU; // start to repeat
20934+ label = 1365LLU; // start to repeat
1862420935 break;
1862520936 }
18626- case 1207LLU: // repeat from here
20937+ case 1365LLU: // repeat from here
1862720938 {
1862820939 if(stack[base + 11]/*lookahead*/ > 0xFF)
1862920940 {
18630- label = 1208LLU; // break loop
20941+ label = 1366LLU; // break loop
1863120942 break;
1863220943 }
1863320944
@@ -18634,7 +20945,7 @@
1863420945 // loop body
1863520946 // call ParseToken from PROCCALL
1863620947 stack[base + 18LLU] = base;
18637- stack[base + 19LLU] = 1209LLU;
20948+ stack[base + 19LLU] = 1367LLU;
1863820949 // arguments for call to ParseToken
1863920950 stack[base + 22LLU] = stack[base + 11]/*lookahead*/;
1864020951 // set stack-base & callee-address
@@ -18642,7 +20953,7 @@
1864220953 label = 2LLU; // ParseToken
1864320954 break;
1864420955 }
18645- case 1209LLU: // return from ParseToken to PROCCALL
20956+ case 1367LLU: // return from ParseToken to PROCCALL
1864620957 {
1864720958 // copy mutable arguments back from call to ParseToken
1864820959 stack[base + 11]/*lookahead*/ = stack[base + 22LLU];
@@ -18651,7 +20962,7 @@
1865120962 stack[base + 13] = stack[base + 21LLU];
1865220963 // call equ from PROCCALL
1865320964 stack[base + 18LLU] = base;
18654- stack[base + 19LLU] = 1210LLU;
20965+ stack[base + 19LLU] = 1368LLU;
1865520966 // arguments for call to equ
1865620967 stack[base + 21LLU] = stack[base + 12]/*variant*/;
1865720968 stack[base + 22LLU] = 4LLU;
@@ -18660,7 +20971,7 @@
1866020971 label = 18446744073709551600LLU; // equ
1866120972 break;
1866220973 }
18663- case 1210LLU: // return from equ to PROCCALL
20974+ case 1368LLU: // return from equ to PROCCALL
1866420975 {
1866520976 // copy mutable arguments back from call to equ
1866620977 // copy back results provided by call to equ
@@ -18667,20 +20978,20 @@
1866720978 stack[base + 17] = stack[base + 20LLU];
1866820979 if(!stack[base + 17]/*isequal*/)
1866920980 {
18670- label = 1211LLU; // jump to alternative
20981+ label = 1369LLU; // jump to alternative
1867120982 break;
1867220983 }
1867320984
1867420985 // consequent
18675- label = 1212LLU; // consequent complete
20986+ label = 1370LLU; // consequent complete
1867620987 break;
1867720988 }
18678- case 1211LLU: // alternative
20989+ case 1369LLU: // alternative
1867920990 {
1868020991 fprintf(stderr, "%s", "expected destination-identifier but found ");
1868120992 // call reporttok from PROCCALL
1868220993 stack[base + 18LLU] = base;
18683- stack[base + 19LLU] = 1213LLU;
20994+ stack[base + 19LLU] = 1371LLU;
1868420995 // arguments for call to reporttok
1868520996 stack[base + 20LLU] = stack[base + 12]/*variant*/;
1868620997 stack[base + 21LLU] = stack[base + 13]/*content*/;
@@ -18689,18 +21000,18 @@
1868921000 label = 18446744073709551582LLU; // reporttok
1869021001 break;
1869121002 }
18692- case 1213LLU: // return from reporttok to PROCCALL
21003+ case 1371LLU: // return from reporttok to PROCCALL
1869321004 {
1869421005 // copy mutable arguments back from call to reporttok
1869521006 exit(-1);
18696- label = 1212LLU; // alternative complete
21007+ label = 1370LLU; // alternative complete
1869721008 break;
1869821009 }
18699- case 1212LLU: // completed if-then-else
21010+ case 1370LLU: // completed if-then-else
1870021011 {
1870121012 // call existslet from PROCCALL
1870221013 stack[base + 19LLU] = base;
18703- stack[base + 20LLU] = 1214LLU;
21014+ stack[base + 20LLU] = 1372LLU;
1870421015 // arguments for call to existslet
1870521016 stack[base + 22LLU] = stack[base + 16]/*results*/;
1870621017 stack[base + 23LLU] = stack[base + 13]/*content*/;
@@ -18709,7 +21020,7 @@
1870921020 label = 262LLU; // existslet
1871021021 break;
1871121022 }
18712- case 1214LLU: // return from existslet to PROCCALL
21023+ case 1372LLU: // return from existslet to PROCCALL
1871321024 {
1871421025 // copy mutable arguments back from call to existslet
1871521026 // copy back results provided by call to existslet
@@ -18716,7 +21027,7 @@
1871621027 stack[base + 18] = stack[base + 21LLU];
1871721028 if(!stack[base + 18]/*found*/)
1871821029 {
18719- label = 1215LLU; // jump to alternative
21030+ label = 1373LLU; // jump to alternative
1872021031 break;
1872121032 }
1872221033
@@ -18724,7 +21035,7 @@
1872421035 fprintf(stderr, "%s", "in function-call - duplicate result-identifier ");
1872521036 // call reportid from PROCCALL
1872621037 stack[base + 19LLU] = base;
18727- stack[base + 20LLU] = 1217LLU;
21038+ stack[base + 20LLU] = 1375LLU;
1872821039 // arguments for call to reportid
1872921040 stack[base + 21LLU] = stack[base + 13]/*content*/;
1873021041 // set stack-base & callee-address
@@ -18732,24 +21043,24 @@
1873221043 label = 18446744073709551586LLU; // reportid
1873321044 break;
1873421045 }
18735- case 1217LLU: // return from reportid to PROCCALL
21046+ case 1375LLU: // return from reportid to PROCCALL
1873621047 {
1873721048 // copy mutable arguments back from call to reportid
1873821049 fprintf(stderr, "%s", "\n");
1873921050 exit(-1);
18740- label = 1216LLU; // consequent complete
21051+ label = 1374LLU; // consequent complete
1874121052 break;
1874221053 }
18743- case 1215LLU: // alternative
21054+ case 1373LLU: // alternative
1874421055 {
18745- label = 1216LLU; // alternative complete
21056+ label = 1374LLU; // alternative complete
1874621057 break;
1874721058 }
18748- case 1216LLU: // completed if-then-else
21059+ case 1374LLU: // completed if-then-else
1874921060 {
1875021061 // call FindLetNew from PROCCALL
1875121062 stack[base + 20LLU] = base;
18752- stack[base + 21LLU] = 1218LLU;
21063+ stack[base + 21LLU] = 1376LLU;
1875321064 // arguments for call to FindLetNew
1875421065 stack[base + 23LLU] = stack[base + 6]/*fnid*/;
1875521066 stack[base + 24LLU] = stack[base + 13]/*content*/;
@@ -18760,7 +21071,7 @@
1876021071 label = 290LLU; // FindLetNew
1876121072 break;
1876221073 }
18763- case 1218LLU: // return from FindLetNew to PROCCALL
21074+ case 1376LLU: // return from FindLetNew to PROCCALL
1876421075 {
1876521076 // copy mutable arguments back from call to FindLetNew
1876621077 // copy back results provided by call to FindLetNew
@@ -18778,7 +21089,7 @@
1877821089 }
1877921090 // call skipwscmnt from PROCCALL
1878021091 stack[base + 18LLU] = base;
18781- stack[base + 19LLU] = 1219LLU;
21092+ stack[base + 19LLU] = 1377LLU;
1878221093 // arguments for call to skipwscmnt
1878321094 stack[base + 21LLU] = stack[base + 11]/*lookahead*/;
1878421095 // set stack-base & callee-address
@@ -18786,7 +21097,7 @@
1878621097 label = 18446744073709551580LLU; // skipwscmnt
1878721098 break;
1878821099 }
18789- case 1219LLU: // return from skipwscmnt to PROCCALL
21100+ case 1377LLU: // return from skipwscmnt to PROCCALL
1879021101 {
1879121102 // copy mutable arguments back from call to skipwscmnt
1879221103 // copy back results provided by call to skipwscmnt
@@ -18793,7 +21104,7 @@
1879321104 stack[base + 11] = stack[base + 20LLU];
1879421105 // call neq from PROCCALL
1879521106 stack[base + 19LLU] = base;
18796- stack[base + 20LLU] = 1220LLU;
21107+ stack[base + 20LLU] = 1378LLU;
1879721108 // arguments for call to neq
1879821109 stack[base + 22LLU] = stack[base + 11]/*lookahead*/;
1879921110 stack[base + 23LLU] = 41LLU;
@@ -18802,7 +21113,7 @@
1880221113 label = 18446744073709551599LLU; // neq
1880321114 break;
1880421115 }
18805- case 1220LLU: // return from neq to PROCCALL
21116+ case 1378LLU: // return from neq to PROCCALL
1880621117 {
1880721118 // copy mutable arguments back from call to neq
1880821119 // copy back results provided by call to neq
@@ -18809,7 +21120,7 @@
1880921120 stack[base + 18] = stack[base + 21LLU];
1881021121 if(!stack[base + 18]/*continue*/)
1881121122 {
18812- label = 1221LLU; // jump to alternative
21123+ label = 1379LLU; // jump to alternative
1881321124 break;
1881421125 }
1881521126
@@ -18816,7 +21127,7 @@
1881621127 // consequent
1881721128 // call MATCHPEEK from PROCCALL
1881821129 stack[base + 19LLU] = base;
18819- stack[base + 20LLU] = 1223LLU;
21130+ stack[base + 20LLU] = 1381LLU;
1882021131 // arguments for call to MATCHPEEK
1882121132 stack[base + 21LLU] = stack[base + 6]/*fnid*/;
1882221133 stack[base + 22LLU] = 44LLU;
@@ -18826,18 +21137,18 @@
1882621137 label = 102LLU; // MATCHPEEK
1882721138 break;
1882821139 }
18829- case 1223LLU: // return from MATCHPEEK to PROCCALL
21140+ case 1381LLU: // return from MATCHPEEK to PROCCALL
1883021141 {
1883121142 // copy mutable arguments back from call to MATCHPEEK
1883221143 stack[base + 11]/*lookahead*/ = stack[base + 23LLU];
18833- label = 1222LLU; // consequent complete
21144+ label = 1380LLU; // consequent complete
1883421145 break;
1883521146 }
18836- case 1221LLU: // alternative
21147+ case 1379LLU: // alternative
1883721148 {
1883821149 // call EOSbyte from PROCCALL
1883921150 stack[base + 19LLU] = base;
18840- stack[base + 20LLU] = 1224LLU;
21151+ stack[base + 20LLU] = 1382LLU;
1884121152 // arguments for call to EOSbyte
1884221153 // set stack-base & callee-address
1884321154 base += 21LLU;
@@ -18844,30 +21155,30 @@
1884421155 label = 35LLU; // EOSbyte
1884521156 break;
1884621157 }
18847- case 1224LLU: // return from EOSbyte to PROCCALL
21158+ case 1382LLU: // return from EOSbyte to PROCCALL
1884821159 {
1884921160 // copy mutable arguments back from call to EOSbyte
1885021161 // copy back results provided by call to EOSbyte
1885121162 stack[base + 11] = stack[base + 21LLU];
18852- label = 1222LLU; // alternative complete
21163+ label = 1380LLU; // alternative complete
1885321164 break;
1885421165 }
18855- case 1222LLU: // completed if-then-else
21166+ case 1380LLU: // completed if-then-else
1885621167 {
1885721168 if(stack[base + 11]/*lookahead*/ <= 0xFF) stack[base + 11]/*lookahead*/ = getchar();
18858- label = 1207LLU; // repeat
21169+ label = 1365LLU; // repeat
1885921170 break;
1886021171 }
18861- case 1208LLU: // loop finished
21172+ case 1366LLU: // loop finished
1886221173 {
18863- label = 1206LLU; // alternative complete
21174+ label = 1364LLU; // alternative complete
1886421175 break;
1886521176 }
18866- case 1206LLU: // completed if-then-else
21177+ case 1364LLU: // completed if-then-else
1886721178 {
1886821179 // call getbyte from PROCCALL
1886921180 stack[base + 18LLU] = base;
18870- stack[base + 19LLU] = 1225LLU;
21181+ stack[base + 19LLU] = 1383LLU;
1887121182 // arguments for call to getbyte
1887221183 // set stack-base & callee-address
1887321184 base += 20LLU;
@@ -18874,7 +21185,7 @@
1887421185 label = 18446744073709551593LLU; // getbyte
1887521186 break;
1887621187 }
18877- case 1225LLU: // return from getbyte to PROCCALL
21188+ case 1383LLU: // return from getbyte to PROCCALL
1887821189 {
1887921190 // copy mutable arguments back from call to getbyte
1888021191 // copy back results provided by call to getbyte
@@ -18882,7 +21193,7 @@
1888221193 list_reverse(((struct listnode **)(&stack[base + 16]/*results*/)));
1888321194 // call matchsym from PROCCALL
1888421195 stack[base + 18LLU] = base;
18885- stack[base + 19LLU] = 1226LLU;
21196+ stack[base + 19LLU] = 1384LLU;
1888621197 // arguments for call to matchsym
1888721198 stack[base + 20LLU] = stack[base + 6]/*fnid*/;
1888821199 stack[base + 21LLU] = 61LLU;
@@ -18892,13 +21203,13 @@
1889221203 label = 110LLU; // matchsym
1889321204 break;
1889421205 }
18895- case 1226LLU: // return from matchsym to PROCCALL
21206+ case 1384LLU: // return from matchsym to PROCCALL
1889621207 {
1889721208 // copy mutable arguments back from call to matchsym
1889821209 stack[base + 11]/*lookahead*/ = stack[base + 22LLU];
1889921210 // call ParseToken from PROCCALL
1890021211 stack[base + 18LLU] = base;
18901- stack[base + 19LLU] = 1227LLU;
21212+ stack[base + 19LLU] = 1385LLU;
1890221213 // arguments for call to ParseToken
1890321214 stack[base + 22LLU] = stack[base + 11]/*lookahead*/;
1890421215 // set stack-base & callee-address
@@ -18906,7 +21217,7 @@
1890621217 label = 2LLU; // ParseToken
1890721218 break;
1890821219 }
18909- case 1227LLU: // return from ParseToken to PROCCALL
21220+ case 1385LLU: // return from ParseToken to PROCCALL
1891021221 {
1891121222 // copy mutable arguments back from call to ParseToken
1891221223 stack[base + 11]/*lookahead*/ = stack[base + 22LLU];
@@ -18915,7 +21226,7 @@
1891521226 stack[base + 13] = stack[base + 21LLU];
1891621227 // call equ from PROCCALL
1891721228 stack[base + 18LLU] = base;
18918- stack[base + 19LLU] = 1228LLU;
21229+ stack[base + 19LLU] = 1386LLU;
1891921230 // arguments for call to equ
1892021231 stack[base + 21LLU] = stack[base + 12]/*variant*/;
1892121232 stack[base + 22LLU] = 4LLU;
@@ -18924,7 +21235,7 @@
1892421235 label = 18446744073709551600LLU; // equ
1892521236 break;
1892621237 }
18927- case 1228LLU: // return from equ to PROCCALL
21238+ case 1386LLU: // return from equ to PROCCALL
1892821239 {
1892921240 // copy mutable arguments back from call to equ
1893021241 // copy back results provided by call to equ
@@ -18931,20 +21242,20 @@
1893121242 stack[base + 17] = stack[base + 20LLU];
1893221243 if(!stack[base + 17]/*isequal*/)
1893321244 {
18934- label = 1229LLU; // jump to alternative
21245+ label = 1387LLU; // jump to alternative
1893521246 break;
1893621247 }
1893721248
1893821249 // consequent
18939- label = 1230LLU; // consequent complete
21250+ label = 1388LLU; // consequent complete
1894021251 break;
1894121252 }
18942- case 1229LLU: // alternative
21253+ case 1387LLU: // alternative
1894321254 {
1894421255 fprintf(stderr, "%s", "parsing function call expected identifier but found ");
1894521256 // call reporttok from PROCCALL
1894621257 stack[base + 18LLU] = base;
18947- stack[base + 19LLU] = 1231LLU;
21258+ stack[base + 19LLU] = 1389LLU;
1894821259 // arguments for call to reporttok
1894921260 stack[base + 20LLU] = stack[base + 12]/*variant*/;
1895021261 stack[base + 21LLU] = stack[base + 13]/*content*/;
@@ -18953,18 +21264,18 @@
1895321264 label = 18446744073709551582LLU; // reporttok
1895421265 break;
1895521266 }
18956- case 1231LLU: // return from reporttok to PROCCALL
21267+ case 1389LLU: // return from reporttok to PROCCALL
1895721268 {
1895821269 // copy mutable arguments back from call to reporttok
1895921270 exit(-1);
18960- label = 1230LLU; // alternative complete
21271+ label = 1388LLU; // alternative complete
1896121272 break;
1896221273 }
18963- case 1230LLU: // completed if-then-else
21274+ case 1388LLU: // completed if-then-else
1896421275 {
1896521276 // call FindFn from PROCCALL
1896621277 stack[base + 19LLU] = base;
18967- stack[base + 20LLU] = 1232LLU;
21278+ stack[base + 20LLU] = 1390LLU;
1896821279 // arguments for call to FindFn
1896921280 stack[base + 22LLU] = stack[base + 6]/*fnid*/;
1897021281 stack[base + 23LLU] = stack[base + 0]/*fndefs*/;
@@ -18974,7 +21285,7 @@
1897421285 label = 628LLU; // FindFn
1897521286 break;
1897621287 }
18977- case 1232LLU: // return from FindFn to PROCCALL
21288+ case 1390LLU: // return from FindFn to PROCCALL
1897821289 {
1897921290 // copy mutable arguments back from call to FindFn
1898021291 // copy back results provided by call to FindFn
@@ -18981,7 +21292,7 @@
1898121292 stack[base + 18] = stack[base + 21LLU];
1898221293 if(/*fndef*/0 != ((uint64_t *)(stack[base + 18]/*calleedef*/))[0])
1898321294 {
18984- label = 1234LLU; // jump to alternative
21295+ label = 1392LLU; // jump to alternative
1898521296 break;
1898621297 }
1898721298
@@ -18995,14 +21306,14 @@
1899521306
1899621307 // case
1899721308 flippedassign(stack[base + 20]/*cerestypes*/, &stack[base + 26]);
18998- label = 1235LLU; // start to repeat
21309+ label = 1393LLU; // start to repeat
1899921310 break;
1900021311 }
19001- case 1235LLU: // repeat from here
21312+ case 1393LLU: // repeat from here
1900221313 {
1900321314 if(!stack[base + 26])
1900421315 {
19005- label = 1236LLU; // break loop
21316+ label = 1394LLU; // break loop
1900621317 break;
1900721318 }
1900821319
@@ -19014,7 +21325,7 @@
1901421325 struct listnode *list = (struct listnode *)stack[base + 16]/*results*/;
1901521326 if(!list)
1901621327 {
19017- label = 1237LLU; // jump to alternative
21328+ label = 1395LLU; // jump to alternative
1901821329 break;
1901921330 }
1902021331
@@ -19026,7 +21337,7 @@
1902621337 }
1902721338 if(/*result*/0 != ((uint64_t *)(stack[base + 27]/*result*/))[0])
1902821339 {
19029- label = 1240LLU; // jump to alternative
21340+ label = 1398LLU; // jump to alternative
1903021341 break;
1903121342 }
1903221343
@@ -19036,7 +21347,7 @@
1903621347 // case
1903721348 if(/*letdef*/0 != ((uint64_t *)(stack[base + 29]/*RESULT*/))[0])
1903821349 {
19039- label = 1242LLU; // jump to alternative
21350+ label = 1400LLU; // jump to alternative
1904021351 break;
1904121352 }
1904221353
@@ -19057,7 +21368,7 @@
1905721368 // call equtype from PROCCALL
1905821369 newstack[0] = (uint64_t)stack; // backup stack location
1905921370 newstack[1] = base;
19060- newstack[2] = 1243LLU;
21371+ newstack[2] = 1401LLU;
1906121372 // arguments for call to equtype
1906221373 newstack[4LLU] = stack[base + 32]/*type*/;
1906321374 newstack[5LLU] = stack[base + 30]/*expected*/;
@@ -19067,7 +21378,7 @@
1906721378 label = 170LLU; // equtype
1906821379 break;
1906921380 }
19070- case 1243LLU: // return from equtype to PROCCALL
21381+ case 1401LLU: // return from equtype to PROCCALL
1907121382 {
1907221383 uint64_t *oldstack = (uint64_t *)stack[0];
1907321384 // copy mutable arguments back from call to equtype
@@ -19082,20 +21393,20 @@
1908221393 stack = oldstack;
1908321394 if(!stack[base + 17]/*isequal*/)
1908421395 {
19085- label = 1244LLU; // jump to alternative
21396+ label = 1402LLU; // jump to alternative
1908621397 break;
1908721398 }
1908821399
1908921400 // consequent
19090- label = 1245LLU; // consequent complete
21401+ label = 1403LLU; // consequent complete
1909121402 break;
1909221403 }
19093- case 1244LLU: // alternative
21404+ case 1402LLU: // alternative
1909421405 {
1909521406 fprintf(stderr, "%s", "in function ");
1909621407 // call reportid from PROCCALL
1909721408 stack[base + 37LLU] = base;
19098- stack[base + 38LLU] = 1246LLU;
21409+ stack[base + 38LLU] = 1404LLU;
1909921410 // arguments for call to reportid
1910021411 stack[base + 39LLU] = stack[base + 6]/*fnid*/;
1910121412 // set stack-base & callee-address
@@ -19103,13 +21414,13 @@
1910321414 label = 18446744073709551586LLU; // reportid
1910421415 break;
1910521416 }
19106- case 1246LLU: // return from reportid to PROCCALL
21417+ case 1404LLU: // return from reportid to PROCCALL
1910721418 {
1910821419 // copy mutable arguments back from call to reportid
1910921420 fprintf(stderr, "%s", " call to ");
1911021421 // call reportid from PROCCALL
1911121422 stack[base + 37LLU] = base;
19112- stack[base + 38LLU] = 1247LLU;
21423+ stack[base + 38LLU] = 1405LLU;
1911321424 // arguments for call to reportid
1911421425 stack[base + 39LLU] = stack[base + 23]/*ceid*/;
1911521426 // set stack-base & callee-address
@@ -19117,13 +21428,13 @@
1911721428 label = 18446744073709551586LLU; // reportid
1911821429 break;
1911921430 }
19120- case 1247LLU: // return from reportid to PROCCALL
21431+ case 1405LLU: // return from reportid to PROCCALL
1912121432 {
1912221433 // copy mutable arguments back from call to reportid
1912321434 fprintf(stderr, "%s", " expected variable ");
1912421435 // call reportid from PROCCALL
1912521436 stack[base + 37LLU] = base;
19126- stack[base + 38LLU] = 1248LLU;
21437+ stack[base + 38LLU] = 1406LLU;
1912721438 // arguments for call to reportid
1912821439 stack[base + 39LLU] = stack[base + 33]/*id*/;
1912921440 // set stack-base & callee-address
@@ -19131,7 +21442,7 @@
1913121442 label = 18446744073709551586LLU; // reportid
1913221443 break;
1913321444 }
19134- case 1248LLU: // return from reportid to PROCCALL
21445+ case 1406LLU: // return from reportid to PROCCALL
1913521446 {
1913621447 // copy mutable arguments back from call to reportid
1913721448 fprintf(stderr, "%s", " has type ");
@@ -19145,7 +21456,7 @@
1914521456 // call reporttype from PROCCALL
1914621457 newstack[0] = (uint64_t)stack; // backup stack location
1914721458 newstack[1] = base;
19148- newstack[2] = 1249LLU;
21459+ newstack[2] = 1407LLU;
1914921460 // arguments for call to reporttype
1915021461 newstack[3LLU] = stack[base + 30]/*expected*/;
1915121462 stack = newstack;
@@ -19154,7 +21465,7 @@
1915421465 label = 159LLU; // reporttype
1915521466 break;
1915621467 }
19157- case 1249LLU: // return from reporttype to PROCCALL
21468+ case 1407LLU: // return from reporttype to PROCCALL
1915821469 {
1915921470 uint64_t *oldstack = (uint64_t *)stack[0];
1916021471 // copy mutable arguments back from call to reporttype
@@ -19176,7 +21487,7 @@
1917621487 // call reporttype from PROCCALL
1917721488 newstack[0] = (uint64_t)stack; // backup stack location
1917821489 newstack[1] = base;
19179- newstack[2] = 1250LLU;
21490+ newstack[2] = 1408LLU;
1918021491 // arguments for call to reporttype
1918121492 newstack[3LLU] = stack[base + 32]/*type*/;
1918221493 stack = newstack;
@@ -19185,7 +21496,7 @@
1918521496 label = 159LLU; // reporttype
1918621497 break;
1918721498 }
19188- case 1250LLU: // return from reporttype to PROCCALL
21499+ case 1408LLU: // return from reporttype to PROCCALL
1918921500 {
1919021501 uint64_t *oldstack = (uint64_t *)stack[0];
1919121502 // copy mutable arguments back from call to reporttype
@@ -19198,27 +21509,27 @@
1919821509 stack = oldstack;
1919921510 fprintf(stderr, "%s", "\n");
1920021511 exit(-1);
19201- label = 1245LLU; // alternative complete
21512+ label = 1403LLU; // alternative complete
1920221513 break;
1920321514 }
19204- case 1245LLU: // completed if-then-else
21515+ case 1403LLU: // completed if-then-else
1920521516 {
1920621517 if(!stack[base + 35]/*mutres*/)
1920721518 {
19208- label = 1251LLU; // jump to alternative
21519+ label = 1409LLU; // jump to alternative
1920921520 break;
1921021521 }
1921121522
1921221523 // consequent
19213- label = 1252LLU; // consequent complete
21524+ label = 1410LLU; // consequent complete
1921421525 break;
1921521526 }
19216- case 1251LLU: // alternative
21527+ case 1409LLU: // alternative
1921721528 {
1921821529 fprintf(stderr, "%s", "in function ");
1921921530 // call reportid from PROCCALL
1922021531 stack[base + 37LLU] = base;
19221- stack[base + 38LLU] = 1253LLU;
21532+ stack[base + 38LLU] = 1411LLU;
1922221533 // arguments for call to reportid
1922321534 stack[base + 39LLU] = stack[base + 6]/*fnid*/;
1922421535 // set stack-base & callee-address
@@ -19226,13 +21537,13 @@
1922621537 label = 18446744073709551586LLU; // reportid
1922721538 break;
1922821539 }
19229- case 1253LLU: // return from reportid to PROCCALL
21540+ case 1411LLU: // return from reportid to PROCCALL
1923021541 {
1923121542 // copy mutable arguments back from call to reportid
1923221543 fprintf(stderr, "%s", " call to ");
1923321544 // call reportid from PROCCALL
1923421545 stack[base + 37LLU] = base;
19235- stack[base + 38LLU] = 1254LLU;
21546+ stack[base + 38LLU] = 1412LLU;
1923621547 // arguments for call to reportid
1923721548 stack[base + 39LLU] = stack[base + 23]/*ceid*/;
1923821549 // set stack-base & callee-address
@@ -19240,7 +21551,7 @@
1924021551 label = 18446744073709551586LLU; // reportid
1924121552 break;
1924221553 }
19243- case 1254LLU: // return from reportid to PROCCALL
21554+ case 1412LLU: // return from reportid to PROCCALL
1924421555 {
1924521556 // copy mutable arguments back from call to reportid
1924621557 fprintf(stderr, "%s", " can't assign to constant ");
@@ -19254,7 +21565,7 @@
1925421565 // call reporttype from PROCCALL
1925521566 newstack[0] = (uint64_t)stack; // backup stack location
1925621567 newstack[1] = base;
19257- newstack[2] = 1255LLU;
21568+ newstack[2] = 1413LLU;
1925821569 // arguments for call to reporttype
1925921570 newstack[3LLU] = stack[base + 32]/*type*/;
1926021571 stack = newstack;
@@ -19263,7 +21574,7 @@
1926321574 label = 159LLU; // reporttype
1926421575 break;
1926521576 }
19266- case 1255LLU: // return from reporttype to PROCCALL
21577+ case 1413LLU: // return from reporttype to PROCCALL
1926721578 {
1926821579 uint64_t *oldstack = (uint64_t *)stack[0];
1926921580 // copy mutable arguments back from call to reporttype
@@ -19277,7 +21588,7 @@
1927721588 fprintf(stderr, "%s", " ");
1927821589 // call reportid from PROCCALL
1927921590 stack[base + 37LLU] = base;
19280- stack[base + 38LLU] = 1256LLU;
21591+ stack[base + 38LLU] = 1414LLU;
1928121592 // arguments for call to reportid
1928221593 stack[base + 39LLU] = stack[base + 33]/*id*/;
1928321594 // set stack-base & callee-address
@@ -19285,15 +21596,15 @@
1928521596 label = 18446744073709551586LLU; // reportid
1928621597 break;
1928721598 }
19288- case 1256LLU: // return from reportid to PROCCALL
21599+ case 1414LLU: // return from reportid to PROCCALL
1928921600 {
1929021601 // copy mutable arguments back from call to reportid
1929121602 fprintf(stderr, "%s", "\n");
1929221603 exit(-1);
19293- label = 1252LLU; // alternative complete
21604+ label = 1410LLU; // alternative complete
1929421605 break;
1929521606 }
19296- case 1252LLU: // completed if-then-else
21607+ case 1410LLU: // completed if-then-else
1929721608 {
1929821609 uint64_t *newstack = (uint64_t *)Calloc(14LLU + 1, sizeof(uint64_t));
1929921610 if(!newstack)
@@ -19305,7 +21616,7 @@
1930521616 // call copytype from PROCCALL
1930621617 newstack[0] = (uint64_t)stack; // backup stack location
1930721618 newstack[1] = base;
19308- newstack[2] = 1257LLU;
21619+ newstack[2] = 1415LLU;
1930921620 // arguments for call to copytype
1931021621 newstack[4LLU] = stack[base + 32]/*type*/;
1931121622 stack = newstack;
@@ -19314,7 +21625,7 @@
1931421625 label = 165LLU; // copytype
1931521626 break;
1931621627 }
19317- case 1257LLU: // return from copytype to PROCCALL
21628+ case 1415LLU: // return from copytype to PROCCALL
1931821629 {
1931921630 uint64_t *oldstack = (uint64_t *)stack[0];
1932021631 // copy mutable arguments back from call to copytype
@@ -19358,27 +21669,27 @@
1935821669 ((uint64_t **)(stack[base + 29]))[1][2] = stack[base + 34];
1935921670 ((uint64_t **)(stack[base + 29]))[1][1] = stack[base + 33];
1936021671 ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 32];
19361- label = 1241LLU; // case complete
21672+ label = 1399LLU; // case complete
1936221673 break;
1936321674 }
19364- case 1242LLU: // try next case
21675+ case 1400LLU: // try next case
1936521676 {
1936621677 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1936721678 exit(-1);
1936821679 }
19369- case 1241LLU: // completed switch
21680+ case 1399LLU: // completed switch
1937021681 {
1937121682 ((uint64_t **)(stack[base + 27]))[1][1] = stack[base + 31];
1937221683 ((uint64_t **)(stack[base + 27]))[1][0] = stack[base + 30];
19373- label = 1239LLU; // case complete
21684+ label = 1397LLU; // case complete
1937421685 break;
1937521686 }
19376- case 1240LLU: // try next case
21687+ case 1398LLU: // try next case
1937721688 {
1937821689 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1937921690 exit(-1);
1938021691 }
19381- case 1239LLU: // completed switch
21692+ case 1397LLU: // completed switch
1938221693 {
1938321694
1938421695 uint64_t *newstack = (uint64_t *)(stack[base + 29] - sizeof(uint64_t) * 3);
@@ -19385,7 +21696,7 @@
1938521696 // call ~letdef from PROCCALL
1938621697 newstack[0] = (uint64_t)stack; // backup stack location
1938721698 newstack[1] = base;
19388- newstack[2] = 1258LLU;
21699+ newstack[2] = 1416LLU;
1938921700 stack = newstack;
1939021701 // set stack-base & callee-address
1939121702 base = 3;
@@ -19392,21 +21703,21 @@
1939221703 label = 229LLU; // ~letdef
1939321704 break;
1939421705 }
19395- case 1258LLU: // return from ~letdef to PROCCALL
21706+ case 1416LLU: // return from ~letdef to PROCCALL
1939621707 {
1939721708 stack = (uint64_t *)stack[0];
1939821709 // releasing toplevel container
1939921710 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 29] - sizeof(uint64_t) * 3));
1940021711
19401- label = 1238LLU; // consequent complete
21712+ label = 1396LLU; // consequent complete
1940221713 break;
1940321714 }
19404- case 1237LLU: // alternative
21715+ case 1395LLU: // alternative
1940521716 {
1940621717 fprintf(stderr, "%s", "in function ");
1940721718 // call reportid from PROCCALL
1940821719 stack[base + 30LLU] = base;
19409- stack[base + 31LLU] = 1259LLU;
21720+ stack[base + 31LLU] = 1417LLU;
1941021721 // arguments for call to reportid
1941121722 stack[base + 32LLU] = stack[base + 6]/*fnid*/;
1941221723 // set stack-base & callee-address
@@ -19414,13 +21725,13 @@
1941421725 label = 18446744073709551586LLU; // reportid
1941521726 break;
1941621727 }
19417- case 1259LLU: // return from reportid to PROCCALL
21728+ case 1417LLU: // return from reportid to PROCCALL
1941821729 {
1941921730 // copy mutable arguments back from call to reportid
1942021731 fprintf(stderr, "%s", " call to ");
1942121732 // call reportid from PROCCALL
1942221733 stack[base + 30LLU] = base;
19423- stack[base + 31LLU] = 1260LLU;
21734+ stack[base + 31LLU] = 1418LLU;
1942421735 // arguments for call to reportid
1942521736 stack[base + 32LLU] = stack[base + 23]/*ceid*/;
1942621737 // set stack-base & callee-address
@@ -19428,22 +21739,22 @@
1942821739 label = 18446744073709551586LLU; // reportid
1942921740 break;
1943021741 }
19431- case 1260LLU: // return from reportid to PROCCALL
21742+ case 1418LLU: // return from reportid to PROCCALL
1943221743 {
1943321744 // copy mutable arguments back from call to reportid
1943421745 fprintf(stderr, "%s", " not enough destination-variables for results");
1943521746 fprintf(stderr, "%s", "\n");
1943621747 exit(-1);
19437- label = 1238LLU; // alternative complete
21748+ label = 1396LLU; // alternative complete
1943821749 break;
1943921750 }
19440- case 1238LLU: // completed if-then-else
21751+ case 1396LLU: // completed if-then-else
1944121752 {
1944221753 ((struct listnode *)(stack[base + 28]/*previous*/))->data = stack[base + 27];
19443- label = 1235LLU; // repeat
21754+ label = 1393LLU; // repeat
1944421755 break;
1944521756 }
19446- case 1236LLU: // loop finished
21757+ case 1394LLU: // loop finished
1944721758 {
1944821759 ((uint64_t **)(stack[base + 18]))[1][6] = stack[base + 25];
1944921760 ((uint64_t **)(stack[base + 18]))[1][5] = stack[base + 24];
@@ -19452,20 +21763,20 @@
1945221763 ((uint64_t **)(stack[base + 18]))[1][2] = stack[base + 21];
1945321764 ((uint64_t **)(stack[base + 18]))[1][1] = stack[base + 20];
1945421765 ((uint64_t **)(stack[base + 18]))[1][0] = stack[base + 19];
19455- label = 1233LLU; // case complete
21766+ label = 1391LLU; // case complete
1945621767 break;
1945721768 }
19458- case 1234LLU: // try next case
21769+ case 1392LLU: // try next case
1945921770 {
1946021771 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1946121772 exit(-1);
1946221773 }
19463- case 1233LLU: // completed switch
21774+ case 1391LLU: // completed switch
1946421775 {
1946521776 list_reverse(((struct listnode **)(&stack[base + 15]/*dsttypeidx*/)));
1946621777 // call matchsym from PROCCALL
1946721778 stack[base + 19LLU] = base;
19468- stack[base + 20LLU] = 1261LLU;
21779+ stack[base + 20LLU] = 1419LLU;
1946921780 // arguments for call to matchsym
1947021781 stack[base + 21LLU] = stack[base + 6]/*fnid*/;
1947121782 stack[base + 22LLU] = 40LLU;
@@ -19475,13 +21786,13 @@
1947521786 label = 110LLU; // matchsym
1947621787 break;
1947721788 }
19478- case 1261LLU: // return from matchsym to PROCCALL
21789+ case 1419LLU: // return from matchsym to PROCCALL
1947921790 {
1948021791 // copy mutable arguments back from call to matchsym
1948121792 stack[base + 11]/*lookahead*/ = stack[base + 23LLU];
1948221793 // call ProcCall from PROCCALL
1948321794 stack[base + 19LLU] = base;
19484- stack[base + 20LLU] = 1262LLU;
21795+ stack[base + 20LLU] = 1420LLU;
1948521796 // arguments for call to ProcCall
1948621797 stack[base + 21LLU] = stack[base + 15]/*dsttypeidx*/;
1948721798 stack[base + 22LLU] = stack[base + 0]/*fndefs*/;
@@ -19502,10 +21813,10 @@
1950221813 stack[base + 37LLU] = stack[base + 14]/*label*/;
1950321814 // set stack-base & callee-address
1950421815 base += 21LLU;
19505- label = 688LLU; // ProcCall
21816+ label = 846LLU; // ProcCall
1950621817 break;
1950721818 }
19508- case 1262LLU: // return from ProcCall to PROCCALL
21819+ case 1420LLU: // return from ProcCall to PROCCALL
1950921820 {
1951021821 // copy mutable arguments back from call to ProcCall
1951121822 stack[base + 14]/*label*/ = stack[base + 37LLU];
@@ -19516,7 +21827,7 @@
1951621827 stack[base + 15]/*dsttypeidx*/ = stack[base + 21LLU];
1951721828 // call matchsym from PROCCALL
1951821829 stack[base + 19LLU] = base;
19519- stack[base + 20LLU] = 1263LLU;
21830+ stack[base + 20LLU] = 1421LLU;
1952021831 // arguments for call to matchsym
1952121832 stack[base + 21LLU] = stack[base + 6]/*fnid*/;
1952221833 stack[base + 22LLU] = 41LLU;
@@ -19526,7 +21837,7 @@
1952621837 label = 110LLU; // matchsym
1952721838 break;
1952821839 }
19529- case 1263LLU: // return from matchsym to PROCCALL
21840+ case 1421LLU: // return from matchsym to PROCCALL
1953021841 {
1953121842 // copy mutable arguments back from call to matchsym
1953221843 stack[base + 11]/*lookahead*/ = stack[base + 23LLU];
@@ -19535,7 +21846,7 @@
1953521846 // call ~fndef from PROCCALL
1953621847 newstack[0] = (uint64_t)stack; // backup stack location
1953721848 newstack[1] = base;
19538- newstack[2] = 1264LLU;
21849+ newstack[2] = 1422LLU;
1953921850 stack = newstack;
1954021851 // set stack-base & callee-address
1954121852 base = 3;
@@ -19542,7 +21853,7 @@
1954221853 label = 610LLU; // ~fndef
1954321854 break;
1954421855 }
19545- case 1264LLU: // return from ~fndef to PROCCALL
21856+ case 1422LLU: // return from ~fndef to PROCCALL
1954621857 {
1954721858 stack = (uint64_t *)stack[0];
1954821859 // releasing toplevel container
@@ -19549,14 +21860,14 @@
1954921860 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 3));
1955021861
1955121862 // delete list
19552- label = 1265LLU; // start to repeat
21863+ label = 1423LLU; // start to repeat
1955321864 break;
1955421865 }
19555- case 1265LLU: // repeat from here
21866+ case 1423LLU: // repeat from here
1955621867 {
1955721868 if(!stack[base + 16])
1955821869 {
19559- label = 1266LLU; // break loop
21870+ label = 1424LLU; // break loop
1956021871 break;
1956121872 }
1956221873
@@ -19566,7 +21877,7 @@
1956621877 // call ~letdef from PROCCALL
1956721878 newstack[0] = (uint64_t)stack; // backup stack location
1956821879 newstack[1] = base;
19569- newstack[2] = 1267LLU;
21880+ newstack[2] = 1425LLU;
1957021881 stack = newstack;
1957121882 // set stack-base & callee-address
1957221883 base = 3;
@@ -19573,7 +21884,7 @@
1957321884 label = 229LLU; // ~letdef
1957421885 break;
1957521886 }
19576- case 1267LLU: // return from ~letdef to PROCCALL
21887+ case 1425LLU: // return from ~letdef to PROCCALL
1957721888 {
1957821889 stack = (uint64_t *)stack[0];
1957921890 // releasing toplevel container
@@ -19584,20 +21895,20 @@
1958421895 stack[base + 16] = (uint64_t)list->next;
1958521896 Free(1, sizeof(struct listnode), list);
1958621897 }
19587- label = 1265LLU; // repeat
21898+ label = 1423LLU; // repeat
1958821899 break;
1958921900 }
19590- case 1266LLU: // loop finished
21901+ case 1424LLU: // loop finished
1959121902 {
1959221903 // delete list
19593- label = 1268LLU; // start to repeat
21904+ label = 1426LLU; // start to repeat
1959421905 break;
1959521906 }
19596- case 1268LLU: // repeat from here
21907+ case 1426LLU: // repeat from here
1959721908 {
1959821909 if(!stack[base + 15])
1959921910 {
19600- label = 1269LLU; // break loop
21911+ label = 1427LLU; // break loop
1960121912 break;
1960221913 }
1960321914
@@ -19607,7 +21918,7 @@
1960721918 // call ~typeidx from PROCCALL
1960821919 newstack[0] = (uint64_t)stack; // backup stack location
1960921920 newstack[1] = base;
19610- newstack[2] = 1270LLU;
21921+ newstack[2] = 1428LLU;
1961121922 stack = newstack;
1961221923 // set stack-base & callee-address
1961321924 base = 3;
@@ -19614,7 +21925,7 @@
1961421925 label = 188LLU; // ~typeidx
1961521926 break;
1961621927 }
19617- case 1270LLU: // return from ~typeidx to PROCCALL
21928+ case 1428LLU: // return from ~typeidx to PROCCALL
1961821929 {
1961921930 stack = (uint64_t *)stack[0];
1962021931 // releasing toplevel container
@@ -19625,10 +21936,10 @@
1962521936 stack[base + 15] = (uint64_t)list->next;
1962621937 Free(1, sizeof(struct listnode), list);
1962721938 }
19628- label = 1268LLU; // repeat
21939+ label = 1426LLU; // repeat
1962921940 break;
1963021941 }
19631- case 1269LLU: // loop finished
21942+ case 1427LLU: // loop finished
1963221943 {
1963321944 // return from PROCCALL
1963421945 label = stack[base - 1];
@@ -19635,7 +21946,7 @@
1963521946 base = stack[base - 2];
1963621947 break;
1963721948 }
19638- case 1271LLU: // assertu64
21949+ case 1429LLU: // assertu64
1963921950 {
1964021951 //#define arg0 0
1964121952 //#define arg1 1
@@ -19644,7 +21955,7 @@
1964421955 //#define arg4 4
1964521956 // call mktypename from assertu64
1964621957 stack[base + 6LLU] = base;
19647- stack[base + 7LLU] = 1272LLU;
21958+ stack[base + 7LLU] = 1430LLU;
1964821959 // arguments for call to mktypename
1964921960 stack[base + 9LLU] = 881834713755418624LLU;
1965021961 // set stack-base & callee-address
@@ -19652,7 +21963,7 @@
1965221963 label = 152LLU; // mktypename
1965321964 break;
1965421965 }
19655- case 1272LLU: // return from mktypename to assertu64
21966+ case 1430LLU: // return from mktypename to assertu64
1965621967 {
1965721968 // copy mutable arguments back from call to mktypename
1965821969 // copy back results provided by call to mktypename
@@ -19659,7 +21970,7 @@
1965921970 stack[base + 5] = stack[base + 8LLU];
1966021971 // call getlettype from assertu64
1966121972 stack[base + 7LLU] = base;
19662- stack[base + 8LLU] = 1273LLU;
21973+ stack[base + 8LLU] = 1431LLU;
1966321974 // arguments for call to getlettype
1966421975 stack[base + 10LLU] = stack[base + 0]/*fnid*/;
1966521976 stack[base + 11LLU] = stack[base + 4]/*variableid*/;
@@ -19670,7 +21981,7 @@
1967021981 label = 326LLU; // getlettype
1967121982 break;
1967221983 }
19673- case 1273LLU: // return from getlettype to assertu64
21984+ case 1431LLU: // return from getlettype to assertu64
1967421985 {
1967521986 // copy mutable arguments back from call to getlettype
1967621987 // copy back results provided by call to getlettype
@@ -19686,7 +21997,7 @@
1968621997 // call equtype from assertu64
1968721998 newstack[0] = (uint64_t)stack; // backup stack location
1968821999 newstack[1] = base;
19689- newstack[2] = 1274LLU;
22000+ newstack[2] = 1432LLU;
1969022001 // arguments for call to equtype
1969122002 newstack[4LLU] = stack[base + 5]/*expected*/;
1969222003 newstack[5LLU] = stack[base + 6]/*found*/;
@@ -19696,7 +22007,7 @@
1969622007 label = 170LLU; // equtype
1969722008 break;
1969822009 }
19699- case 1274LLU: // return from equtype to assertu64
22010+ case 1432LLU: // return from equtype to assertu64
1970022011 {
1970122012 uint64_t *oldstack = (uint64_t *)stack[0];
1970222013 // copy mutable arguments back from call to equtype
@@ -19711,20 +22022,20 @@
1971122022 stack = oldstack;
1971222023 if(!stack[base + 7]/*isequ*/)
1971322024 {
19714- label = 1275LLU; // jump to alternative
22025+ label = 1433LLU; // jump to alternative
1971522026 break;
1971622027 }
1971722028
1971822029 // consequent
19719- label = 1276LLU; // consequent complete
22030+ label = 1434LLU; // consequent complete
1972022031 break;
1972122032 }
19722- case 1275LLU: // alternative
22033+ case 1433LLU: // alternative
1972322034 {
1972422035 fprintf(stderr, "%s", "in ");
1972522036 // call reportid from assertu64
1972622037 stack[base + 8LLU] = base;
19727- stack[base + 9LLU] = 1277LLU;
22038+ stack[base + 9LLU] = 1435LLU;
1972822039 // arguments for call to reportid
1972922040 stack[base + 10LLU] = stack[base + 1]/*fnname*/;
1973022041 // set stack-base & callee-address
@@ -19732,7 +22043,7 @@
1973222043 label = 18446744073709551586LLU; // reportid
1973322044 break;
1973422045 }
19735- case 1277LLU: // return from reportid to assertu64
22046+ case 1435LLU: // return from reportid to assertu64
1973622047 {
1973722048 // copy mutable arguments back from call to reportid
1973822049 fprintf(stderr, "%s", " expected type ");
@@ -19746,7 +22057,7 @@
1974622057 // call reporttype from assertu64
1974722058 newstack[0] = (uint64_t)stack; // backup stack location
1974822059 newstack[1] = base;
19749- newstack[2] = 1278LLU;
22060+ newstack[2] = 1436LLU;
1975022061 // arguments for call to reporttype
1975122062 newstack[3LLU] = stack[base + 5]/*expected*/;
1975222063 stack = newstack;
@@ -19755,7 +22066,7 @@
1975522066 label = 159LLU; // reporttype
1975622067 break;
1975722068 }
19758- case 1278LLU: // return from reporttype to assertu64
22069+ case 1436LLU: // return from reporttype to assertu64
1975922070 {
1976022071 uint64_t *oldstack = (uint64_t *)stack[0];
1976122072 // copy mutable arguments back from call to reporttype
@@ -19777,7 +22088,7 @@
1977722088 // call reporttype from assertu64
1977822089 newstack[0] = (uint64_t)stack; // backup stack location
1977922090 newstack[1] = base;
19780- newstack[2] = 1279LLU;
22091+ newstack[2] = 1437LLU;
1978122092 // arguments for call to reporttype
1978222093 newstack[3LLU] = stack[base + 6]/*found*/;
1978322094 stack = newstack;
@@ -19786,7 +22097,7 @@
1978622097 label = 159LLU; // reporttype
1978722098 break;
1978822099 }
19789- case 1279LLU: // return from reporttype to assertu64
22100+ case 1437LLU: // return from reporttype to assertu64
1979022101 {
1979122102 uint64_t *oldstack = (uint64_t *)stack[0];
1979222103 // copy mutable arguments back from call to reporttype
@@ -19799,10 +22110,10 @@
1979922110 stack = oldstack;
1980022111 fprintf(stderr, "%s", "\n");
1980122112 exit(-1);
19802- label = 1276LLU; // alternative complete
22113+ label = 1434LLU; // alternative complete
1980322114 break;
1980422115 }
19805- case 1276LLU: // completed if-then-else
22116+ case 1434LLU: // completed if-then-else
1980622117 {
1980722118
1980822119 uint64_t *newstack = (uint64_t *)(stack[base + 6] - sizeof(uint64_t) * 3);
@@ -19809,7 +22120,7 @@
1980922120 // call ~type from assertu64
1981022121 newstack[0] = (uint64_t)stack; // backup stack location
1981122122 newstack[1] = base;
19812- newstack[2] = 1280LLU;
22123+ newstack[2] = 1438LLU;
1981322124 stack = newstack;
1981422125 // set stack-base & callee-address
1981522126 base = 3;
@@ -19816,7 +22127,7 @@
1981622127 label = 148LLU; // ~type
1981722128 break;
1981822129 }
19819- case 1280LLU: // return from ~type to assertu64
22130+ case 1438LLU: // return from ~type to assertu64
1982022131 {
1982122132 stack = (uint64_t *)stack[0];
1982222133 // releasing toplevel container
@@ -19827,7 +22138,7 @@
1982722138 // call ~type from assertu64
1982822139 newstack[0] = (uint64_t)stack; // backup stack location
1982922140 newstack[1] = base;
19830- newstack[2] = 1281LLU;
22141+ newstack[2] = 1439LLU;
1983122142 stack = newstack;
1983222143 // set stack-base & callee-address
1983322144 base = 3;
@@ -19834,7 +22145,7 @@
1983422145 label = 148LLU; // ~type
1983522146 break;
1983622147 }
19837- case 1281LLU: // return from ~type to assertu64
22148+ case 1439LLU: // return from ~type to assertu64
1983822149 {
1983922150 stack = (uint64_t *)stack[0];
1984022151 // releasing toplevel container
@@ -19845,7 +22156,7 @@
1984522156 base = stack[base - 2];
1984622157 break;
1984722158 }
19848- case 1282LLU: // assertUorL
22159+ case 1440LLU: // assertUorL
1984922160 {
1985022161 //#define arg0 0
1985122162 //#define arg1 1
@@ -19854,7 +22165,7 @@
1985422165 //#define arg4 4
1985522166 // call getlettype from assertUorL
1985622167 stack[base + 6LLU] = base;
19857- stack[base + 7LLU] = 1283LLU;
22168+ stack[base + 7LLU] = 1441LLU;
1985822169 // arguments for call to getlettype
1985922170 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
1986022171 stack[base + 10LLU] = stack[base + 4]/*variableid*/;
@@ -19865,7 +22176,7 @@
1986522176 label = 326LLU; // getlettype
1986622177 break;
1986722178 }
19868- case 1283LLU: // return from getlettype to assertUorL
22179+ case 1441LLU: // return from getlettype to assertUorL
1986922180 {
1987022181 // copy mutable arguments back from call to getlettype
1987122182 // copy back results provided by call to getlettype
@@ -19872,7 +22183,7 @@
1987222183 stack[base + 5] = stack[base + 8LLU];
1987322184 if(/*typelist*/1 != ((uint64_t *)(stack[base + 5]/*found*/))[0])
1987422185 {
19875- label = 1285LLU; // jump to alternative
22186+ label = 1443LLU; // jump to alternative
1987622187 break;
1987722188 }
1987822189
@@ -19880,15 +22191,15 @@
1988022191
1988122192 // case
1988222193 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
19883- label = 1284LLU; // case complete
22194+ label = 1442LLU; // case complete
1988422195 break;
1988522196 }
19886- case 1285LLU: // try next case
22197+ case 1443LLU: // try next case
1988722198 {
1988822199 // default
1988922200 // call assertu64 from assertUorL
1989022201 stack[base + 6LLU] = base;
19891- stack[base + 7LLU] = 1286LLU;
22202+ stack[base + 7LLU] = 1444LLU;
1989222203 // arguments for call to assertu64
1989322204 stack[base + 8LLU] = stack[base + 0]/*fnid*/;
1989422205 stack[base + 9LLU] = stack[base + 1]/*fnname*/;
@@ -19897,16 +22208,16 @@
1989722208 stack[base + 12LLU] = stack[base + 4]/*variableid*/;
1989822209 // set stack-base & callee-address
1989922210 base += 8LLU;
19900- label = 1271LLU; // assertu64
22211+ label = 1429LLU; // assertu64
1990122212 break;
1990222213 }
19903- case 1286LLU: // return from assertu64 to assertUorL
22214+ case 1444LLU: // return from assertu64 to assertUorL
1990422215 {
1990522216 // copy mutable arguments back from call to assertu64
19906- label = 1284LLU; // default complete
22217+ label = 1442LLU; // default complete
1990722218 break;
1990822219 }
19909- case 1284LLU: // completed switch
22220+ case 1442LLU: // completed switch
1991022221 {
1991122222
1991222223 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 3);
@@ -19913,7 +22224,7 @@
1991322224 // call ~type from assertUorL
1991422225 newstack[0] = (uint64_t)stack; // backup stack location
1991522226 newstack[1] = base;
19916- newstack[2] = 1287LLU;
22227+ newstack[2] = 1445LLU;
1991722228 stack = newstack;
1991822229 // set stack-base & callee-address
1991922230 base = 3;
@@ -19920,7 +22231,7 @@
1992022231 label = 148LLU; // ~type
1992122232 break;
1992222233 }
19923- case 1287LLU: // return from ~type to assertUorL
22234+ case 1445LLU: // return from ~type to assertUorL
1992422235 {
1992522236 stack = (uint64_t *)stack[0];
1992622237 // releasing toplevel container
@@ -19931,7 +22242,7 @@
1993122242 base = stack[base - 2];
1993222243 break;
1993322244 }
19934- case 1288LLU: // assertlist
22245+ case 1446LLU: // assertlist
1993522246 {
1993622247 //#define arg0 0
1993722248 //#define arg1 1
@@ -19940,7 +22251,7 @@
1994022251 //#define arg4 4
1994122252 // call getlettype from assertlist
1994222253 stack[base + 6LLU] = base;
19943- stack[base + 7LLU] = 1289LLU;
22254+ stack[base + 7LLU] = 1447LLU;
1994422255 // arguments for call to getlettype
1994522256 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
1994622257 stack[base + 10LLU] = stack[base + 4]/*variableid*/;
@@ -19951,7 +22262,7 @@
1995122262 label = 326LLU; // getlettype
1995222263 break;
1995322264 }
19954- case 1289LLU: // return from getlettype to assertlist
22265+ case 1447LLU: // return from getlettype to assertlist
1995522266 {
1995622267 // copy mutable arguments back from call to getlettype
1995722268 // copy back results provided by call to getlettype
@@ -19958,7 +22269,7 @@
1995822269 stack[base + 5] = stack[base + 8LLU];
1995922270 if(/*typelist*/1 != ((uint64_t *)(stack[base + 5]/*found*/))[0])
1996022271 {
19961- label = 1291LLU; // jump to alternative
22272+ label = 1449LLU; // jump to alternative
1996222273 break;
1996322274 }
1996422275
@@ -19966,16 +22277,16 @@
1996622277
1996722278 // case
1996822279 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
19969- label = 1290LLU; // case complete
22280+ label = 1448LLU; // case complete
1997022281 break;
1997122282 }
19972- case 1291LLU: // try next case
22283+ case 1449LLU: // try next case
1997322284 {
1997422285 // default
1997522286 fprintf(stderr, "%s", "in ");
1997622287 // call reportid from assertlist
1997722288 stack[base + 6LLU] = base;
19978- stack[base + 7LLU] = 1292LLU;
22289+ stack[base + 7LLU] = 1450LLU;
1997922290 // arguments for call to reportid
1998022291 stack[base + 8LLU] = stack[base + 1]/*fnname*/;
1998122292 // set stack-base & callee-address
@@ -19983,7 +22294,7 @@
1998322294 label = 18446744073709551586LLU; // reportid
1998422295 break;
1998522296 }
19986- case 1292LLU: // return from reportid to assertlist
22297+ case 1450LLU: // return from reportid to assertlist
1998722298 {
1998822299 // copy mutable arguments back from call to reportid
1998922300 fprintf(stderr, "%s", " expected type [] but found type ");
@@ -19997,7 +22308,7 @@
1999722308 // call reporttype from assertlist
1999822309 newstack[0] = (uint64_t)stack; // backup stack location
1999922310 newstack[1] = base;
20000- newstack[2] = 1293LLU;
22311+ newstack[2] = 1451LLU;
2000122312 // arguments for call to reporttype
2000222313 newstack[3LLU] = stack[base + 5]/*found*/;
2000322314 stack = newstack;
@@ -20006,7 +22317,7 @@
2000622317 label = 159LLU; // reporttype
2000722318 break;
2000822319 }
20009- case 1293LLU: // return from reporttype to assertlist
22320+ case 1451LLU: // return from reporttype to assertlist
2001022321 {
2001122322 uint64_t *oldstack = (uint64_t *)stack[0];
2001222323 // copy mutable arguments back from call to reporttype
@@ -20019,10 +22330,10 @@
2001922330 stack = oldstack;
2002022331 fprintf(stderr, "%s", "\n");
2002122332 exit(-1);
20022- label = 1290LLU; // default complete
22333+ label = 1448LLU; // default complete
2002322334 break;
2002422335 }
20025- case 1290LLU: // completed switch
22336+ case 1448LLU: // completed switch
2002622337 {
2002722338
2002822339 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 3);
@@ -20029,7 +22340,7 @@
2002922340 // call ~type from assertlist
2003022341 newstack[0] = (uint64_t)stack; // backup stack location
2003122342 newstack[1] = base;
20032- newstack[2] = 1294LLU;
22343+ newstack[2] = 1452LLU;
2003322344 stack = newstack;
2003422345 // set stack-base & callee-address
2003522346 base = 3;
@@ -20036,7 +22347,7 @@
2003622347 label = 148LLU; // ~type
2003722348 break;
2003822349 }
20039- case 1294LLU: // return from ~type to assertlist
22350+ case 1452LLU: // return from ~type to assertlist
2004022351 {
2004122352 stack = (uint64_t *)stack[0];
2004222353 // releasing toplevel container
@@ -20047,7 +22358,7 @@
2004722358 base = stack[base - 2];
2004822359 break;
2004922360 }
20050- case 1295LLU: // markswap
22361+ case 1453LLU: // markswap
2005122362 {
2005222363 //#define arg0 0
2005322364 //#define arg1 1
@@ -20057,7 +22368,7 @@
2005722368 stack[base + 5] = 0;
2005822369 // call getlettype from markswap
2005922370 stack[base + 7LLU] = base;
20060- stack[base + 8LLU] = 1296LLU;
22371+ stack[base + 8LLU] = 1454LLU;
2006122372 // arguments for call to getlettype
2006222373 stack[base + 10LLU] = stack[base + 0]/*fnid*/;
2006322374 stack[base + 11LLU] = stack[base + 3]/*xidsearch*/;
@@ -20068,7 +22379,7 @@
2006822379 label = 326LLU; // getlettype
2006922380 break;
2007022381 }
20071- case 1296LLU: // return from getlettype to markswap
22382+ case 1454LLU: // return from getlettype to markswap
2007222383 {
2007322384 // copy mutable arguments back from call to getlettype
2007422385 // copy back results provided by call to getlettype
@@ -20075,7 +22386,7 @@
2007522386 stack[base + 6] = stack[base + 9LLU];
2007622387 // call getlettype from markswap
2007722388 stack[base + 8LLU] = base;
20078- stack[base + 9LLU] = 1297LLU;
22389+ stack[base + 9LLU] = 1455LLU;
2007922390 // arguments for call to getlettype
2008022391 stack[base + 11LLU] = stack[base + 0]/*fnid*/;
2008122392 stack[base + 12LLU] = stack[base + 4]/*yidsearch*/;
@@ -20086,7 +22397,7 @@
2008622397 label = 326LLU; // getlettype
2008722398 break;
2008822399 }
20089- case 1297LLU: // return from getlettype to markswap
22400+ case 1455LLU: // return from getlettype to markswap
2009022401 {
2009122402 // copy mutable arguments back from call to getlettype
2009222403 // copy back results provided by call to getlettype
@@ -20101,7 +22412,7 @@
2010122412 // call equtype from markswap
2010222413 newstack[0] = (uint64_t)stack; // backup stack location
2010322414 newstack[1] = base;
20104- newstack[2] = 1298LLU;
22415+ newstack[2] = 1456LLU;
2010522416 // arguments for call to equtype
2010622417 newstack[4LLU] = stack[base + 6]/*xtype*/;
2010722418 newstack[5LLU] = stack[base + 7]/*ytype*/;
@@ -20111,7 +22422,7 @@
2011122422 label = 170LLU; // equtype
2011222423 break;
2011322424 }
20114- case 1298LLU: // return from equtype to markswap
22425+ case 1456LLU: // return from equtype to markswap
2011522426 {
2011622427 uint64_t *oldstack = (uint64_t *)stack[0];
2011722428 // copy mutable arguments back from call to equtype
@@ -20126,20 +22437,20 @@
2012622437 stack = oldstack;
2012722438 if(!stack[base + 5]/*isequal*/)
2012822439 {
20129- label = 1299LLU; // jump to alternative
22440+ label = 1457LLU; // jump to alternative
2013022441 break;
2013122442 }
2013222443
2013322444 // consequent
20134- label = 1300LLU; // consequent complete
22445+ label = 1458LLU; // consequent complete
2013522446 break;
2013622447 }
20137- case 1299LLU: // alternative
22448+ case 1457LLU: // alternative
2013822449 {
2013922450 fprintf(stderr, "%s", "in function ");
2014022451 // call reportid from markswap
2014122452 stack[base + 8LLU] = base;
20142- stack[base + 9LLU] = 1301LLU;
22453+ stack[base + 9LLU] = 1459LLU;
2014322454 // arguments for call to reportid
2014422455 stack[base + 10LLU] = stack[base + 0]/*fnid*/;
2014522456 // set stack-base & callee-address
@@ -20147,7 +22458,7 @@
2014722458 label = 18446744073709551586LLU; // reportid
2014822459 break;
2014922460 }
20150- case 1301LLU: // return from reportid to markswap
22461+ case 1459LLU: // return from reportid to markswap
2015122462 {
2015222463 // copy mutable arguments back from call to reportid
2015322464 fprintf(stderr, "%s", ": can't swap different types ");
@@ -20161,7 +22472,7 @@
2016122472 // call reporttype from markswap
2016222473 newstack[0] = (uint64_t)stack; // backup stack location
2016322474 newstack[1] = base;
20164- newstack[2] = 1302LLU;
22475+ newstack[2] = 1460LLU;
2016522476 // arguments for call to reporttype
2016622477 newstack[3LLU] = stack[base + 6]/*xtype*/;
2016722478 stack = newstack;
@@ -20170,7 +22481,7 @@
2017022481 label = 159LLU; // reporttype
2017122482 break;
2017222483 }
20173- case 1302LLU: // return from reporttype to markswap
22484+ case 1460LLU: // return from reporttype to markswap
2017422485 {
2017522486 uint64_t *oldstack = (uint64_t *)stack[0];
2017622487 // copy mutable arguments back from call to reporttype
@@ -20192,7 +22503,7 @@
2019222503 // call reporttype from markswap
2019322504 newstack[0] = (uint64_t)stack; // backup stack location
2019422505 newstack[1] = base;
20195- newstack[2] = 1303LLU;
22506+ newstack[2] = 1461LLU;
2019622507 // arguments for call to reporttype
2019722508 newstack[3LLU] = stack[base + 7]/*ytype*/;
2019822509 stack = newstack;
@@ -20201,7 +22512,7 @@
2020122512 label = 159LLU; // reporttype
2020222513 break;
2020322514 }
20204- case 1303LLU: // return from reporttype to markswap
22515+ case 1461LLU: // return from reporttype to markswap
2020522516 {
2020622517 uint64_t *oldstack = (uint64_t *)stack[0];
2020722518 // copy mutable arguments back from call to reporttype
@@ -20214,14 +22525,14 @@
2021422525 stack = oldstack;
2021522526 fprintf(stderr, "%s", "\n");
2021622527 exit(-1);
20217- label = 1300LLU; // alternative complete
22528+ label = 1458LLU; // alternative complete
2021822529 break;
2021922530 }
20220- case 1300LLU: // completed if-then-else
22531+ case 1458LLU: // completed if-then-else
2022122532 {
2022222533 // call findletmut from markswap
2022322534 stack[base + 9LLU] = base;
20224- stack[base + 10LLU] = 1304LLU;
22535+ stack[base + 10LLU] = 1462LLU;
2022522536 // arguments for call to findletmut
2022622537 stack[base + 12LLU] = stack[base + 0]/*fnid*/;
2022722538 stack[base + 13LLU] = stack[base + 3]/*xidsearch*/;
@@ -20232,7 +22543,7 @@
2023222543 label = 337LLU; // findletmut
2023322544 break;
2023422545 }
20235- case 1304LLU: // return from findletmut to markswap
22546+ case 1462LLU: // return from findletmut to markswap
2023622547 {
2023722548 // copy mutable arguments back from call to findletmut
2023822549 // copy back results provided by call to findletmut
@@ -20239,7 +22550,7 @@
2023922550 stack[base + 8] = stack[base + 11LLU];
2024022551 // call findletmut from markswap
2024122552 stack[base + 10LLU] = base;
20242- stack[base + 11LLU] = 1305LLU;
22553+ stack[base + 11LLU] = 1463LLU;
2024322554 // arguments for call to findletmut
2024422555 stack[base + 13LLU] = stack[base + 0]/*fnid*/;
2024522556 stack[base + 14LLU] = stack[base + 4]/*yidsearch*/;
@@ -20250,7 +22561,7 @@
2025022561 label = 337LLU; // findletmut
2025122562 break;
2025222563 }
20253- case 1305LLU: // return from findletmut to markswap
22564+ case 1463LLU: // return from findletmut to markswap
2025422565 {
2025522566 // copy mutable arguments back from call to findletmut
2025622567 // copy back results provided by call to findletmut
@@ -20257,20 +22568,20 @@
2025722568 stack[base + 9] = stack[base + 12LLU];
2025822569 if(!stack[base + 8]/*xmutable*/)
2025922570 {
20260- label = 1306LLU; // jump to alternative
22571+ label = 1464LLU; // jump to alternative
2026122572 break;
2026222573 }
2026322574
2026422575 // consequent
20265- label = 1307LLU; // consequent complete
22576+ label = 1465LLU; // consequent complete
2026622577 break;
2026722578 }
20268- case 1306LLU: // alternative
22579+ case 1464LLU: // alternative
2026922580 {
2027022581 fprintf(stderr, "%s", "can't swap constant ");
2027122582 // call reportid from markswap
2027222583 stack[base + 10LLU] = base;
20273- stack[base + 11LLU] = 1308LLU;
22584+ stack[base + 11LLU] = 1466LLU;
2027422585 // arguments for call to reportid
2027522586 stack[base + 12LLU] = stack[base + 3]/*xidsearch*/;
2027622587 // set stack-base & callee-address
@@ -20278,7 +22589,7 @@
2027822589 label = 18446744073709551586LLU; // reportid
2027922590 break;
2028022591 }
20281- case 1308LLU: // return from reportid to markswap
22592+ case 1466LLU: // return from reportid to markswap
2028222593 {
2028322594 // copy mutable arguments back from call to reportid
2028422595 fprintf(stderr, "%s", " of type ");
@@ -20292,7 +22603,7 @@
2029222603 // call reporttype from markswap
2029322604 newstack[0] = (uint64_t)stack; // backup stack location
2029422605 newstack[1] = base;
20295- newstack[2] = 1309LLU;
22606+ newstack[2] = 1467LLU;
2029622607 // arguments for call to reporttype
2029722608 newstack[3LLU] = stack[base + 6]/*xtype*/;
2029822609 stack = newstack;
@@ -20301,7 +22612,7 @@
2030122612 label = 159LLU; // reporttype
2030222613 break;
2030322614 }
20304- case 1309LLU: // return from reporttype to markswap
22615+ case 1467LLU: // return from reporttype to markswap
2030522616 {
2030622617 uint64_t *oldstack = (uint64_t *)stack[0];
2030722618 // copy mutable arguments back from call to reporttype
@@ -20314,27 +22625,27 @@
2031422625 stack = oldstack;
2031522626 fprintf(stderr, "%s", "\n");
2031622627 exit(-1);
20317- label = 1307LLU; // alternative complete
22628+ label = 1465LLU; // alternative complete
2031822629 break;
2031922630 }
20320- case 1307LLU: // completed if-then-else
22631+ case 1465LLU: // completed if-then-else
2032122632 {
2032222633 if(!stack[base + 9]/*ymutable*/)
2032322634 {
20324- label = 1310LLU; // jump to alternative
22635+ label = 1468LLU; // jump to alternative
2032522636 break;
2032622637 }
2032722638
2032822639 // consequent
20329- label = 1311LLU; // consequent complete
22640+ label = 1469LLU; // consequent complete
2033022641 break;
2033122642 }
20332- case 1310LLU: // alternative
22643+ case 1468LLU: // alternative
2033322644 {
2033422645 fprintf(stderr, "%s", "can't swap constant ");
2033522646 // call reportid from markswap
2033622647 stack[base + 10LLU] = base;
20337- stack[base + 11LLU] = 1312LLU;
22648+ stack[base + 11LLU] = 1470LLU;
2033822649 // arguments for call to reportid
2033922650 stack[base + 12LLU] = stack[base + 4]/*yidsearch*/;
2034022651 // set stack-base & callee-address
@@ -20342,7 +22653,7 @@
2034222653 label = 18446744073709551586LLU; // reportid
2034322654 break;
2034422655 }
20345- case 1312LLU: // return from reportid to markswap
22656+ case 1470LLU: // return from reportid to markswap
2034622657 {
2034722658 // copy mutable arguments back from call to reportid
2034822659 fprintf(stderr, "%s", " of type ");
@@ -20356,7 +22667,7 @@
2035622667 // call reporttype from markswap
2035722668 newstack[0] = (uint64_t)stack; // backup stack location
2035822669 newstack[1] = base;
20359- newstack[2] = 1313LLU;
22670+ newstack[2] = 1471LLU;
2036022671 // arguments for call to reporttype
2036122672 newstack[3LLU] = stack[base + 7]/*ytype*/;
2036222673 stack = newstack;
@@ -20365,7 +22676,7 @@
2036522676 label = 159LLU; // reporttype
2036622677 break;
2036722678 }
20368- case 1313LLU: // return from reporttype to markswap
22679+ case 1471LLU: // return from reporttype to markswap
2036922680 {
2037022681 uint64_t *oldstack = (uint64_t *)stack[0];
2037122682 // copy mutable arguments back from call to reporttype
@@ -20378,10 +22689,10 @@
2037822689 stack = oldstack;
2037922690 fprintf(stderr, "%s", "\n");
2038022691 exit(-1);
20381- label = 1311LLU; // alternative complete
22692+ label = 1469LLU; // alternative complete
2038222693 break;
2038322694 }
20384- case 1311LLU: // completed if-then-else
22695+ case 1469LLU: // completed if-then-else
2038522696 {
2038622697
2038722698 uint64_t *newstack = (uint64_t *)(stack[base + 7] - sizeof(uint64_t) * 3);
@@ -20388,7 +22699,7 @@
2038822699 // call ~type from markswap
2038922700 newstack[0] = (uint64_t)stack; // backup stack location
2039022701 newstack[1] = base;
20391- newstack[2] = 1314LLU;
22702+ newstack[2] = 1472LLU;
2039222703 stack = newstack;
2039322704 // set stack-base & callee-address
2039422705 base = 3;
@@ -20395,7 +22706,7 @@
2039522706 label = 148LLU; // ~type
2039622707 break;
2039722708 }
20398- case 1314LLU: // return from ~type to markswap
22709+ case 1472LLU: // return from ~type to markswap
2039922710 {
2040022711 stack = (uint64_t *)stack[0];
2040122712 // releasing toplevel container
@@ -20406,7 +22717,7 @@
2040622717 // call ~type from markswap
2040722718 newstack[0] = (uint64_t)stack; // backup stack location
2040822719 newstack[1] = base;
20409- newstack[2] = 1315LLU;
22720+ newstack[2] = 1473LLU;
2041022721 stack = newstack;
2041122722 // set stack-base & callee-address
2041222723 base = 3;
@@ -20413,7 +22724,7 @@
2041322724 label = 148LLU; // ~type
2041422725 break;
2041522726 }
20416- case 1315LLU: // return from ~type to markswap
22727+ case 1473LLU: // return from ~type to markswap
2041722728 {
2041822729 stack = (uint64_t *)stack[0];
2041922730 // releasing toplevel container
@@ -20421,7 +22732,7 @@
2042122732
2042222733 // call findletidx from markswap
2042322734 stack[base + 7LLU] = base;
20424- stack[base + 8LLU] = 1316LLU;
22735+ stack[base + 8LLU] = 1474LLU;
2042522736 // arguments for call to findletidx
2042622737 stack[base + 10LLU] = stack[base + 0]/*fnid*/;
2042722738 stack[base + 11LLU] = stack[base + 3]/*xidsearch*/;
@@ -20432,7 +22743,7 @@
2043222743 label = 332LLU; // findletidx
2043322744 break;
2043422745 }
20435- case 1316LLU: // return from findletidx to markswap
22746+ case 1474LLU: // return from findletidx to markswap
2043622747 {
2043722748 // copy mutable arguments back from call to findletidx
2043822749 // copy back results provided by call to findletidx
@@ -20439,7 +22750,7 @@
2043922750 stack[base + 6] = stack[base + 9LLU];
2044022751 // call findletidx from markswap
2044122752 stack[base + 8LLU] = base;
20442- stack[base + 9LLU] = 1317LLU;
22753+ stack[base + 9LLU] = 1475LLU;
2044322754 // arguments for call to findletidx
2044422755 stack[base + 11LLU] = stack[base + 0]/*fnid*/;
2044522756 stack[base + 12LLU] = stack[base + 4]/*yidsearch*/;
@@ -20450,7 +22761,7 @@
2045022761 label = 332LLU; // findletidx
2045122762 break;
2045222763 }
20453- case 1317LLU: // return from findletidx to markswap
22764+ case 1475LLU: // return from findletidx to markswap
2045422765 {
2045522766 // copy mutable arguments back from call to findletidx
2045622767 // copy back results provided by call to findletidx
@@ -20458,7 +22769,7 @@
2045822769 printf("%s", "\n swap(&");
2045922770 // call emitvaridx from markswap
2046022771 stack[base + 8LLU] = base;
20461- stack[base + 9LLU] = 1318LLU;
22772+ stack[base + 9LLU] = 1476LLU;
2046222773 // arguments for call to emitvaridx
2046322774 stack[base + 10LLU] = stack[base + 6]/*xindex*/;
2046422775 // set stack-base & callee-address
@@ -20466,13 +22777,13 @@
2046622777 label = 347LLU; // emitvaridx
2046722778 break;
2046822779 }
20469- case 1318LLU: // return from emitvaridx to markswap
22780+ case 1476LLU: // return from emitvaridx to markswap
2047022781 {
2047122782 // copy mutable arguments back from call to emitvaridx
2047222783 printf("%s", ", &");
2047322784 // call emitvaridx from markswap
2047422785 stack[base + 8LLU] = base;
20475- stack[base + 9LLU] = 1319LLU;
22786+ stack[base + 9LLU] = 1477LLU;
2047622787 // arguments for call to emitvaridx
2047722788 stack[base + 10LLU] = stack[base + 7]/*yindex*/;
2047822789 // set stack-base & callee-address
@@ -20480,7 +22791,7 @@
2048022791 label = 347LLU; // emitvaridx
2048122792 break;
2048222793 }
20483- case 1319LLU: // return from emitvaridx to markswap
22794+ case 1477LLU: // return from emitvaridx to markswap
2048422795 {
2048522796 // copy mutable arguments back from call to emitvaridx
2048622797 printf("%s", ");");
@@ -20489,7 +22800,7 @@
2048922800 base = stack[base - 2];
2049022801 break;
2049122802 }
20492- case 1320LLU: // AssignFrom
22803+ case 1478LLU: // AssignFrom
2049322804 {
2049422805 //#define arg0 0
2049522806 //#define arg1 1
@@ -20507,7 +22818,7 @@
2050722818 stack[base + 13] = 0;
2050822819 // call getlettype from AssignFrom
2050922820 stack[base + 15LLU] = base;
20510- stack[base + 16LLU] = 1321LLU;
22821+ stack[base + 16LLU] = 1479LLU;
2051122822 // arguments for call to getlettype
2051222823 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2051322824 stack[base + 19LLU] = stack[base + 1]/*id*/;
@@ -20518,7 +22829,7 @@
2051822829 label = 326LLU; // getlettype
2051922830 break;
2052022831 }
20521- case 1321LLU: // return from getlettype to AssignFrom
22832+ case 1479LLU: // return from getlettype to AssignFrom
2052222833 {
2052322834 // copy mutable arguments back from call to getlettype
2052422835 // copy back results provided by call to getlettype
@@ -20525,7 +22836,7 @@
2052522836 stack[base + 14] = stack[base + 17LLU];
2052622837 if(/*typename*/0 != ((uint64_t *)(stack[base + 14]/*type*/))[0])
2052722838 {
20528- label = 1323LLU; // jump to alternative
22839+ label = 1481LLU; // jump to alternative
2052922840 break;
2053022841 }
2053122842
@@ -20534,7 +22845,7 @@
2053422845 // case
2053522846 // call equ from AssignFrom
2053622847 stack[base + 16LLU] = base;
20537- stack[base + 17LLU] = 1324LLU;
22848+ stack[base + 17LLU] = 1482LLU;
2053822849 // arguments for call to equ
2053922850 stack[base + 19LLU] = 881834713755418624LLU;
2054022851 stack[base + 20LLU] = stack[base + 15]/*name*/;
@@ -20543,7 +22854,7 @@
2054322854 label = 18446744073709551600LLU; // equ
2054422855 break;
2054522856 }
20546- case 1324LLU: // return from equ to AssignFrom
22857+ case 1482LLU: // return from equ to AssignFrom
2054722858 {
2054822859 // copy mutable arguments back from call to equ
2054922860 // copy back results provided by call to equ
@@ -20550,7 +22861,7 @@
2055022861 stack[base + 13] = stack[base + 18LLU];
2055122862 if(!stack[base + 13]/*isequal*/)
2055222863 {
20553- label = 1325LLU; // jump to alternative
22864+ label = 1483LLU; // jump to alternative
2055422865 break;
2055522866 }
2055622867
@@ -20557,7 +22868,7 @@
2055722868 // consequent
2055822869 // call isncs from AssignFrom
2055922870 stack[base + 16LLU] = base;
20560- stack[base + 17LLU] = 1327LLU;
22871+ stack[base + 17LLU] = 1485LLU;
2056122872 // arguments for call to isncs
2056222873 stack[base + 19LLU] = stack[base + 11]/*variant*/;
2056322874 // set stack-base & callee-address
@@ -20565,7 +22876,7 @@
2056522876 label = 138LLU; // isncs
2056622877 break;
2056722878 }
20568- case 1327LLU: // return from isncs to AssignFrom
22879+ case 1485LLU: // return from isncs to AssignFrom
2056922880 {
2057022881 // copy mutable arguments back from call to isncs
2057122882 // copy back results provided by call to isncs
@@ -20572,7 +22883,7 @@
2057222883 stack[base + 13] = stack[base + 18LLU];
2057322884 if(!stack[base + 13]/*isequal*/)
2057422885 {
20575- label = 1328LLU; // jump to alternative
22886+ label = 1486LLU; // jump to alternative
2057622887 break;
2057722888 }
2057822889
@@ -20580,7 +22891,7 @@
2058022891 printf("%s", "\n ");
2058122892 // call emitvar from AssignFrom
2058222893 stack[base + 16LLU] = base;
20583- stack[base + 17LLU] = 1330LLU;
22894+ stack[base + 17LLU] = 1488LLU;
2058422895 // arguments for call to emitvar
2058522896 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2058622897 stack[base + 19LLU] = stack[base + 1]/*id*/;
@@ -20591,13 +22902,13 @@
2059122902 label = 349LLU; // emitvar
2059222903 break;
2059322904 }
20594- case 1330LLU: // return from emitvar to AssignFrom
22905+ case 1488LLU: // return from emitvar to AssignFrom
2059522906 {
2059622907 // copy mutable arguments back from call to emitvar
2059722908 printf("%s", " = ");
2059822909 // call printnr from AssignFrom
2059922910 stack[base + 16LLU] = base;
20600- stack[base + 17LLU] = 1331LLU;
22911+ stack[base + 17LLU] = 1489LLU;
2060122912 // arguments for call to printnr
2060222913 stack[base + 18LLU] = stack[base + 12]/*content*/;
2060322914 // set stack-base & callee-address
@@ -20605,18 +22916,18 @@
2060522916 label = 18446744073709551590LLU; // printnr
2060622917 break;
2060722918 }
20608- case 1331LLU: // return from printnr to AssignFrom
22919+ case 1489LLU: // return from printnr to AssignFrom
2060922920 {
2061022921 // copy mutable arguments back from call to printnr
2061122922 printf("%s", ";");
20612- label = 1329LLU; // consequent complete
22923+ label = 1487LLU; // consequent complete
2061322924 break;
2061422925 }
20615- case 1328LLU: // alternative
22926+ case 1486LLU: // alternative
2061622927 {
2061722928 // call equ from AssignFrom
2061822929 stack[base + 16LLU] = base;
20619- stack[base + 17LLU] = 1332LLU;
22930+ stack[base + 17LLU] = 1490LLU;
2062022931 // arguments for call to equ
2062122932 stack[base + 19LLU] = stack[base + 11]/*variant*/;
2062222933 stack[base + 20LLU] = 4LLU;
@@ -20625,7 +22936,7 @@
2062522936 label = 18446744073709551600LLU; // equ
2062622937 break;
2062722938 }
20628- case 1332LLU: // return from equ to AssignFrom
22939+ case 1490LLU: // return from equ to AssignFrom
2062922940 {
2063022941 // copy mutable arguments back from call to equ
2063122942 // copy back results provided by call to equ
@@ -20632,7 +22943,7 @@
2063222943 stack[base + 13] = stack[base + 18LLU];
2063322944 if(!stack[base + 13]/*isequal*/)
2063422945 {
20635- label = 1333LLU; // jump to alternative
22946+ label = 1491LLU; // jump to alternative
2063622947 break;
2063722948 }
2063822949
@@ -20640,7 +22951,7 @@
2064022951 printf("%s", "\n ");
2064122952 // call emitvar from AssignFrom
2064222953 stack[base + 16LLU] = base;
20643- stack[base + 17LLU] = 1335LLU;
22954+ stack[base + 17LLU] = 1493LLU;
2064422955 // arguments for call to emitvar
2064522956 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2064622957 stack[base + 19LLU] = stack[base + 1]/*id*/;
@@ -20651,13 +22962,13 @@
2065122962 label = 349LLU; // emitvar
2065222963 break;
2065322964 }
20654- case 1335LLU: // return from emitvar to AssignFrom
22965+ case 1493LLU: // return from emitvar to AssignFrom
2065522966 {
2065622967 // copy mutable arguments back from call to emitvar
2065722968 printf("%s", " = ");
2065822969 // call emitvar from AssignFrom
2065922970 stack[base + 16LLU] = base;
20660- stack[base + 17LLU] = 1336LLU;
22971+ stack[base + 17LLU] = 1494LLU;
2066122972 // arguments for call to emitvar
2066222973 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2066322974 stack[base + 19LLU] = stack[base + 12]/*content*/;
@@ -20668,19 +22979,19 @@
2066822979 label = 349LLU; // emitvar
2066922980 break;
2067022981 }
20671- case 1336LLU: // return from emitvar to AssignFrom
22982+ case 1494LLU: // return from emitvar to AssignFrom
2067222983 {
2067322984 // copy mutable arguments back from call to emitvar
2067422985 printf("%s", ";");
20675- label = 1334LLU; // consequent complete
22986+ label = 1492LLU; // consequent complete
2067622987 break;
2067722988 }
20678- case 1333LLU: // alternative
22989+ case 1491LLU: // alternative
2067922990 {
2068022991 fprintf(stderr, "%s", "parsing assignment unexpected token ");
2068122992 // call reporttok from AssignFrom
2068222993 stack[base + 16LLU] = base;
20683- stack[base + 17LLU] = 1337LLU;
22994+ stack[base + 17LLU] = 1495LLU;
2068422995 // arguments for call to reporttok
2068522996 stack[base + 18LLU] = stack[base + 11]/*variant*/;
2068622997 stack[base + 19LLU] = stack[base + 12]/*content*/;
@@ -20689,30 +23000,30 @@
2068923000 label = 18446744073709551582LLU; // reporttok
2069023001 break;
2069123002 }
20692- case 1337LLU: // return from reporttok to AssignFrom
23003+ case 1495LLU: // return from reporttok to AssignFrom
2069323004 {
2069423005 // copy mutable arguments back from call to reporttok
2069523006 fprintf(stderr, "%s", "\n");
2069623007 exit(-1);
20697- label = 1334LLU; // alternative complete
23008+ label = 1492LLU; // alternative complete
2069823009 break;
2069923010 }
20700- case 1334LLU: // completed if-then-else
23011+ case 1492LLU: // completed if-then-else
2070123012 {
20702- label = 1329LLU; // alternative complete
23013+ label = 1487LLU; // alternative complete
2070323014 break;
2070423015 }
20705- case 1329LLU: // completed if-then-else
23016+ case 1487LLU: // completed if-then-else
2070623017 {
20707- label = 1326LLU; // consequent complete
23018+ label = 1484LLU; // consequent complete
2070823019 break;
2070923020 }
20710- case 1325LLU: // alternative
23021+ case 1483LLU: // alternative
2071123022 {
2071223023 fprintf(stderr, "%s", "in function ");
2071323024 // call reportid from AssignFrom
2071423025 stack[base + 16LLU] = base;
20715- stack[base + 17LLU] = 1338LLU;
23026+ stack[base + 17LLU] = 1496LLU;
2071623027 // arguments for call to reportid
2071723028 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2071823029 // set stack-base & callee-address
@@ -20720,7 +23031,7 @@
2072023031 label = 18446744073709551586LLU; // reportid
2072123032 break;
2072223033 }
20723- case 1338LLU: // return from reportid to AssignFrom
23034+ case 1496LLU: // return from reportid to AssignFrom
2072423035 {
2072523036 // copy mutable arguments back from call to reportid
2072623037 fprintf(stderr, "%s", ": can only assign to u64 but found ");
@@ -20734,7 +23045,7 @@
2073423045 // call reporttype from AssignFrom
2073523046 newstack[0] = (uint64_t)stack; // backup stack location
2073623047 newstack[1] = base;
20737- newstack[2] = 1339LLU;
23048+ newstack[2] = 1497LLU;
2073823049 // arguments for call to reporttype
2073923050 newstack[3LLU] = stack[base + 14]/*type*/;
2074023051 stack = newstack;
@@ -20743,7 +23054,7 @@
2074323054 label = 159LLU; // reporttype
2074423055 break;
2074523056 }
20746- case 1339LLU: // return from reporttype to AssignFrom
23057+ case 1497LLU: // return from reporttype to AssignFrom
2074723058 {
2074823059 uint64_t *oldstack = (uint64_t *)stack[0];
2074923060 // copy mutable arguments back from call to reporttype
@@ -20757,7 +23068,7 @@
2075723068 fprintf(stderr, "%s", " ");
2075823069 // call reportid from AssignFrom
2075923070 stack[base + 16LLU] = base;
20760- stack[base + 17LLU] = 1340LLU;
23071+ stack[base + 17LLU] = 1498LLU;
2076123072 // arguments for call to reportid
2076223073 stack[base + 18LLU] = stack[base + 1]/*id*/;
2076323074 // set stack-base & callee-address
@@ -20765,25 +23076,25 @@
2076523076 label = 18446744073709551586LLU; // reportid
2076623077 break;
2076723078 }
20768- case 1340LLU: // return from reportid to AssignFrom
23079+ case 1498LLU: // return from reportid to AssignFrom
2076923080 {
2077023081 // copy mutable arguments back from call to reportid
2077123082 fprintf(stderr, "%s", " instead - use SWAP\n");
2077223083 exit(-1);
20773- label = 1326LLU; // alternative complete
23084+ label = 1484LLU; // alternative complete
2077423085 break;
2077523086 }
20776- case 1326LLU: // completed if-then-else
23087+ case 1484LLU: // completed if-then-else
2077723088 {
2077823089 ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15];
20779- label = 1322LLU; // case complete
23090+ label = 1480LLU; // case complete
2078023091 break;
2078123092 }
20782- case 1323LLU: // try next case
23093+ case 1481LLU: // try next case
2078323094 {
2078423095 if(/*typelist*/1 != ((uint64_t *)(stack[base + 14]/*type*/))[0])
2078523096 {
20786- label = 1341LLU; // jump to alternative
23097+ label = 1499LLU; // jump to alternative
2078723098 break;
2078823099 }
2078923100
@@ -20793,7 +23104,7 @@
2079323104 fprintf(stderr, "%s", "in function ");
2079423105 // call reportid from AssignFrom
2079523106 stack[base + 16LLU] = base;
20796- stack[base + 17LLU] = 1342LLU;
23107+ stack[base + 17LLU] = 1500LLU;
2079723108 // arguments for call to reportid
2079823109 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2079923110 // set stack-base & callee-address
@@ -20801,7 +23112,7 @@
2080123112 label = 18446744073709551586LLU; // reportid
2080223113 break;
2080323114 }
20804- case 1342LLU: // return from reportid to AssignFrom
23115+ case 1500LLU: // return from reportid to AssignFrom
2080523116 {
2080623117 // copy mutable arguments back from call to reportid
2080723118 fprintf(stderr, "%s", ": cannot assign to list ");
@@ -20815,7 +23126,7 @@
2081523126 // call reporttype from AssignFrom
2081623127 newstack[0] = (uint64_t)stack; // backup stack location
2081723128 newstack[1] = base;
20818- newstack[2] = 1343LLU;
23129+ newstack[2] = 1501LLU;
2081923130 // arguments for call to reporttype
2082023131 newstack[3LLU] = stack[base + 14]/*type*/;
2082123132 stack = newstack;
@@ -20824,7 +23135,7 @@
2082423135 label = 159LLU; // reporttype
2082523136 break;
2082623137 }
20827- case 1343LLU: // return from reporttype to AssignFrom
23138+ case 1501LLU: // return from reporttype to AssignFrom
2082823139 {
2082923140 uint64_t *oldstack = (uint64_t *)stack[0];
2083023141 // copy mutable arguments back from call to reporttype
@@ -20838,7 +23149,7 @@
2083823149 fprintf(stderr, "%s", " ");
2083923150 // call reportid from AssignFrom
2084023151 stack[base + 16LLU] = base;
20841- stack[base + 17LLU] = 1344LLU;
23152+ stack[base + 17LLU] = 1502LLU;
2084223153 // arguments for call to reportid
2084323154 stack[base + 18LLU] = stack[base + 1]/*id*/;
2084423155 // set stack-base & callee-address
@@ -20846,21 +23157,21 @@
2084623157 label = 18446744073709551586LLU; // reportid
2084723158 break;
2084823159 }
20849- case 1344LLU: // return from reportid to AssignFrom
23160+ case 1502LLU: // return from reportid to AssignFrom
2085023161 {
2085123162 // copy mutable arguments back from call to reportid
2085223163 fprintf(stderr, "%s", " - use SWAP instead\n");
2085323164 exit(-1);
2085423165 ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15];
20855- label = 1322LLU; // case complete
23166+ label = 1480LLU; // case complete
2085623167 break;
2085723168 }
20858- case 1341LLU: // try next case
23169+ case 1499LLU: // try next case
2085923170 {
2086023171 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2086123172 exit(-1);
2086223173 }
20863- case 1322LLU: // completed switch
23174+ case 1480LLU: // completed switch
2086423175 {
2086523176
2086623177 uint64_t *newstack = (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 3);
@@ -20867,7 +23178,7 @@
2086723178 // call ~type from AssignFrom
2086823179 newstack[0] = (uint64_t)stack; // backup stack location
2086923180 newstack[1] = base;
20870- newstack[2] = 1345LLU;
23181+ newstack[2] = 1503LLU;
2087123182 stack = newstack;
2087223183 // set stack-base & callee-address
2087323184 base = 3;
@@ -20874,7 +23185,7 @@
2087423185 label = 148LLU; // ~type
2087523186 break;
2087623187 }
20877- case 1345LLU: // return from ~type to AssignFrom
23188+ case 1503LLU: // return from ~type to AssignFrom
2087823189 {
2087923190 stack = (uint64_t *)stack[0];
2088023191 // releasing toplevel container
@@ -20885,20 +23196,20 @@
2088523196 base = stack[base - 2];
2088623197 break;
2088723198 }
20888- case 1346LLU: // closescope
23199+ case 1504LLU: // closescope
2088923200 {
2089023201 //#define arg0 0
2089123202 //#define arg1 1
2089223203 //#define arg2 2
2089323204 //#define arg3 3
20894- label = 1347LLU; // start to repeat
23205+ label = 1505LLU; // start to repeat
2089523206 break;
2089623207 }
20897- case 1347LLU: // repeat from here
23208+ case 1505LLU: // repeat from here
2089823209 {
2089923210 if(!stack[base + 2])
2090023211 {
20901- label = 1348LLU; // break loop
23212+ label = 1506LLU; // break loop
2090223213 break;
2090323214 }
2090423215
@@ -20911,7 +23222,7 @@
2091123222 }
2091223223 if(/*letdef*/0 != ((uint64_t *)(stack[base + 4]/*letdef*/))[0])
2091323224 {
20914- label = 1350LLU; // jump to alternative
23225+ label = 1508LLU; // jump to alternative
2091523226 break;
2091623227 }
2091723228
@@ -20932,7 +23243,7 @@
2093223243 // call calldestr from closescope
2093323244 newstack[0] = (uint64_t)stack; // backup stack location
2093423245 newstack[1] = base;
20935- newstack[2] = 1351LLU;
23246+ newstack[2] = 1509LLU;
2093623247 // arguments for call to calldestr
2093723248 newstack[3LLU] = stack[base + 0]/*fnid*/;
2093823249 newstack[4LLU] = stack[base + 1]/*typedefs*/;
@@ -20946,7 +23257,7 @@
2094623257 label = 501LLU; // calldestr
2094723258 break;
2094823259 }
20949- case 1351LLU: // return from calldestr to closescope
23260+ case 1509LLU: // return from calldestr to closescope
2095023261 {
2095123262 uint64_t *oldstack = (uint64_t *)stack[0];
2095223263 // copy mutable arguments back from call to calldestr
@@ -20963,15 +23274,15 @@
2096323274 ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 7];
2096423275 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 6];
2096523276 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 5];
20966- label = 1349LLU; // case complete
23277+ label = 1507LLU; // case complete
2096723278 break;
2096823279 }
20969- case 1350LLU: // try next case
23280+ case 1508LLU: // try next case
2097023281 {
2097123282 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2097223283 exit(-1);
2097323284 }
20974- case 1349LLU: // completed switch
23285+ case 1507LLU: // completed switch
2097523286 {
2097623287
2097723288 uint64_t *newstack = (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 3);
@@ -20978,7 +23289,7 @@
2097823289 // call ~letdef from closescope
2097923290 newstack[0] = (uint64_t)stack; // backup stack location
2098023291 newstack[1] = base;
20981- newstack[2] = 1352LLU;
23292+ newstack[2] = 1510LLU;
2098223293 stack = newstack;
2098323294 // set stack-base & callee-address
2098423295 base = 3;
@@ -20985,16 +23296,16 @@
2098523296 label = 229LLU; // ~letdef
2098623297 break;
2098723298 }
20988- case 1352LLU: // return from ~letdef to closescope
23299+ case 1510LLU: // return from ~letdef to closescope
2098923300 {
2099023301 stack = (uint64_t *)stack[0];
2099123302 // releasing toplevel container
2099223303 Free(2 + 3, sizeof(uint64_t), (uint64_t *)(stack[base + 4] - sizeof(uint64_t) * 3));
2099323304
20994- label = 1347LLU; // repeat
23305+ label = 1505LLU; // repeat
2099523306 break;
2099623307 }
20997- case 1348LLU: // loop finished
23308+ case 1506LLU: // loop finished
2099823309 {
2099923310 // return from closescope
2100023311 label = stack[base - 1];
@@ -21001,7 +23312,7 @@
2100123312 base = stack[base - 2];
2100223313 break;
2100323314 }
21004- case 1353LLU: // verbatim
23315+ case 1511LLU: // verbatim
2100523316 {
2100623317 //#define arg0 0
2100723318
@@ -21020,14 +23331,14 @@
2102023331 }
2102123332
2102223333 printf("%s", "\n");
21023- label = 1354LLU; // start to repeat
23334+ label = 1512LLU; // start to repeat
2102423335 break;
2102523336 }
21026- case 1354LLU: // repeat from here
23337+ case 1512LLU: // repeat from here
2102723338 {
2102823339 if(stack[base + 0]/*lookahead*/ > 0xFF)
2102923340 {
21030- label = 1355LLU; // break loop
23341+ label = 1513LLU; // break loop
2103123342 break;
2103223343 }
2103323344
@@ -21034,7 +23345,7 @@
2103423345 // loop body
2103523346 // call equ from verbatim
2103623347 stack[base + 2LLU] = base;
21037- stack[base + 3LLU] = 1356LLU;
23348+ stack[base + 3LLU] = 1514LLU;
2103823349 // arguments for call to equ
2103923350 stack[base + 5LLU] = stack[base + 0]/*lookahead*/;
2104023351 stack[base + 6LLU] = 96LLU;
@@ -21043,7 +23354,7 @@
2104323354 label = 18446744073709551600LLU; // equ
2104423355 break;
2104523356 }
21046- case 1356LLU: // return from equ to verbatim
23357+ case 1514LLU: // return from equ to verbatim
2104723358 {
2104823359 // copy mutable arguments back from call to equ
2104923360 // copy back results provided by call to equ
@@ -21050,7 +23361,7 @@
2105023361 stack[base + 1] = stack[base + 4LLU];
2105123362 if(!stack[base + 1]/*isequal*/)
2105223363 {
21053- label = 1357LLU; // jump to alternative
23364+ label = 1515LLU; // jump to alternative
2105423365 break;
2105523366 }
2105623367
@@ -21057,7 +23368,7 @@
2105723368 // consequent
2105823369 // call EOSbyte from verbatim
2105923370 stack[base + 2LLU] = base;
21060- stack[base + 3LLU] = 1359LLU;
23371+ stack[base + 3LLU] = 1517LLU;
2106123372 // arguments for call to EOSbyte
2106223373 // set stack-base & callee-address
2106323374 base += 4LLU;
@@ -21064,19 +23375,19 @@
2106423375 label = 35LLU; // EOSbyte
2106523376 break;
2106623377 }
21067- case 1359LLU: // return from EOSbyte to verbatim
23378+ case 1517LLU: // return from EOSbyte to verbatim
2106823379 {
2106923380 // copy mutable arguments back from call to EOSbyte
2107023381 // copy back results provided by call to EOSbyte
2107123382 stack[base + 0] = stack[base + 4LLU];
21072- label = 1358LLU; // consequent complete
23383+ label = 1516LLU; // consequent complete
2107323384 break;
2107423385 }
21075- case 1357LLU: // alternative
23386+ case 1515LLU: // alternative
2107623387 {
2107723388 // call printbyte from verbatim
2107823389 stack[base + 2LLU] = base;
21079- stack[base + 3LLU] = 1360LLU;
23390+ stack[base + 3LLU] = 1518LLU;
2108023391 // arguments for call to printbyte
2108123392 stack[base + 4LLU] = stack[base + 0]/*lookahead*/;
2108223393 // set stack-base & callee-address
@@ -21084,19 +23395,19 @@
2108423395 label = 18446744073709551592LLU; // printbyte
2108523396 break;
2108623397 }
21087- case 1360LLU: // return from printbyte to verbatim
23398+ case 1518LLU: // return from printbyte to verbatim
2108823399 {
2108923400 // copy mutable arguments back from call to printbyte
21090- label = 1358LLU; // alternative complete
23401+ label = 1516LLU; // alternative complete
2109123402 break;
2109223403 }
21093- case 1358LLU: // completed if-then-else
23404+ case 1516LLU: // completed if-then-else
2109423405 {
2109523406 if(stack[base + 0]/*lookahead*/ <= 0xFF) stack[base + 0]/*lookahead*/ = getchar();
21096- label = 1354LLU; // repeat
23407+ label = 1512LLU; // repeat
2109723408 break;
2109823409 }
21099- case 1355LLU: // loop finished
23410+ case 1513LLU: // loop finished
2110023411 {
2110123412 stack[base + 0]/*lookahead*/ = 32;
2110223413 // return from verbatim
@@ -21104,7 +23415,7 @@
2110423415 base = stack[base - 2];
2110523416 break;
2110623417 }
21107- case 1361LLU: // procblock
23418+ case 1519LLU: // procblock
2110823419 {
2110923420 //#define arg0 0
2111023421 //#define arg1 1
@@ -21138,14 +23449,14 @@
2113823449 stack[base + 2]/*scopes*/ = (uint64_t)list;
2113923450 MOVE(&list->data, &stack[base + 19]/*newscope*/);
2114023451 }
21141- label = 1362LLU; // start to repeat
23452+ label = 1520LLU; // start to repeat
2114223453 break;
2114323454 }
21144- case 1362LLU: // repeat from here
23455+ case 1520LLU: // repeat from here
2114523456 {
2114623457 if(stack[base + 18]/*lookahead*/ > 0xFF)
2114723458 {
21148- label = 1363LLU; // break loop
23459+ label = 1521LLU; // break loop
2114923460 break;
2115023461 }
2115123462
@@ -21152,7 +23463,7 @@
2115223463 // loop body
2115323464 // call skipwscmnt from procblock
2115423465 stack[base + 19LLU] = base;
21155- stack[base + 20LLU] = 1364LLU;
23466+ stack[base + 20LLU] = 1522LLU;
2115623467 // arguments for call to skipwscmnt
2115723468 stack[base + 22LLU] = stack[base + 18]/*lookahead*/;
2115823469 // set stack-base & callee-address
@@ -21160,7 +23471,7 @@
2116023471 label = 18446744073709551580LLU; // skipwscmnt
2116123472 break;
2116223473 }
21163- case 1364LLU: // return from skipwscmnt to procblock
23474+ case 1522LLU: // return from skipwscmnt to procblock
2116423475 {
2116523476 // copy mutable arguments back from call to skipwscmnt
2116623477 // copy back results provided by call to skipwscmnt
@@ -21168,7 +23479,7 @@
2116823479 stack[base + 19] = 0;
2116923480 // call equ from procblock
2117023481 stack[base + 20LLU] = base;
21171- stack[base + 21LLU] = 1365LLU;
23482+ stack[base + 21LLU] = 1523LLU;
2117223483 // arguments for call to equ
2117323484 stack[base + 23LLU] = stack[base + 18]/*lookahead*/;
2117423485 stack[base + 24LLU] = 125LLU;
@@ -21177,7 +23488,7 @@
2117723488 label = 18446744073709551600LLU; // equ
2117823489 break;
2117923490 }
21180- case 1365LLU: // return from equ to procblock
23491+ case 1523LLU: // return from equ to procblock
2118123492 {
2118223493 // copy mutable arguments back from call to equ
2118323494 // copy back results provided by call to equ
@@ -21184,7 +23495,7 @@
2118423495 stack[base + 19] = stack[base + 22LLU];
2118523496 if(!stack[base + 19]/*isequal*/)
2118623497 {
21187- label = 1366LLU; // jump to alternative
23498+ label = 1524LLU; // jump to alternative
2118823499 break;
2118923500 }
2119023501
@@ -21191,7 +23502,7 @@
2119123502 // consequent
2119223503 if(!stack[base + 4]/*blkresults*/)
2119323504 {
21194- label = 1368LLU; // jump to alternative
23505+ label = 1526LLU; // jump to alternative
2119523506 break;
2119623507 }
2119723508
@@ -21199,7 +23510,7 @@
2119923510 fprintf(stderr, "%s", "in function ");
2120023511 // call reportid from procblock
2120123512 stack[base + 20LLU] = base;
21202- stack[base + 21LLU] = 1370LLU;
23513+ stack[base + 21LLU] = 1528LLU;
2120323514 // arguments for call to reportid
2120423515 stack[base + 22LLU] = stack[base + 7]/*fnid*/;
2120523516 // set stack-base & callee-address
@@ -21207,24 +23518,24 @@
2120723518 label = 18446744073709551586LLU; // reportid
2120823519 break;
2120923520 }
21210- case 1370LLU: // return from reportid to procblock
23521+ case 1528LLU: // return from reportid to procblock
2121123522 {
2121223523 // copy mutable arguments back from call to reportid
2121323524 fprintf(stderr, "%s", ": missing return\n");
2121423525 exit(-1);
21215- label = 1369LLU; // consequent complete
23526+ label = 1527LLU; // consequent complete
2121623527 break;
2121723528 }
21218- case 1368LLU: // alternative
23529+ case 1526LLU: // alternative
2121923530 {
21220- label = 1369LLU; // alternative complete
23531+ label = 1527LLU; // alternative complete
2122123532 break;
2122223533 }
21223- case 1369LLU: // completed if-then-else
23534+ case 1527LLU: // completed if-then-else
2122423535 {
2122523536 // call EOSbyte from procblock
2122623537 stack[base + 20LLU] = base;
21227- stack[base + 21LLU] = 1371LLU;
23538+ stack[base + 21LLU] = 1529LLU;
2122823539 // arguments for call to EOSbyte
2122923540 // set stack-base & callee-address
2123023541 base += 22LLU;
@@ -21231,19 +23542,19 @@
2123123542 label = 35LLU; // EOSbyte
2123223543 break;
2123323544 }
21234- case 1371LLU: // return from EOSbyte to procblock
23545+ case 1529LLU: // return from EOSbyte to procblock
2123523546 {
2123623547 // copy mutable arguments back from call to EOSbyte
2123723548 // copy back results provided by call to EOSbyte
2123823549 stack[base + 18] = stack[base + 22LLU];
21239- label = 1367LLU; // consequent complete
23550+ label = 1525LLU; // consequent complete
2124023551 break;
2124123552 }
21242- case 1366LLU: // alternative
23553+ case 1524LLU: // alternative
2124323554 {
2124423555 // call ParseToken from procblock
2124523556 stack[base + 20LLU] = base;
21246- stack[base + 21LLU] = 1372LLU;
23557+ stack[base + 21LLU] = 1530LLU;
2124723558 // arguments for call to ParseToken
2124823559 stack[base + 24LLU] = stack[base + 18]/*lookahead*/;
2124923560 // set stack-base & callee-address
@@ -21251,7 +23562,7 @@
2125123562 label = 2LLU; // ParseToken
2125223563 break;
2125323564 }
21254- case 1372LLU: // return from ParseToken to procblock
23565+ case 1530LLU: // return from ParseToken to procblock
2125523566 {
2125623567 // copy mutable arguments back from call to ParseToken
2125723568 stack[base + 18]/*lookahead*/ = stack[base + 24LLU];
@@ -21260,7 +23571,7 @@
2126023571 stack[base + 15] = stack[base + 23LLU];
2126123572 // call equ from procblock
2126223573 stack[base + 20LLU] = base;
21263- stack[base + 21LLU] = 1373LLU;
23574+ stack[base + 21LLU] = 1531LLU;
2126423575 // arguments for call to equ
2126523576 stack[base + 23LLU] = stack[base + 14]/*variant*/;
2126623577 stack[base + 24LLU] = 0LLU;
@@ -21269,7 +23580,7 @@
2126923580 label = 18446744073709551600LLU; // equ
2127023581 break;
2127123582 }
21272- case 1373LLU: // return from equ to procblock
23583+ case 1531LLU: // return from equ to procblock
2127323584 {
2127423585 // copy mutable arguments back from call to equ
2127523586 // copy back results provided by call to equ
@@ -21276,7 +23587,7 @@
2127623587 stack[base + 19] = stack[base + 22LLU];
2127723588 if(!stack[base + 19]/*isequal*/)
2127823589 {
21279- label = 1374LLU; // jump to alternative
23590+ label = 1532LLU; // jump to alternative
2128023591 break;
2128123592 }
2128223593
@@ -21283,7 +23594,7 @@
2128323594 // consequent
2128423595 // call equ from procblock
2128523596 stack[base + 20LLU] = base;
21286- stack[base + 21LLU] = 1376LLU;
23597+ stack[base + 21LLU] = 1534LLU;
2128723598 // arguments for call to equ
2128823599 stack[base + 23LLU] = stack[base + 15]/*content*/;
2128923600 stack[base + 24LLU] = 123LLU;
@@ -21292,7 +23603,7 @@
2129223603 label = 18446744073709551600LLU; // equ
2129323604 break;
2129423605 }
21295- case 1376LLU: // return from equ to procblock
23606+ case 1534LLU: // return from equ to procblock
2129623607 {
2129723608 // copy mutable arguments back from call to equ
2129823609 // copy back results provided by call to equ
@@ -21299,7 +23610,7 @@
2129923610 stack[base + 19] = stack[base + 22LLU];
2130023611 if(!stack[base + 19]/*isequal*/)
2130123612 {
21302- label = 1377LLU; // jump to alternative
23613+ label = 1535LLU; // jump to alternative
2130323614 break;
2130423615 }
2130523616
@@ -21315,7 +23626,7 @@
2131523626 // call procblock from procblock
2131623627 newstack[0] = (uint64_t)stack; // backup stack location
2131723628 newstack[1] = base;
21318- newstack[2] = 1379LLU;
23629+ newstack[2] = 1537LLU;
2131923630 // arguments for call to procblock
2132023631 newstack[3LLU] = stack[base + 0]/*fndefs*/;
2132123632 newstack[4LLU] = stack[base + 1]/*typedefs*/;
@@ -21337,10 +23648,10 @@
2133723648 stack = newstack;
2133823649 // set stack-base & callee-address
2133923650 base = 3;
21340- label = 1361LLU; // procblock
23651+ label = 1519LLU; // procblock
2134123652 break;
2134223653 }
21343- case 1379LLU: // return from procblock to procblock
23654+ case 1537LLU: // return from procblock to procblock
2134423655 {
2134523656 uint64_t *oldstack = (uint64_t *)stack[0];
2134623657 // copy mutable arguments back from call to procblock
@@ -21358,14 +23669,14 @@
2135823669 Free(146LLU + 1, sizeof(uint64_t), stack);
2135923670 stack = oldstack;
2136023671 // delete list
21361- label = 1380LLU; // start to repeat
23672+ label = 1538LLU; // start to repeat
2136223673 break;
2136323674 }
21364- case 1380LLU: // repeat from here
23675+ case 1538LLU: // repeat from here
2136523676 {
2136623677 if(!stack[base + 20])
2136723678 {
21368- label = 1381LLU; // break loop
23679+ label = 1539LLU; // break loop
2136923680 break;
2137023681 }
2137123682
@@ -21375,7 +23686,7 @@
2137523686 // call ~typeidx from procblock
2137623687 newstack[0] = (uint64_t)stack; // backup stack location
2137723688 newstack[1] = base;
21378- newstack[2] = 1382LLU;
23689+ newstack[2] = 1540LLU;
2137923690 stack = newstack;
2138023691 // set stack-base & callee-address
2138123692 base = 3;
@@ -21382,7 +23693,7 @@
2138223693 label = 188LLU; // ~typeidx
2138323694 break;
2138423695 }
21385- case 1382LLU: // return from ~typeidx to procblock
23696+ case 1540LLU: // return from ~typeidx to procblock
2138623697 {
2138723698 stack = (uint64_t *)stack[0];
2138823699 // releasing toplevel container
@@ -21393,19 +23704,19 @@
2139323704 stack[base + 20] = (uint64_t)list->next;
2139423705 Free(1, sizeof(struct listnode), list);
2139523706 }
21396- label = 1380LLU; // repeat
23707+ label = 1538LLU; // repeat
2139723708 break;
2139823709 }
21399- case 1381LLU: // loop finished
23710+ case 1539LLU: // loop finished
2140023711 {
21401- label = 1378LLU; // consequent complete
23712+ label = 1536LLU; // consequent complete
2140223713 break;
2140323714 }
21404- case 1377LLU: // alternative
23715+ case 1535LLU: // alternative
2140523716 {
2140623717 // call equ from procblock
2140723718 stack[base + 20LLU] = base;
21408- stack[base + 21LLU] = 1383LLU;
23719+ stack[base + 21LLU] = 1541LLU;
2140923720 // arguments for call to equ
2141023721 stack[base + 23LLU] = stack[base + 15]/*content*/;
2141123722 stack[base + 24LLU] = 96LLU;
@@ -21414,7 +23725,7 @@
2141423725 label = 18446744073709551600LLU; // equ
2141523726 break;
2141623727 }
21417- case 1383LLU: // return from equ to procblock
23728+ case 1541LLU: // return from equ to procblock
2141823729 {
2141923730 // copy mutable arguments back from call to equ
2142023731 // copy back results provided by call to equ
@@ -21421,7 +23732,7 @@
2142123732 stack[base + 19] = stack[base + 22LLU];
2142223733 if(!stack[base + 19]/*isequal*/)
2142323734 {
21424- label = 1384LLU; // jump to alternative
23735+ label = 1542LLU; // jump to alternative
2142523736 break;
2142623737 }
2142723738
@@ -21428,26 +23739,26 @@
2142823739 // consequent
2142923740 // call verbatim from procblock
2143023741 stack[base + 20LLU] = base;
21431- stack[base + 21LLU] = 1386LLU;
23742+ stack[base + 21LLU] = 1544LLU;
2143223743 // arguments for call to verbatim
2143323744 stack[base + 22LLU] = stack[base + 18]/*lookahead*/;
2143423745 // set stack-base & callee-address
2143523746 base += 22LLU;
21436- label = 1353LLU; // verbatim
23747+ label = 1511LLU; // verbatim
2143723748 break;
2143823749 }
21439- case 1386LLU: // return from verbatim to procblock
23750+ case 1544LLU: // return from verbatim to procblock
2144023751 {
2144123752 // copy mutable arguments back from call to verbatim
2144223753 stack[base + 18]/*lookahead*/ = stack[base + 22LLU];
21443- label = 1385LLU; // consequent complete
23754+ label = 1543LLU; // consequent complete
2144423755 break;
2144523756 }
21446- case 1384LLU: // alternative
23757+ case 1542LLU: // alternative
2144723758 {
2144823759 // call equ from procblock
2144923760 stack[base + 20LLU] = base;
21450- stack[base + 21LLU] = 1387LLU;
23761+ stack[base + 21LLU] = 1545LLU;
2145123762 // arguments for call to equ
2145223763 stack[base + 23LLU] = stack[base + 15]/*content*/;
2145323764 stack[base + 24LLU] = 40LLU;
@@ -21456,7 +23767,7 @@
2145623767 label = 18446744073709551600LLU; // equ
2145723768 break;
2145823769 }
21459- case 1387LLU: // return from equ to procblock
23770+ case 1545LLU: // return from equ to procblock
2146023771 {
2146123772 // copy mutable arguments back from call to equ
2146223773 // copy back results provided by call to equ
@@ -21463,7 +23774,7 @@
2146323774 stack[base + 19] = stack[base + 22LLU];
2146423775 if(!stack[base + 19]/*isequal*/)
2146523776 {
21466- label = 1388LLU; // jump to alternative
23777+ label = 1546LLU; // jump to alternative
2146723778 break;
2146823779 }
2146923780
@@ -21470,7 +23781,7 @@
2147023781 // consequent
2147123782 // call PROCCALL from procblock
2147223783 stack[base + 20LLU] = base;
21473- stack[base + 21LLU] = 1390LLU;
23784+ stack[base + 21LLU] = 1548LLU;
2147423785 // arguments for call to PROCCALL
2147523786 stack[base + 22LLU] = stack[base + 0]/*fndefs*/;
2147623787 stack[base + 23LLU] = stack[base + 2]/*scopes*/;
@@ -21489,10 +23800,10 @@
2148923800 stack[base + 36LLU] = stack[base + 16]/*label*/;
2149023801 // set stack-base & callee-address
2149123802 base += 22LLU;
21492- label = 1198LLU; // PROCCALL
23803+ label = 1356LLU; // PROCCALL
2149323804 break;
2149423805 }
21495- case 1390LLU: // return from PROCCALL to procblock
23806+ case 1548LLU: // return from PROCCALL to procblock
2149623807 {
2149723808 // copy mutable arguments back from call to PROCCALL
2149823809 stack[base + 16]/*label*/ = stack[base + 36LLU];
@@ -21502,7 +23813,7 @@
2150223813 stack[base + 11]/*fnmaxcount*/ = stack[base + 32LLU];
2150323814 // call delimiter from procblock
2150423815 stack[base + 20LLU] = base;
21505- stack[base + 21LLU] = 1391LLU;
23816+ stack[base + 21LLU] = 1549LLU;
2150623817 // arguments for call to delimiter
2150723818 stack[base + 22LLU] = stack[base + 7]/*fnid*/;
2150823819 stack[base + 23LLU] = stack[base + 18]/*lookahead*/;
@@ -21511,19 +23822,19 @@
2151123822 label = 11LLU; // delimiter
2151223823 break;
2151323824 }
21514- case 1391LLU: // return from delimiter to procblock
23825+ case 1549LLU: // return from delimiter to procblock
2151523826 {
2151623827 // copy mutable arguments back from call to delimiter
2151723828 stack[base + 18]/*lookahead*/ = stack[base + 23LLU];
21518- label = 1389LLU; // consequent complete
23829+ label = 1547LLU; // consequent complete
2151923830 break;
2152023831 }
21521- case 1388LLU: // alternative
23832+ case 1546LLU: // alternative
2152223833 {
2152323834 fprintf(stderr, "%s", "parsing block unexpected token ");
2152423835 // call reporttok from procblock
2152523836 stack[base + 20LLU] = base;
21526- stack[base + 21LLU] = 1392LLU;
23837+ stack[base + 21LLU] = 1550LLU;
2152723838 // arguments for call to reporttok
2152823839 stack[base + 22LLU] = stack[base + 14]/*variant*/;
2152923840 stack[base + 23LLU] = stack[base + 15]/*content*/;
@@ -21532,34 +23843,34 @@
2153223843 label = 18446744073709551582LLU; // reporttok
2153323844 break;
2153423845 }
21535- case 1392LLU: // return from reporttok to procblock
23846+ case 1550LLU: // return from reporttok to procblock
2153623847 {
2153723848 // copy mutable arguments back from call to reporttok
2153823849 fprintf(stderr, "%s", "\n");
2153923850 exit(-1);
21540- label = 1389LLU; // alternative complete
23851+ label = 1547LLU; // alternative complete
2154123852 break;
2154223853 }
21543- case 1389LLU: // completed if-then-else
23854+ case 1547LLU: // completed if-then-else
2154423855 {
21545- label = 1385LLU; // alternative complete
23856+ label = 1543LLU; // alternative complete
2154623857 break;
2154723858 }
21548- case 1385LLU: // completed if-then-else
23859+ case 1543LLU: // completed if-then-else
2154923860 {
21550- label = 1378LLU; // alternative complete
23861+ label = 1536LLU; // alternative complete
2155123862 break;
2155223863 }
21553- case 1378LLU: // completed if-then-else
23864+ case 1536LLU: // completed if-then-else
2155423865 {
21555- label = 1375LLU; // consequent complete
23866+ label = 1533LLU; // consequent complete
2155623867 break;
2155723868 }
21558- case 1374LLU: // alternative
23869+ case 1532LLU: // alternative
2155923870 {
2156023871 // call equ from procblock
2156123872 stack[base + 20LLU] = base;
21562- stack[base + 21LLU] = 1393LLU;
23873+ stack[base + 21LLU] = 1551LLU;
2156323874 // arguments for call to equ
2156423875 stack[base + 23LLU] = stack[base + 14]/*variant*/;
2156523876 stack[base + 24LLU] = 4LLU;
@@ -21568,7 +23879,7 @@
2156823879 label = 18446744073709551600LLU; // equ
2156923880 break;
2157023881 }
21571- case 1393LLU: // return from equ to procblock
23882+ case 1551LLU: // return from equ to procblock
2157223883 {
2157323884 // copy mutable arguments back from call to equ
2157423885 // copy back results provided by call to equ
@@ -21575,7 +23886,7 @@
2157523886 stack[base + 19] = stack[base + 22LLU];
2157623887 if(!stack[base + 19]/*isequal*/)
2157723888 {
21578- label = 1394LLU; // jump to alternative
23889+ label = 1552LLU; // jump to alternative
2157923890 break;
2158023891 }
2158123892
@@ -21582,7 +23893,7 @@
2158223893 // consequent
2158323894 // call equ from procblock
2158423895 stack[base + 21LLU] = base;
21585- stack[base + 22LLU] = 1396LLU;
23896+ stack[base + 22LLU] = 1554LLU;
2158623897 // arguments for call to equ
2158723898 stack[base + 24LLU] = stack[base + 15]/*content*/;
2158823899 stack[base + 25LLU] = 819865187908583424LLU;
@@ -21591,7 +23902,7 @@
2159123902 label = 18446744073709551600LLU; // equ
2159223903 break;
2159323904 }
21594- case 1396LLU: // return from equ to procblock
23905+ case 1554LLU: // return from equ to procblock
2159523906 {
2159623907 // copy mutable arguments back from call to equ
2159723908 // copy back results provided by call to equ
@@ -21598,7 +23909,7 @@
2159823909 stack[base + 20] = stack[base + 23LLU];
2159923910 if(!stack[base + 20]/*returnflag*/)
2160023911 {
21601- label = 1397LLU; // jump to alternative
23912+ label = 1555LLU; // jump to alternative
2160223913 break;
2160323914 }
2160423915
@@ -21605,7 +23916,7 @@
2160523916 // consequent
2160623917 // call ParseToken from procblock
2160723918 stack[base + 21LLU] = base;
21608- stack[base + 22LLU] = 1399LLU;
23919+ stack[base + 22LLU] = 1557LLU;
2160923920 // arguments for call to ParseToken
2161023921 stack[base + 25LLU] = stack[base + 18]/*lookahead*/;
2161123922 // set stack-base & callee-address
@@ -21613,7 +23924,7 @@
2161323924 label = 2LLU; // ParseToken
2161423925 break;
2161523926 }
21616- case 1399LLU: // return from ParseToken to procblock
23927+ case 1557LLU: //

Part of diff was cut off due to size limit. Use your local client to view the full diff.

Show on old repository browser