OSDN > ソフトウェアを探す > ソフトウェア開発 > コンパイラ > JPL > SCM > SVN > コミット

JPL

R/O
SSH
HTTPS

jpl: コミット

コミットメタ情報

リビジョン	243 (tree)
日時	2018-10-15 09:09:56
作者	jakobthomsen

ログメッセージ

fix match-result

変更サマリ

modified: trunk/experimental/compiler.compiled.c (diff)
modified: trunk/experimental/compiler.source.c (diff)
modified: trunk/experimental/unit_tests/unit_test_list_head_union.c (diff)
modified: trunk/experimental/unit_tests/unit_test_list_head_union.txt (diff)

差分

--- trunk/experimental/compiler.compiled.c (revision 242)

+++ trunk/experimental/compiler.compiled.c (revision 243)

		@@ -11820,198 +11820,395 @@
11820	11820	/* SP = 23LLU */
11821	11821	{
11822	11822	/* CALLBEGIN */
11823		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
11824		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
11825		- /* leave place for return addr // SP + 1LLU = 25LLU */
	11823	+ /* reserve space for 1LLU returned values // SP + 1LLU = 24LLU */
	11824	+{ /* PUSH / stack[stackbase + 24LLU] = stackbase; }/ SP + 1LLU = 25LLU */
	11825	+ /* leave place for return addr // SP + 1LLU = 26LLU */
11826	11826	}
11827		-{ /* PUSH / stack[stackbase + 25LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ SP + 1LLU = 26LLU */
	11827	+{ /* PUSH / stack[stackbase + 26LLU] = / LOCAL VAR / stack[stackbase + 1LLU]; }/ SP + 1LLU = 27LLU */
	11828	+{ /* PUSH / stack[stackbase + 27LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 28LLU */
11828	11829	{
11829	11830	/CALLEND/
11830		- stackbase += 25LLU;
	11831	+ stackbase += 26LLU;
11831	11832	stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD5LLU;
11832		- fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
11833		-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
	11833	+ fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
	11834	+if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
11834	11835	break;
11835	11836	}
11836	11837	case 0xFFFFFFFFFFFFFCD5LLU:
11837		-/* SP = 23LLU */
	11838	+/* SP = 24LLU */
11838	11839	{
11839	11840	/* CALLBEGIN */
11840		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
11841		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
11842		- /* leave place for return addr // SP + 1LLU = 25LLU */
	11841	+ /* reserve space for 0LLU returned values // SP + 0LLU = 24LLU */
	11842	+{ /* PUSH / stack[stackbase + 24LLU] = stackbase; }/ SP + 1LLU = 25LLU */
	11843	+ /* leave place for return addr // SP + 1LLU = 26LLU */
11843	11844	}
11844		-{ /* PUSH / stack[stackbase + 25LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP + 1LLU = 26LLU */
	11845	+{ /* PUSH / stack[stackbase + 26LLU] = / LOCAL VAR / stack[stackbase + 23LLU]; }/ SP + 1LLU = 27LLU */
11845	11846	{
11846	11847	/CALLEND/
11847		- stackbase += 25LLU;
	11848	+ stackbase += 26LLU;
11848	11849	stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD4LLU;
11849		- fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
11850		-if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
	11850	+ fnaddr = /SP_SUB____/0x4D00135420000000LLU;/* SP = 0LLU */
	11851	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SUB____/\n"); exit(-1); }
11851	11852	break;
11852	11853	}
11853	11854	case 0xFFFFFFFFFFFFFCD4LLU:
11854		-/* SP = 23LLU /fputs(" / skip other */", stdout); fputs("\ncase ", stdout);
	11855	+/* SP = 24LLU */
	11856	+{ /* PUSH / stack[stackbase + 24LLU] = 0LLU; }/ SP + 1LLU = 25LLU */
	11857	+case 0xFFFFFFFFFFFFFCD3LLU: /* loop to here // predicate */
	11858	+
11855	11859	{
11856	11860	/* CALLBEGIN */
11857		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
11858		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
11859		- /* leave place for return addr // SP + 1LLU = 25LLU */
	11861	+ /* reserve space for 1LLU returned values // SP + 1LLU = 26LLU */
	11862	+{ /* PUSH / stack[stackbase + 26LLU] = stackbase; }/ SP + 1LLU = 27LLU */
	11863	+ /* leave place for return addr // SP + 1LLU = 28LLU */
11860	11864	}
	11865	+{ /* PUSH / stack[stackbase + 28LLU] = / LOCAL VAR / stack[stackbase + 24LLU]; }/ SP + 1LLU = 29LLU */
	11866	+{ /* PUSH / stack[stackbase + 29LLU] = / LOCAL VAR / stack[stackbase + 23LLU]; }/ SP + 1LLU = 30LLU */
11861	11867	{
	11868	+ /CALLEND/
	11869	+ stackbase += 28LLU;
	11870	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD1LLU;
	11871	+ fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
	11872	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
	11873	+ break;
	11874	+ }
	11875	+case 0xFFFFFFFFFFFFFCD1LLU:
	11876	+/* SP = 26LLU */
	11877	+if(!/* SP - 1LLU = 25LLU */stack[stackbase + 25LLU])
	11878	+{ /* JUMP / fnaddr = 18446744073709550802LLU; break; } / skip loop */
	11879	+/* loop /fputs("\n{ / MATCH-RESULT */", stdout);
	11880	+ {
11862	11881	/* CALLBEGIN */
	11882	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	11883	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	11884	+ /* leave place for return addr // SP + 1LLU = 27LLU */
	11885	+ }
	11886	+ {
	11887	+ /* CALLBEGIN */
	11888	+ /* reserve space for 1LLU returned values // SP + 1LLU = 28LLU */
	11889	+{ /* PUSH / stack[stackbase + 28LLU] = stackbase; }/ SP + 1LLU = 29LLU */
	11890	+ /* leave place for return addr // SP + 1LLU = 30LLU */
	11891	+ }
	11892	+{ /* PUSH / stack[stackbase + 30LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ SP + 1LLU = 31LLU */
	11893	+{ /* PUSH / stack[stackbase + 31LLU] = / LOCAL VAR / stack[stackbase + 24LLU]; }/ SP + 1LLU = 32LLU // SPMAX = 32LLU */
	11894	+ {
	11895	+ /CALLEND/
	11896	+ stackbase += 30LLU;
	11897	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD0LLU;
	11898	+ fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
	11899	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
	11900	+ break;
	11901	+ }
	11902	+case 0xFFFFFFFFFFFFFCD0LLU:
	11903	+/* SP = 28LLU */
	11904	+ {
	11905	+ /CALLEND/
	11906	+ stackbase += 27LLU;
	11907	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCFLLU;
	11908	+ fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
	11909	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
	11910	+ break;
	11911	+ }
	11912	+case 0xFFFFFFFFFFFFFCCFLLU:
	11913	+/* SP = 25LLU */fputs(" = ", stdout);
	11914	+ {
	11915	+ /* CALLBEGIN */
	11916	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	11917	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	11918	+ /* leave place for return addr // SP + 1LLU = 27LLU */
	11919	+ }
	11920	+ {
	11921	+ /* CALLBEGIN */
	11922	+ /* reserve space for 1LLU returned values // SP + 1LLU = 28LLU */
	11923	+{ /* PUSH / stack[stackbase + 28LLU] = stackbase; }/ SP + 1LLU = 29LLU */
	11924	+ /* leave place for return addr // SP + 1LLU = 30LLU */
	11925	+ }
	11926	+ {
	11927	+ /* CALLBEGIN */
	11928	+ /* reserve space for 1LLU returned values // SP + 1LLU = 31LLU */
	11929	+{ /* PUSH / stack[stackbase + 31LLU] = stackbase; }/ SP + 1LLU = 32LLU */
	11930	+ /* leave place for return addr // SP + 1LLU = 33LLU // SPMAX = 33LLU */
	11931	+ }
	11932	+ {
	11933	+ /CALLEND/
	11934	+ stackbase += 33LLU;
	11935	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCELLU;
	11936	+ fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
	11937	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
	11938	+ break;
	11939	+ }
	11940	+case 0xFFFFFFFFFFFFFCCELLU:
	11941	+/* SP = 31LLU */
	11942	+{ /* PUSH / stack[stackbase + 31LLU] = / LOCAL VAR / stack[stackbase + 24LLU]; }/ SP + 1LLU = 32LLU */
	11943	+ {
	11944	+ /CALLEND/
	11945	+ stackbase += 30LLU;
	11946	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCDLLU;
	11947	+ fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
	11948	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
	11949	+ break;
	11950	+ }
	11951	+case 0xFFFFFFFFFFFFFCCDLLU:
	11952	+/* SP = 28LLU */
	11953	+ {
	11954	+ /CALLEND/
	11955	+ stackbase += 27LLU;
	11956	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCCLLU;
	11957	+ fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
	11958	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
	11959	+ break;
	11960	+ }
	11961	+case 0xFFFFFFFFFFFFFCCCLLU:
	11962	+/* SP = 25LLU */fputs("; }", stdout);
	11963	+ {
	11964	+ /* CALLBEGIN */
11863	11965	/* reserve space for 1LLU returned values // SP + 1LLU = 26LLU */
11864	11966	{ /* PUSH / stack[stackbase + 26LLU] = stackbase; }/ SP + 1LLU = 27LLU */
11865	11967	/* leave place for return addr // SP + 1LLU = 28LLU */
11866	11968	}
11867		-{ /* PUSH / stack[stackbase + 28LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP + 1LLU = 29LLU */
	11969	+{ /* PUSH / stack[stackbase + 28LLU] = / LOCAL VAR / stack[stackbase + 24LLU]; }/ SP + 1LLU = 29LLU */
11868	11970	{ /* PUSH / stack[stackbase + 29LLU] = 1LLU; }/ SP + 1LLU = 30LLU */
11869	11971	{
11870	11972	/CALLEND/
11871	11973	stackbase += 28LLU;
11872		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD3LLU;
	11974	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCBLLU;
11873	11975	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
11874	11976	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
11875	11977	break;
11876	11978	}
11877		-case 0xFFFFFFFFFFFFFCD3LLU:
11878		-/* SP = 26LLU */
	11979	+case 0xFFFFFFFFFFFFFCCBLLU:
	11980	+/* SP = 26LLU // SP = 25LLU */
	11981	+{ /* assign / / LOCAL VAR / stack[stackbase + 24LLU] = / LOCAL VAR / stack[stackbase + 25LLU]; }/ SP = 25LLU */
	11982	+{ /* JUMP / fnaddr = 18446744073709550803LLU; break; } / loop */
	11983	+case 18446744073709550802LLU: /* skip to here */
11879	11984	{
	11985	+ /* CALLBEGIN */
	11986	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	11987	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	11988	+ /* leave place for return addr // SP + 1LLU = 27LLU */
	11989	+ }
	11990	+ {
	11991	+ /* CALLBEGIN */
	11992	+ /* reserve space for 1LLU returned values // SP + 1LLU = 28LLU */
	11993	+{ /* PUSH / stack[stackbase + 28LLU] = stackbase; }/ SP + 1LLU = 29LLU */
	11994	+ /* leave place for return addr // SP + 1LLU = 30LLU */
	11995	+ }
	11996	+{ /* PUSH / stack[stackbase + 30LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ SP + 1LLU = 31LLU */
	11997	+{ /* PUSH / stack[stackbase + 31LLU] = / LOCAL VAR / stack[stackbase + 23LLU]; }/ SP + 1LLU = 32LLU */
	11998	+ {
11880	11999	/CALLEND/
11881		- stackbase += 25LLU;
11882		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD2LLU;
	12000	+ stackbase += 30LLU;
	12001	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCALLU;
	12002	+ fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
	12003	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
	12004	+ break;
	12005	+ }
	12006	+case 0xFFFFFFFFFFFFFCCALLU:
	12007	+/* SP = 28LLU */
	12008	+ {
	12009	+ /CALLEND/
	12010	+ stackbase += 27LLU;
	12011	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC9LLU;
	12012	+ fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
	12013	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
	12014	+ break;
	12015	+ }
	12016	+case 0xFFFFFFFFFFFFFCC9LLU:
	12017	+/* SP = 25LLU */
	12018	+ {
	12019	+ /* CALLBEGIN */
	12020	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12021	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12022	+ /* leave place for return addr // SP + 1LLU = 27LLU */
	12023	+ }
	12024	+{ /* PUSH / stack[stackbase + 27LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP + 1LLU = 28LLU */
	12025	+ {
	12026	+ /CALLEND/
	12027	+ stackbase += 27LLU;
	12028	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC8LLU;
	12029	+ fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
	12030	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
	12031	+ break;
	12032	+ }
	12033	+case 0xFFFFFFFFFFFFFCC8LLU:
	12034	+/* SP = 25LLU /fputs(" / skip other */", stdout); fputs("\ncase ", stdout);
	12035	+ {
	12036	+ /* CALLBEGIN */
	12037	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12038	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12039	+ /* leave place for return addr // SP + 1LLU = 27LLU */
	12040	+ }
	12041	+ {
	12042	+ /* CALLBEGIN */
	12043	+ /* reserve space for 1LLU returned values // SP + 1LLU = 28LLU */
	12044	+{ /* PUSH / stack[stackbase + 28LLU] = stackbase; }/ SP + 1LLU = 29LLU */
	12045	+ /* leave place for return addr // SP + 1LLU = 30LLU */
	12046	+ }
	12047	+{ /* PUSH / stack[stackbase + 30LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP + 1LLU = 31LLU */
	12048	+{ /* PUSH / stack[stackbase + 31LLU] = 1LLU; }/ SP + 1LLU = 32LLU */
	12049	+ {
	12050	+ /CALLEND/
	12051	+ stackbase += 30LLU;
	12052	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC7LLU;
	12053	+ fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
	12054	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
	12055	+ break;
	12056	+ }
	12057	+case 0xFFFFFFFFFFFFFCC7LLU:
	12058	+/* SP = 28LLU */
	12059	+ {
	12060	+ /CALLEND/
	12061	+ stackbase += 27LLU;
	12062	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC6LLU;
11883	12063	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
11884	12064	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
11885	12065	break;
11886	12066	}
11887		-case 0xFFFFFFFFFFFFFCD2LLU:
11888		-/* SP = 23LLU /fputs(": / other */", stdout);
	12067	+case 0xFFFFFFFFFFFFFCC6LLU:
	12068	+/* SP = 25LLU /fputs(": / other */", stdout);
11889	12069	{
11890	12070	/* CALLBEGIN */
11891		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
11892		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
11893		- /* leave place for return addr // SP + 1LLU = 25LLU */
	12071	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12072	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12073	+ /* leave place for return addr // SP + 1LLU = 27LLU */
11894	12074	}
11895	12075	{
11896	12076	/CALLEND/
11897		- stackbase += 25LLU;
11898		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD1LLU;
	12077	+ stackbase += 27LLU;
	12078	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC5LLU;
11899	12079	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11900	12080	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
11901	12081	break;
11902	12082	}
11903		-case 0xFFFFFFFFFFFFFCD1LLU:
11904		-/* SP = 23LLU // predicate */
	12083	+case 0xFFFFFFFFFFFFFCC5LLU:
	12084	+/* SP = 25LLU // predicate */
11905	12085
11906	12086	{
11907	12087	/* CALLBEGIN */
11908		- /* reserve space for 1LLU returned values // SP + 1LLU = 24LLU */
11909		-{ /* PUSH / stack[stackbase + 24LLU] = stackbase; }/ SP + 1LLU = 25LLU */
11910		- /* leave place for return addr // SP + 1LLU = 26LLU */
	12088	+ /* reserve space for 1LLU returned values // SP + 1LLU = 26LLU */
	12089	+{ /* PUSH / stack[stackbase + 26LLU] = stackbase; }/ SP + 1LLU = 27LLU */
	12090	+ /* leave place for return addr // SP + 1LLU = 28LLU */
11911	12091	}
11912		-{ /* PUSH / stack[stackbase + 26LLU] = 12319843844370726912LLU; }/ SP + 1LLU = 27LLU */
	12092	+{ /* PUSH / stack[stackbase + 28LLU] = 12319843844370726912LLU; }/ SP + 1LLU = 29LLU */
11913	12093	{
11914	12094	/CALLEND/
11915		- stackbase += 26LLU;
11916		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCELLU;
	12095	+ stackbase += 28LLU;
	12096	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC2LLU;
11917	12097	fnaddr = /matchoptid/0xA1CBDE8EAAEF91F0LLU;/* SP = 0LLU */
11918	12098	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchoptid/\n"); exit(-1); }
11919	12099	break;
11920	12100	}
11921		-case 0xFFFFFFFFFFFFFCCELLU:
11922		-/* SP = 24LLU */
11923		-if(!/* SP - 1LLU = 23LLU */stack[stackbase + 23LLU])
11924		-{ /* JUMP / fnaddr = 18446744073709550800LLU; break; } / skip consequent */
	12101	+case 0xFFFFFFFFFFFFFCC2LLU:
	12102	+/* SP = 26LLU */
	12103	+if(!/* SP - 1LLU = 25LLU */stack[stackbase + 25LLU])
	12104	+{ /* JUMP / fnaddr = 18446744073709550788LLU; break; } / skip consequent */
11925	12105	/* consequent */
11926	12106	{
11927	12107	/* CALLBEGIN */
11928		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
11929		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
11930		- /* leave place for return addr // SP + 1LLU = 25LLU */
	12108	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12109	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12110	+ /* leave place for return addr // SP + 1LLU = 27LLU */
11931	12111	}
	12112	+{ /* PUSH / stack[stackbase + 27LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ SP + 1LLU = 28LLU */
11932	12113	{
11933	12114	/CALLEND/
11934		- stackbase += 25LLU;
11935		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCDLLU;
	12115	+ stackbase += 27LLU;
	12116	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC1LLU;
	12117	+ fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
	12118	+if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
	12119	+ break;
	12120	+ }
	12121	+case 0xFFFFFFFFFFFFFCC1LLU:
	12122	+/* SP = 25LLU */
	12123	+ {
	12124	+ /* CALLBEGIN */
	12125	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12126	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12127	+ /* leave place for return addr // SP + 1LLU = 27LLU */
	12128	+ }
	12129	+ {
	12130	+ /CALLEND/
	12131	+ stackbase += 27LLU;
	12132	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC0LLU;
11936	12133	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11937	12134	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
11938	12135	break;
11939	12136	}
11940		-case 0xFFFFFFFFFFFFFCCDLLU:
11941		-/* SP = 23LLU */
	12137	+case 0xFFFFFFFFFFFFFCC0LLU:
	12138	+/* SP = 25LLU */
11942	12139	{
11943	12140	/* CALLBEGIN */
11944		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
11945		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
11946		- /* leave place for return addr // SP + 1LLU = 25LLU */
	12141	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12142	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12143	+ /* leave place for return addr // SP + 1LLU = 27LLU */
11947	12144	}
11948		-{ /* PUSH / stack[stackbase + 25LLU] = 0LLU; }/ SP + 1LLU = 26LLU */
11949		-{ /* PUSH / stack[stackbase + 26LLU] = / LOCAL VAR / stack[stackbase + 1LLU]; }/ SP + 1LLU = 27LLU */
11950		-{ /* PUSH / stack[stackbase + 27LLU] = / LOCAL VAR / stack[stackbase + 2LLU]; }/ SP + 1LLU = 28LLU */
	12145	+{ /* PUSH / stack[stackbase + 27LLU] = 0LLU; }/ SP + 1LLU = 28LLU */
	12146	+{ /* PUSH / stack[stackbase + 28LLU] = / LOCAL VAR / stack[stackbase + 1LLU]; }/ SP + 1LLU = 29LLU */
	12147	+{ /* PUSH / stack[stackbase + 29LLU] = / LOCAL VAR / stack[stackbase + 2LLU]; }/ SP + 1LLU = 30LLU */
11951	12148	{
11952	12149	/* CALLBEGIN */
11953		- /* reserve space for 1LLU returned values // SP + 1LLU = 29LLU */
11954		-{ /* PUSH / stack[stackbase + 29LLU] = stackbase; }/ SP + 1LLU = 30LLU */
11955		- /* leave place for return addr // SP + 1LLU = 31LLU */
	12150	+ /* reserve space for 1LLU returned values // SP + 1LLU = 31LLU */
	12151	+{ /* PUSH / stack[stackbase + 31LLU] = stackbase; }/ SP + 1LLU = 32LLU */
	12152	+ /* leave place for return addr // SP + 1LLU = 33LLU */
11956	12153	}
11957	12154	{
11958	12155	/CALLEND/
11959		- stackbase += 31LLU;
11960		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCCLLU;
	12156	+ stackbase += 33LLU;
	12157	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBFLLU;
11961	12158	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
11962	12159	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
11963	12160	break;
11964	12161	}
11965		-case 0xFFFFFFFFFFFFFCCCLLU:
11966		-/* SP = 29LLU */
11967		-{ /* PUSH / stack[stackbase + 29LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */
11968		-{ /* PUSH / stack[stackbase + 30LLU] = 0LLU; }/ SP + 1LLU = 31LLU */
	12162	+case 0xFFFFFFFFFFFFFCBFLLU:
	12163	+/* SP = 31LLU */
	12164	+{ /* PUSH / stack[stackbase + 31LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 32LLU */
	12165	+{ /* PUSH / stack[stackbase + 32LLU] = 0LLU; }/ SP + 1LLU = 33LLU */
11969	12166	{
11970	12167	/CALLEND/
11971		- stackbase += 25LLU;
11972		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCBLLU;
	12168	+ stackbase += 27LLU;
	12169	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBELLU;
11973	12170	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11974	12171	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
11975	12172	break;
11976	12173	}
11977		-case 0xFFFFFFFFFFFFFCCBLLU:
11978		-/* SP = 23LLU */fputs("\ncase ", stdout);
	12174	+case 0xFFFFFFFFFFFFFCBELLU:
	12175	+/* SP = 25LLU */fputs("\ncase ", stdout);
11979	12176	{
11980	12177	/* CALLBEGIN */
11981		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
11982		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
11983		- /* leave place for return addr // SP + 1LLU = 25LLU */
	12178	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12179	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12180	+ /* leave place for return addr // SP + 1LLU = 27LLU */
11984	12181	}
11985		-{ /* PUSH / stack[stackbase + 25LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP + 1LLU = 26LLU */
	12182	+{ /* PUSH / stack[stackbase + 27LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP + 1LLU = 28LLU */
11986	12183	{
11987	12184	/CALLEND/
11988		- stackbase += 25LLU;
11989		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCALLU;
	12185	+ stackbase += 27LLU;
	12186	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBDLLU;
11990	12187	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
11991	12188	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
11992	12189	break;
11993	12190	}
11994		-case 0xFFFFFFFFFFFFFCCALLU:
11995		-/* SP = 23LLU /fputs(": / skip to here /\n", stdout); / SP = 23LLU // SP = 23LLU */
11996		-{ /* JUMP / fnaddr = 18446744073709550799LLU; break; } / skip alternative */
11997		-case 18446744073709550800LLU: /* alternative */
	12191	+case 0xFFFFFFFFFFFFFCBDLLU:
	12192	+/* SP = 25LLU /fputs(": / skip to here /\n", stdout); / SP = 25LLU // SP = 25LLU */
	12193	+{ /* JUMP / fnaddr = 18446744073709550787LLU; break; } / skip alternative */
	12194	+case 18446744073709550788LLU: /* alternative */
11998	12195	{
11999	12196	/* CALLBEGIN */
12000		- /* reserve space for 0LLU returned values // SP + 0LLU = 23LLU */
12001		-{ /* PUSH / stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
12002		- /* leave place for return addr // SP + 1LLU = 25LLU */
	12197	+ /* reserve space for 0LLU returned values // SP + 0LLU = 25LLU */
	12198	+{ /* PUSH / stack[stackbase + 25LLU] = stackbase; }/ SP + 1LLU = 26LLU */
	12199	+ /* leave place for return addr // SP + 1LLU = 27LLU */
12003	12200	}
12004	12201	{
12005	12202	/CALLEND/
12006		- stackbase += 25LLU;
12007		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC9LLU;
	12203	+ stackbase += 27LLU;
	12204	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBCLLU;
12008	12205	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
12009	12206	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
12010	12207	break;
12011	12208	}
12012		-case 0xFFFFFFFFFFFFFCC9LLU:
12013		-/* SP = 23LLU /fputs("missing keyword \"other\"\n", stderr); exit(-1);/ SP = 23LLU */
12014		-case 18446744073709550799LLU: /* skip to here */
	12209	+case 0xFFFFFFFFFFFFFCBCLLU:
	12210	+/* SP = 25LLU /fputs("missing keyword \"other\"\n", stderr); exit(-1);/ SP = 25LLU */
	12211	+case 18446744073709550787LLU: /* skip to here */
12015	12212	/* SP = 13LLU // SP = 6LLU // SP = 6LLU */
12016	12213	{ /* JUMP / fnaddr = 18446744073709550841LLU; break; } / skip alternative */
12017	12214	case 18446744073709550842LLU: /* alternative */

		@@ -12026,12 +12223,12 @@
12026	12223	{
12027	12224	/CALLEND/
12028	12225	stackbase += 9LLU;
12029		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC8LLU;
	12226	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBBLLU;
12030	12227	fnaddr = /findvaro__/0x864A5FC5CB6A0000LLU;/* SP = 0LLU */
12031	12228	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /findvaro__/\n"); exit(-1); }
12032	12229	break;
12033	12230	}
12034		-case 0xFFFFFFFFFFFFFCC8LLU:
	12231	+case 0xFFFFFFFFFFFFFCBBLLU:
12035	12232	/* SP = 7LLU */
12036	12233	{
12037	12234	/* CALLBEGIN */

		@@ -12044,12 +12241,12 @@
12044	12241	{
12045	12242	/CALLEND/
12046	12243	stackbase += 10LLU;
12047		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC7LLU;
	12244	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBALLU;
12048	12245	fnaddr = /findvart__/0x864A5FC5CB6F0000LLU;/* SP = 0LLU */
12049	12246	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /findvart__/\n"); exit(-1); }
12050	12247	break;
12051	12248	}
12052		-case 0xFFFFFFFFFFFFFCC7LLU:
	12249	+case 0xFFFFFFFFFFFFFCBALLU:
12053	12250	/* SP = 8LLU */
12054	12251	{
12055	12252	/* CALLBEGIN */

		@@ -12062,12 +12259,12 @@
12062	12259	{
12063	12260	/CALLEND/
12064	12261	stackbase += 11LLU;
12065		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC6LLU;
	12262	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB9LLU;
12066	12263	fnaddr = /findvarv__/0x864A5FC5CB710000LLU;/* SP = 0LLU */
12067	12264	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /findvarv__/\n"); exit(-1); }
12068	12265	break;
12069	12266	}
12070		-case 0xFFFFFFFFFFFFFCC6LLU:
	12267	+case 0xFFFFFFFFFFFFFCB9LLU:
12071	12268	/* SP = 9LLU // predicate */
12072	12269
12073	12270	{

		@@ -12080,15 +12277,15 @@
12080	12277	{
12081	12278	/CALLEND/
12082	12279	stackbase += 12LLU;
12083		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC3LLU;
	12280	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB6LLU;
12084	12281	fnaddr = /typeisval_/0xBF4AE092EC5C9C00LLU;/* SP = 0LLU */
12085	12282	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeisval_/\n"); exit(-1); }
12086	12283	break;
12087	12284	}
12088		-case 0xFFFFFFFFFFFFFCC3LLU:
	12285	+case 0xFFFFFFFFFFFFFCB6LLU:
12089	12286	/* SP = 10LLU */
12090	12287	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
12091		-{ /* JUMP / fnaddr = 18446744073709550789LLU; break; } / skip consequent */
	12288	+{ /* JUMP / fnaddr = 18446744073709550776LLU; break; } / skip consequent */
12092	12289	/* consequent */
12093	12290	{
12094	12291	/* CALLBEGIN */

		@@ -12101,12 +12298,12 @@
12101	12298	{
12102	12299	/CALLEND/
12103	12300	stackbase += 12LLU;
12104		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC2LLU;
	12301	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB5LLU;
12105	12302	fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
12106	12303	if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
12107	12304	break;
12108	12305	}
12109		-case 0xFFFFFFFFFFFFFCC2LLU:
	12306	+case 0xFFFFFFFFFFFFFCB5LLU:
12110	12307	/* SP = 10LLU // predicate */
12111	12308
12112	12309	{

		@@ -12120,15 +12317,15 @@
12120	12317	{
12121	12318	/CALLEND/
12122	12319	stackbase += 13LLU;
12123		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC0LLU;
	12320	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB3LLU;
12124	12321	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
12125	12322	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
12126	12323	break;
12127	12324	}
12128		-case 0xFFFFFFFFFFFFFCC0LLU:
	12325	+case 0xFFFFFFFFFFFFFCB3LLU:
12129	12326	/* SP = 11LLU */
12130	12327	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
12131		-{ /* JUMP / fnaddr = 18446744073709550785LLU; break; } / skip consequent */
	12328	+{ /* JUMP / fnaddr = 18446744073709550772LLU; break; } / skip consequent */
12132	12329	/* consequent */fputs("SIZE OF ", stderr);
12133	12330	{
12134	12331	/* CALLBEGIN */

		@@ -12140,12 +12337,12 @@
12140	12337	{
12141	12338	/CALLEND/
12142	12339	stackbase += 12LLU;
12143		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBFLLU;
	12340	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB2LLU;
12144	12341	fnaddr = /debugtype_/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
12145	12342	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugtype_/\n"); exit(-1); }
12146	12343	break;
12147	12344	}
12148		-case 0xFFFFFFFFFFFFFCBFLLU:
	12345	+case 0xFFFFFFFFFFFFFCB2LLU:
12149	12346	/* SP = 10LLU */fputs(" ", stderr);
12150	12347	{
12151	12348	/* CALLBEGIN */

		@@ -12157,14 +12354,14 @@
12157	12354	{
12158	12355	/CALLEND/
12159	12356	stackbase += 12LLU;
12160		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBELLU;
	12357	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB1LLU;
12161	12358	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
12162	12359	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
12163	12360	break;
12164	12361	}
12165		-case 0xFFFFFFFFFFFFFCBELLU:
	12362	+case 0xFFFFFFFFFFFFFCB1LLU:
12166	12363	/* SP = 10LLU /fputs(" IS NULL", stderr); / SP = 10LLU */
12167		-case 18446744073709550785LLU: /* alternative */
	12364	+case 18446744073709550772LLU: /* alternative */
12168	12365	{
12169	12366	/* CALLBEGIN */
12170	12367	/* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */

		@@ -12174,12 +12371,12 @@
12174	12371	{
12175	12372	/CALLEND/
12176	12373	stackbase += 12LLU;
12177		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBDLLU;
	12374	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB0LLU;
12178	12375	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12179	12376	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
12180	12377	break;
12181	12378	}
12182		-case 0xFFFFFFFFFFFFFCBDLLU:
	12379	+case 0xFFFFFFFFFFFFFCB0LLU:
12183	12380	/* SP = 10LLU // predicate */
12184	12381
12185	12382	{

		@@ -12192,15 +12389,15 @@
12192	12389	{
12193	12390	/CALLEND/
12194	12391	stackbase += 13LLU;
12195		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBBLLU;
	12392	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAELLU;
12196	12393	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
12197	12394	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
12198	12395	break;
12199	12396	}
12200		-case 0xFFFFFFFFFFFFFCBBLLU:
	12397	+case 0xFFFFFFFFFFFFFCAELLU:
12201	12398	/* SP = 11LLU */
12202	12399	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
12203		-{ /* JUMP / fnaddr = 18446744073709550780LLU; break; } / skip consequent */
	12400	+{ /* JUMP / fnaddr = 18446744073709550767LLU; break; } / skip consequent */
12204	12401	/* consequent */
12205	12402	{
12206	12403	/* CALLBEGIN */

		@@ -12211,12 +12408,12 @@
12211	12408	{
12212	12409	/CALLEND/
12213	12410	stackbase += 12LLU;
12214		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBALLU;
	12411	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCADLLU;
12215	12412	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12216	12413	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
12217	12414	break;
12218	12415	}
12219		-case 0xFFFFFFFFFFFFFCBALLU:
	12416	+case 0xFFFFFFFFFFFFFCADLLU:
12220	12417	/* SP = 10LLU // predicate */
12221	12418
12222	12419	{

		@@ -12234,25 +12431,25 @@
12234	12431	{
12235	12432	/CALLEND/
12236	12433	stackbase += 16LLU;
12237		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB7LLU;
	12434	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAALLU;
12238	12435	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
12239	12436	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
12240	12437	break;
12241	12438	}
12242		-case 0xFFFFFFFFFFFFFCB7LLU:
	12439	+case 0xFFFFFFFFFFFFFCAALLU:
12243	12440	/* SP = 14LLU */
12244	12441	{
12245	12442	/CALLEND/
12246	12443	stackbase += 13LLU;
12247		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB6LLU;
	12444	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA9LLU;
12248	12445	fnaddr = /isalpha___/0x92E727AE37000000LLU;/* SP = 0LLU */
12249	12446	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /isalpha___/\n"); exit(-1); }
12250	12447	break;
12251	12448	}
12252		-case 0xFFFFFFFFFFFFFCB6LLU:
	12449	+case 0xFFFFFFFFFFFFFCA9LLU:
12253	12450	/* SP = 11LLU */
12254	12451	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
12255		-{ /* JUMP / fnaddr = 18446744073709550777LLU; break; } / skip consequent */
	12452	+{ /* JUMP / fnaddr = 18446744073709550764LLU; break; } / skip consequent */
12256	12453	/* consequent */
12257	12454	{
12258	12455	/* CALLBEGIN */

		@@ -12277,22 +12474,22 @@
12277	12474	{
12278	12475	/CALLEND/
12279	12476	stackbase += 21LLU;
12280		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB5LLU;
	12477	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA8LLU;
12281	12478	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
12282	12479	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); }
12283	12480	break;
12284	12481	}
12285		-case 0xFFFFFFFFFFFFFCB5LLU:
	12482	+case 0xFFFFFFFFFFFFFCA8LLU:
12286	12483	/* SP = 19LLU */
12287	12484	{
12288	12485	/CALLEND/
12289	12486	stackbase += 18LLU;
12290		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB4LLU;
	12487	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA7LLU;
12291	12488	fnaddr = /subtoid___/0xBB076FAA47C00000LLU;/* SP = 0LLU */
12292	12489	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtoid___/\n"); exit(-1); }
12293	12490	break;
12294	12491	}
12295		-case 0xFFFFFFFFFFFFFCB4LLU:
	12492	+case 0xFFFFFFFFFFFFFCA7LLU:
12296	12493	/* SP = 16LLU */
12297	12494	{
12298	12495	/* CALLBEGIN */

		@@ -12303,22 +12500,22 @@
12303	12500	{
12304	12501	/CALLEND/
12305	12502	stackbase += 19LLU;
12306		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB3LLU;
	12503	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA6LLU;
12307	12504	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
12308	12505	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
12309	12506	break;
12310	12507	}
12311		-case 0xFFFFFFFFFFFFFCB3LLU:
	12508	+case 0xFFFFFFFFFFFFFCA6LLU:
12312	12509	/* SP = 17LLU */
12313	12510	{
12314	12511	/CALLEND/
12315	12512	stackbase += 14LLU;
12316		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB2LLU;
	12513	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA5LLU;
12317	12514	fnaddr = /getdefelem/0x8A0BDF8218278280LLU;/* SP = 0LLU */
12318	12515	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /getdefelem/\n"); exit(-1); }
12319	12516	break;
12320	12517	}
12321		-case 0xFFFFFFFFFFFFFCB2LLU:
	12518	+case 0xFFFFFFFFFFFFFCA5LLU:
12322	12519	/* SP = 12LLU */
12323	12520	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP + 1LLU = 13LLU */
12324	12521	{ /* PUSH / stack[stackbase + 13LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ SP + 1LLU = 14LLU */

		@@ -12333,12 +12530,12 @@
12333	12530	{
12334	12531	/CALLEND/
12335	12532	stackbase += 17LLU;
12336		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB1LLU;
	12533	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA4LLU;
12337	12534	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
12338	12535	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
12339	12536	break;
12340	12537	}
12341		-case 0xFFFFFFFFFFFFFCB1LLU:
	12538	+case 0xFFFFFFFFFFFFFCA4LLU:
12342	12539	/* SP = 15LLU // SP = 14LLU */
12343	12540	{ /* assign / / LOCAL VAR / stack[stackbase + 6LLU] = / LOCAL VAR */ stack[stackbase + 14LLU]; }
12344	12541	{ /* PUSH / stack[stackbase + 14LLU] = / LOCAL VAR / stack[stackbase + 13LLU]; }/ SP + 1LLU = 15LLU // SP = 14LLU */

		@@ -12354,16 +12551,16 @@
12354	12551	{
12355	12552	/CALLEND/
12356	12553	stackbase += 17LLU;
12357		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB0LLU;
	12554	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA3LLU;
12358	12555	fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
12359	12556	if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
12360	12557	break;
12361	12558	}
12362		-case 0xFFFFFFFFFFFFFCB0LLU:
	12559	+case 0xFFFFFFFFFFFFFCA3LLU:
12363	12560	/* SP = 15LLU // SP = 14LLU */
12364	12561	{ /* assign / / LOCAL VAR / stack[stackbase + 9LLU] = / LOCAL VAR / stack[stackbase + 14LLU]; }/ SP = 10LLU // SP = 10LLU */
12365		-{ /* JUMP / fnaddr = 18446744073709550776LLU; break; } / skip alternative */
12366		-case 18446744073709550777LLU: /* alternative */
	12562	+{ /* JUMP / fnaddr = 18446744073709550763LLU; break; } / skip alternative */
	12563	+case 18446744073709550764LLU: /* alternative */
12367	12564	{
12368	12565	/* CALLBEGIN */
12369	12566	/* reserve space for 1LLU returned values // SP + 1LLU = 11LLU */

		@@ -12373,12 +12570,12 @@
12373	12570	{
12374	12571	/CALLEND/
12375	12572	stackbase += 13LLU;
12376		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAFLLU;
	12573	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA2LLU;
12377	12574	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
12378	12575	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
12379	12576	break;
12380	12577	}
12381		-case 0xFFFFFFFFFFFFFCAFLLU:
	12578	+case 0xFFFFFFFFFFFFFCA2LLU:
12382	12579	/* SP = 11LLU // predicate */
12383	12580
12384	12581	{

		@@ -12392,15 +12589,15 @@
12392	12589	{
12393	12590	/CALLEND/
12394	12591	stackbase += 14LLU;
12395		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCACLLU;
	12592	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9FLLU;
12396	12593	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
12397	12594	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
12398	12595	break;
12399	12596	}
12400		-case 0xFFFFFFFFFFFFFCACLLU:
	12597	+case 0xFFFFFFFFFFFFFC9FLLU:
12401	12598	/* SP = 12LLU */
12402	12599	if(!/* SP - 1LLU = 11LLU */stack[stackbase + 11LLU])
12403		-{ /* JUMP / fnaddr = 18446744073709550766LLU; break; } / skip consequent */
	12600	+{ /* JUMP / fnaddr = 18446744073709550753LLU; break; } / skip consequent */
12404	12601	/* consequent */
12405	12602	{
12406	12603	/* CALLBEGIN */

		@@ -12413,12 +12610,12 @@
12413	12610	{
12414	12611	/CALLEND/
12415	12612	stackbase += 14LLU;
12416		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCABLLU;
	12613	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9ELLU;
12417	12614	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
12418	12615	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
12419	12616	break;
12420	12617	}
12421		-case 0xFFFFFFFFFFFFFCABLLU:
	12618	+case 0xFFFFFFFFFFFFFC9ELLU:
12422	12619	/* SP = 12LLU // SP = 11LLU */
12423	12620	{ /* assign / / LOCAL VAR / stack[stackbase + 6LLU] = / LOCAL VAR */ stack[stackbase + 11LLU]; }
12424	12621	{ /* PUSH / stack[stackbase + 11LLU] = 1LLU; }/ SP + 1LLU = 12LLU // SP = 11LLU */

		@@ -12433,16 +12630,16 @@
12433	12630	{
12434	12631	/CALLEND/
12435	12632	stackbase += 14LLU;
12436		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAALLU;
	12633	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9DLLU;
12437	12634	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
12438	12635	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
12439	12636	break;
12440	12637	}
12441		-case 0xFFFFFFFFFFFFFCAALLU:
	12638	+case 0xFFFFFFFFFFFFFC9DLLU:
12442	12639	/* SP = 12LLU // SP = 11LLU */
12443	12640	{ /* assign / / LOCAL VAR / stack[stackbase + 7LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ SP = 11LLU // SP = 11LLU */
12444		-{ /* JUMP / fnaddr = 18446744073709550765LLU; break; } / skip alternative */
12445		-case 18446744073709550766LLU: /* alternative */
	12641	+{ /* JUMP / fnaddr = 18446744073709550752LLU; break; } / skip alternative */
	12642	+case 18446744073709550753LLU: /* alternative */
12446	12643	{
12447	12644	/* CALLBEGIN */
12448	12645	/* reserve space for 0LLU returned values // SP + 0LLU = 11LLU */

		@@ -12452,12 +12649,12 @@
12452	12649	{
12453	12650	/CALLEND/
12454	12651	stackbase += 13LLU;
12455		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA9LLU;
	12652	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9CLLU;
12456	12653	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
12457	12654	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
12458	12655	break;
12459	12656	}
12460		-case 0xFFFFFFFFFFFFFCA9LLU:
	12657	+case 0xFFFFFFFFFFFFFC9CLLU:
12461	12658	/* SP = 11LLU */fputs("variable ", stderr);
12462	12659	{
12463	12660	/* CALLBEGIN */

		@@ -12469,12 +12666,12 @@
12469	12666	{
12470	12667	/CALLEND/
12471	12668	stackbase += 13LLU;
12472		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA8LLU;
	12669	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9BLLU;
12473	12670	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
12474	12671	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
12475	12672	break;
12476	12673	}
12477		-case 0xFFFFFFFFFFFFFCA8LLU:
	12674	+case 0xFFFFFFFFFFFFFC9BLLU:
12478	12675	/* SP = 11LLU */fputs(" of size ", stderr);
12479	12676	{
12480	12677	/* CALLBEGIN */

		@@ -12486,12 +12683,12 @@
12486	12683	{
12487	12684	/CALLEND/
12488	12685	stackbase += 13LLU;
12489		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA7LLU;
	12686	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9ALLU;
12490	12687	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
12491	12688	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
12492	12689	break;
12493	12690	}
12494		-case 0xFFFFFFFFFFFFFCA7LLU:
	12691	+case 0xFFFFFFFFFFFFFC9ALLU:
12495	12692	/* SP = 11LLU */fputs(" has no element ", stderr);
12496	12693	{
12497	12694	/* CALLBEGIN */

		@@ -12503,18 +12700,18 @@
12503	12700	{
12504	12701	/CALLEND/
12505	12702	stackbase += 13LLU;
12506		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA6LLU;
	12703	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC99LLU;
12507	12704	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
12508	12705	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
12509	12706	break;
12510	12707	}
12511		-case 0xFFFFFFFFFFFFFCA6LLU:
	12708	+case 0xFFFFFFFFFFFFFC99LLU:
12512	12709	/* SP = 11LLU /exit(-1);/ SP = 11LLU */
12513		-case 18446744073709550765LLU: /* skip to here */
	12710	+case 18446744073709550752LLU: /* skip to here */
12514	12711	/* SP = 10LLU */
12515		-case 18446744073709550776LLU: /* skip to here */
	12712	+case 18446744073709550763LLU: /* skip to here */
12516	12713	/* SP = 10LLU */
12517		-case 18446744073709550780LLU: /* alternative */
	12714	+case 18446744073709550767LLU: /* alternative */
12518	12715	{
12519	12716	/* CALLBEGIN */
12520	12717	/* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */

		@@ -12524,12 +12721,12 @@
12524	12721	{
12525	12722	/CALLEND/
12526	12723	stackbase += 12LLU;
12527		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA5LLU;
	12724	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC98LLU;
12528	12725	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12529	12726	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
12530	12727	break;
12531	12728	}
12532		-case 0xFFFFFFFFFFFFFCA5LLU:
	12729	+case 0xFFFFFFFFFFFFFC98LLU:
12533	12730	/* SP = 10LLU // predicate */
12534	12731
12535	12732	{

		@@ -12542,15 +12739,15 @@
12542	12739	{
12543	12740	/CALLEND/
12544	12741	stackbase += 13LLU;
12545		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA2LLU;
	12742	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC95LLU;
12546	12743	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
12547	12744	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
12548	12745	break;
12549	12746	}
12550		-case 0xFFFFFFFFFFFFFCA2LLU:
	12747	+case 0xFFFFFFFFFFFFFC95LLU:
12551	12748	/* SP = 11LLU */
12552	12749	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
12553		-{ /* JUMP / fnaddr = 18446744073709550756LLU; break; } / skip consequent */
	12750	+{ /* JUMP / fnaddr = 18446744073709550743LLU; break; } / skip consequent */
12554	12751	/* consequent */
12555	12752	{
12556	12753	/* CALLBEGIN */

		@@ -12568,23 +12765,23 @@
12568	12765	{
12569	12766	/CALLEND/
12570	12767	stackbase += 15LLU;
12571		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA1LLU;
	12768	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC94LLU;
12572	12769	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
12573	12770	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
12574	12771	break;
12575	12772	}
12576		-case 0xFFFFFFFFFFFFFCA1LLU:
	12773	+case 0xFFFFFFFFFFFFFC94LLU:
12577	12774	/* SP = 13LLU */
12578	12775	{ /* PUSH / stack[stackbase + 13LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 14LLU */
12579	12776	{
12580	12777	/CALLEND/
12581	12778	stackbase += 12LLU;
12582		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA0LLU;
	12779	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC93LLU;
12583	12780	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
12584	12781	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); }
12585	12782	break;
12586	12783	}
12587		-case 0xFFFFFFFFFFFFFCA0LLU:
	12784	+case 0xFFFFFFFFFFFFFC93LLU:
12588	12785	/* SP = 10LLU */
12589	12786	{
12590	12787	/* CALLBEGIN */

		@@ -12595,12 +12792,12 @@
12595	12792	{
12596	12793	/CALLEND/
12597	12794	stackbase += 12LLU;
12598		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9FLLU;
	12795	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC92LLU;
12599	12796	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12600	12797	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
12601	12798	break;
12602	12799	}
12603		-case 0xFFFFFFFFFFFFFC9FLLU:
	12800	+case 0xFFFFFFFFFFFFFC92LLU:
12604	12801	/* SP = 10LLU */
12605	12802	{
12606	12803	/* CALLBEGIN */

		@@ -12611,12 +12808,12 @@
12611	12808	{
12612	12809	/CALLEND/
12613	12810	stackbase += 13LLU;
12614		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9ELLU;
	12811	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC91LLU;
12615	12812	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
12616	12813	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
12617	12814	break;
12618	12815	}
12619		-case 0xFFFFFFFFFFFFFC9ELLU:
	12816	+case 0xFFFFFFFFFFFFFC91LLU:
12620	12817	/* SP = 11LLU */
12621	12818	{
12622	12819	/* CALLBEGIN */

		@@ -12636,12 +12833,12 @@
12636	12833	{
12637	12834	/CALLEND/
12638	12835	stackbase += 19LLU;
12639		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9DLLU;
	12836	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC90LLU;
12640	12837	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
12641	12838	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
12642	12839	break;
12643	12840	}
12644		-case 0xFFFFFFFFFFFFFC9DLLU:
	12841	+case 0xFFFFFFFFFFFFFC90LLU:
12645	12842	/* SP = 17LLU */
12646	12843	{ /* PUSH / stack[stackbase + 17LLU] = / LOCAL VAR / stack[stackbase + 7LLU]; }/ SP + 1LLU = 18LLU */
12647	12844	{ /* PUSH / stack[stackbase + 18LLU] = 0LLU; }/ SP + 1LLU = 19LLU */

		@@ -12648,12 +12845,12 @@
12648	12845	{
12649	12846	/CALLEND/
12650	12847	stackbase += 13LLU;
12651		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9CLLU;
	12848	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8FLLU;
12652	12849	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12653	12850	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
12654	12851	break;
12655	12852	}
12656		-case 0xFFFFFFFFFFFFFC9CLLU:
	12853	+case 0xFFFFFFFFFFFFFC8FLLU:
12657	12854	/* SP = 11LLU */
12658	12855	{
12659	12856	/* CALLBEGIN */

		@@ -12665,15 +12862,15 @@
12665	12862	{
12666	12863	/CALLEND/
12667	12864	stackbase += 13LLU;
12668		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9BLLU;
	12865	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8ELLU;
12669	12866	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
12670	12867	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
12671	12868	break;
12672	12869	}
12673		-case 0xFFFFFFFFFFFFFC9BLLU:
	12870	+case 0xFFFFFFFFFFFFFC8ELLU:
12674	12871	/* SP = 11LLU */
12675	12872	{ /* PUSH / stack[stackbase + 11LLU] = 0LLU; }/ SP + 1LLU = 12LLU */
12676		-case 0xFFFFFFFFFFFFFC9ALLU: /* loop to here // predicate */
	12873	+case 0xFFFFFFFFFFFFFC8DLLU: /* loop to here // predicate */
12677	12874
12678	12875	{
12679	12876	/* CALLBEGIN */

		@@ -12686,15 +12883,15 @@
12686	12883	{
12687	12884	/CALLEND/
12688	12885	stackbase += 15LLU;
12689		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC98LLU;
	12886	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8BLLU;
12690	12887	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
12691	12888	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
12692	12889	break;
12693	12890	}
12694		-case 0xFFFFFFFFFFFFFC98LLU:
	12891	+case 0xFFFFFFFFFFFFFC8BLLU:
12695	12892	/* SP = 13LLU */
12696	12893	if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU])
12697		-{ /* JUMP / fnaddr = 18446744073709550745LLU; break; } / skip loop */
	12894	+{ /* JUMP / fnaddr = 18446744073709550732LLU; break; } / skip loop */
12698	12895	/* loop /fputs("\n{ / assign */ ", stdout);
12699	12896	{
12700	12897	/* CALLBEGIN */

		@@ -12713,22 +12910,22 @@
12713	12910	{
12714	12911	/CALLEND/
12715	12912	stackbase += 17LLU;
12716		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC97LLU;
	12913	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8ALLU;
12717	12914	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
12718	12915	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
12719	12916	break;
12720	12917	}
12721		-case 0xFFFFFFFFFFFFFC97LLU:
	12918	+case 0xFFFFFFFFFFFFFC8ALLU:
12722	12919	/* SP = 15LLU */
12723	12920	{
12724	12921	/CALLEND/
12725	12922	stackbase += 14LLU;
12726		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC96LLU;
	12923	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC89LLU;
12727	12924	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
12728	12925	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
12729	12926	break;
12730	12927	}
12731		-case 0xFFFFFFFFFFFFFC96LLU:
	12928	+case 0xFFFFFFFFFFFFFC89LLU:
12732	12929	/* SP = 12LLU */fputs(" = ", stdout);
12733	12930	{
12734	12931	/* CALLBEGIN */

		@@ -12747,22 +12944,22 @@
12747	12944	{
12748	12945	/CALLEND/
12749	12946	stackbase += 17LLU;
12750		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC95LLU;
	12947	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC88LLU;
12751	12948	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
12752	12949	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
12753	12950	break;
12754	12951	}
12755		-case 0xFFFFFFFFFFFFFC95LLU:
	12952	+case 0xFFFFFFFFFFFFFC88LLU:
12756	12953	/* SP = 15LLU */
12757	12954	{
12758	12955	/CALLEND/
12759	12956	stackbase += 14LLU;
12760		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC94LLU;
	12957	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC87LLU;
12761	12958	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
12762	12959	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
12763	12960	break;
12764	12961	}
12765		-case 0xFFFFFFFFFFFFFC94LLU:
	12962	+case 0xFFFFFFFFFFFFFC87LLU:
12766	12963	/* SP = 12LLU */
12767	12964	{
12768	12965	/* CALLBEGIN */

		@@ -12775,18 +12972,18 @@
12775	12972	{
12776	12973	/CALLEND/
12777	12974	stackbase += 15LLU;
12778		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC93LLU;
	12975	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC86LLU;
12779	12976	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
12780	12977	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
12781	12978	break;
12782	12979	}
12783		-case 0xFFFFFFFFFFFFFC93LLU:
	12980	+case 0xFFFFFFFFFFFFFC86LLU:
12784	12981	/* SP = 13LLU // SP = 12LLU */
12785	12982	{ /* assign / / LOCAL VAR / stack[stackbase + 11LLU] = / LOCAL VAR / stack[stackbase + 12LLU]; }fputs("; }", stdout); / SP = 12LLU */
12786		-{ /* JUMP / fnaddr = 18446744073709550746LLU; break; } / loop */
12787		-case 18446744073709550745LLU: /* skip to here // SP = 10LLU // SP = 10LLU */
12788		-{ /* JUMP / fnaddr = 18446744073709550755LLU; break; } / skip alternative */
12789		-case 18446744073709550756LLU: /* alternative */
	12983	+{ /* JUMP / fnaddr = 18446744073709550733LLU; break; } / loop */
	12984	+case 18446744073709550732LLU: /* skip to here // SP = 10LLU // SP = 10LLU */
	12985	+{ /* JUMP / fnaddr = 18446744073709550742LLU; break; } / skip alternative */
	12986	+case 18446744073709550743LLU: /* alternative */
12790	12987	{
12791	12988	/* CALLBEGIN */
12792	12989	/* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */

		@@ -12799,14 +12996,14 @@
12799	12996	{
12800	12997	/CALLEND/
12801	12998	stackbase += 12LLU;
12802		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC92LLU;
	12999	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC85LLU;
12803	13000	fnaddr = /typecheckV/0xBF4AE07A381E9960LLU;/* SP = 0LLU */
12804	13001	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheckV/\n"); exit(-1); }
12805	13002	break;
12806	13003	}
12807		-case 0xFFFFFFFFFFFFFC92LLU:
	13004	+case 0xFFFFFFFFFFFFFC85LLU:
12808	13005	/* SP = 10LLU */
12809		-case 0xFFFFFFFFFFFFFC91LLU: /* loop to here // predicate */
	13006	+case 0xFFFFFFFFFFFFFC84LLU: /* loop to here // predicate */
12810	13007
12811	13008	{
12812	13009	/* CALLBEGIN */

		@@ -12819,15 +13016,15 @@
12819	13016	{
12820	13017	/CALLEND/
12821	13018	stackbase += 13LLU;
12822		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8FLLU;
	13019	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC82LLU;
12823	13020	fnaddr = /gtr_______/0x8AFB400000000000LLU;/* SP = 0LLU */
12824	13021	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /gtr_______/\n"); exit(-1); }
12825	13022	break;
12826	13023	}
12827		-case 0xFFFFFFFFFFFFFC8FLLU:
	13024	+case 0xFFFFFFFFFFFFFC82LLU:
12828	13025	/* SP = 11LLU */
12829	13026	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
12830		-{ /* JUMP / fnaddr = 18446744073709550736LLU; break; } / skip loop */
	13027	+{ /* JUMP / fnaddr = 18446744073709550723LLU; break; } / skip loop */
12831	13028	/* loop */
12832	13029	{
12833	13030	/* CALLBEGIN */

		@@ -12840,12 +13037,12 @@
12840	13037	{
12841	13038	/CALLEND/
12842	13039	stackbase += 13LLU;
12843		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8ELLU;
	13040	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC81LLU;
12844	13041	fnaddr = /sub_______/0xBB07400000000000LLU;/* SP = 0LLU */
12845	13042	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /sub_______/\n"); exit(-1); }
12846	13043	break;
12847	13044	}
12848		-case 0xFFFFFFFFFFFFFC8ELLU:
	13045	+case 0xFFFFFFFFFFFFFC81LLU:
12849	13046	/* SP = 11LLU // SP = 10LLU */
12850	13047	{ /* assign / / LOCAL VAR / stack[stackbase + 9LLU] = / LOCAL VAR */ stack[stackbase + 10LLU]; }
12851	13048	{

		@@ -12857,12 +13054,12 @@
12857	13054	{
12858	13055	/CALLEND/
12859	13056	stackbase += 12LLU;
12860		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8DLLU;
	13057	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC80LLU;
12861	13058	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
12862	13059	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); }
12863	13060	break;
12864	13061	}
12865		-case 0xFFFFFFFFFFFFFC8DLLU:
	13062	+case 0xFFFFFFFFFFFFFC80LLU:
12866	13063	/* SP = 10LLU */
12867	13064	{
12868	13065	/* CALLBEGIN */

		@@ -12874,12 +13071,12 @@
12874	13071	{
12875	13072	/CALLEND/
12876	13073	stackbase += 12LLU;
12877		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8CLLU;
	13074	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7FLLU;
12878	13075	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
12879	13076	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
12880	13077	break;
12881	13078	}
12882		-case 0xFFFFFFFFFFFFFC8CLLU:
	13079	+case 0xFFFFFFFFFFFFFC7FLLU:
12883	13080	/* SP = 10LLU */
12884	13081	{
12885	13082	/* CALLBEGIN */

		@@ -12890,12 +13087,12 @@
12890	13087	{
12891	13088	/CALLEND/
12892	13089	stackbase += 12LLU;
12893		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8BLLU;
	13090	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7ELLU;
12894	13091	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
12895	13092	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); }
12896	13093	break;
12897	13094	}
12898		-case 0xFFFFFFFFFFFFFC8BLLU:
	13095	+case 0xFFFFFFFFFFFFFC7ELLU:
12899	13096	/* SP = 10LLU */
12900	13097	{
12901	13098	/* CALLBEGIN */

		@@ -12908,20 +13105,20 @@
12908	13105	{
12909	13106	/CALLEND/
12910	13107	stackbase += 13LLU;
12911		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8ALLU;
	13108	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7DLLU;
12912	13109	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
12913	13110	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
12914	13111	break;
12915	13112	}
12916		-case 0xFFFFFFFFFFFFFC8ALLU:
	13113	+case 0xFFFFFFFFFFFFFC7DLLU:
12917	13114	/* SP = 11LLU // SP = 10LLU */
12918	13115	{ /* assign / / LOCAL VAR / stack[stackbase + 6LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP = 10LLU */
12919		-{ /* JUMP / fnaddr = 18446744073709550737LLU; break; } / loop */
12920		-case 18446744073709550736LLU: /* skip to here // SP = 10LLU */
12921		-case 18446744073709550755LLU: /* skip to here */
	13116	+{ /* JUMP / fnaddr = 18446744073709550724LLU; break; } / loop */
	13117	+case 18446744073709550723LLU: /* skip to here // SP = 10LLU */
	13118	+case 18446744073709550742LLU: /* skip to here */
12922	13119	/* SP = 9LLU // SP = 9LLU */
12923		-{ /* JUMP / fnaddr = 18446744073709550788LLU; break; } / skip alternative */
12924		-case 18446744073709550789LLU: /* alternative */
	13120	+{ /* JUMP / fnaddr = 18446744073709550775LLU; break; } / skip alternative */
	13121	+case 18446744073709550776LLU: /* alternative */
12925	13122	{
12926	13123	/* CALLBEGIN */
12927	13124	/* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */

		@@ -12931,12 +13128,12 @@
12931	13128	{
12932	13129	/CALLEND/
12933	13130	stackbase += 11LLU;
12934		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC89LLU;
	13131	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7CLLU;
12935	13132	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12936	13133	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
12937	13134	break;
12938	13135	}
12939		-case 0xFFFFFFFFFFFFFC89LLU:
	13136	+case 0xFFFFFFFFFFFFFC7CLLU:
12940	13137	/* SP = 9LLU // predicate */
12941	13138
12942	13139	{

		@@ -12949,15 +13146,15 @@
12949	13146	{
12950	13147	/CALLEND/
12951	13148	stackbase += 12LLU;
12952		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC86LLU;
	13149	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC79LLU;
12953	13150	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
12954	13151	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
12955	13152	break;
12956	13153	}
12957		-case 0xFFFFFFFFFFFFFC86LLU:
	13154	+case 0xFFFFFFFFFFFFFC79LLU:
12958	13155	/* SP = 10LLU */
12959	13156	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
12960		-{ /* JUMP / fnaddr = 18446744073709550728LLU; break; } / skip consequent */
	13157	+{ /* JUMP / fnaddr = 18446744073709550715LLU; break; } / skip consequent */
12961	13158	/* consequent // predicate */
12962	13159
12963	13160	{

		@@ -12970,15 +13167,15 @@
12970	13167	{
12971	13168	/CALLEND/
12972	13169	stackbase += 12LLU;
12973		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC84LLU;
	13170	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC77LLU;
12974	13171	fnaddr = /not_______/0xA6ABC00000000000LLU;/* SP = 0LLU */
12975	13172	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /not_______/\n"); exit(-1); }
12976	13173	break;
12977	13174	}
12978		-case 0xFFFFFFFFFFFFFC84LLU:
	13175	+case 0xFFFFFFFFFFFFFC77LLU:
12979	13176	/* SP = 10LLU */
12980	13177	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
12981		-{ /* JUMP / fnaddr = 18446744073709550725LLU; break; } / skip consequent */
	13178	+{ /* JUMP / fnaddr = 18446744073709550712LLU; break; } / skip consequent */
12982	13179	/* consequent */
12983	13180	{
12984	13181	/* CALLBEGIN */

		@@ -12989,12 +13186,12 @@
12989	13186	{
12990	13187	/CALLEND/
12991	13188	stackbase += 11LLU;
12992		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC83LLU;
	13189	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC76LLU;
12993	13190	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
12994	13191	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
12995	13192	break;
12996	13193	}
12997		-case 0xFFFFFFFFFFFFFC83LLU:
	13194	+case 0xFFFFFFFFFFFFFC76LLU:
12998	13195	/* SP = 9LLU */fputs("accessing unverified list ", stderr);
12999	13196	{
13000	13197	/* CALLBEGIN */

		@@ -13006,14 +13203,14 @@
13006	13203	{
13007	13204	/CALLEND/
13008	13205	stackbase += 11LLU;
13009		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC82LLU;
	13206	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC75LLU;
13010	13207	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
13011	13208	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
13012	13209	break;
13013	13210	}
13014		-case 0xFFFFFFFFFFFFFC82LLU:
	13211	+case 0xFFFFFFFFFFFFFC75LLU:
13015	13212	/* SP = 9LLU /fputs("\n", stderr); exit(-1);/ SP = 9LLU */
13016		-case 18446744073709550725LLU: /* alternative */
	13213	+case 18446744073709550712LLU: /* alternative */
13017	13214	{
13018	13215	/* CALLBEGIN */
13019	13216	/* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */

		@@ -13023,12 +13220,12 @@
13023	13220	{
13024	13221	/CALLEND/
13025	13222	stackbase += 11LLU;
13026		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC81LLU;
	13223	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC74LLU;
13027	13224	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13028	13225	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
13029	13226	break;
13030	13227	}
13031		-case 0xFFFFFFFFFFFFFC81LLU:
	13228	+case 0xFFFFFFFFFFFFFC74LLU:
13032	13229	/* SP = 9LLU // predicate */
13033	13230
13034	13231	{

		@@ -13047,25 +13244,25 @@
13047	13244	{
13048	13245	/CALLEND/
13049	13246	stackbase += 16LLU;
13050		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7ELLU;
	13247	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC71LLU;
13051	13248	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
13052	13249	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
13053	13250	break;
13054	13251	}
13055		-case 0xFFFFFFFFFFFFFC7ELLU:
	13252	+case 0xFFFFFFFFFFFFFC71LLU:
13056	13253	/* SP = 14LLU */
13057	13254	{
13058	13255	/CALLEND/
13059	13256	stackbase += 12LLU;
13060		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7DLLU;
	13257	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC70LLU;
13061	13258	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
13062	13259	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
13063	13260	break;
13064	13261	}
13065		-case 0xFFFFFFFFFFFFFC7DLLU:
	13262	+case 0xFFFFFFFFFFFFFC70LLU:
13066	13263	/* SP = 10LLU */
13067	13264	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
13068		-{ /* JUMP / fnaddr = 18446744073709550720LLU; break; } / skip consequent */
	13265	+{ /* JUMP / fnaddr = 18446744073709550707LLU; break; } / skip consequent */
13069	13266	/* consequent */
13070	13267	{
13071	13268	/* CALLBEGIN */

		@@ -13077,12 +13274,12 @@
13077	13274	{
13078	13275	/CALLEND/
13079	13276	stackbase += 12LLU;
13080		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7CLLU;
	13277	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6FLLU;
13081	13278	fnaddr = /typelistel/0xBF4AE09E4BAF8270LLU;/* SP = 0LLU */
13082	13279	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typelistel/\n"); exit(-1); }
13083	13280	break;
13084	13281	}
13085		-case 0xFFFFFFFFFFFFFC7CLLU:
	13282	+case 0xFFFFFFFFFFFFFC6FLLU:
13086	13283	/* SP = 10LLU // SP = 9LLU */
13087	13284	{ /* assign / / LOCAL VAR / stack[stackbase + 7LLU] = / LOCAL VAR */ stack[stackbase + 9LLU]; }
13088	13285	{

		@@ -13094,12 +13291,12 @@
13094	13291	{
13095	13292	/CALLEND/
13096	13293	stackbase += 11LLU;
13097		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7BLLU;
	13294	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6ELLU;
13098	13295	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13099	13296	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
13100	13297	break;
13101	13298	}
13102		-case 0xFFFFFFFFFFFFFC7BLLU:
	13299	+case 0xFFFFFFFFFFFFFC6ELLU:
13103	13300	/* SP = 9LLU // predicate */
13104	13301
13105	13302	{

		@@ -13112,15 +13309,15 @@
13112	13309	{
13113	13310	/CALLEND/
13114	13311	stackbase += 12LLU;
13115		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC78LLU;
	13312	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6BLLU;
13116	13313	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
13117	13314	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
13118	13315	break;
13119	13316	}
13120		-case 0xFFFFFFFFFFFFFC78LLU:
	13317	+case 0xFFFFFFFFFFFFFC6BLLU:
13121	13318	/* SP = 10LLU */
13122	13319	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
13123		-{ /* JUMP / fnaddr = 18446744073709550714LLU; break; } / skip consequent */
	13320	+{ /* JUMP / fnaddr = 18446744073709550701LLU; break; } / skip consequent */
13124	13321	/* consequent */
13125	13322	{
13126	13323	/* CALLBEGIN */

		@@ -13138,23 +13335,23 @@
13138	13335	{
13139	13336	/CALLEND/
13140	13337	stackbase += 14LLU;
13141		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC77LLU;
	13338	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6ALLU;
13142	13339	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
13143	13340	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
13144	13341	break;
13145	13342	}
13146		-case 0xFFFFFFFFFFFFFC77LLU:
	13343	+case 0xFFFFFFFFFFFFFC6ALLU:
13147	13344	/* SP = 12LLU */
13148	13345	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 13LLU */
13149	13346	{
13150	13347	/CALLEND/
13151	13348	stackbase += 11LLU;
13152		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC76LLU;
	13349	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC69LLU;
13153	13350	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
13154	13351	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); }
13155	13352	break;
13156	13353	}
13157		-case 0xFFFFFFFFFFFFFC76LLU:
	13354	+case 0xFFFFFFFFFFFFFC69LLU:
13158	13355	/* SP = 9LLU */
13159	13356	{
13160	13357	/* CALLBEGIN */

		@@ -13165,12 +13362,12 @@
13165	13362	{
13166	13363	/CALLEND/
13167	13364	stackbase += 12LLU;
13168		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC75LLU;
	13365	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC68LLU;
13169	13366	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
13170	13367	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
13171	13368	break;
13172	13369	}
13173		-case 0xFFFFFFFFFFFFFC75LLU:
	13370	+case 0xFFFFFFFFFFFFFC68LLU:
13174	13371	/* SP = 10LLU */
13175	13372	{
13176	13373	/* CALLBEGIN */

		@@ -13181,12 +13378,12 @@
13181	13378	{
13182	13379	/CALLEND/
13183	13380	stackbase += 12LLU;
13184		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC74LLU;
	13381	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC67LLU;
13185	13382	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13186	13383	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
13187	13384	break;
13188	13385	}
13189		-case 0xFFFFFFFFFFFFFC74LLU:
	13386	+case 0xFFFFFFFFFFFFFC67LLU:
13190	13387	/* SP = 10LLU */
13191	13388	{
13192	13389	/* CALLBEGIN */

		@@ -13206,12 +13403,12 @@
13206	13403	{
13207	13404	/CALLEND/
13208	13405	stackbase += 18LLU;
13209		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC73LLU;
	13406	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC66LLU;
13210	13407	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
13211	13408	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
13212	13409	break;
13213	13410	}
13214		-case 0xFFFFFFFFFFFFFC73LLU:
	13411	+case 0xFFFFFFFFFFFFFC66LLU:
13215	13412	/* SP = 16LLU */
13216	13413	{ /* PUSH / stack[stackbase + 16LLU] = / LOCAL VAR / stack[stackbase + 7LLU]; }/ SP + 1LLU = 17LLU */
13217	13414	{ /* PUSH / stack[stackbase + 17LLU] = 0LLU; }/ SP + 1LLU = 18LLU */

		@@ -13218,12 +13415,12 @@
13218	13415	{
13219	13416	/CALLEND/
13220	13417	stackbase += 12LLU;
13221		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC72LLU;
	13418	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC65LLU;
13222	13419	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13223	13420	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
13224	13421	break;
13225	13422	}
13226		-case 0xFFFFFFFFFFFFFC72LLU:
	13423	+case 0xFFFFFFFFFFFFFC65LLU:
13227	13424	/* SP = 10LLU */
13228	13425	{
13229	13426	/* CALLBEGIN */

		@@ -13236,12 +13433,12 @@
13236	13433	{
13237	13434	/CALLEND/
13238	13435	stackbase += 13LLU;
13239		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC71LLU;
	13436	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC64LLU;
13240	13437	fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
13241	13438	if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
13242	13439	break;
13243	13440	}
13244		-case 0xFFFFFFFFFFFFFC71LLU:
	13441	+case 0xFFFFFFFFFFFFFC64LLU:
13245	13442	/* SP = 11LLU */
13246	13443	{
13247	13444	/* CALLBEGIN */

		@@ -13253,15 +13450,15 @@
13253	13450	{
13254	13451	/CALLEND/
13255	13452	stackbase += 13LLU;
13256		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC70LLU;
	13453	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC63LLU;
13257	13454	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
13258	13455	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
13259	13456	break;
13260	13457	}
13261		-case 0xFFFFFFFFFFFFFC70LLU:
	13458	+case 0xFFFFFFFFFFFFFC63LLU:
13262	13459	/* SP = 11LLU */
13263	13460	{ /* PUSH / stack[stackbase + 11LLU] = 0LLU; }/ SP + 1LLU = 12LLU */
13264		-case 0xFFFFFFFFFFFFFC6FLLU: /* loop to here // predicate */
	13461	+case 0xFFFFFFFFFFFFFC62LLU: /* loop to here // predicate */
13265	13462
13266	13463	{
13267	13464	/* CALLBEGIN */

		@@ -13274,15 +13471,15 @@
13274	13471	{
13275	13472	/CALLEND/
13276	13473	stackbase += 15LLU;
13277		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6DLLU;
	13474	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC60LLU;
13278	13475	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
13279	13476	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
13280	13477	break;
13281	13478	}
13282		-case 0xFFFFFFFFFFFFFC6DLLU:
	13479	+case 0xFFFFFFFFFFFFFC60LLU:
13283	13480	/* SP = 13LLU */
13284	13481	if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU])
13285		-{ /* JUMP / fnaddr = 18446744073709550702LLU; break; } / skip loop */
	13482	+{ /* JUMP / fnaddr = 18446744073709550689LLU; break; } / skip loop */
13286	13483	/* loop /fputs("\n{ / LIST-WRITE /", stdout); fputs("/ DEREF-LIST */ stack[", stdout);
13287	13484	{
13288	13485	/* CALLBEGIN */

		@@ -13294,12 +13491,12 @@
13294	13491	{
13295	13492	/CALLEND/
13296	13493	stackbase += 14LLU;
13297		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6CLLU;
	13494	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5FLLU;
13298	13495	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
13299	13496	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
13300	13497	break;
13301	13498	}
13302		-case 0xFFFFFFFFFFFFFC6CLLU:
	13499	+case 0xFFFFFFFFFFFFFC5FLLU:
13303	13500	/* SP = 12LLU */fputs(" + ", stdout);
13304	13501	{
13305	13502	/* CALLBEGIN */

		@@ -13318,22 +13515,22 @@
13318	13515	{
13319	13516	/CALLEND/
13320	13517	stackbase += 17LLU;
13321		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6BLLU;
	13518	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5ELLU;
13322	13519	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
13323	13520	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
13324	13521	break;
13325	13522	}
13326		-case 0xFFFFFFFFFFFFFC6BLLU:
	13523	+case 0xFFFFFFFFFFFFFC5ELLU:
13327	13524	/* SP = 15LLU */
13328	13525	{
13329	13526	/CALLEND/
13330	13527	stackbase += 14LLU;
13331		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6ALLU;
	13528	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5DLLU;
13332	13529	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
13333	13530	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
13334	13531	break;
13335	13532	}
13336		-case 0xFFFFFFFFFFFFFC6ALLU:
	13533	+case 0xFFFFFFFFFFFFFC5DLLU:
13337	13534	/* SP = 12LLU */fputs("] = ", stdout);
13338	13535	{
13339	13536	/* CALLBEGIN */

		@@ -13352,22 +13549,22 @@
13352	13549	{
13353	13550	/CALLEND/
13354	13551	stackbase += 17LLU;
13355		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC69LLU;
	13552	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5CLLU;
13356	13553	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
13357	13554	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
13358	13555	break;
13359	13556	}
13360		-case 0xFFFFFFFFFFFFFC69LLU:
	13557	+case 0xFFFFFFFFFFFFFC5CLLU:
13361	13558	/* SP = 15LLU */
13362	13559	{
13363	13560	/CALLEND/
13364	13561	stackbase += 14LLU;
13365		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC68LLU;
	13562	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5BLLU;
13366	13563	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
13367	13564	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
13368	13565	break;
13369	13566	}
13370		-case 0xFFFFFFFFFFFFFC68LLU:
	13567	+case 0xFFFFFFFFFFFFFC5BLLU:
13371	13568	/* SP = 12LLU */fputs("; }", stdout);
13372	13569	{
13373	13570	/* CALLBEGIN */

		@@ -13380,18 +13577,18 @@
13380	13577	{
13381	13578	/CALLEND/
13382	13579	stackbase += 15LLU;
13383		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC67LLU;
	13580	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5ALLU;
13384	13581	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
13385	13582	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
13386	13583	break;
13387	13584	}
13388		-case 0xFFFFFFFFFFFFFC67LLU:
	13585	+case 0xFFFFFFFFFFFFFC5ALLU:
13389	13586	/* SP = 13LLU // SP = 12LLU */
13390	13587	{ /* assign / / LOCAL VAR / stack[stackbase + 11LLU] = / LOCAL VAR / stack[stackbase + 12LLU]; }/ SP = 12LLU */
13391		-{ /* JUMP / fnaddr = 18446744073709550703LLU; break; } / loop */
13392		-case 18446744073709550702LLU: /* skip to here // SP = 9LLU // SP = 9LLU */
13393		-{ /* JUMP / fnaddr = 18446744073709550713LLU; break; } / skip alternative */
13394		-case 18446744073709550714LLU: /* alternative */
	13588	+{ /* JUMP / fnaddr = 18446744073709550690LLU; break; } / loop */
	13589	+case 18446744073709550689LLU: /* skip to here // SP = 9LLU // SP = 9LLU */
	13590	+{ /* JUMP / fnaddr = 18446744073709550700LLU; break; } / skip alternative */
	13591	+case 18446744073709550701LLU: /* alternative */
13395	13592	{
13396	13593	/* CALLBEGIN */
13397	13594	/* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */

		@@ -13404,12 +13601,12 @@
13404	13601	{
13405	13602	/CALLEND/
13406	13603	stackbase += 11LLU;
13407		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC66LLU;
	13604	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC59LLU;
13408	13605	fnaddr = /typecheckV/0xBF4AE07A381E9960LLU;/* SP = 0LLU */
13409	13606	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheckV/\n"); exit(-1); }
13410	13607	break;
13411	13608	}
13412		-case 0xFFFFFFFFFFFFFC66LLU:
	13609	+case 0xFFFFFFFFFFFFFC59LLU:
13413	13610	/* SP = 9LLU */
13414	13611	{
13415	13612	/* CALLBEGIN */

		@@ -13422,15 +13619,15 @@
13422	13619	{
13423	13620	/CALLEND/
13424	13621	stackbase += 12LLU;
13425		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC65LLU;
	13622	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC58LLU;
13426	13623	fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
13427	13624	if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
13428	13625	break;
13429	13626	}
13430		-case 0xFFFFFFFFFFFFFC65LLU:
	13627	+case 0xFFFFFFFFFFFFFC58LLU:
13431	13628	/* SP = 10LLU */
13432	13629	{ /* PUSH / stack[stackbase + 10LLU] = 0LLU; }/ SP + 1LLU = 11LLU */
13433		-case 0xFFFFFFFFFFFFFC64LLU: /* loop to here // predicate */
	13630	+case 0xFFFFFFFFFFFFFC57LLU: /* loop to here // predicate */
13434	13631
13435	13632	{
13436	13633	/* CALLBEGIN */

		@@ -13443,15 +13640,15 @@
13443	13640	{
13444	13641	/CALLEND/
13445	13642	stackbase += 14LLU;
13446		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC62LLU;
	13643	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC55LLU;
13447	13644	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
13448	13645	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
13449	13646	break;
13450	13647	}
13451		-case 0xFFFFFFFFFFFFFC62LLU:
	13648	+case 0xFFFFFFFFFFFFFC55LLU:
13452	13649	/* SP = 12LLU */
13453	13650	if(!/* SP - 1LLU = 11LLU */stack[stackbase + 11LLU])
13454		-{ /* JUMP / fnaddr = 18446744073709550691LLU; break; } / skip loop */
	13651	+{ /* JUMP / fnaddr = 18446744073709550678LLU; break; } / skip loop */
13455	13652	/* loop /fputs("\n{ / LIST-READ */", stdout);
13456	13653	{
13457	13654	/* CALLBEGIN */

		@@ -13462,12 +13659,12 @@
13462	13659	{
13463	13660	/CALLEND/
13464	13661	stackbase += 13LLU;
13465		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC61LLU;
	13662	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC54LLU;
13466	13663	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
13467	13664	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); }
13468	13665	break;
13469	13666	}
13470		-case 0xFFFFFFFFFFFFFC61LLU:
	13667	+case 0xFFFFFFFFFFFFFC54LLU:
13471	13668	/* SP = 11LLU /fputs("/ DEREF-LIST */ stack[", stdout);
13472	13669	{
13473	13670	/* CALLBEGIN */

		@@ -13479,12 +13676,12 @@
13479	13676	{
13480	13677	/CALLEND/
13481	13678	stackbase += 13LLU;
13482		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC60LLU;
	13679	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC53LLU;
13483	13680	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
13484	13681	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
13485	13682	break;
13486	13683	}
13487		-case 0xFFFFFFFFFFFFFC60LLU:
	13684	+case 0xFFFFFFFFFFFFFC53LLU:
13488	13685	/* SP = 11LLU */fputs(" + ", stdout);
13489	13686	{
13490	13687	/* CALLBEGIN */

		@@ -13503,22 +13700,22 @@
13503	13700	{
13504	13701	/CALLEND/
13505	13702	stackbase += 16LLU;
13506		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5FLLU;
	13703	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC52LLU;
13507	13704	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
13508	13705	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
13509	13706	break;
13510	13707	}
13511		-case 0xFFFFFFFFFFFFFC5FLLU:
	13708	+case 0xFFFFFFFFFFFFFC52LLU:
13512	13709	/* SP = 14LLU */
13513	13710	{
13514	13711	/CALLEND/
13515	13712	stackbase += 13LLU;
13516		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5ELLU;
	13713	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC51LLU;
13517	13714	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
13518	13715	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
13519	13716	break;
13520	13717	}
13521		-case 0xFFFFFFFFFFFFFC5ELLU:
	13718	+case 0xFFFFFFFFFFFFFC51LLU:
13522	13719	/* SP = 11LLU */fputs("]", stdout);
13523	13720	{
13524	13721	/* CALLBEGIN */

		@@ -13529,12 +13726,12 @@
13529	13726	{
13530	13727	/CALLEND/
13531	13728	stackbase += 13LLU;
13532		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5DLLU;
	13729	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC50LLU;
13533	13730	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
13534	13731	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); }
13535	13732	break;
13536	13733	}
13537		-case 0xFFFFFFFFFFFFFC5DLLU:
	13734	+case 0xFFFFFFFFFFFFFC50LLU:
13538	13735	/* SP = 11LLU */fputs(" }", stdout);
13539	13736	{
13540	13737	/* CALLBEGIN */

		@@ -13547,20 +13744,20 @@
13547	13744	{
13548	13745	/CALLEND/
13549	13746	stackbase += 14LLU;
13550		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5CLLU;
	13747	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4FLLU;
13551	13748	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
13552	13749	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
13553	13750	break;
13554	13751	}
13555		-case 0xFFFFFFFFFFFFFC5CLLU:
	13752	+case 0xFFFFFFFFFFFFFC4FLLU:
13556	13753	/* SP = 12LLU // SP = 11LLU */
13557	13754	{ /* assign / / LOCAL VAR / stack[stackbase + 10LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ SP = 11LLU */
13558		-{ /* JUMP / fnaddr = 18446744073709550692LLU; break; } / loop */
13559		-case 18446744073709550691LLU: /* skip to here // SP = 9LLU */
13560		-case 18446744073709550713LLU: /* skip to here */
	13755	+{ /* JUMP / fnaddr = 18446744073709550679LLU; break; } / loop */
	13756	+case 18446744073709550678LLU: /* skip to here // SP = 9LLU */
	13757	+case 18446744073709550700LLU: /* skip to here */
13561	13758	/* SP = 9LLU // SP = 9LLU */
13562		-{ /* JUMP / fnaddr = 18446744073709550719LLU; break; } / skip alternative */
13563		-case 18446744073709550720LLU: /* alternative */
	13759	+{ /* JUMP / fnaddr = 18446744073709550706LLU; break; } / skip alternative */
	13760	+case 18446744073709550707LLU: /* alternative */
13564	13761	{ /* PUSH / stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU */
13565	13762	{
13566	13763	/* CALLBEGIN */

		@@ -13577,23 +13774,23 @@
13577	13774	{
13578	13775	/CALLEND/
13579	13776	stackbase += 16LLU;
13580		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5BLLU;
	13777	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4ELLU;
13581	13778	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
13582	13779	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
13583	13780	break;
13584	13781	}
13585		-case 0xFFFFFFFFFFFFFC5BLLU:
	13782	+case 0xFFFFFFFFFFFFFC4ELLU:
13586	13783	/* SP = 14LLU */
13587	13784	{ /* PUSH / stack[stackbase + 14LLU] = 1LLU; }/ SP + 1LLU = 15LLU */
13588	13785	{
13589	13786	/CALLEND/
13590	13787	stackbase += 13LLU;
13591		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5ALLU;
	13788	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4DLLU;
13592	13789	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
13593	13790	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
13594	13791	break;
13595	13792	}
13596		-case 0xFFFFFFFFFFFFFC5ALLU:
	13793	+case 0xFFFFFFFFFFFFFC4DLLU:
13597	13794	/* SP = 11LLU // SP = 10LLU */
13598	13795	{ /* assign / / LOCAL VAR / stack[stackbase + 9LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ predicate */
13599	13796

		@@ -13620,35 +13817,35 @@
13620	13817	{
13621	13818	/CALLEND/
13622	13819	stackbase += 20LLU;
13623		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC57LLU;
	13820	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4ALLU;
13624	13821	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
13625	13822	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); }
13626	13823	break;
13627	13824	}
13628		-case 0xFFFFFFFFFFFFFC57LLU:
	13825	+case 0xFFFFFFFFFFFFFC4ALLU:
13629	13826	/* SP = 18LLU */
13630	13827	{
13631	13828	/CALLEND/
13632	13829	stackbase += 17LLU;
13633		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC56LLU;
	13830	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC49LLU;
13634	13831	fnaddr = /subtosize_/0xBB076FAAE9358000LLU;/* SP = 0LLU */
13635	13832	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtosize_/\n"); exit(-1); }
13636	13833	break;
13637	13834	}
13638		-case 0xFFFFFFFFFFFFFC56LLU:
	13835	+case 0xFFFFFFFFFFFFFC49LLU:
13639	13836	/* SP = 15LLU */
13640	13837	{
13641	13838	/CALLEND/
13642	13839	stackbase += 13LLU;
13643		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC55LLU;
	13840	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC48LLU;
13644	13841	fnaddr = /leq_______/0x9E0B000000000000LLU;/* SP = 0LLU */
13645	13842	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /leq_______/\n"); exit(-1); }
13646	13843	break;
13647	13844	}
13648		-case 0xFFFFFFFFFFFFFC55LLU:
	13845	+case 0xFFFFFFFFFFFFFC48LLU:
13649	13846	/* SP = 11LLU */
13650	13847	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
13651		-{ /* JUMP / fnaddr = 18446744073709550681LLU; break; } / skip consequent */
	13848	+{ /* JUMP / fnaddr = 18446744073709550668LLU; break; } / skip consequent */
13652	13849	/* consequent // predicate */
13653	13850
13654	13851	{

		@@ -13662,15 +13859,15 @@
13662	13859	{
13663	13860	/CALLEND/
13664	13861	stackbase += 13LLU;
13665		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC52LLU;
	13862	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC45LLU;
13666	13863	fnaddr = /gtr_______/0x8AFB400000000000LLU;/* SP = 0LLU */
13667	13864	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /gtr_______/\n"); exit(-1); }
13668	13865	break;
13669	13866	}
13670		-case 0xFFFFFFFFFFFFFC52LLU:
	13867	+case 0xFFFFFFFFFFFFFC45LLU:
13671	13868	/* SP = 11LLU */
13672	13869	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
13673		-{ /* JUMP / fnaddr = 18446744073709550676LLU; break; } / skip consequent */
	13870	+{ /* JUMP / fnaddr = 18446744073709550663LLU; break; } / skip consequent */
13674	13871	/* consequent */
13675	13872	{
13676	13873	/* CALLBEGIN */

		@@ -13682,17 +13879,17 @@
13682	13879	{
13683	13880	/CALLEND/
13684	13881	stackbase += 13LLU;
13685		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC51LLU;
	13882	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC44LLU;
13686	13883	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
13687	13884	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
13688	13885	break;
13689	13886	}
13690		-case 0xFFFFFFFFFFFFFC51LLU:
	13887	+case 0xFFFFFFFFFFFFFC44LLU:
13691	13888	/* SP = 11LLU // SP = 10LLU */
13692	13889	{ /* assign / / LOCAL VAR / stack[stackbase + 7LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ SP = 10LLU // SP = 10LLU */
13693		-{ /* JUMP / fnaddr = 18446744073709550675LLU; break; } / skip alternative */
13694		-case 18446744073709550676LLU: /* alternative // SP = 10LLU */
13695		-case 18446744073709550675LLU: /* skip to here */
	13890	+{ /* JUMP / fnaddr = 18446744073709550662LLU; break; } / skip alternative */
	13891	+case 18446744073709550663LLU: /* alternative // SP = 10LLU */
	13892	+case 18446744073709550662LLU: /* skip to here */
13696	13893
13697	13894	{
13698	13895	/* CALLBEGIN */

		@@ -13703,12 +13900,12 @@
13703	13900	{
13704	13901	/CALLEND/
13705	13902	stackbase += 12LLU;
13706		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC50LLU;
	13903	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC43LLU;
13707	13904	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13708	13905	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
13709	13906	break;
13710	13907	}
13711		-case 0xFFFFFFFFFFFFFC50LLU:
	13908	+case 0xFFFFFFFFFFFFFC43LLU:
13712	13909	/* SP = 10LLU // predicate */
13713	13910
13714	13911	{

		@@ -13721,15 +13918,15 @@
13721	13918	{
13722	13919	/CALLEND/
13723	13920	stackbase += 13LLU;
13724		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4DLLU;
	13921	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC40LLU;
13725	13922	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
13726	13923	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
13727	13924	break;
13728	13925	}
13729		-case 0xFFFFFFFFFFFFFC4DLLU:
	13926	+case 0xFFFFFFFFFFFFFC40LLU:
13730	13927	/* SP = 11LLU */
13731	13928	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
13732		-{ /* JUMP / fnaddr = 18446744073709550671LLU; break; } / skip consequent */
	13929	+{ /* JUMP / fnaddr = 18446744073709550658LLU; break; } / skip consequent */
13733	13930	/* consequent */
13734	13931	{
13735	13932	/* CALLBEGIN */

		@@ -13747,23 +13944,23 @@
13747	13944	{
13748	13945	/CALLEND/
13749	13946	stackbase += 15LLU;
13750		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4CLLU;
	13947	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3FLLU;
13751	13948	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
13752	13949	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
13753	13950	break;
13754	13951	}
13755		-case 0xFFFFFFFFFFFFFC4CLLU:
	13952	+case 0xFFFFFFFFFFFFFC3FLLU:
13756	13953	/* SP = 13LLU */
13757	13954	{ /* PUSH / stack[stackbase + 13LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 14LLU */
13758	13955	{
13759	13956	/CALLEND/
13760	13957	stackbase += 12LLU;
13761		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4BLLU;
	13958	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ELLU;
13762	13959	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
13763	13960	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); }
13764	13961	break;
13765	13962	}
13766		-case 0xFFFFFFFFFFFFFC4BLLU:
	13963	+case 0xFFFFFFFFFFFFFC3ELLU:
13767	13964	/* SP = 10LLU */
13768	13965	{
13769	13966	/* CALLBEGIN */

		@@ -13774,12 +13971,12 @@
13774	13971	{
13775	13972	/CALLEND/
13776	13973	stackbase += 12LLU;
13777		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4ALLU;
	13974	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3DLLU;
13778	13975	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13779	13976	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
13780	13977	break;
13781	13978	}
13782		-case 0xFFFFFFFFFFFFFC4ALLU:
	13979	+case 0xFFFFFFFFFFFFFC3DLLU:
13783	13980	/* SP = 10LLU */
13784	13981	{
13785	13982	/* CALLBEGIN */

		@@ -13799,12 +13996,12 @@
13799	13996	{
13800	13997	/CALLEND/
13801	13998	stackbase += 18LLU;
13802		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC49LLU;
	13999	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3CLLU;
13803	14000	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
13804	14001	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
13805	14002	break;
13806	14003	}
13807		-case 0xFFFFFFFFFFFFFC49LLU:
	14004	+case 0xFFFFFFFFFFFFFC3CLLU:
13808	14005	/* SP = 16LLU */
13809	14006	{ /* PUSH / stack[stackbase + 16LLU] = / LOCAL VAR / stack[stackbase + 7LLU]; }/ SP + 1LLU = 17LLU */
13810	14007	{ /* PUSH / stack[stackbase + 17LLU] = 0LLU; }/ SP + 1LLU = 18LLU */

		@@ -13811,12 +14008,12 @@
13811	14008	{
13812	14009	/CALLEND/
13813	14010	stackbase += 12LLU;
13814		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC48LLU;
	14011	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3BLLU;
13815	14012	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13816	14013	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
13817	14014	break;
13818	14015	}
13819		-case 0xFFFFFFFFFFFFFC48LLU:
	14016	+case 0xFFFFFFFFFFFFFC3BLLU:
13820	14017	/* SP = 10LLU /fputs("/ DEREF-LIST */ stack[", stdout);
13821	14018	{
13822	14019	/* CALLBEGIN */

		@@ -13828,12 +14025,12 @@
13828	14025	{
13829	14026	/CALLEND/
13830	14027	stackbase += 12LLU;
13831		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC47LLU;
	14028	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ALLU;
13832	14029	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
13833	14030	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
13834	14031	break;
13835	14032	}
13836		-case 0xFFFFFFFFFFFFFC47LLU:
	14033	+case 0xFFFFFFFFFFFFFC3ALLU:
13837	14034	/* SP = 10LLU */fputs(" + ", stdout);
13838	14035	{
13839	14036	/* CALLBEGIN */

		@@ -13845,12 +14042,12 @@
13845	14042	{
13846	14043	/CALLEND/
13847	14044	stackbase += 12LLU;
13848		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC46LLU;
	14045	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC39LLU;
13849	14046	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
13850	14047	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
13851	14048	break;
13852	14049	}
13853		-case 0xFFFFFFFFFFFFFC46LLU:
	14050	+case 0xFFFFFFFFFFFFFC39LLU:
13854	14051	/* SP = 10LLU */fputs("]", stdout); fputs(" = ", stdout);
13855	14052	{
13856	14053	/* CALLBEGIN */

		@@ -13861,15 +14058,15 @@
13861	14058	{
13862	14059	/CALLEND/
13863	14060	stackbase += 12LLU;
13864		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC45LLU;
	14061	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC38LLU;
13865	14062	fnaddr = /POP_______/0x40F4000000000000LLU;/* SP = 0LLU */
13866	14063	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_______/\n"); exit(-1); }
13867	14064	break;
13868	14065	}
13869		-case 0xFFFFFFFFFFFFFC45LLU:
	14066	+case 0xFFFFFFFFFFFFFC38LLU:
13870	14067	/* SP = 10LLU // SP = 10LLU // SP = 10LLU */
13871		-{ /* JUMP / fnaddr = 18446744073709550670LLU; break; } / skip alternative */
13872		-case 18446744073709550671LLU: /* alternative */
	14068	+{ /* JUMP / fnaddr = 18446744073709550657LLU; break; } / skip alternative */
	14069	+case 18446744073709550658LLU: /* alternative */
13873	14070	{
13874	14071	/* CALLBEGIN */
13875	14072	/* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */

		@@ -13882,12 +14079,12 @@
13882	14079	{
13883	14080	/CALLEND/
13884	14081	stackbase += 12LLU;
13885		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC44LLU;
	14082	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC37LLU;
13886	14083	fnaddr = /typecheckV/0xBF4AE07A381E9960LLU;/* SP = 0LLU */
13887	14084	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheckV/\n"); exit(-1); }
13888	14085	break;
13889	14086	}
13890		-case 0xFFFFFFFFFFFFFC44LLU:
	14087	+case 0xFFFFFFFFFFFFFC37LLU:
13891	14088	/* SP = 10LLU */
13892	14089	{
13893	14090	/* CALLBEGIN */

		@@ -13898,12 +14095,12 @@
13898	14095	{
13899	14096	/CALLEND/
13900	14097	stackbase += 12LLU;
13901		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC43LLU;
	14098	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC36LLU;
13902	14099	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
13903	14100	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); }
13904	14101	break;
13905	14102	}
13906		-case 0xFFFFFFFFFFFFFC43LLU:
	14103	+case 0xFFFFFFFFFFFFFC36LLU:
13907	14104	/* SP = 10LLU /fputs("/ DEREF-LIST */ stack[", stdout);
13908	14105	{
13909	14106	/* CALLBEGIN */

		@@ -13915,12 +14112,12 @@
13915	14112	{
13916	14113	/CALLEND/
13917	14114	stackbase += 12LLU;
13918		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC42LLU;
	14115	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC35LLU;
13919	14116	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
13920	14117	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
13921	14118	break;
13922	14119	}
13923		-case 0xFFFFFFFFFFFFFC42LLU:
	14120	+case 0xFFFFFFFFFFFFFC35LLU:
13924	14121	/* SP = 10LLU */fputs(" + ", stdout);
13925	14122	{
13926	14123	/* CALLBEGIN */

		@@ -13932,12 +14129,12 @@
13932	14129	{
13933	14130	/CALLEND/
13934	14131	stackbase += 12LLU;
13935		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC41LLU;
	14132	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC34LLU;
13936	14133	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
13937	14134	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
13938	14135	break;
13939	14136	}
13940		-case 0xFFFFFFFFFFFFFC41LLU:
	14137	+case 0xFFFFFFFFFFFFFC34LLU:
13941	14138	/* SP = 10LLU */fputs("]", stdout);
13942	14139	{
13943	14140	/* CALLBEGIN */

		@@ -13948,17 +14145,17 @@
13948	14145	{
13949	14146	/CALLEND/
13950	14147	stackbase += 12LLU;
13951		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC40LLU;
	14148	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC33LLU;
13952	14149	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
13953	14150	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); }
13954	14151	break;
13955	14152	}
13956		-case 0xFFFFFFFFFFFFFC40LLU:
	14153	+case 0xFFFFFFFFFFFFFC33LLU:
13957	14154	/* SP = 10LLU // SP = 10LLU */
13958		-case 18446744073709550670LLU: /* skip to here */
	14155	+case 18446744073709550657LLU: /* skip to here */
13959	14156	/* SP = 10LLU // SP = 10LLU */
13960		-{ /* JUMP / fnaddr = 18446744073709550680LLU; break; } / skip alternative */
13961		-case 18446744073709550681LLU: /* alternative */
	14157	+{ /* JUMP / fnaddr = 18446744073709550667LLU; break; } / skip alternative */
	14158	+case 18446744073709550668LLU: /* alternative */
13962	14159	{
13963	14160	/* CALLBEGIN */
13964	14161	/* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */

		@@ -13968,12 +14165,12 @@
13968	14165	{
13969	14166	/CALLEND/
13970	14167	stackbase += 12LLU;
13971		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3FLLU;
	14168	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC32LLU;
13972	14169	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
13973	14170	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
13974	14171	break;
13975	14172	}
13976		-case 0xFFFFFFFFFFFFFC3FLLU:
	14173	+case 0xFFFFFFFFFFFFFC32LLU:
13977	14174	/* SP = 10LLU */fputs("element of list ", stderr);
13978	14175	{
13979	14176	/* CALLBEGIN */

		@@ -13985,12 +14182,12 @@
13985	14182	{
13986	14183	/CALLEND/
13987	14184	stackbase += 12LLU;
13988		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ELLU;
	14185	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC31LLU;
13989	14186	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
13990	14187	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
13991	14188	break;
13992	14189	}
13993		-case 0xFFFFFFFFFFFFFC3ELLU:
	14190	+case 0xFFFFFFFFFFFFFC31LLU:
13994	14191	/* SP = 10LLU */fputs(" of size ", stderr);
13995	14192	{
13996	14193	/* CALLBEGIN */

		@@ -14014,32 +14211,32 @@
14014	14211	{
14015	14212	/CALLEND/
14016	14213	stackbase += 18LLU;
14017		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3DLLU;
	14214	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC30LLU;
14018	14215	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
14019	14216	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); }
14020	14217	break;
14021	14218	}
14022		-case 0xFFFFFFFFFFFFFC3DLLU:
	14219	+case 0xFFFFFFFFFFFFFC30LLU:
14023	14220	/* SP = 16LLU */
14024	14221	{
14025	14222	/CALLEND/
14026	14223	stackbase += 15LLU;
14027		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3CLLU;
	14224	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2FLLU;
14028	14225	fnaddr = /subtosize_/0xBB076FAAE9358000LLU;/* SP = 0LLU */
14029	14226	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtosize_/\n"); exit(-1); }
14030	14227	break;
14031	14228	}
14032		-case 0xFFFFFFFFFFFFFC3CLLU:
	14229	+case 0xFFFFFFFFFFFFFC2FLLU:
14033	14230	/* SP = 13LLU */
14034	14231	{
14035	14232	/CALLEND/
14036	14233	stackbase += 12LLU;
14037		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3BLLU;
	14234	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2ELLU;
14038	14235	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
14039	14236	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
14040	14237	break;
14041	14238	}
14042		-case 0xFFFFFFFFFFFFFC3BLLU:
	14239	+case 0xFFFFFFFFFFFFFC2ELLU:
14043	14240	/* SP = 10LLU */fputs(" has no element ", stderr);
14044	14241	{
14045	14242	/* CALLBEGIN */

		@@ -14058,29 +14255,29 @@
14058	14255	{
14059	14256	/CALLEND/
14060	14257	stackbase += 15LLU;
14061		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ALLU;
	14258	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2DLLU;
14062	14259	fnaddr = /sub_______/0xBB07400000000000LLU;/* SP = 0LLU */
14063	14260	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /sub_______/\n"); exit(-1); }
14064	14261	break;
14065	14262	}
14066		-case 0xFFFFFFFFFFFFFC3ALLU:
	14263	+case 0xFFFFFFFFFFFFFC2DLLU:
14067	14264	/* SP = 13LLU */
14068	14265	{
14069	14266	/CALLEND/
14070	14267	stackbase += 12LLU;
14071		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC39LLU;
	14268	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2CLLU;
14072	14269	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
14073	14270	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
14074	14271	break;
14075	14272	}
14076		-case 0xFFFFFFFFFFFFFC39LLU:
	14273	+case 0xFFFFFFFFFFFFFC2CLLU:
14077	14274	/* SP = 10LLU /exit(-1);/ SP = 10LLU */
14078		-case 18446744073709550680LLU: /* skip to here */
	14275	+case 18446744073709550667LLU: /* skip to here */
14079	14276	/* SP = 9LLU */
14080		-case 18446744073709550719LLU: /* skip to here */
	14277	+case 18446744073709550706LLU: /* skip to here */
14081	14278	/* SP = 9LLU // SP = 9LLU */
14082		-{ /* JUMP / fnaddr = 18446744073709550727LLU; break; } / skip alternative */
14083		-case 18446744073709550728LLU: /* alternative */
	14279	+{ /* JUMP / fnaddr = 18446744073709550714LLU; break; } / skip alternative */
	14280	+case 18446744073709550715LLU: /* alternative */
14084	14281	{
14085	14282	/* CALLBEGIN */
14086	14283	/* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */

		@@ -14090,12 +14287,12 @@
14090	14287	{
14091	14288	/CALLEND/
14092	14289	stackbase += 11LLU;
14093		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC38LLU;
	14290	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2BLLU;
14094	14291	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14095	14292	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
14096	14293	break;
14097	14294	}
14098		-case 0xFFFFFFFFFFFFFC38LLU:
	14295	+case 0xFFFFFFFFFFFFFC2BLLU:
14099	14296	/* SP = 9LLU // predicate */
14100	14297
14101	14298	{

		@@ -14108,15 +14305,15 @@
14108	14305	{
14109	14306	/CALLEND/
14110	14307	stackbase += 12LLU;
14111		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC35LLU;
	14308	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC28LLU;
14112	14309	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14113	14310	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14114	14311	break;
14115	14312	}
14116		-case 0xFFFFFFFFFFFFFC35LLU:
	14313	+case 0xFFFFFFFFFFFFFC28LLU:
14117	14314	/* SP = 10LLU */
14118	14315	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
14119		-{ /* JUMP / fnaddr = 18446744073709550647LLU; break; } / skip consequent */
	14316	+{ /* JUMP / fnaddr = 18446744073709550634LLU; break; } / skip consequent */
14120	14317	/* consequent */
14121	14318	{
14122	14319	/* CALLBEGIN */

		@@ -14134,23 +14331,23 @@
14134	14331	{
14135	14332	/CALLEND/
14136	14333	stackbase += 14LLU;
14137		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC34LLU;
	14334	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC27LLU;
14138	14335	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
14139	14336	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
14140	14337	break;
14141	14338	}
14142		-case 0xFFFFFFFFFFFFFC34LLU:
	14339	+case 0xFFFFFFFFFFFFFC27LLU:
14143	14340	/* SP = 12LLU */
14144	14341	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 13LLU */
14145	14342	{
14146	14343	/CALLEND/
14147	14344	stackbase += 11LLU;
14148		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC33LLU;
	14345	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC26LLU;
14149	14346	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
14150	14347	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); }
14151	14348	break;
14152	14349	}
14153		-case 0xFFFFFFFFFFFFFC33LLU:
	14350	+case 0xFFFFFFFFFFFFFC26LLU:
14154	14351	/* SP = 9LLU */
14155	14352	{
14156	14353	/* CALLBEGIN */

		@@ -14161,12 +14358,12 @@
14161	14358	{
14162	14359	/CALLEND/
14163	14360	stackbase += 11LLU;
14164		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC32LLU;
	14361	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC25LLU;
14165	14362	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14166	14363	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
14167	14364	break;
14168	14365	}
14169		-case 0xFFFFFFFFFFFFFC32LLU:
	14366	+case 0xFFFFFFFFFFFFFC25LLU:
14170	14367	/* SP = 9LLU */
14171	14368	{
14172	14369	/* CALLBEGIN */

		@@ -14178,12 +14375,12 @@
14178	14375	{
14179	14376	/CALLEND/
14180	14377	stackbase += 11LLU;
14181		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC31LLU;
	14378	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC24LLU;
14182	14379	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
14183	14380	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
14184	14381	break;
14185	14382	}
14186		-case 0xFFFFFFFFFFFFFC31LLU:
	14383	+case 0xFFFFFFFFFFFFFC24LLU:
14187	14384	/* SP = 9LLU */fputs("\n{", stdout);
14188	14385	{
14189	14386	/* CALLBEGIN */

		@@ -14195,15 +14392,15 @@
14195	14392	{
14196	14393	/CALLEND/
14197	14394	stackbase += 11LLU;
14198		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC30LLU;
	14395	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC23LLU;
14199	14396	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
14200	14397	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
14201	14398	break;
14202	14399	}
14203		-case 0xFFFFFFFFFFFFFC30LLU:
	14400	+case 0xFFFFFFFFFFFFFC23LLU:
14204	14401	/* SP = 9LLU /fputs(" = 0;}", stdout); / SP = 9LLU // SP = 9LLU */
14205		-{ /* JUMP / fnaddr = 18446744073709550646LLU; break; } / skip alternative */
14206		-case 18446744073709550647LLU: /* alternative */
	14402	+{ /* JUMP / fnaddr = 18446744073709550633LLU; break; } / skip alternative */
	14403	+case 18446744073709550634LLU: /* alternative */
14207	14404	{
14208	14405	/* CALLBEGIN */
14209	14406	/* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */

		@@ -14216,12 +14413,12 @@
14216	14413	{
14217	14414	/CALLEND/
14218	14415	stackbase += 11LLU;
14219		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2FLLU;
	14416	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC22LLU;
14220	14417	fnaddr = /typecheckV/0xBF4AE07A381E9960LLU;/* SP = 0LLU */
14221	14418	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheckV/\n"); exit(-1); }
14222	14419	break;
14223	14420	}
14224		-case 0xFFFFFFFFFFFFFC2FLLU:
	14421	+case 0xFFFFFFFFFFFFFC22LLU:
14225	14422	/* SP = 9LLU */
14226	14423	{
14227	14424	/* CALLBEGIN */

		@@ -14232,12 +14429,12 @@
14232	14429	{
14233	14430	/CALLEND/
14234	14431	stackbase += 11LLU;
14235		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2ELLU;
	14432	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC21LLU;
14236	14433	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
14237	14434	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); }
14238	14435	break;
14239	14436	}
14240		-case 0xFFFFFFFFFFFFFC2ELLU:
	14437	+case 0xFFFFFFFFFFFFFC21LLU:
14241	14438	/* SP = 9LLU */
14242	14439	{
14243	14440	/* CALLBEGIN */

		@@ -14249,12 +14446,12 @@
14249	14446	{
14250	14447	/CALLEND/
14251	14448	stackbase += 11LLU;
14252		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2DLLU;
	14449	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC20LLU;
14253	14450	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
14254	14451	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
14255	14452	break;
14256	14453	}
14257		-case 0xFFFFFFFFFFFFFC2DLLU:
	14454	+case 0xFFFFFFFFFFFFFC20LLU:
14258	14455	/* SP = 9LLU */
14259	14456	{
14260	14457	/* CALLBEGIN */

		@@ -14265,18 +14462,18 @@
14265	14462	{
14266	14463	/CALLEND/
14267	14464	stackbase += 11LLU;
14268		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2CLLU;
	14465	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1FLLU;
14269	14466	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
14270	14467	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); }
14271	14468	break;
14272	14469	}
14273		-case 0xFFFFFFFFFFFFFC2CLLU:
	14470	+case 0xFFFFFFFFFFFFFC1FLLU:
14274	14471	/* SP = 9LLU // SP = 9LLU */
14275		-case 18446744073709550646LLU: /* skip to here */
	14472	+case 18446744073709550633LLU: /* skip to here */
14276	14473	/* SP = 9LLU */
14277		-case 18446744073709550727LLU: /* skip to here */
	14474	+case 18446744073709550714LLU: /* skip to here */
14278	14475	/* SP = 9LLU */
14279		-case 18446744073709550788LLU: /* skip to here */
	14476	+case 18446744073709550775LLU: /* skip to here */
14280	14477	/* SP = 6LLU */
14281	14478	case 18446744073709550841LLU: /* skip to here */
14282	14479

		@@ -14297,15 +14494,15 @@
14297	14494	{
14298	14495	/CALLEND/
14299	14496	stackbase += 9LLU;
14300		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC29LLU;
	14497	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1CLLU;
14301	14498	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14302	14499	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14303	14500	break;
14304	14501	}
14305		-case 0xFFFFFFFFFFFFFC29LLU:
	14502	+case 0xFFFFFFFFFFFFFC1CLLU:
14306	14503	/* SP = 7LLU */
14307	14504	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14308		-{ /* JUMP / fnaddr = 18446744073709550635LLU; break; } / skip consequent */
	14505	+{ /* JUMP / fnaddr = 18446744073709550622LLU; break; } / skip consequent */
14309	14506	/* consequent */
14310	14507	{
14311	14508	/* CALLBEGIN */

		@@ -14327,25 +14524,25 @@
14327	14524	{
14328	14525	/CALLEND/
14329	14526	stackbase += 16LLU;
14330		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC28LLU;
	14527	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1BLLU;
14331	14528	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
14332	14529	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
14333	14530	break;
14334	14531	}
14335		-case 0xFFFFFFFFFFFFFC28LLU:
	14532	+case 0xFFFFFFFFFFFFFC1BLLU:
14336	14533	/* SP = 14LLU */
14337	14534	{
14338	14535	/CALLEND/
14339	14536	stackbase += 8LLU;
14340		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC27LLU;
	14537	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1ALLU;
14341	14538	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14342	14539	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
14343	14540	break;
14344	14541	}
14345		-case 0xFFFFFFFFFFFFFC27LLU:
	14542	+case 0xFFFFFFFFFFFFFC1ALLU:
14346	14543	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14347		-{ /* JUMP / fnaddr = 18446744073709550634LLU; break; } / skip alternative */
14348		-case 18446744073709550635LLU: /* alternative // predicate */
	14544	+{ /* JUMP / fnaddr = 18446744073709550621LLU; break; } / skip alternative */
	14545	+case 18446744073709550622LLU: /* alternative // predicate */
14349	14546
14350	14547	{
14351	14548	/* CALLBEGIN */

		@@ -14362,25 +14559,25 @@
14362	14559	{
14363	14560	/CALLEND/
14364	14561	stackbase += 12LLU;
14365		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC24LLU;
	14562	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC17LLU;
14366	14563	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
14367	14564	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
14368	14565	break;
14369	14566	}
14370		-case 0xFFFFFFFFFFFFFC24LLU:
	14567	+case 0xFFFFFFFFFFFFFC17LLU:
14371	14568	/* SP = 10LLU */
14372	14569	{
14373	14570	/CALLEND/
14374	14571	stackbase += 9LLU;
14375		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC23LLU;
	14572	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC16LLU;
14376	14573	fnaddr = /isdigit___/0x92E7E48A4BC00000LLU;/* SP = 0LLU */
14377	14574	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /isdigit___/\n"); exit(-1); }
14378	14575	break;
14379	14576	}
14380		-case 0xFFFFFFFFFFFFFC23LLU:
	14577	+case 0xFFFFFFFFFFFFFC16LLU:
14381	14578	/* SP = 7LLU */
14382	14579	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14383		-{ /* JUMP / fnaddr = 18446744073709550630LLU; break; } / skip consequent */
	14580	+{ /* JUMP / fnaddr = 18446744073709550617LLU; break; } / skip consequent */
14384	14581	/* consequent */
14385	14582	{
14386	14583	/* CALLBEGIN */

		@@ -14393,15 +14590,15 @@
14393	14590	{
14394	14591	/CALLEND/
14395	14592	stackbase += 8LLU;
14396		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC22LLU;
	14593	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC15LLU;
14397	14594	fnaddr = /pushconst_/0xAF0BA37AAA6EBC00LLU;/* SP = 0LLU */
14398	14595	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /pushconst_/\n"); exit(-1); }
14399	14596	break;
14400	14597	}
14401		-case 0xFFFFFFFFFFFFFC22LLU:
	14598	+case 0xFFFFFFFFFFFFFC15LLU:
14402	14599	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14403		-{ /* JUMP / fnaddr = 18446744073709550629LLU; break; } / skip alternative */
14404		-case 18446744073709550630LLU: /* alternative // predicate */
	14600	+{ /* JUMP / fnaddr = 18446744073709550616LLU; break; } / skip alternative */
	14601	+case 18446744073709550617LLU: /* alternative // predicate */
14405	14602
14406	14603	{
14407	14604	/* CALLBEGIN */

		@@ -14413,15 +14610,15 @@
14413	14610	{
14414	14611	/CALLEND/
14415	14612	stackbase += 9LLU;
14416		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1FLLU;
	14613	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC12LLU;
14417	14614	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14418	14615	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14419	14616	break;
14420	14617	}
14421		-case 0xFFFFFFFFFFFFFC1FLLU:
	14618	+case 0xFFFFFFFFFFFFFC12LLU:
14422	14619	/* SP = 7LLU */
14423	14620	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14424		-{ /* JUMP / fnaddr = 18446744073709550625LLU; break; } / skip consequent */
	14621	+{ /* JUMP / fnaddr = 18446744073709550612LLU; break; } / skip consequent */
14425	14622	/* consequent */
14426	14623	{
14427	14624	/* CALLBEGIN */

		@@ -14433,15 +14630,15 @@
14433	14630	{
14434	14631	/CALLEND/
14435	14632	stackbase += 8LLU;
14436		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1ELLU;
	14633	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC11LLU;
14437	14634	fnaddr = /pusharg___/0xAF0BA372D8800000LLU;/* SP = 0LLU */
14438	14635	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /pusharg___/\n"); exit(-1); }
14439	14636	break;
14440	14637	}
14441		-case 0xFFFFFFFFFFFFFC1ELLU:
	14638	+case 0xFFFFFFFFFFFFFC11LLU:
14442	14639	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14443		-{ /* JUMP / fnaddr = 18446744073709550624LLU; break; } / skip alternative */
14444		-case 18446744073709550625LLU: /* alternative // predicate */
	14640	+{ /* JUMP / fnaddr = 18446744073709550611LLU; break; } / skip alternative */
	14641	+case 18446744073709550612LLU: /* alternative // predicate */
14445	14642
14446	14643	{
14447	14644	/* CALLBEGIN */

		@@ -14453,15 +14650,15 @@
14453	14650	{
14454	14651	/CALLEND/
14455	14652	stackbase += 9LLU;
14456		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1BLLU;
	14653	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ELLU;
14457	14654	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14458	14655	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14459	14656	break;
14460	14657	}
14461		-case 0xFFFFFFFFFFFFFC1BLLU:
	14658	+case 0xFFFFFFFFFFFFFC0ELLU:
14462	14659	/* SP = 7LLU */
14463	14660	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14464		-{ /* JUMP / fnaddr = 18446744073709550621LLU; break; } / skip consequent */
	14661	+{ /* JUMP / fnaddr = 18446744073709550608LLU; break; } / skip consequent */
14465	14662	/* consequent */
14466	14663	{
14467	14664	/* CALLBEGIN */

		@@ -14472,15 +14669,15 @@
14472	14669	{
14473	14670	/CALLEND/
14474	14671	stackbase += 8LLU;
14475		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1ALLU;
	14672	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0DLLU;
14476	14673	fnaddr = /pushglob__/0xAF0BA38A7A9D0000LLU;/* SP = 0LLU */
14477	14674	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /pushglob__/\n"); exit(-1); }
14478	14675	break;
14479	14676	}
14480		-case 0xFFFFFFFFFFFFFC1ALLU:
	14677	+case 0xFFFFFFFFFFFFFC0DLLU:
14481	14678	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14482		-{ /* JUMP / fnaddr = 18446744073709550620LLU; break; } / skip alternative */
14483		-case 18446744073709550621LLU: /* alternative // predicate */
	14679	+{ /* JUMP / fnaddr = 18446744073709550607LLU; break; } / skip alternative */
	14680	+case 18446744073709550608LLU: /* alternative // predicate */
14484	14681
14485	14682	{
14486	14683	/* CALLBEGIN */

		@@ -14492,15 +14689,15 @@
14492	14689	{
14493	14690	/CALLEND/
14494	14691	stackbase += 9LLU;
14495		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC17LLU;
	14692	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ALLU;
14496	14693	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14497	14694	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14498	14695	break;
14499	14696	}
14500		-case 0xFFFFFFFFFFFFFC17LLU:
	14697	+case 0xFFFFFFFFFFFFFC0ALLU:
14501	14698	/* SP = 7LLU */
14502	14699	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14503		-{ /* JUMP / fnaddr = 18446744073709550617LLU; break; } / skip consequent */
	14700	+{ /* JUMP / fnaddr = 18446744073709550604LLU; break; } / skip consequent */
14504	14701	/* consequent */
14505	14702	{
14506	14703	/* CALLBEGIN */

		@@ -14511,15 +14708,15 @@
14511	14708	{
14512	14709	/CALLEND/
14513	14710	stackbase += 8LLU;
14514		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC16LLU;
	14711	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC09LLU;
14515	14712	fnaddr = /pushvar___/0xAF0BA3C5CB400000LLU;/* SP = 0LLU */
14516	14713	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /pushvar___/\n"); exit(-1); }
14517	14714	break;
14518	14715	}
14519		-case 0xFFFFFFFFFFFFFC16LLU:
	14716	+case 0xFFFFFFFFFFFFFC09LLU:
14520	14717	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14521		-{ /* JUMP / fnaddr = 18446744073709550616LLU; break; } / skip alternative */
14522		-case 18446744073709550617LLU: /* alternative // predicate */
	14718	+{ /* JUMP / fnaddr = 18446744073709550603LLU; break; } / skip alternative */
	14719	+case 18446744073709550604LLU: /* alternative // predicate */
14523	14720
14524	14721	{
14525	14722	/* CALLBEGIN */

		@@ -14531,15 +14728,15 @@
14531	14728	{
14532	14729	/CALLEND/
14533	14730	stackbase += 9LLU;
14534		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC13LLU;
	14731	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC06LLU;
14535	14732	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14536	14733	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14537	14734	break;
14538	14735	}
14539		-case 0xFFFFFFFFFFFFFC13LLU:
	14736	+case 0xFFFFFFFFFFFFFC06LLU:
14540	14737	/* SP = 7LLU */
14541	14738	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14542		-{ /* JUMP / fnaddr = 18446744073709550613LLU; break; } / skip consequent */
	14739	+{ /* JUMP / fnaddr = 18446744073709550600LLU; break; } / skip consequent */
14543	14740	/* consequent */
14544	14741	{
14545	14742	/* CALLBEGIN */

		@@ -14550,12 +14747,12 @@
14550	14747	{
14551	14748	/CALLEND/
14552	14749	stackbase += 8LLU;
14553		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC12LLU;
	14750	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC05LLU;
14554	14751	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
14555	14752	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
14556	14753	break;
14557	14754	}
14558		-case 0xFFFFFFFFFFFFFC12LLU:
	14755	+case 0xFFFFFFFFFFFFFC05LLU:
14559	14756	/* SP = 6LLU */fputs("reference DEACTIVATED\n", stderr); exit(-1);
14560	14757	{
14561	14758	/* CALLBEGIN */

		@@ -14567,15 +14764,15 @@
14567	14764	{
14568	14765	/CALLEND/
14569	14766	stackbase += 8LLU;
14570		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC11LLU;
	14767	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC04LLU;
14571	14768	fnaddr = /pushvarref/0xAF0BA3C5CB6D8210LLU;/* SP = 0LLU */
14572	14769	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /pushvarref/\n"); exit(-1); }
14573	14770	break;
14574	14771	}
14575		-case 0xFFFFFFFFFFFFFC11LLU:
	14772	+case 0xFFFFFFFFFFFFFC04LLU:
14576	14773	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14577		-{ /* JUMP / fnaddr = 18446744073709550612LLU; break; } / skip alternative */
14578		-case 18446744073709550613LLU: /* alternative // predicate */
	14774	+{ /* JUMP / fnaddr = 18446744073709550599LLU; break; } / skip alternative */
	14775	+case 18446744073709550600LLU: /* alternative // predicate */
14579	14776
14580	14777	{
14581	14778	/* CALLBEGIN */

		@@ -14587,15 +14784,15 @@
14587	14784	{
14588	14785	/CALLEND/
14589	14786	stackbase += 9LLU;
14590		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ELLU;
	14787	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC01LLU;
14591	14788	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14592	14789	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14593	14790	break;
14594	14791	}
14595		-case 0xFFFFFFFFFFFFFC0ELLU:
	14792	+case 0xFFFFFFFFFFFFFC01LLU:
14596	14793	/* SP = 7LLU */
14597	14794	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14598		-{ /* JUMP / fnaddr = 18446744073709550608LLU; break; } / skip consequent */
	14795	+{ /* JUMP / fnaddr = 18446744073709550595LLU; break; } / skip consequent */
14599	14796	/* consequent */
14600	14797	{
14601	14798	/* CALLBEGIN */

		@@ -14606,12 +14803,12 @@
14606	14803	{
14607	14804	/CALLEND/
14608	14805	stackbase += 8LLU;
14609		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0DLLU;
	14806	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC00LLU;
14610	14807	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
14611	14808	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
14612	14809	break;
14613	14810	}
14614		-case 0xFFFFFFFFFFFFFC0DLLU:
	14811	+case 0xFFFFFFFFFFFFFC00LLU:
14615	14812	/* SP = 6LLU /fputs("de-reference DEACTIVATED\n", stderr); exit(-1);fputs("\n", stdout); fputs("/ SP ", stdout);
14616	14813	{
14617	14814	/* CALLBEGIN */

		@@ -14628,22 +14825,22 @@
14628	14825	{
14629	14826	/CALLEND/
14630	14827	stackbase += 11LLU;
14631		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0CLLU;
	14828	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFFLLU;
14632	14829	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
14633	14830	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
14634	14831	break;
14635	14832	}
14636		-case 0xFFFFFFFFFFFFFC0CLLU:
	14833	+case 0xFFFFFFFFFFFFFBFFLLU:
14637	14834	/* SP = 9LLU */
14638	14835	{
14639	14836	/CALLEND/
14640	14837	stackbase += 8LLU;
14641		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0BLLU;
	14838	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFELLU;
14642	14839	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
14643	14840	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
14644	14841	break;
14645	14842	}
14646		-case 0xFFFFFFFFFFFFFC0BLLU:
	14843	+case 0xFFFFFFFFFFFFFBFELLU:
14647	14844	/* SP = 6LLU /fputs("/", stdout);
14648	14845	{
14649	14846	/* CALLBEGIN */

		@@ -14654,12 +14851,12 @@
14654	14851	{
14655	14852	/CALLEND/
14656	14853	stackbase += 8LLU;
14657		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ALLU;
	14854	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFDLLU;
14658	14855	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14659	14856	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
14660	14857	break;
14661	14858	}
14662		-case 0xFFFFFFFFFFFFFC0ALLU:
	14859	+case 0xFFFFFFFFFFFFFBFDLLU:
14663	14860	/* SP = 6LLU */
14664	14861	{
14665	14862	/* CALLBEGIN */

		@@ -14679,12 +14876,12 @@
14679	14876	{
14680	14877	/CALLEND/
14681	14878	stackbase += 14LLU;
14682		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC09LLU;
	14879	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFCLLU;
14683	14880	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
14684	14881	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
14685	14882	break;
14686	14883	}
14687		-case 0xFFFFFFFFFFFFFC09LLU:
	14884	+case 0xFFFFFFFFFFFFFBFCLLU:
14688	14885	/* SP = 12LLU */
14689	14886	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 13LLU */
14690	14887	{ /* PUSH / stack[stackbase + 13LLU] = 0LLU; }/ SP + 1LLU = 14LLU */

		@@ -14691,12 +14888,12 @@
14691	14888	{
14692	14889	/CALLEND/
14693	14890	stackbase += 8LLU;
14694		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC08LLU;
	14891	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFBLLU;
14695	14892	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14696	14893	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
14697	14894	break;
14698	14895	}
14699		-case 0xFFFFFFFFFFFFFC08LLU:
	14896	+case 0xFFFFFFFFFFFFFBFBLLU:
14700	14897	/* SP = 6LLU */
14701	14898	{
14702	14899	/* CALLBEGIN */

		@@ -14707,12 +14904,12 @@
14707	14904	{
14708	14905	/CALLEND/
14709	14906	stackbase += 8LLU;
14710		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC07LLU;
	14907	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFALLU;
14711	14908	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14712	14909	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); }
14713	14910	break;
14714	14911	}
14715		-case 0xFFFFFFFFFFFFFC07LLU:
	14912	+case 0xFFFFFFFFFFFFFBFALLU:
14716	14913	/* SP = 6LLU /fputs(" = (/ DEREF */ stack[", stdout);
14717	14914	{
14718	14915	/* CALLBEGIN */

		@@ -14723,12 +14920,12 @@
14723	14920	{
14724	14921	/CALLEND/
14725	14922	stackbase += 8LLU;
14726		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC06LLU;
	14923	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF9LLU;
14727	14924	fnaddr = /POP_START_/0x40F4004D40525000LLU;/* SP = 0LLU */
14728	14925	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_START_/\n"); exit(-1); }
14729	14926	break;
14730	14927	}
14731		-case 0xFFFFFFFFFFFFFC06LLU:
	14928	+case 0xFFFFFFFFFFFFFBF9LLU:
14732	14929	/* SP = 6LLU */fputs("])", stdout);
14733	14930	{
14734	14931	/* CALLBEGIN */

		@@ -14739,12 +14936,12 @@
14739	14936	{
14740	14937	/CALLEND/
14741	14938	stackbase += 8LLU;
14742		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC05LLU;
	14939	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF8LLU;
14743	14940	fnaddr = /TOP_END___/0x50F40014E1000000LLU;/* SP = 0LLU */
14744	14941	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_END___/\n"); exit(-1); }
14745	14942	break;
14746	14943	}
14747		-case 0xFFFFFFFFFFFFFC05LLU:
	14944	+case 0xFFFFFFFFFFFFFBF8LLU:
14748	14945	/* SP = 6LLU */
14749	14946	{
14750	14947	/* CALLBEGIN */

		@@ -14756,12 +14953,12 @@
14756	14953	{
14757	14954	/CALLEND/
14758	14955	stackbase += 8LLU;
14759		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC04LLU;
	14956	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF7LLU;
14760	14957	fnaddr = /SP_ADD____/0x4D00011040000000LLU;/* SP = 0LLU */
14761	14958	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_ADD____/\n"); exit(-1); }
14762	14959	break;
14763	14960	}
14764		-case 0xFFFFFFFFFFFFFC04LLU:
	14961	+case 0xFFFFFFFFFFFFFBF7LLU:
14765	14962	/* SP = 6LLU /fputs("/ SP ", stdout);
14766	14963	{
14767	14964	/* CALLBEGIN */

		@@ -14778,25 +14975,25 @@
14778	14975	{
14779	14976	/CALLEND/
14780	14977	stackbase += 11LLU;
14781		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC03LLU;
	14978	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF6LLU;
14782	14979	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
14783	14980	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
14784	14981	break;
14785	14982	}
14786		-case 0xFFFFFFFFFFFFFC03LLU:
	14983	+case 0xFFFFFFFFFFFFFBF6LLU:
14787	14984	/* SP = 9LLU */
14788	14985	{
14789	14986	/CALLEND/
14790	14987	stackbase += 8LLU;
14791		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC02LLU;
	14988	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF5LLU;
14792	14989	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
14793	14990	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
14794	14991	break;
14795	14992	}
14796		-case 0xFFFFFFFFFFFFFC02LLU:
	14993	+case 0xFFFFFFFFFFFFFBF5LLU:
14797	14994	/* SP = 6LLU /fputs("/", stdout); /* SP = 6LLU // SP = 6LLU */
14798		-{ /* JUMP / fnaddr = 18446744073709550607LLU; break; } / skip alternative */
14799		-case 18446744073709550608LLU: /* alternative // predicate */
	14995	+{ /* JUMP / fnaddr = 18446744073709550594LLU; break; } / skip alternative */
	14996	+case 18446744073709550595LLU: /* alternative // predicate */
14800	14997
14801	14998	{
14802	14999	/* CALLBEGIN */

		@@ -14808,15 +15005,15 @@
14808	15005	{
14809	15006	/CALLEND/
14810	15007	stackbase += 9LLU;
14811		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFFLLU;
	15008	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF2LLU;
14812	15009	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14813	15010	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14814	15011	break;
14815	15012	}
14816		-case 0xFFFFFFFFFFFFFBFFLLU:
	15013	+case 0xFFFFFFFFFFFFFBF2LLU:
14817	15014	/* SP = 7LLU */
14818	15015	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14819		-{ /* JUMP / fnaddr = 18446744073709550593LLU; break; } / skip consequent */
	15016	+{ /* JUMP / fnaddr = 18446744073709550580LLU; break; } / skip consequent */
14820	15017	/* consequent */
14821	15018	{
14822	15019	/* CALLBEGIN */

		@@ -14827,12 +15024,12 @@
14827	15024	{
14828	15025	/CALLEND/
14829	15026	stackbase += 8LLU;
14830		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFELLU;
	15027	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF1LLU;
14831	15028	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14832	15029	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
14833	15030	break;
14834	15031	}
14835		-case 0xFFFFFFFFFFFFFBFELLU:
	15032	+case 0xFFFFFFFFFFFFFBF1LLU:
14836	15033	/* SP = 6LLU */
14837	15034	{
14838	15035	/* CALLBEGIN */

		@@ -14852,12 +15049,12 @@
14852	15049	{
14853	15050	/CALLEND/
14854	15051	stackbase += 14LLU;
14855		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFDLLU;
	15052	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF0LLU;
14856	15053	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
14857	15054	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
14858	15055	break;
14859	15056	}
14860		-case 0xFFFFFFFFFFFFFBFDLLU:
	15057	+case 0xFFFFFFFFFFFFFBF0LLU:
14861	15058	/* SP = 12LLU */
14862	15059	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 13LLU */
14863	15060	{ /* PUSH / stack[stackbase + 13LLU] = 0LLU; }/ SP + 1LLU = 14LLU */

		@@ -14864,12 +15061,12 @@
14864	15061	{
14865	15062	/CALLEND/
14866	15063	stackbase += 8LLU;
14867		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFCLLU;
	15064	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEFLLU;
14868	15065	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14869	15066	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
14870	15067	break;
14871	15068	}
14872		-case 0xFFFFFFFFFFFFFBFCLLU:
	15069	+case 0xFFFFFFFFFFFFFBEFLLU:
14873	15070	/* SP = 6LLU */
14874	15071	{
14875	15072	/* CALLBEGIN */

		@@ -14880,12 +15077,12 @@
14880	15077	{
14881	15078	/CALLEND/
14882	15079	stackbase += 8LLU;
14883		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFBLLU;
	15080	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEELLU;
14884	15081	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14885	15082	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
14886	15083	break;
14887	15084	}
14888		-case 0xFFFFFFFFFFFFFBFBLLU:
	15085	+case 0xFFFFFFFFFFFFFBEELLU:
14889	15086	/* SP = 6LLU */
14890	15087	{
14891	15088	/* CALLBEGIN */

		@@ -14897,15 +15094,15 @@
14897	15094	{
14898	15095	/CALLEND/
14899	15096	stackbase += 8LLU;
14900		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFALLU;
	15097	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEDLLU;
14901	15098	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
14902	15099	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
14903	15100	break;
14904	15101	}
14905		-case 0xFFFFFFFFFFFFFBFALLU:
	15102	+case 0xFFFFFFFFFFFFFBEDLLU:
14906	15103	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14907		-{ /* JUMP / fnaddr = 18446744073709550592LLU; break; } / skip alternative */
14908		-case 18446744073709550593LLU: /* alternative // predicate */
	15104	+{ /* JUMP / fnaddr = 18446744073709550579LLU; break; } / skip alternative */
	15105	+case 18446744073709550580LLU: /* alternative // predicate */
14909	15106
14910	15107	{
14911	15108	/* CALLBEGIN */

		@@ -14917,15 +15114,15 @@
14917	15114	{
14918	15115	/CALLEND/
14919	15116	stackbase += 9LLU;
14920		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF7LLU;
	15117	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEALLU;
14921	15118	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
14922	15119	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
14923	15120	break;
14924	15121	}
14925		-case 0xFFFFFFFFFFFFFBF7LLU:
	15122	+case 0xFFFFFFFFFFFFFBEALLU:
14926	15123	/* SP = 7LLU */
14927	15124	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
14928		-{ /* JUMP / fnaddr = 18446744073709550585LLU; break; } / skip consequent */
	15125	+{ /* JUMP / fnaddr = 18446744073709550572LLU; break; } / skip consequent */
14929	15126	/* consequent */
14930	15127	{
14931	15128	/* CALLBEGIN */

		@@ -14936,15 +15133,15 @@
14936	15133	{
14937	15134	/CALLEND/
14938	15135	stackbase += 8LLU;
14939		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF6LLU;
	15136	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE9LLU;
14940	15137	fnaddr = /verbatim__/0xC60B5D72F9280000LLU;/* SP = 0LLU */
14941	15138	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /verbatim__/\n"); exit(-1); }
14942	15139	break;
14943	15140	}
14944		-case 0xFFFFFFFFFFFFFBF6LLU:
	15141	+case 0xFFFFFFFFFFFFFBE9LLU:
14945	15142	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
14946		-{ /* JUMP / fnaddr = 18446744073709550584LLU; break; } / skip alternative */
14947		-case 18446744073709550585LLU: /* alternative */
	15143	+{ /* JUMP / fnaddr = 18446744073709550571LLU; break; } / skip alternative */
	15144	+case 18446744073709550572LLU: /* alternative */
14948	15145	{
14949	15146	/* CALLBEGIN */
14950	15147	/* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */

		@@ -14954,12 +15151,12 @@
14954	15151	{
14955	15152	/CALLEND/
14956	15153	stackbase += 8LLU;
14957		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF5LLU;
	15154	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE8LLU;
14958	15155	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
14959	15156	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
14960	15157	break;
14961	15158	}
14962		-case 0xFFFFFFFFFFFFFBF5LLU:
	15159	+case 0xFFFFFFFFFFFFFBE8LLU:
14963	15160	/* SP = 6LLU */fputs("unexpected ", stderr);
14964	15161	{
14965	15162	/* CALLBEGIN */

		@@ -14976,40 +15173,40 @@
14976	15173	{
14977	15174	/CALLEND/
14978	15175	stackbase += 11LLU;
14979		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF4LLU;
	15176	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE7LLU;
14980	15177	fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
14981	15178	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); }
14982	15179	break;
14983	15180	}
14984		-case 0xFFFFFFFFFFFFFBF4LLU:
	15181	+case 0xFFFFFFFFFFFFFBE7LLU:
14985	15182	/* SP = 9LLU */
14986	15183	{
14987	15184	/CALLEND/
14988	15185	stackbase += 8LLU;
14989		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF3LLU;
	15186	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE6LLU;
14990	15187	fnaddr = /debugchar_/0x7E077089E8DCB400LLU;/* SP = 0LLU */
14991	15188	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugchar_/\n"); exit(-1); }
14992	15189	break;
14993	15190	}
14994		-case 0xFFFFFFFFFFFFFBF3LLU:
	15191	+case 0xFFFFFFFFFFFFFBE6LLU:
14995	15192	/* SP = 6LLU /fputs(" in expression\n", stderr); exit(-1);/ SP = 6LLU */
14996		-case 18446744073709550584LLU: /* skip to here */
	15193	+case 18446744073709550571LLU: /* skip to here */
14997	15194
14998		-case 18446744073709550592LLU: /* skip to here */
	15195	+case 18446744073709550579LLU: /* skip to here */
14999	15196
15000		-case 18446744073709550607LLU: /* skip to here */
	15197	+case 18446744073709550594LLU: /* skip to here */
15001	15198
15002		-case 18446744073709550612LLU: /* skip to here */
	15199	+case 18446744073709550599LLU: /* skip to here */
15003	15200
15004		-case 18446744073709550616LLU: /* skip to here */
	15201	+case 18446744073709550603LLU: /* skip to here */
15005	15202
15006		-case 18446744073709550620LLU: /* skip to here */
	15203	+case 18446744073709550607LLU: /* skip to here */
15007	15204
15008		-case 18446744073709550624LLU: /* skip to here */
	15205	+case 18446744073709550611LLU: /* skip to here */
15009	15206
15010		-case 18446744073709550629LLU: /* skip to here */
	15207	+case 18446744073709550616LLU: /* skip to here */
15011	15208
15012		-case 18446744073709550634LLU: /* skip to here */
	15209	+case 18446744073709550621LLU: /* skip to here */
15013	15210
15014	15211	case 18446744073709550966LLU: /* skip to here */
15015	15212	/* SP = 6LLU // SP = 6LLU */

		@@ -15026,12 +15223,12 @@
15026	15223	{
15027	15224	/CALLEND/
15028	15225	stackbase += 8LLU;
15029		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF2LLU;
	15226	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE5LLU;
15030	15227	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15031	15228	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15032	15229	break;
15033	15230	}
15034		-case 0xFFFFFFFFFFFFFBF2LLU:
	15231	+case 0xFFFFFFFFFFFFFBE5LLU:
15035	15232	/* SP = 6LLU // predicate */
15036	15233
15037	15234	{

		@@ -15049,26 +15246,26 @@
15049	15246	{
15050	15247	/CALLEND/
15051	15248	stackbase += 12LLU;
15052		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF0LLU;
	15249	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE3LLU;
15053	15250	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
15054	15251	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
15055	15252	break;
15056	15253	}
15057		-case 0xFFFFFFFFFFFFFBF0LLU:
	15254	+case 0xFFFFFFFFFFFFFBE3LLU:
15058	15255	/* SP = 10LLU */
15059	15256	{ /* PUSH / stack[stackbase + 10LLU] = 255LLU; }/ SP + 1LLU = 11LLU */
15060	15257	{
15061	15258	/CALLEND/
15062	15259	stackbase += 9LLU;
15063		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEFLLU;
	15260	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE2LLU;
15064	15261	fnaddr = /leq_______/0x9E0B000000000000LLU;/* SP = 0LLU */
15065	15262	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /leq_______/\n"); exit(-1); }
15066	15263	break;
15067	15264	}
15068		-case 0xFFFFFFFFFFFFFBEFLLU:
	15265	+case 0xFFFFFFFFFFFFFBE2LLU:
15069	15266	/* SP = 7LLU */
15070	15267	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
15071		-{ /* JUMP / fnaddr = 18446744073709550577LLU; break; } / skip consequent */
	15268	+{ /* JUMP / fnaddr = 18446744073709550564LLU; break; } / skip consequent */
15072	15269	/* consequent // predicate */
15073	15270
15074	15271	{

		@@ -15086,25 +15283,25 @@
15086	15283	{
15087	15284	/CALLEND/
15088	15285	stackbase += 12LLU;
15089		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBECLLU;
	15286	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDFLLU;
15090	15287	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
15091	15288	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
15092	15289	break;
15093	15290	}
15094		-case 0xFFFFFFFFFFFFFBECLLU:
	15291	+case 0xFFFFFFFFFFFFFBDFLLU:
15095	15292	/* SP = 10LLU */
15096	15293	{
15097	15294	/CALLEND/
15098	15295	stackbase += 9LLU;
15099		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEBLLU;
	15296	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDELLU;
15100	15297	fnaddr = /isalpha___/0x92E727AE37000000LLU;/* SP = 0LLU */
15101	15298	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /isalpha___/\n"); exit(-1); }
15102	15299	break;
15103	15300	}
15104		-case 0xFFFFFFFFFFFFFBEBLLU:
	15301	+case 0xFFFFFFFFFFFFFBDELLU:
15105	15302	/* SP = 7LLU */
15106	15303	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
15107		-{ /* JUMP / fnaddr = 18446744073709550574LLU; break; } / skip consequent */
	15304	+{ /* JUMP / fnaddr = 18446744073709550561LLU; break; } / skip consequent */
15108	15305	/* consequent */
15109	15306	{
15110	15307	/* CALLBEGIN */

		@@ -15115,12 +15312,12 @@
15115	15312	{
15116	15313	/CALLEND/
15117	15314	stackbase += 9LLU;
15118		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEALLU;
	15315	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDDLLU;
15119	15316	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
15120	15317	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
15121	15318	break;
15122	15319	}
15123		-case 0xFFFFFFFFFFFFFBEALLU:
	15320	+case 0xFFFFFFFFFFFFFBDDLLU:
15124	15321	/* SP = 7LLU // SP = 6LLU */
15125	15322	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR / stack[stackbase + 6LLU]; }/ predicate */
15126	15323

		@@ -15135,15 +15332,15 @@
15135	15332	{
15136	15333	/CALLEND/
15137	15334	stackbase += 9LLU;
15138		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE7LLU;
	15335	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDALLU;
15139	15336	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
15140	15337	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
15141	15338	break;
15142	15339	}
15143		-case 0xFFFFFFFFFFFFFBE7LLU:
	15340	+case 0xFFFFFFFFFFFFFBDALLU:
15144	15341	/* SP = 7LLU */
15145	15342	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
15146		-{ /* JUMP / fnaddr = 18446744073709550569LLU; break; } / skip consequent */
	15343	+{ /* JUMP / fnaddr = 18446744073709550556LLU; break; } / skip consequent */
15147	15344	/* consequent */
15148	15345	{
15149	15346	/* CALLBEGIN */

		@@ -15154,12 +15351,12 @@
15154	15351	{
15155	15352	/CALLEND/
15156	15353	stackbase += 8LLU;
15157		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE6LLU;
	15354	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD9LLU;
15158	15355	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15159	15356	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15160	15357	break;
15161	15358	}
15162		-case 0xFFFFFFFFFFFFFBE6LLU:
	15359	+case 0xFFFFFFFFFFFFFBD9LLU:
15163	15360	/* SP = 6LLU */
15164	15361	{
15165	15362	/* CALLBEGIN */

		@@ -15179,12 +15376,12 @@
15179	15376	{
15180	15377	/CALLEND/
15181	15378	stackbase += 14LLU;
15182		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE5LLU;
	15379	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD8LLU;
15183	15380	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
15184	15381	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
15185	15382	break;
15186	15383	}
15187		-case 0xFFFFFFFFFFFFFBE5LLU:
	15384	+case 0xFFFFFFFFFFFFFBD8LLU:
15188	15385	/* SP = 12LLU */
15189	15386	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 13LLU */
15190	15387	{ /* PUSH / stack[stackbase + 13LLU] = 0LLU; }/ SP + 1LLU = 14LLU */

		@@ -15191,12 +15388,12 @@
15191	15388	{
15192	15389	/CALLEND/
15193	15390	stackbase += 8LLU;
15194		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE4LLU;
	15391	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD7LLU;
15195	15392	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
15196	15393	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
15197	15394	break;
15198	15395	}
15199		-case 0xFFFFFFFFFFFFFBE4LLU:
	15396	+case 0xFFFFFFFFFFFFFBD7LLU:
15200	15397	/* SP = 6LLU */
15201	15398	{
15202	15399	/* CALLBEGIN */

		@@ -15209,12 +15406,12 @@
15209	15406	{
15210	15407	/CALLEND/
15211	15408	stackbase += 9LLU;
15212		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE3LLU;
	15409	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD6LLU;
15213	15410	fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
15214	15411	if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
15215	15412	break;
15216	15413	}
15217		-case 0xFFFFFFFFFFFFFBE3LLU:
	15414	+case 0xFFFFFFFFFFFFFBD6LLU:
15218	15415	/* SP = 7LLU */
15219	15416	{ /* PUSH / stack[stackbase + 7LLU] = 0LLU; }/ SP + 1LLU = 8LLU */
15220	15417	{

		@@ -15227,14 +15424,14 @@
15227	15424	{
15228	15425	/CALLEND/
15229	15426	stackbase += 10LLU;
15230		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE2LLU;
	15427	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD5LLU;
15231	15428	fnaddr = /SP_SUB____/0x4D00135420000000LLU;/* SP = 0LLU */
15232	15429	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SUB____/\n"); exit(-1); }
15233	15430	break;
15234	15431	}
15235		-case 0xFFFFFFFFFFFFFBE2LLU:
	15432	+case 0xFFFFFFFFFFFFFBD5LLU:
15236	15433	/* SP = 8LLU */
15237		-case 0xFFFFFFFFFFFFFBE1LLU: /* loop to here // predicate */
	15434	+case 0xFFFFFFFFFFFFFBD4LLU: /* loop to here // predicate */
15238	15435
15239	15436	{
15240	15437	/* CALLBEGIN */

		@@ -15247,15 +15444,15 @@
15247	15444	{
15248	15445	/CALLEND/
15249	15446	stackbase += 11LLU;
15250		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDFLLU;
	15447	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD2LLU;
15251	15448	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
15252	15449	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
15253	15450	break;
15254	15451	}
15255		-case 0xFFFFFFFFFFFFFBDFLLU:
	15452	+case 0xFFFFFFFFFFFFFBD2LLU:
15256	15453	/* SP = 9LLU */
15257	15454	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
15258		-{ /* JUMP / fnaddr = 18446744073709550560LLU; break; } / skip loop */
	15455	+{ /* JUMP / fnaddr = 18446744073709550547LLU; break; } / skip loop */
15259	15456	/* loop /fputs("\n{ / RESULT */", stdout);
15260	15457	{
15261	15458	/* CALLBEGIN */

		@@ -15274,22 +15471,22 @@
15274	15471	{
15275	15472	/CALLEND/
15276	15473	stackbase += 13LLU;
15277		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDELLU;
	15474	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD1LLU;
15278	15475	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
15279	15476	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
15280	15477	break;
15281	15478	}
15282		-case 0xFFFFFFFFFFFFFBDELLU:
	15479	+case 0xFFFFFFFFFFFFFBD1LLU:
15283	15480	/* SP = 11LLU */
15284	15481	{
15285	15482	/CALLEND/
15286	15483	stackbase += 10LLU;
15287		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDDLLU;
	15484	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD0LLU;
15288	15485	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
15289	15486	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
15290	15487	break;
15291	15488	}
15292		-case 0xFFFFFFFFFFFFFBDDLLU:
	15489	+case 0xFFFFFFFFFFFFFBD0LLU:
15293	15490	/* SP = 8LLU */fputs(" = ", stdout);
15294	15491	{
15295	15492	/* CALLBEGIN */

		@@ -15312,33 +15509,33 @@
15312	15509	{
15313	15510	/CALLEND/
15314	15511	stackbase += 16LLU;
15315		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDCLLU;
	15512	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCFLLU;
15316	15513	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
15317	15514	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
15318	15515	break;
15319	15516	}
15320		-case 0xFFFFFFFFFFFFFBDCLLU:
	15517	+case 0xFFFFFFFFFFFFFBCFLLU:
15321	15518	/* SP = 14LLU */
15322	15519	{ /* PUSH / stack[stackbase + 14LLU] = / LOCAL VAR / stack[stackbase + 7LLU]; }/ SP + 1LLU = 15LLU */
15323	15520	{
15324	15521	/CALLEND/
15325	15522	stackbase += 13LLU;
15326		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDBLLU;
	15523	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCELLU;
15327	15524	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
15328	15525	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
15329	15526	break;
15330	15527	}
15331		-case 0xFFFFFFFFFFFFFBDBLLU:
	15528	+case 0xFFFFFFFFFFFFFBCELLU:
15332	15529	/* SP = 11LLU */
15333	15530	{
15334	15531	/CALLEND/
15335	15532	stackbase += 10LLU;
15336		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDALLU;
	15533	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCDLLU;
15337	15534	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
15338	15535	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
15339	15536	break;
15340	15537	}
15341		-case 0xFFFFFFFFFFFFFBDALLU:
	15538	+case 0xFFFFFFFFFFFFFBCDLLU:
15342	15539	/* SP = 8LLU */fputs("; }", stdout);
15343	15540	{
15344	15541	/* CALLBEGIN */

		@@ -15351,16 +15548,16 @@
15351	15548	{
15352	15549	/CALLEND/
15353	15550	stackbase += 11LLU;
15354		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD9LLU;
	15551	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCCLLU;
15355	15552	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
15356	15553	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
15357	15554	break;
15358	15555	}
15359		-case 0xFFFFFFFFFFFFFBD9LLU:
	15556	+case 0xFFFFFFFFFFFFFBCCLLU:
15360	15557	/* SP = 9LLU // SP = 8LLU */
15361	15558	{ /* assign / / LOCAL VAR / stack[stackbase + 7LLU] = / LOCAL VAR / stack[stackbase + 8LLU]; }/ SP = 8LLU */
15362		-{ /* JUMP / fnaddr = 18446744073709550561LLU; break; } / loop */
15363		-case 18446744073709550560LLU: /* skip to here */
	15559	+{ /* JUMP / fnaddr = 18446744073709550548LLU; break; } / loop */
	15560	+case 18446744073709550547LLU: /* skip to here */
15364	15561	{
15365	15562	/* CALLBEGIN */
15366	15563	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -15374,43 +15571,26 @@
15374	15571	/* leave place for return addr // SP + 1LLU = 13LLU */
15375	15572	}
15376	15573	{ /* PUSH / stack[stackbase + 13LLU] = / LOCAL VAR / stack[stackbase + 5LLU]; }/ SP + 1LLU = 14LLU */
	15574	+{ /* PUSH / stack[stackbase + 14LLU] = / LOCAL VAR / stack[stackbase + 6LLU]; }/ SP + 1LLU = 15LLU */
15377	15575	{
15378		- /* CALLBEGIN */
15379		- /* reserve space for 1LLU returned values // SP + 1LLU = 15LLU */
15380		-{ /* PUSH / stack[stackbase + 15LLU] = stackbase; }/ SP + 1LLU = 16LLU */
15381		- /* leave place for return addr // SP + 1LLU = 17LLU */
15382		- }
15383		-{ /* PUSH / stack[stackbase + 17LLU] = / LOCAL VAR / stack[stackbase + 1LLU]; }/ SP + 1LLU = 18LLU */
15384		-{ /* PUSH / stack[stackbase + 18LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 19LLU */
15385		- {
15386	15576	/CALLEND/
15387		- stackbase += 17LLU;
15388		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD8LLU;
15389		- fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
15390		-if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
15391		- break;
15392		- }
15393		-case 0xFFFFFFFFFFFFFBD8LLU:
15394		-/* SP = 15LLU */
15395		- {
15396		- /CALLEND/
15397	15577	stackbase += 13LLU;
15398		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD7LLU;
	15578	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCBLLU;
15399	15579	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
15400	15580	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
15401	15581	break;
15402	15582	}
15403		-case 0xFFFFFFFFFFFFFBD7LLU:
	15583	+case 0xFFFFFFFFFFFFFBCBLLU:
15404	15584	/* SP = 11LLU */
15405	15585	{
15406	15586	/CALLEND/
15407	15587	stackbase += 10LLU;
15408		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD6LLU;
	15588	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCALLU;
15409	15589	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
15410	15590	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
15411	15591	break;
15412	15592	}
15413		-case 0xFFFFFFFFFFFFFBD6LLU:
	15593	+case 0xFFFFFFFFFFFFFBCALLU:
15414	15594	/* SP = 8LLU */
15415	15595	{
15416	15596	/* CALLBEGIN */

		@@ -15421,12 +15601,12 @@
15421	15601	{
15422	15602	/CALLEND/
15423	15603	stackbase += 10LLU;
15424		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD5LLU;
	15604	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC9LLU;
15425	15605	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15426	15606	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15427	15607	break;
15428	15608	}
15429		-case 0xFFFFFFFFFFFFFBD5LLU:
	15609	+case 0xFFFFFFFFFFFFFBC9LLU:
15430	15610	/* SP = 8LLU // predicate */
15431	15611
15432	15612	{

		@@ -15445,25 +15625,25 @@
15445	15625	{
15446	15626	/CALLEND/
15447	15627	stackbase += 14LLU;
15448		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD3LLU;
	15628	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC7LLU;
15449	15629	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
15450	15630	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
15451	15631	break;
15452	15632	}
15453		-case 0xFFFFFFFFFFFFFBD3LLU:
	15633	+case 0xFFFFFFFFFFFFFBC7LLU:
15454	15634	/* SP = 12LLU */
15455	15635	{
15456	15636	/CALLEND/
15457	15637	stackbase += 11LLU;
15458		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD2LLU;
	15638	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC6LLU;
15459	15639	fnaddr = /not_______/0xA6ABC00000000000LLU;/* SP = 0LLU */
15460	15640	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /not_______/\n"); exit(-1); }
15461	15641	break;
15462	15642	}
15463		-case 0xFFFFFFFFFFFFFBD2LLU:
	15643	+case 0xFFFFFFFFFFFFFBC6LLU:
15464	15644	/* SP = 9LLU */
15465	15645	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
15466		-{ /* JUMP / fnaddr = 18446744073709550548LLU; break; } / skip consequent */
	15646	+{ /* JUMP / fnaddr = 18446744073709550536LLU; break; } / skip consequent */
15467	15647	/* consequent */
15468	15648	{
15469	15649	/* CALLBEGIN */

		@@ -15474,16 +15654,16 @@
15474	15654	{
15475	15655	/CALLEND/
15476	15656	stackbase += 10LLU;
15477		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBD1LLU;
	15657	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC5LLU;
15478	15658	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
15479	15659	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
15480	15660	break;
15481	15661	}
15482		-case 0xFFFFFFFFFFFFFBD1LLU:
	15662	+case 0xFFFFFFFFFFFFFBC5LLU:
15483	15663	/* SP = 8LLU /fputs("missing '}' - result must be last statement in block\n", stderr); exit(-1);/ SP = 8LLU */
15484		-case 18446744073709550548LLU: /* alternative // SP = 6LLU // SP = 6LLU */
15485		-{ /* JUMP / fnaddr = 18446744073709550568LLU; break; } / skip alternative */
15486		-case 18446744073709550569LLU: /* alternative // predicate */
	15664	+case 18446744073709550536LLU: /* alternative // SP = 6LLU // SP = 6LLU */
	15665	+{ /* JUMP / fnaddr = 18446744073709550555LLU; break; } / skip alternative */
	15666	+case 18446744073709550556LLU: /* alternative // predicate */
15487	15667
15488	15668	{
15489	15669	/* CALLBEGIN */

		@@ -15496,15 +15676,15 @@
15496	15676	{
15497	15677	/CALLEND/
15498	15678	stackbase += 9LLU;
15499		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCELLU;
	15679	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC2LLU;
15500	15680	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
15501	15681	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
15502	15682	break;
15503	15683	}
15504		-case 0xFFFFFFFFFFFFFBCELLU:
	15684	+case 0xFFFFFFFFFFFFFBC2LLU:
15505	15685	/* SP = 7LLU */
15506	15686	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
15507		-{ /* JUMP / fnaddr = 18446744073709550544LLU; break; } / skip consequent */
	15687	+{ /* JUMP / fnaddr = 18446744073709550532LLU; break; } / skip consequent */
15508	15688	/* consequent */
15509	15689	{
15510	15690	/* CALLBEGIN */

		@@ -15515,12 +15695,12 @@
15515	15695	{
15516	15696	/CALLEND/
15517	15697	stackbase += 8LLU;
15518		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCDLLU;
	15698	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC1LLU;
15519	15699	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15520	15700	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15521	15701	break;
15522	15702	}
15523		-case 0xFFFFFFFFFFFFFBCDLLU:
	15703	+case 0xFFFFFFFFFFFFFBC1LLU:
15524	15704	/* SP = 6LLU // predicate */
15525	15705
15526	15706	{

		@@ -15533,15 +15713,15 @@
15533	15713	{
15534	15714	/CALLEND/
15535	15715	stackbase += 9LLU;
15536		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBCALLU;
	15716	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBELLU;
15537	15717	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
15538	15718	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
15539	15719	break;
15540	15720	}
15541		-case 0xFFFFFFFFFFFFFBCALLU:
	15721	+case 0xFFFFFFFFFFFFFBBELLU:
15542	15722	/* SP = 7LLU */
15543	15723	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
15544		-{ /* JUMP / fnaddr = 18446744073709550540LLU; break; } / skip consequent */
	15724	+{ /* JUMP / fnaddr = 18446744073709550528LLU; break; } / skip consequent */
15545	15725	/* consequent */
15546	15726	{
15547	15727	/* CALLBEGIN */

		@@ -15552,12 +15732,12 @@
15552	15732	{
15553	15733	/CALLEND/
15554	15734	stackbase += 8LLU;
15555		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC9LLU;
	15735	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBDLLU;
15556	15736	fnaddr = /initvar___/0x92992FC5CB400000LLU;/* SP = 0LLU */
15557	15737	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /initvar___/\n"); exit(-1); }
15558	15738	break;
15559	15739	}
15560		-case 0xFFFFFFFFFFFFFBC9LLU:
	15740	+case 0xFFFFFFFFFFFFFBBDLLU:
15561	15741	/* SP = 6LLU */
15562	15742	{
15563	15743	/* CALLBEGIN */

		@@ -15568,12 +15748,12 @@
15568	15748	{
15569	15749	/CALLEND/
15570	15750	stackbase += 8LLU;
15571		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC8LLU;
	15751	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBCLLU;
15572	15752	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15573	15753	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15574	15754	break;
15575	15755	}
15576		-case 0xFFFFFFFFFFFFFBC8LLU:
	15756	+case 0xFFFFFFFFFFFFFBBCLLU:
15577	15757	/* SP = 6LLU */
15578	15758	{
15579	15759	/* CALLBEGIN */

		@@ -15585,12 +15765,12 @@
15585	15765	{
15586	15766	/CALLEND/
15587	15767	stackbase += 8LLU;
15588		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC7LLU;
	15768	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBBLLU;
15589	15769	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
15590	15770	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
15591	15771	break;
15592	15772	}
15593		-case 0xFFFFFFFFFFFFFBC7LLU:
	15773	+case 0xFFFFFFFFFFFFFBBBLLU:
15594	15774	/* SP = 6LLU */
15595	15775	{
15596	15776	/* CALLBEGIN */

		@@ -15601,12 +15781,12 @@
15601	15781	{
15602	15782	/CALLEND/
15603	15783	stackbase += 8LLU;
15604		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC6LLU;
	15784	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBALLU;
15605	15785	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15606	15786	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15607	15787	break;
15608	15788	}
15609		-case 0xFFFFFFFFFFFFFBC6LLU:
	15789	+case 0xFFFFFFFFFFFFFBBALLU:
15610	15790	/* SP = 6LLU */
15611	15791	{
15612	15792	/* CALLBEGIN */

		@@ -15626,12 +15806,12 @@
15626	15806	{
15627	15807	/CALLEND/
15628	15808	stackbase += 14LLU;
15629		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC5LLU;
	15809	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB9LLU;
15630	15810	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
15631	15811	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
15632	15812	break;
15633	15813	}
15634		-case 0xFFFFFFFFFFFFFBC5LLU:
	15814	+case 0xFFFFFFFFFFFFFBB9LLU:
15635	15815	/* SP = 12LLU */
15636	15816	{
15637	15817	/* CALLBEGIN */

		@@ -15643,23 +15823,23 @@
15643	15823	{
15644	15824	/CALLEND/
15645	15825	stackbase += 15LLU;
15646		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC4LLU;
	15826	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB8LLU;
15647	15827	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
15648	15828	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
15649	15829	break;
15650	15830	}
15651		-case 0xFFFFFFFFFFFFFBC4LLU:
	15831	+case 0xFFFFFFFFFFFFFBB8LLU:
15652	15832	/* SP = 13LLU */
15653	15833	{ /* PUSH / stack[stackbase + 13LLU] = 0LLU; }/ SP + 1LLU = 14LLU */
15654	15834	{
15655	15835	/CALLEND/
15656	15836	stackbase += 8LLU;
15657		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC3LLU;
	15837	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB7LLU;
15658	15838	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
15659	15839	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
15660	15840	break;
15661	15841	}
15662		-case 0xFFFFFFFFFFFFFBC3LLU:
	15842	+case 0xFFFFFFFFFFFFFBB7LLU:
15663	15843	/* SP = 6LLU */
15664	15844	{
15665	15845	/* CALLBEGIN */

		@@ -15676,15 +15856,15 @@
15676	15856	{
15677	15857	/CALLEND/
15678	15858	stackbase += 8LLU;
15679		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC2LLU;
	15859	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB6LLU;
15680	15860	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
15681	15861	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
15682	15862	break;
15683	15863	}
15684		-case 0xFFFFFFFFFFFFFBC2LLU:
	15864	+case 0xFFFFFFFFFFFFFBB6LLU:
15685	15865	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
15686		-{ /* JUMP / fnaddr = 18446744073709550539LLU; break; } / skip alternative */
15687		-case 18446744073709550540LLU: /* alternative */
	15866	+{ /* JUMP / fnaddr = 18446744073709550527LLU; break; } / skip alternative */
	15867	+case 18446744073709550528LLU: /* alternative */
15688	15868	{ /* PUSH / stack[stackbase + 6LLU] = 0LLU; }/ SP + 1LLU = 7LLU */
15689	15869	{ /* PUSH / stack[stackbase + 7LLU] = 0LLU; }/ SP + 1LLU = 8LLU */
15690	15870	{ /* PUSH / stack[stackbase + 8LLU] = 0LLU; }/ SP + 1LLU = 9LLU */

		@@ -15700,12 +15880,12 @@
15700	15880	{
15701	15881	/CALLEND/
15702	15882	stackbase += 13LLU;
15703		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC1LLU;
	15883	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB5LLU;
15704	15884	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
15705	15885	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
15706	15886	break;
15707	15887	}
15708		-case 0xFFFFFFFFFFFFFBC1LLU:
	15888	+case 0xFFFFFFFFFFFFFBB5LLU:
15709	15889	/* SP = 11LLU // SP = 10LLU */
15710	15890	{ /* assign / / LOCAL VAR / stack[stackbase + 7LLU] = / LOCAL VAR */ stack[stackbase + 10LLU]; }
15711	15891	{

		@@ -15717,12 +15897,12 @@
15717	15897	{
15718	15898	/CALLEND/
15719	15899	stackbase += 13LLU;
15720		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBC0LLU;
	15900	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB4LLU;
15721	15901	fnaddr = /parsetype_/0xADCB6E82FD2B8000LLU;/* SP = 0LLU */
15722	15902	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetype_/\n"); exit(-1); }
15723	15903	break;
15724	15904	}
15725		-case 0xFFFFFFFFFFFFFBC0LLU:
	15905	+case 0xFFFFFFFFFFFFFBB4LLU:
15726	15906	/* SP = 11LLU // SP = 10LLU */
15727	15907	{ /* assign / / LOCAL VAR / stack[stackbase + 8LLU] = / LOCAL VAR */ stack[stackbase + 10LLU]; }
15728	15908	{ /* PUSH / stack[stackbase + 10LLU] = 0LLU; }/ SP + 1LLU = 11LLU // SP = 10LLU */

		@@ -15736,12 +15916,12 @@
15736	15916	{
15737	15917	/CALLEND/
15738	15918	stackbase += 12LLU;
15739		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBFLLU;
	15919	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB3LLU;
15740	15920	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15741	15921	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15742	15922	break;
15743	15923	}
15744		-case 0xFFFFFFFFFFFFFBBFLLU:
	15924	+case 0xFFFFFFFFFFFFFBB3LLU:
15745	15925	/* SP = 10LLU */
15746	15926	{
15747	15927	/* CALLBEGIN */

		@@ -15752,12 +15932,12 @@
15752	15932	{
15753	15933	/CALLEND/
15754	15934	stackbase += 13LLU;
15755		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBELLU;
	15935	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB2LLU;
15756	15936	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
15757	15937	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
15758	15938	break;
15759	15939	}
15760		-case 0xFFFFFFFFFFFFFBBELLU:
	15940	+case 0xFFFFFFFFFFFFFBB2LLU:
15761	15941	/* SP = 11LLU // SP = 10LLU */
15762	15942	{ /* assign / / LOCAL VAR / stack[stackbase + 6LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ predicate */
15763	15943

		@@ -15772,15 +15952,15 @@
15772	15952	{
15773	15953	/CALLEND/
15774	15954	stackbase += 13LLU;
15775		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBCLLU;
	15955	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB0LLU;
15776	15956	fnaddr = /existsvar_/0x83392EBEEC5CB400LLU;/* SP = 0LLU */
15777	15957	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsvar_/\n"); exit(-1); }
15778	15958	break;
15779	15959	}
15780		-case 0xFFFFFFFFFFFFFBBCLLU:
	15960	+case 0xFFFFFFFFFFFFFBB0LLU:
15781	15961	/* SP = 11LLU */
15782	15962	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
15783		-{ /* JUMP / fnaddr = 18446744073709550525LLU; break; } / skip consequent */
	15963	+{ /* JUMP / fnaddr = 18446744073709550513LLU; break; } / skip consequent */
15784	15964	/* consequent */
15785	15965	{
15786	15966	/* CALLBEGIN */

		@@ -15791,12 +15971,12 @@
15791	15971	{
15792	15972	/CALLEND/
15793	15973	stackbase += 12LLU;
15794		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBBLLU;
	15974	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBAFLLU;
15795	15975	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
15796	15976	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
15797	15977	break;
15798	15978	}
15799		-case 0xFFFFFFFFFFFFFBBBLLU:
	15979	+case 0xFFFFFFFFFFFFFBAFLLU:
15800	15980	/* SP = 10LLU */fputs("warning: re-definition of variable ", stderr);
15801	15981	{
15802	15982	/* CALLBEGIN */

		@@ -15808,14 +15988,14 @@
15808	15988	{
15809	15989	/CALLEND/
15810	15990	stackbase += 12LLU;
15811		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBBALLU;
	15991	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBAELLU;
15812	15992	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
15813	15993	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
15814	15994	break;
15815	15995	}
15816		-case 0xFFFFFFFFFFFFFBBALLU:
	15996	+case 0xFFFFFFFFFFFFFBAELLU:
15817	15997	/* SP = 10LLU /fputs(" shadows previous definition\n", stderr); / SP = 10LLU */
15818		-case 18446744073709550525LLU: /* alternative */
	15998	+case 18446744073709550513LLU: /* alternative */
15819	15999	{
15820	16000	/* CALLBEGIN */
15821	16001	/* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */

		@@ -15825,12 +16005,12 @@
15825	16005	{
15826	16006	/CALLEND/
15827	16007	stackbase += 12LLU;
15828		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB9LLU;
	16008	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBADLLU;
15829	16009	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15830	16010	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15831	16011	break;
15832	16012	}
15833		-case 0xFFFFFFFFFFFFFBB9LLU:
	16013	+case 0xFFFFFFFFFFFFFBADLLU:
15834	16014	/* SP = 10LLU */
15835	16015	{
15836	16016	/* CALLBEGIN */

		@@ -15842,12 +16022,12 @@
15842	16022	{
15843	16023	/CALLEND/
15844	16024	stackbase += 12LLU;
15845		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB8LLU;
	16025	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBACLLU;
15846	16026	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
15847	16027	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
15848	16028	break;
15849	16029	}
15850		-case 0xFFFFFFFFFFFFFBB8LLU:
	16030	+case 0xFFFFFFFFFFFFFBACLLU:
15851	16031	/* SP = 10LLU */
15852	16032	{
15853	16033	/* CALLBEGIN */

		@@ -15858,12 +16038,12 @@
15858	16038	{
15859	16039	/CALLEND/
15860	16040	stackbase += 12LLU;
15861		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB7LLU;
	16041	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBABLLU;
15862	16042	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15863	16043	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15864	16044	break;
15865	16045	}
15866		-case 0xFFFFFFFFFFFFFBB7LLU:
	16046	+case 0xFFFFFFFFFFFFFBABLLU:
15867	16047	/* SP = 10LLU */
15868	16048	{
15869	16049	/* CALLBEGIN */

		@@ -15883,12 +16063,12 @@
15883	16063	{
15884	16064	/CALLEND/
15885	16065	stackbase += 18LLU;
15886		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB6LLU;
	16066	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBAALLU;
15887	16067	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
15888	16068	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
15889	16069	break;
15890	16070	}
15891		-case 0xFFFFFFFFFFFFFBB6LLU:
	16071	+case 0xFFFFFFFFFFFFFBAALLU:
15892	16072	/* SP = 16LLU */
15893	16073	{ /* PUSH / stack[stackbase + 16LLU] = / LOCAL VAR / stack[stackbase + 8LLU]; }/ SP + 1LLU = 17LLU */
15894	16074	{ /* PUSH / stack[stackbase + 17LLU] = 0LLU; }/ SP + 1LLU = 18LLU */

		@@ -15895,12 +16075,12 @@
15895	16075	{
15896	16076	/CALLEND/
15897	16077	stackbase += 12LLU;
15898		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB5LLU;
	16078	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA9LLU;
15899	16079	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
15900	16080	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
15901	16081	break;
15902	16082	}
15903		-case 0xFFFFFFFFFFFFFBB5LLU:
	16083	+case 0xFFFFFFFFFFFFFBA9LLU:
15904	16084	/* SP = 10LLU */
15905	16085	{ /* PUSH / stack[stackbase + 10LLU] = (/ REF TO LINK / stackbase + 11LLU); }/ SP + 1LLU = 11LLU */
15906	16086	{ /* PUSH / stack[stackbase + 11LLU] = / LOCAL VAR / stack[stackbase + 2LLU]; }/ SP + 1LLU = 12LLU */

		@@ -15923,17 +16103,17 @@
15923	16103	{
15924	16104	/CALLEND/
15925	16105	stackbase += 18LLU;
15926		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB4LLU;
	16106	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA8LLU;
15927	16107	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
15928	16108	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
15929	16109	break;
15930	16110	}
15931		-case 0xFFFFFFFFFFFFFBB4LLU:
	16111	+case 0xFFFFFFFFFFFFFBA8LLU:
15932	16112	/* SP = 16LLU // SP = 6LLU */
15933		-case 18446744073709550539LLU: /* skip to here */
	16113	+case 18446744073709550527LLU: /* skip to here */
15934	16114	/* SP = 6LLU // SP = 6LLU */
15935		-{ /* JUMP / fnaddr = 18446744073709550543LLU; break; } / skip alternative */
15936		-case 18446744073709550544LLU: /* alternative // predicate */
	16115	+{ /* JUMP / fnaddr = 18446744073709550531LLU; break; } / skip alternative */
	16116	+case 18446744073709550532LLU: /* alternative // predicate */
15937	16117
15938	16118	{
15939	16119	/* CALLBEGIN */

		@@ -15946,15 +16126,15 @@
15946	16126	{
15947	16127	/CALLEND/
15948	16128	stackbase += 9LLU;
15949		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB1LLU;
	16129	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA5LLU;
15950	16130	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
15951	16131	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
15952	16132	break;
15953	16133	}
15954		-case 0xFFFFFFFFFFFFFBB1LLU:
	16134	+case 0xFFFFFFFFFFFFFBA5LLU:
15955	16135	/* SP = 7LLU */
15956	16136	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
15957		-{ /* JUMP / fnaddr = 18446744073709550515LLU; break; } / skip consequent */
	16137	+{ /* JUMP / fnaddr = 18446744073709550503LLU; break; } / skip consequent */
15958	16138	/* consequent */
15959	16139	{
15960	16140	/* CALLBEGIN */

		@@ -15965,12 +16145,12 @@
15965	16145	{
15966	16146	/CALLEND/
15967	16147	stackbase += 9LLU;
15968		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBB0LLU;
	16148	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA4LLU;
15969	16149	fnaddr = /ADDRNEXT__/0x441123856140000LLU;/* SP = 0LLU */
15970	16150	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRNEXT__/\n"); exit(-1); }
15971	16151	break;
15972	16152	}
15973		-case 0xFFFFFFFFFFFFFBB0LLU:
	16153	+case 0xFFFFFFFFFFFFFBA4LLU:
15974	16154	/* SP = 7LLU */
15975	16155	{
15976	16156	/* CALLBEGIN */

		@@ -15981,12 +16161,12 @@
15981	16161	{
15982	16162	/CALLEND/
15983	16163	stackbase += 9LLU;
15984		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBAFLLU;
	16164	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA3LLU;
15985	16165	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15986	16166	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
15987	16167	break;
15988	16168	}
15989		-case 0xFFFFFFFFFFFFFBAFLLU:
	16169	+case 0xFFFFFFFFFFFFFBA3LLU:
15990	16170	/* SP = 7LLU /fputs("/ predicate */\n", stdout);
15991	16171	{
15992	16172	/* CALLBEGIN */

		@@ -15997,12 +16177,12 @@
15997	16177	{
15998	16178	/CALLEND/
15999	16179	stackbase += 9LLU;
16000		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBAELLU;
	16180	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA2LLU;
16001	16181	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16002	16182	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16003	16183	break;
16004	16184	}
16005		-case 0xFFFFFFFFFFFFFBAELLU:
	16185	+case 0xFFFFFFFFFFFFFBA2LLU:
16006	16186	/* SP = 7LLU */
16007	16187	{
16008	16188	/* CALLBEGIN */

		@@ -16022,12 +16202,12 @@
16022	16202	{
16023	16203	/CALLEND/
16024	16204	stackbase += 15LLU;
16025		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBADLLU;
	16205	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA1LLU;
16026	16206	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
16027	16207	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
16028	16208	break;
16029	16209	}
16030		-case 0xFFFFFFFFFFFFFBADLLU:
	16210	+case 0xFFFFFFFFFFFFFBA1LLU:
16031	16211	/* SP = 13LLU */
16032	16212	{
16033	16213	/* CALLBEGIN */

		@@ -16039,23 +16219,23 @@
16039	16219	{
16040	16220	/CALLEND/
16041	16221	stackbase += 16LLU;
16042		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBACLLU;
	16222	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA0LLU;
16043	16223	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
16044	16224	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
16045	16225	break;
16046	16226	}
16047		-case 0xFFFFFFFFFFFFFBACLLU:
	16227	+case 0xFFFFFFFFFFFFFBA0LLU:
16048	16228	/* SP = 14LLU */
16049	16229	{ /* PUSH / stack[stackbase + 14LLU] = 0LLU; }/ SP + 1LLU = 15LLU */
16050	16230	{
16051	16231	/CALLEND/
16052	16232	stackbase += 9LLU;
16053		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBABLLU;
	16233	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9FLLU;
16054	16234	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16055	16235	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16056	16236	break;
16057	16237	}
16058		-case 0xFFFFFFFFFFFFFBABLLU:
	16238	+case 0xFFFFFFFFFFFFFB9FLLU:
16059	16239	/* SP = 7LLU */fputs("\nif(!", stdout);
16060	16240	{
16061	16241	/* CALLBEGIN */

		@@ -16066,12 +16246,12 @@
16066	16246	{
16067	16247	/CALLEND/
16068	16248	stackbase += 9LLU;
16069		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBAALLU;
	16249	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9ELLU;
16070	16250	fnaddr = /POP_START_/0x40F4004D40525000LLU;/* SP = 0LLU */
16071	16251	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_START_/\n"); exit(-1); }
16072	16252	break;
16073	16253	}
16074		-case 0xFFFFFFFFFFFFFBAALLU:
	16254	+case 0xFFFFFFFFFFFFFB9ELLU:
16075	16255	/* SP = 7LLU */fputs(")", stdout);
16076	16256	{
16077	16257	/* CALLBEGIN */

		@@ -16083,12 +16263,12 @@
16083	16263	{
16084	16264	/CALLEND/
16085	16265	stackbase += 9LLU;
16086		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA9LLU;
	16266	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9DLLU;
16087	16267	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
16088	16268	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
16089	16269	break;
16090	16270	}
16091		-case 0xFFFFFFFFFFFFFBA9LLU:
	16271	+case 0xFFFFFFFFFFFFFB9DLLU:
16092	16272	/* SP = 7LLU /fputs(" / skip consequent /", stdout); fputs("\n/ consequent */", stdout);
16093	16273	{
16094	16274	/* CALLBEGIN */

		@@ -16099,12 +16279,12 @@
16099	16279	{
16100	16280	/CALLEND/
16101	16281	stackbase += 9LLU;
16102		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA8LLU;
	16282	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9CLLU;
16103	16283	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16104	16284	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16105	16285	break;
16106	16286	}
16107		-case 0xFFFFFFFFFFFFFBA8LLU:
	16287	+case 0xFFFFFFFFFFFFFB9CLLU:
16108	16288	/* SP = 7LLU */
16109	16289	{
16110	16290	/* CALLBEGIN */

		@@ -16116,12 +16296,12 @@
16116	16296	{
16117	16297	/CALLEND/
16118	16298	stackbase += 9LLU;
16119		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA7LLU;
	16299	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9BLLU;
16120	16300	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
16121	16301	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
16122	16302	break;
16123	16303	}
16124		-case 0xFFFFFFFFFFFFFBA7LLU:
	16304	+case 0xFFFFFFFFFFFFFB9BLLU:
16125	16305	/* SP = 7LLU */
16126	16306	{
16127	16307	/* CALLBEGIN */

		@@ -16143,12 +16323,12 @@
16143	16323	{
16144	16324	/CALLEND/
16145	16325	stackbase += 16LLU;
16146		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA6LLU;
	16326	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9ALLU;
16147	16327	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
16148	16328	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
16149	16329	break;
16150	16330	}
16151		-case 0xFFFFFFFFFFFFFBA6LLU:
	16331	+case 0xFFFFFFFFFFFFFB9ALLU:
16152	16332	/* SP = 14LLU */
16153	16333	{
16154	16334	/* CALLBEGIN */

		@@ -16159,22 +16339,22 @@
16159	16339	{
16160	16340	/CALLEND/
16161	16341	stackbase += 17LLU;
16162		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA5LLU;
	16342	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB99LLU;
16163	16343	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
16164	16344	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
16165	16345	break;
16166	16346	}
16167		-case 0xFFFFFFFFFFFFFBA5LLU:
	16347	+case 0xFFFFFFFFFFFFFB99LLU:
16168	16348	/* SP = 15LLU */
16169	16349	{
16170	16350	/CALLEND/
16171	16351	stackbase += 9LLU;
16172		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA4LLU;
	16352	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB98LLU;
16173	16353	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16174	16354	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16175	16355	break;
16176	16356	}
16177		-case 0xFFFFFFFFFFFFFBA4LLU:
	16357	+case 0xFFFFFFFFFFFFFB98LLU:
16178	16358	/* SP = 7LLU */fputs("\ncase ", stdout);
16179	16359	{
16180	16360	/* CALLBEGIN */

		@@ -16186,12 +16366,12 @@
16186	16366	{
16187	16367	/CALLEND/
16188	16368	stackbase += 9LLU;
16189		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA3LLU;
	16369	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB97LLU;
16190	16370	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
16191	16371	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
16192	16372	break;
16193	16373	}
16194		-case 0xFFFFFFFFFFFFFBA3LLU:
	16374	+case 0xFFFFFFFFFFFFFB97LLU:
16195	16375	/* SP = 7LLU /fputs(": / alternative */", stdout);
16196	16376	{
16197	16377	/* CALLBEGIN */

		@@ -16208,15 +16388,15 @@
16208	16388	{
16209	16389	/CALLEND/
16210	16390	stackbase += 9LLU;
16211		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBA2LLU;
	16391	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB96LLU;
16212	16392	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16213	16393	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16214	16394	break;
16215	16395	}
16216		-case 0xFFFFFFFFFFFFFBA2LLU:
	16396	+case 0xFFFFFFFFFFFFFB96LLU:
16217	16397	/* SP = 7LLU // SP = 6LLU // SP = 6LLU */
16218		-{ /* JUMP / fnaddr = 18446744073709550514LLU; break; } / skip alternative */
16219		-case 18446744073709550515LLU: /* alternative // predicate */
	16398	+{ /* JUMP / fnaddr = 18446744073709550502LLU; break; } / skip alternative */
	16399	+case 18446744073709550503LLU: /* alternative // predicate */
16220	16400
16221	16401	{
16222	16402	/* CALLBEGIN */

		@@ -16229,15 +16409,15 @@
16229	16409	{
16230	16410	/CALLEND/
16231	16411	stackbase += 9LLU;
16232		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9FLLU;
	16412	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB93LLU;
16233	16413	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
16234	16414	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
16235	16415	break;
16236	16416	}
16237		-case 0xFFFFFFFFFFFFFB9FLLU:
	16417	+case 0xFFFFFFFFFFFFFB93LLU:
16238	16418	/* SP = 7LLU */
16239	16419	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
16240		-{ /* JUMP / fnaddr = 18446744073709550497LLU; break; } / skip consequent */
	16420	+{ /* JUMP / fnaddr = 18446744073709550485LLU; break; } / skip consequent */
16241	16421	/* consequent */fputs("\ncase ", stdout);
16242	16422	{
16243	16423	/* CALLBEGIN */

		@@ -16254,22 +16434,22 @@
16254	16434	{
16255	16435	/CALLEND/
16256	16436	stackbase += 11LLU;
16257		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9ELLU;
	16437	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB92LLU;
16258	16438	fnaddr = /ADDRNEXT__/0x441123856140000LLU;/* SP = 0LLU */
16259	16439	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRNEXT__/\n"); exit(-1); }
16260	16440	break;
16261	16441	}
16262		-case 0xFFFFFFFFFFFFFB9ELLU:
	16442	+case 0xFFFFFFFFFFFFFB92LLU:
16263	16443	/* SP = 9LLU */
16264	16444	{
16265	16445	/CALLEND/
16266	16446	stackbase += 8LLU;
16267		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9DLLU;
	16447	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB91LLU;
16268	16448	fnaddr = /printhexnr/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
16269	16449	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printhexnr/\n"); exit(-1); }
16270	16450	break;
16271	16451	}
16272		-case 0xFFFFFFFFFFFFFB9DLLU:
	16452	+case 0xFFFFFFFFFFFFFB91LLU:
16273	16453	/* SP = 6LLU /fputs(": / loop to here */", stdout);
16274	16454	{
16275	16455	/* CALLBEGIN */

		@@ -16280,12 +16460,12 @@
16280	16460	{
16281	16461	/CALLEND/
16282	16462	stackbase += 9LLU;
16283		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9CLLU;
	16463	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB90LLU;
16284	16464	fnaddr = /ADDRNEXT__/0x441123856140000LLU;/* SP = 0LLU */
16285	16465	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRNEXT__/\n"); exit(-1); }
16286	16466	break;
16287	16467	}
16288		-case 0xFFFFFFFFFFFFFB9CLLU:
	16468	+case 0xFFFFFFFFFFFFFB90LLU:
16289	16469	/* SP = 7LLU */
16290	16470	{
16291	16471	/* CALLBEGIN */

		@@ -16296,12 +16476,12 @@
16296	16476	{
16297	16477	/CALLEND/
16298	16478	stackbase += 9LLU;
16299		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9BLLU;
	16479	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8FLLU;
16300	16480	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16301	16481	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16302	16482	break;
16303	16483	}
16304		-case 0xFFFFFFFFFFFFFB9BLLU:
	16484	+case 0xFFFFFFFFFFFFFB8FLLU:
16305	16485	/* SP = 7LLU /fputs("/ predicate */\n", stdout);
16306	16486	{
16307	16487	/* CALLBEGIN */

		@@ -16312,12 +16492,12 @@
16312	16492	{
16313	16493	/CALLEND/
16314	16494	stackbase += 9LLU;
16315		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB9ALLU;
	16495	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8ELLU;
16316	16496	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16317	16497	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16318	16498	break;
16319	16499	}
16320		-case 0xFFFFFFFFFFFFFB9ALLU:
	16500	+case 0xFFFFFFFFFFFFFB8ELLU:
16321	16501	/* SP = 7LLU */
16322	16502	{
16323	16503	/* CALLBEGIN */

		@@ -16337,12 +16517,12 @@
16337	16517	{
16338	16518	/CALLEND/
16339	16519	stackbase += 15LLU;
16340		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB99LLU;
	16520	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8DLLU;
16341	16521	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
16342	16522	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
16343	16523	break;
16344	16524	}
16345		-case 0xFFFFFFFFFFFFFB99LLU:
	16525	+case 0xFFFFFFFFFFFFFB8DLLU:
16346	16526	/* SP = 13LLU */
16347	16527	{
16348	16528	/* CALLBEGIN */

		@@ -16354,23 +16534,23 @@
16354	16534	{
16355	16535	/CALLEND/
16356	16536	stackbase += 16LLU;
16357		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB98LLU;
	16537	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8CLLU;
16358	16538	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
16359	16539	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
16360	16540	break;
16361	16541	}
16362		-case 0xFFFFFFFFFFFFFB98LLU:
	16542	+case 0xFFFFFFFFFFFFFB8CLLU:
16363	16543	/* SP = 14LLU */
16364	16544	{ /* PUSH / stack[stackbase + 14LLU] = 0LLU; }/ SP + 1LLU = 15LLU */
16365	16545	{
16366	16546	/CALLEND/
16367	16547	stackbase += 9LLU;
16368		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB97LLU;
	16548	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8BLLU;
16369	16549	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16370	16550	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16371	16551	break;
16372	16552	}
16373		-case 0xFFFFFFFFFFFFFB97LLU:
	16553	+case 0xFFFFFFFFFFFFFB8BLLU:
16374	16554	/* SP = 7LLU */fputs("\nif(!", stdout);
16375	16555	{
16376	16556	/* CALLBEGIN */

		@@ -16381,12 +16561,12 @@
16381	16561	{
16382	16562	/CALLEND/
16383	16563	stackbase += 9LLU;
16384		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB96LLU;
	16564	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8ALLU;
16385	16565	fnaddr = /POP_START_/0x40F4004D40525000LLU;/* SP = 0LLU */
16386	16566	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_START_/\n"); exit(-1); }
16387	16567	break;
16388	16568	}
16389		-case 0xFFFFFFFFFFFFFB96LLU:
	16569	+case 0xFFFFFFFFFFFFFB8ALLU:
16390	16570	/* SP = 7LLU */fputs(")", stdout);
16391	16571	{
16392	16572	/* CALLBEGIN */

		@@ -16398,12 +16578,12 @@
16398	16578	{
16399	16579	/CALLEND/
16400	16580	stackbase += 9LLU;
16401		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB95LLU;
	16581	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB89LLU;
16402	16582	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
16403	16583	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
16404	16584	break;
16405	16585	}
16406		-case 0xFFFFFFFFFFFFFB95LLU:
	16586	+case 0xFFFFFFFFFFFFFB89LLU:
16407	16587	/* SP = 7LLU /fputs(" / skip loop /", stdout); fputs("\n/ loop */", stdout);
16408	16588	{
16409	16589	/* CALLBEGIN */

		@@ -16414,12 +16594,12 @@
16414	16594	{
16415	16595	/CALLEND/
16416	16596	stackbase += 9LLU;
16417		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB94LLU;
	16597	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB88LLU;
16418	16598	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16419	16599	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16420	16600	break;
16421	16601	}
16422		-case 0xFFFFFFFFFFFFFB94LLU:
	16602	+case 0xFFFFFFFFFFFFFB88LLU:
16423	16603	/* SP = 7LLU */
16424	16604	{
16425	16605	/* CALLBEGIN */

		@@ -16431,12 +16611,12 @@
16431	16611	{
16432	16612	/CALLEND/
16433	16613	stackbase += 9LLU;
16434		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB93LLU;
	16614	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB87LLU;
16435	16615	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
16436	16616	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
16437	16617	break;
16438	16618	}
16439		-case 0xFFFFFFFFFFFFFB93LLU:
	16619	+case 0xFFFFFFFFFFFFFB87LLU:
16440	16620	/* SP = 7LLU */
16441	16621	{
16442	16622	/* CALLBEGIN */

		@@ -16458,12 +16638,12 @@
16458	16638	{
16459	16639	/CALLEND/
16460	16640	stackbase += 16LLU;
16461		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB92LLU;
	16641	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB86LLU;
16462	16642	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
16463	16643	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
16464	16644	break;
16465	16645	}
16466		-case 0xFFFFFFFFFFFFFB92LLU:
	16646	+case 0xFFFFFFFFFFFFFB86LLU:
16467	16647	/* SP = 14LLU */
16468	16648	{
16469	16649	/* CALLBEGIN */

		@@ -16474,22 +16654,22 @@
16474	16654	{
16475	16655	/CALLEND/
16476	16656	stackbase += 17LLU;
16477		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB91LLU;
	16657	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB85LLU;
16478	16658	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
16479	16659	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
16480	16660	break;
16481	16661	}
16482		-case 0xFFFFFFFFFFFFFB91LLU:
	16662	+case 0xFFFFFFFFFFFFFB85LLU:
16483	16663	/* SP = 15LLU */
16484	16664	{
16485	16665	/CALLEND/
16486	16666	stackbase += 9LLU;
16487		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB90LLU;
	16667	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB84LLU;
16488	16668	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16489	16669	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16490	16670	break;
16491	16671	}
16492		-case 0xFFFFFFFFFFFFFB90LLU:
	16672	+case 0xFFFFFFFFFFFFFB84LLU:
16493	16673	/* SP = 7LLU */
16494	16674	{
16495	16675	/* CALLBEGIN */

		@@ -16508,22 +16688,22 @@
16508	16688	{
16509	16689	/CALLEND/
16510	16690	stackbase += 12LLU;
16511		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8FLLU;
	16691	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB83LLU;
16512	16692	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
16513	16693	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
16514	16694	break;
16515	16695	}
16516		-case 0xFFFFFFFFFFFFFB8FLLU:
	16696	+case 0xFFFFFFFFFFFFFB83LLU:
16517	16697	/* SP = 10LLU */
16518	16698	{
16519	16699	/CALLEND/
16520	16700	stackbase += 9LLU;
16521		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8ELLU;
	16701	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB82LLU;
16522	16702	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
16523	16703	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
16524	16704	break;
16525	16705	}
16526		-case 0xFFFFFFFFFFFFFB8ELLU:
	16706	+case 0xFFFFFFFFFFFFFB82LLU:
16527	16707	/* SP = 7LLU /fputs(" / loop */", stdout); fputs("\ncase ", stdout);
16528	16708	{
16529	16709	/* CALLBEGIN */

		@@ -16535,12 +16715,12 @@
16535	16715	{
16536	16716	/CALLEND/
16537	16717	stackbase += 9LLU;
16538		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8DLLU;
	16718	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB81LLU;
16539	16719	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
16540	16720	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
16541	16721	break;
16542	16722	}
16543		-case 0xFFFFFFFFFFFFFB8DLLU:
	16723	+case 0xFFFFFFFFFFFFFB81LLU:
16544	16724	/* SP = 7LLU /fputs(": / skip to here */", stdout);
16545	16725	{
16546	16726	/* CALLBEGIN */

		@@ -16557,15 +16737,15 @@
16557	16737	{
16558	16738	/CALLEND/
16559	16739	stackbase += 9LLU;
16560		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB8CLLU;
	16740	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB80LLU;
16561	16741	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16562	16742	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16563	16743	break;
16564	16744	}
16565		-case 0xFFFFFFFFFFFFFB8CLLU:
	16745	+case 0xFFFFFFFFFFFFFB80LLU:
16566	16746	/* SP = 7LLU // SP = 6LLU // SP = 6LLU */
16567		-{ /* JUMP / fnaddr = 18446744073709550496LLU; break; } / skip alternative */
16568		-case 18446744073709550497LLU: /* alternative // predicate */
	16747	+{ /* JUMP / fnaddr = 18446744073709550484LLU; break; } / skip alternative */
	16748	+case 18446744073709550485LLU: /* alternative // predicate */
16569	16749
16570	16750	{
16571	16751	/* CALLBEGIN */

		@@ -16578,15 +16758,15 @@
16578	16758	{
16579	16759	/CALLEND/
16580	16760	stackbase += 9LLU;
16581		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB89LLU;
	16761	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7DLLU;
16582	16762	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
16583	16763	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
16584	16764	break;
16585	16765	}
16586		-case 0xFFFFFFFFFFFFFB89LLU:
	16766	+case 0xFFFFFFFFFFFFFB7DLLU:
16587	16767	/* SP = 7LLU */
16588	16768	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
16589		-{ /* JUMP / fnaddr = 18446744073709550475LLU; break; } / skip consequent */
	16769	+{ /* JUMP / fnaddr = 18446744073709550463LLU; break; } / skip consequent */
16590	16770	/* consequent */
16591	16771	{ /* PUSH / stack[stackbase + 6LLU] = 0LLU; }/ SP + 1LLU = 7LLU */
16592	16772	{ /* PUSH / stack[stackbase + 7LLU] = 0LLU; }/ SP + 1LLU = 8LLU */

		@@ -16603,12 +16783,12 @@
16603	16783	{
16604	16784	/CALLEND/
16605	16785	stackbase += 13LLU;
16606		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB88LLU;
	16786	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7CLLU;
16607	16787	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
16608	16788	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
16609	16789	break;
16610	16790	}
16611		-case 0xFFFFFFFFFFFFFB88LLU:
	16791	+case 0xFFFFFFFFFFFFFB7CLLU:
16612	16792	/* SP = 11LLU // SP = 10LLU */
16613	16793	{ /* assign / / LOCAL VAR / stack[stackbase + 7LLU] = / LOCAL VAR */ stack[stackbase + 10LLU]; }
16614	16794	{ /* PUSH / stack[stackbase + 10LLU] = 0LLU; }/ SP + 1LLU = 11LLU // SP = 10LLU */

		@@ -16624,12 +16804,12 @@
16624	16804	{
16625	16805	/CALLEND/
16626	16806	stackbase += 12LLU;
16627		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB87LLU;
	16807	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7BLLU;
16628	16808	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16629	16809	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16630	16810	break;
16631	16811	}
16632		-case 0xFFFFFFFFFFFFFB87LLU:
	16812	+case 0xFFFFFFFFFFFFFB7BLLU:
16633	16813	/* SP = 10LLU */
16634	16814	{
16635	16815	/* CALLBEGIN */

		@@ -16646,22 +16826,22 @@
16646	16826	{
16647	16827	/CALLEND/
16648	16828	stackbase += 16LLU;
16649		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB86LLU;
	16829	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7ALLU;
16650	16830	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
16651	16831	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
16652	16832	break;
16653	16833	}
16654		-case 0xFFFFFFFFFFFFFB86LLU:
	16834	+case 0xFFFFFFFFFFFFFB7ALLU:
16655	16835	/* SP = 14LLU */
16656	16836	{
16657	16837	/CALLEND/
16658	16838	stackbase += 13LLU;
16659		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB85LLU;
	16839	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB79LLU;
16660	16840	fnaddr = /parsestype/0xADCB6E82EBF4AE00LLU;/* SP = 0LLU */
16661	16841	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestype/\n"); exit(-1); }
16662	16842	break;
16663	16843	}
16664		-case 0xFFFFFFFFFFFFFB85LLU:
	16844	+case 0xFFFFFFFFFFFFFB79LLU:
16665	16845	/* SP = 11LLU */
16666	16846	{
16667	16847	/* CALLBEGIN */

		@@ -16673,12 +16853,12 @@
16673	16853	{
16674	16854	/CALLEND/
16675	16855	stackbase += 14LLU;
16676		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB84LLU;
	16856	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB78LLU;
16677	16857	fnaddr = /encodeLIST/0x8297AA7E03094D40LLU;/* SP = 0LLU */
16678	16858	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeLIST/\n"); exit(-1); }
16679	16859	break;
16680	16860	}
16681		-case 0xFFFFFFFFFFFFFB84LLU:
	16861	+case 0xFFFFFFFFFFFFFB78LLU:
16682	16862	/* SP = 12LLU // SP = 11LLU */
16683	16863	{ /* assign / / LOCAL VAR / stack[stackbase + 8LLU] = / LOCAL VAR */ stack[stackbase + 11LLU]; }
16684	16864	{

		@@ -16690,12 +16870,12 @@
16690	16870	{
16691	16871	/CALLEND/
16692	16872	stackbase += 13LLU;
16693		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB83LLU;
	16873	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB77LLU;
16694	16874	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16695	16875	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16696	16876	break;
16697	16877	}
16698		-case 0xFFFFFFFFFFFFFB83LLU:
	16878	+case 0xFFFFFFFFFFFFFB77LLU:
16699	16879	/* SP = 11LLU */
16700	16880	{
16701	16881	/* CALLBEGIN */

		@@ -16706,12 +16886,12 @@
16706	16886	{
16707	16887	/CALLEND/
16708	16888	stackbase += 14LLU;
16709		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB82LLU;
	16889	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB76LLU;
16710	16890	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
16711	16891	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
16712	16892	break;
16713	16893	}
16714		-case 0xFFFFFFFFFFFFFB82LLU:
	16894	+case 0xFFFFFFFFFFFFFB76LLU:
16715	16895	/* SP = 12LLU // SP = 11LLU */
16716	16896	{ /* assign / / LOCAL VAR / stack[stackbase + 6LLU] = / LOCAL VAR / stack[stackbase + 11LLU]; }/ predicate */
16717	16897

		@@ -16726,15 +16906,15 @@
16726	16906	{
16727	16907	/CALLEND/
16728	16908	stackbase += 14LLU;
16729		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7FLLU;
	16909	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB73LLU;
16730	16910	fnaddr = /existsvar_/0x83392EBEEC5CB400LLU;/* SP = 0LLU */
16731	16911	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsvar_/\n"); exit(-1); }
16732	16912	break;
16733	16913	}
16734		-case 0xFFFFFFFFFFFFFB7FLLU:
	16914	+case 0xFFFFFFFFFFFFFB73LLU:
16735	16915	/* SP = 12LLU */
16736	16916	if(!/* SP - 1LLU = 11LLU */stack[stackbase + 11LLU])
16737		-{ /* JUMP / fnaddr = 18446744073709550465LLU; break; } / skip consequent */
	16917	+{ /* JUMP / fnaddr = 18446744073709550453LLU; break; } / skip consequent */
16738	16918	/* consequent */
16739	16919	{
16740	16920	/* CALLBEGIN */

		@@ -16745,12 +16925,12 @@
16745	16925	{
16746	16926	/CALLEND/
16747	16927	stackbase += 13LLU;
16748		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7ELLU;
	16928	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB72LLU;
16749	16929	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
16750	16930	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
16751	16931	break;
16752	16932	}
16753		-case 0xFFFFFFFFFFFFFB7ELLU:
	16933	+case 0xFFFFFFFFFFFFFB72LLU:
16754	16934	/* SP = 11LLU */fputs("re-definition of variable ", stderr);
16755	16935	{
16756	16936	/* CALLBEGIN */

		@@ -16762,15 +16942,15 @@
16762	16942	{
16763	16943	/CALLEND/
16764	16944	stackbase += 13LLU;
16765		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7DLLU;
	16945	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB71LLU;
16766	16946	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
16767	16947	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
16768	16948	break;
16769	16949	}
16770		-case 0xFFFFFFFFFFFFFB7DLLU:
	16950	+case 0xFFFFFFFFFFFFFB71LLU:
16771	16951	/* SP = 11LLU /fputs("\n", stderr); exit(-1);/ SP = 11LLU // SP = 11LLU */
16772		-{ /* JUMP / fnaddr = 18446744073709550464LLU; break; } / skip alternative */
16773		-case 18446744073709550465LLU: /* alternative */
	16952	+{ /* JUMP / fnaddr = 18446744073709550452LLU; break; } / skip alternative */
	16953	+case 18446744073709550453LLU: /* alternative */
16774	16954	{
16775	16955	/* CALLBEGIN */
16776	16956	/* reserve space for 0LLU returned values // SP + 0LLU = 11LLU */

		@@ -16780,12 +16960,12 @@
16780	16960	{
16781	16961	/CALLEND/
16782	16962	stackbase += 13LLU;
16783		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7CLLU;
	16963	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB70LLU;
16784	16964	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
16785	16965	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); }
16786	16966	break;
16787	16967	}
16788		-case 0xFFFFFFFFFFFFFB7CLLU:
	16968	+case 0xFFFFFFFFFFFFFB70LLU:
16789	16969	/* SP = 11LLU /fputs("(/ REF TO LINK */ stackbase + ", stdout);
16790	16970	{
16791	16971	/* CALLBEGIN */

		@@ -16804,22 +16984,22 @@
16804	16984	{
16805	16985	/CALLEND/
16806	16986	stackbase += 16LLU;
16807		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7BLLU;
	16987	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6FLLU;
16808	16988	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
16809	16989	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
16810	16990	break;
16811	16991	}
16812		-case 0xFFFFFFFFFFFFFB7BLLU:
	16992	+case 0xFFFFFFFFFFFFFB6FLLU:
16813	16993	/* SP = 14LLU */
16814	16994	{
16815	16995	/CALLEND/
16816	16996	stackbase += 13LLU;
16817		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB7ALLU;
	16997	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6ELLU;
16818	16998	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
16819	16999	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
16820	17000	break;
16821	17001	}
16822		-case 0xFFFFFFFFFFFFFB7ALLU:
	17002	+case 0xFFFFFFFFFFFFFB6ELLU:
16823	17003	/* SP = 11LLU */fputs(")", stdout);
16824	17004	{
16825	17005	/* CALLBEGIN */

		@@ -16830,12 +17010,12 @@
16830	17010	{
16831	17011	/CALLEND/
16832	17012	stackbase += 13LLU;
16833		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB79LLU;
	17013	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6DLLU;
16834	17014	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
16835	17015	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); }
16836	17016	break;
16837	17017	}
16838		-case 0xFFFFFFFFFFFFFB79LLU:
	17018	+case 0xFFFFFFFFFFFFFB6DLLU:
16839	17019	/* SP = 11LLU */
16840	17020	{
16841	17021	/* CALLBEGIN */

		@@ -16846,12 +17026,12 @@
16846	17026	{
16847	17027	/CALLEND/
16848	17028	stackbase += 13LLU;
16849		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB78LLU;
	17029	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6CLLU;
16850	17030	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16851	17031	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16852	17032	break;
16853	17033	}
16854		-case 0xFFFFFFFFFFFFFB78LLU:
	17034	+case 0xFFFFFFFFFFFFFB6CLLU:
16855	17035	/* SP = 11LLU */
16856	17036	{
16857	17037	/* CALLBEGIN */

		@@ -16863,12 +17043,12 @@
16863	17043	{
16864	17044	/CALLEND/
16865	17045	stackbase += 13LLU;
16866		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB77LLU;
	17046	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6BLLU;
16867	17047	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
16868	17048	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
16869	17049	break;
16870	17050	}
16871		-case 0xFFFFFFFFFFFFFB77LLU:
	17051	+case 0xFFFFFFFFFFFFFB6BLLU:
16872	17052	/* SP = 11LLU */
16873	17053	{
16874	17054	/* CALLBEGIN */

		@@ -16879,12 +17059,12 @@
16879	17059	{
16880	17060	/CALLEND/
16881	17061	stackbase += 13LLU;
16882		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB76LLU;
	17062	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6ALLU;
16883	17063	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16884	17064	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16885	17065	break;
16886	17066	}
16887		-case 0xFFFFFFFFFFFFFB76LLU:
	17067	+case 0xFFFFFFFFFFFFFB6ALLU:
16888	17068	/* SP = 11LLU */
16889	17069	{
16890	17070	/* CALLBEGIN */

		@@ -16904,12 +17084,12 @@
16904	17084	{
16905	17085	/CALLEND/
16906	17086	stackbase += 19LLU;
16907		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB75LLU;
	17087	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB69LLU;
16908	17088	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
16909	17089	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
16910	17090	break;
16911	17091	}
16912		-case 0xFFFFFFFFFFFFFB75LLU:
	17092	+case 0xFFFFFFFFFFFFFB69LLU:
16913	17093	/* SP = 17LLU */
16914	17094	{ /* PUSH / stack[stackbase + 17LLU] = / LOCAL VAR / stack[stackbase + 8LLU]; }/ SP + 1LLU = 18LLU */
16915	17095	{ /* PUSH / stack[stackbase + 18LLU] = 0LLU; }/ SP + 1LLU = 19LLU */

		@@ -16916,12 +17096,12 @@
16916	17096	{
16917	17097	/CALLEND/
16918	17098	stackbase += 13LLU;
16919		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB74LLU;
	17099	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB68LLU;
16920	17100	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16921	17101	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16922	17102	break;
16923	17103	}
16924		-case 0xFFFFFFFFFFFFFB74LLU:
	17104	+case 0xFFFFFFFFFFFFFB68LLU:
16925	17105	/* SP = 11LLU */
16926	17106	{
16927	17107	/* CALLBEGIN */

		@@ -16932,12 +17112,12 @@
16932	17112	{
16933	17113	/CALLEND/
16934	17114	stackbase += 13LLU;
16935		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB73LLU;
	17115	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB67LLU;
16936	17116	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
16937	17117	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
16938	17118	break;
16939	17119	}
16940		-case 0xFFFFFFFFFFFFFB73LLU:
	17120	+case 0xFFFFFFFFFFFFFB67LLU:
16941	17121	/* SP = 11LLU */
16942	17122	{
16943	17123	/* CALLBEGIN */

		@@ -16957,12 +17137,12 @@
16957	17137	{
16958	17138	/CALLEND/
16959	17139	stackbase += 19LLU;
16960		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB72LLU;
	17140	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB66LLU;
16961	17141	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
16962	17142	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
16963	17143	break;
16964	17144	}
16965		-case 0xFFFFFFFFFFFFFB72LLU:
	17145	+case 0xFFFFFFFFFFFFFB66LLU:
16966	17146	/* SP = 17LLU */
16967	17147	{
16968	17148	/* CALLBEGIN */

		@@ -16974,23 +17154,23 @@
16974	17154	{
16975	17155	/CALLEND/
16976	17156	stackbase += 20LLU;
16977		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB71LLU;
	17157	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB65LLU;
16978	17158	fnaddr = /encodeVAL_/0x8297AA7E05813000LLU;/* SP = 0LLU */
16979	17159	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeVAL_/\n"); exit(-1); }
16980	17160	break;
16981	17161	}
16982		-case 0xFFFFFFFFFFFFFB71LLU:
	17162	+case 0xFFFFFFFFFFFFFB65LLU:
16983	17163	/* SP = 18LLU */
16984	17164	{ /* PUSH / stack[stackbase + 18LLU] = 0LLU; }/ SP + 1LLU = 19LLU */
16985	17165	{
16986	17166	/CALLEND/
16987	17167	stackbase += 13LLU;
16988		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB70LLU;
	17168	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB64LLU;
16989	17169	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
16990	17170	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
16991	17171	break;
16992	17172	}
16993		-case 0xFFFFFFFFFFFFFB70LLU:
	17173	+case 0xFFFFFFFFFFFFFB64LLU:
16994	17174	/* SP = 11LLU */
16995	17175	{ /* PUSH / stack[stackbase + 11LLU] = (/ REF TO LINK / stackbase + 12LLU); }/ SP + 1LLU = 12LLU */
16996	17176	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 2LLU]; }/ SP + 1LLU = 13LLU */

		@@ -17013,17 +17193,17 @@
17013	17193	{
17014	17194	/CALLEND/
17015	17195	stackbase += 19LLU;
17016		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6FLLU;
	17196	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB63LLU;
17017	17197	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
17018	17198	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
17019	17199	break;
17020	17200	}
17021		-case 0xFFFFFFFFFFFFFB6FLLU:
	17201	+case 0xFFFFFFFFFFFFFB63LLU:
17022	17202	/* SP = 17LLU // SP = 11LLU */
17023		-case 18446744073709550464LLU: /* skip to here */
	17203	+case 18446744073709550452LLU: /* skip to here */
17024	17204	/* SP = 6LLU // SP = 6LLU */
17025		-{ /* JUMP / fnaddr = 18446744073709550474LLU; break; } / skip alternative */
17026		-case 18446744073709550475LLU: /* alternative // predicate */
	17205	+{ /* JUMP / fnaddr = 18446744073709550462LLU; break; } / skip alternative */
	17206	+case 18446744073709550463LLU: /* alternative // predicate */
17027	17207
17028	17208	{
17029	17209	/* CALLBEGIN */

		@@ -17036,15 +17216,15 @@
17036	17216	{
17037	17217	/CALLEND/
17038	17218	stackbase += 9LLU;
17039		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6CLLU;
	17219	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB60LLU;
17040	17220	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
17041	17221	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
17042	17222	break;
17043	17223	}
17044		-case 0xFFFFFFFFFFFFFB6CLLU:
	17224	+case 0xFFFFFFFFFFFFFB60LLU:
17045	17225	/* SP = 7LLU */
17046	17226	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
17047		-{ /* JUMP / fnaddr = 18446744073709550446LLU; break; } / skip consequent */
	17227	+{ /* JUMP / fnaddr = 18446744073709550434LLU; break; } / skip consequent */
17048	17228	/* consequent */
17049	17229	{
17050	17230	/* CALLBEGIN */

		@@ -17055,12 +17235,12 @@
17055	17235	{
17056	17236	/CALLEND/
17057	17237	stackbase += 8LLU;
17058		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6BLLU;
	17238	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5FLLU;
17059	17239	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
17060	17240	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
17061	17241	break;
17062	17242	}
17063		-case 0xFFFFFFFFFFFFFB6BLLU:
	17243	+case 0xFFFFFFFFFFFFFB5FLLU:
17064	17244	/* SP = 6LLU */
17065	17245	{
17066	17246	/* CALLBEGIN */

		@@ -17071,12 +17251,12 @@
17071	17251	{
17072	17252	/CALLEND/
17073	17253	stackbase += 9LLU;
17074		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB6ALLU;
	17254	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5ELLU;
17075	17255	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
17076	17256	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
17077	17257	break;
17078	17258	}
17079		-case 0xFFFFFFFFFFFFFB6ALLU:
	17259	+case 0xFFFFFFFFFFFFFB5ELLU:
17080	17260	/* SP = 7LLU // SP = 6LLU */
17081	17261	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR */ stack[stackbase + 6LLU]; }
17082	17262	{

		@@ -17090,12 +17270,12 @@
17090	17270	{
17091	17271	/CALLEND/
17092	17272	stackbase += 9LLU;
17093		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB69LLU;
	17273	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5DLLU;
17094	17274	fnaddr = /findvaro__/0x864A5FC5CB6A0000LLU;/* SP = 0LLU */
17095	17275	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /findvaro__/\n"); exit(-1); }
17096	17276	break;
17097	17277	}
17098		-case 0xFFFFFFFFFFFFFB69LLU:
	17278	+case 0xFFFFFFFFFFFFFB5DLLU:
17099	17279	/* SP = 7LLU */
17100	17280	{
17101	17281	/* CALLBEGIN */

		@@ -17108,12 +17288,12 @@
17108	17288	{
17109	17289	/CALLEND/
17110	17290	stackbase += 10LLU;
17111		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB68LLU;
	17291	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5CLLU;
17112	17292	fnaddr = /findvart__/0x864A5FC5CB6F0000LLU;/* SP = 0LLU */
17113	17293	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /findvart__/\n"); exit(-1); }
17114	17294	break;
17115	17295	}
17116		-case 0xFFFFFFFFFFFFFB68LLU:
	17296	+case 0xFFFFFFFFFFFFFB5CLLU:
17117	17297	/* SP = 8LLU // predicate */
17118	17298
17119	17299	{

		@@ -17126,15 +17306,15 @@
17126	17306	{
17127	17307	/CALLEND/
17128	17308	stackbase += 11LLU;
17129		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB65LLU;
	17309	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB59LLU;
17130	17310	fnaddr = /typeislist/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
17131	17311	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeislist/\n"); exit(-1); }
17132	17312	break;
17133	17313	}
17134		-case 0xFFFFFFFFFFFFFB65LLU:
	17314	+case 0xFFFFFFFFFFFFFB59LLU:
17135	17315	/* SP = 9LLU */
17136	17316	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
17137		-{ /* JUMP / fnaddr = 18446744073709550439LLU; break; } / skip consequent */
	17317	+{ /* JUMP / fnaddr = 18446744073709550427LLU; break; } / skip consequent */
17138	17318	/* consequent */
17139	17319	{ /* PUSH / stack[stackbase + 8LLU] = 0LLU; }/ SP + 1LLU = 9LLU */
17140	17320	{ /* PUSH / stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU */

		@@ -17157,12 +17337,12 @@
17157	17337	{
17158	17338	/CALLEND/
17159	17339	stackbase += 15LLU;
17160		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB64LLU;
	17340	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB58LLU;
17161	17341	fnaddr = /ADDRNEXT__/0x441123856140000LLU;/* SP = 0LLU */
17162	17342	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRNEXT__/\n"); exit(-1); }
17163	17343	break;
17164	17344	}
17165		-case 0xFFFFFFFFFFFFFB64LLU:
	17345	+case 0xFFFFFFFFFFFFFB58LLU:
17166	17346	/* SP = 13LLU /fputs("/ predicate: list non-empty? */\n", stdout);
17167	17347	{
17168	17348	/* CALLBEGIN */

		@@ -17173,12 +17353,12 @@
17173	17353	{
17174	17354	/CALLEND/
17175	17355	stackbase += 15LLU;
17176		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB63LLU;
	17356	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB57LLU;
17177	17357	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
17178	17358	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); }
17179	17359	break;
17180	17360	}
17181		-case 0xFFFFFFFFFFFFFB63LLU:
	17361	+case 0xFFFFFFFFFFFFFB57LLU:
17182	17362	/* SP = 13LLU */
17183	17363	{
17184	17364	/* CALLBEGIN */

		@@ -17190,12 +17370,12 @@
17190	17370	{
17191	17371	/CALLEND/
17192	17372	stackbase += 15LLU;
17193		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB62LLU;
	17373	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB56LLU;
17194	17374	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
17195	17375	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
17196	17376	break;
17197	17377	}
17198		-case 0xFFFFFFFFFFFFFB62LLU:
	17378	+case 0xFFFFFFFFFFFFFB56LLU:
17199	17379	/* SP = 13LLU */
17200	17380	{
17201	17381	/* CALLBEGIN */

		@@ -17206,12 +17386,12 @@
17206	17386	{
17207	17387	/CALLEND/
17208	17388	stackbase += 15LLU;
17209		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB61LLU;
	17389	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB55LLU;
17210	17390	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
17211	17391	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); }
17212	17392	break;
17213	17393	}
17214		-case 0xFFFFFFFFFFFFFB61LLU:
	17394	+case 0xFFFFFFFFFFFFFB55LLU:
17215	17395	/* SP = 13LLU */fputs("\nif(!", stdout);
17216	17396	{
17217	17397	/* CALLBEGIN */

		@@ -17222,12 +17402,12 @@
17222	17402	{
17223	17403	/CALLEND/
17224	17404	stackbase += 15LLU;
17225		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB60LLU;
	17405	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB54LLU;
17226	17406	fnaddr = /POP_START_/0x40F4004D40525000LLU;/* SP = 0LLU */
17227	17407	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_START_/\n"); exit(-1); }
17228	17408	break;
17229	17409	}
17230		-case 0xFFFFFFFFFFFFFB60LLU:
	17410	+case 0xFFFFFFFFFFFFFB54LLU:
17231	17411	/* SP = 13LLU */fputs(")", stdout);
17232	17412	{
17233	17413	/* CALLBEGIN */

		@@ -17239,12 +17419,12 @@
17239	17419	{
17240	17420	/CALLEND/
17241	17421	stackbase += 15LLU;
17242		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5FLLU;
	17422	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB53LLU;
17243	17423	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
17244	17424	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
17245	17425	break;
17246	17426	}
17247		-case 0xFFFFFFFFFFFFFB5FLLU:
	17427	+case 0xFFFFFFFFFFFFFB53LLU:
17248	17428	/* SP = 13LLU /fputs(" / skip consequent /", stdout); fputs("\n/ consequent */", stdout);
17249	17429	{
17250	17430	/* CALLBEGIN */

		@@ -17255,12 +17435,12 @@
17255	17435	{
17256	17436	/CALLEND/
17257	17437	stackbase += 15LLU;
17258		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5ELLU;
	17438	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB52LLU;
17259	17439	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
17260	17440	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
17261	17441	break;
17262	17442	}
17263		-case 0xFFFFFFFFFFFFFB5ELLU:
	17443	+case 0xFFFFFFFFFFFFFB52LLU:
17264	17444	/* SP = 13LLU */
17265	17445	{
17266	17446	/* CALLBEGIN */

		@@ -17272,12 +17452,12 @@
17272	17452	{
17273	17453	/CALLEND/
17274	17454	stackbase += 15LLU;
17275		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5DLLU;
	17455	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB51LLU;
17276	17456	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
17277	17457	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
17278	17458	break;
17279	17459	}
17280		-case 0xFFFFFFFFFFFFFB5DLLU:
	17460	+case 0xFFFFFFFFFFFFFB51LLU:
17281	17461	/* SP = 13LLU */
17282	17462	{ /* PUSH / stack[stackbase + 13LLU] = (/ REF TO LINK / stackbase + 14LLU); }/ SP + 1LLU = 14LLU */
17283	17463	{ /* PUSH / stack[stackbase + 14LLU] = / LOCAL VAR / stack[stackbase + 2LLU]; }/ SP + 1LLU = 15LLU */

		@@ -17305,12 +17485,12 @@
17305	17485	{
17306	17486	/CALLEND/
17307	17487	stackbase += 28LLU;
17308		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5CLLU;
	17488	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB50LLU;
17309	17489	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
17310	17490	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
17311	17491	break;
17312	17492	}
17313		-case 0xFFFFFFFFFFFFFB5CLLU:
	17493	+case 0xFFFFFFFFFFFFFB50LLU:
17314	17494	/* SP = 26LLU */
17315	17495	{
17316	17496	/* CALLBEGIN */

		@@ -17321,22 +17501,22 @@
17321	17501	{
17322	17502	/CALLEND/
17323	17503	stackbase += 29LLU;
17324		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5BLLU;
	17504	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4FLLU;
17325	17505	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
17326	17506	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
17327	17507	break;
17328	17508	}
17329		-case 0xFFFFFFFFFFFFFB5BLLU:
	17509	+case 0xFFFFFFFFFFFFFB4FLLU:
17330	17510	/* SP = 27LLU */
17331	17511	{
17332	17512	/CALLEND/
17333	17513	stackbase += 21LLU;
17334		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB5ALLU;
	17514	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4ELLU;
17335	17515	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
17336	17516	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
17337	17517	break;
17338	17518	}
17339		-case 0xFFFFFFFFFFFFFB5ALLU:
	17519	+case 0xFFFFFFFFFFFFFB4ELLU:
17340	17520	/* SP = 19LLU */fputs("\ncase ", stdout);
17341	17521	{
17342	17522	/* CALLBEGIN */

		@@ -17348,12 +17528,12 @@
17348	17528	{
17349	17529	/CALLEND/
17350	17530	stackbase += 21LLU;
17351		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB59LLU;
	17531	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4DLLU;
17352	17532	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
17353	17533	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
17354	17534	break;
17355	17535	}
17356		-case 0xFFFFFFFFFFFFFB59LLU:
	17536	+case 0xFFFFFFFFFFFFFB4DLLU:
17357	17537	/* SP = 19LLU /fputs(": / skipped consequent */", stdout);
17358	17538	{
17359	17539	/* CALLBEGIN */

		@@ -17370,15 +17550,15 @@
17370	17550	{
17371	17551	/CALLEND/
17372	17552	stackbase += 21LLU;
17373		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB58LLU;
	17553	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4CLLU;
17374	17554	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
17375	17555	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
17376	17556	break;
17377	17557	}
17378		-case 0xFFFFFFFFFFFFFB58LLU:
	17558	+case 0xFFFFFFFFFFFFFB4CLLU:
17379	17559	/* SP = 19LLU // SP = 8LLU // SP = 8LLU */
17380		-{ /* JUMP / fnaddr = 18446744073709550438LLU; break; } / skip alternative */
17381		-case 18446744073709550439LLU: /* alternative */
	17560	+{ /* JUMP / fnaddr = 18446744073709550426LLU; break; } / skip alternative */
	17561	+case 18446744073709550427LLU: /* alternative */
17382	17562	{
17383	17563	/* CALLBEGIN */
17384	17564	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -17388,12 +17568,12 @@
17388	17568	{
17389	17569	/CALLEND/
17390	17570	stackbase += 10LLU;
17391		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB57LLU;
	17571	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4BLLU;
17392	17572	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
17393	17573	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
17394	17574	break;
17395	17575	}
17396		-case 0xFFFFFFFFFFFFFB57LLU:
	17576	+case 0xFFFFFFFFFFFFFB4BLLU:
17397	17577	/* SP = 8LLU */fputs("accesslist needs list-type but found ", stderr);
17398	17578	{
17399	17579	/* CALLBEGIN */

		@@ -17405,17 +17585,17 @@
17405	17585	{
17406	17586	/CALLEND/
17407	17587	stackbase += 10LLU;
17408		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB56LLU;
	17588	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4ALLU;
17409	17589	fnaddr = /debugtype_/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
17410	17590	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugtype_/\n"); exit(-1); }
17411	17591	break;
17412	17592	}
17413		-case 0xFFFFFFFFFFFFFB56LLU:
	17593	+case 0xFFFFFFFFFFFFFB4ALLU:
17414	17594	/* SP = 8LLU /exit(-1);/ SP = 8LLU */
17415		-case 18446744073709550438LLU: /* skip to here */
	17595	+case 18446744073709550426LLU: /* skip to here */
17416	17596	/* SP = 6LLU // SP = 6LLU */
17417		-{ /* JUMP / fnaddr = 18446744073709550445LLU; break; } / skip alternative */
17418		-case 18446744073709550446LLU: /* alternative // predicate */
	17597	+{ /* JUMP / fnaddr = 18446744073709550433LLU; break; } / skip alternative */
	17598	+case 18446744073709550434LLU: /* alternative // predicate */
17419	17599
17420	17600	{
17421	17601	/* CALLBEGIN */

		@@ -17428,15 +17608,15 @@
17428	17608	{
17429	17609	/CALLEND/
17430	17610	stackbase += 9LLU;
17431		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB53LLU;
	17611	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB47LLU;
17432	17612	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
17433	17613	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
17434	17614	break;
17435	17615	}
17436		-case 0xFFFFFFFFFFFFFB53LLU:
	17616	+case 0xFFFFFFFFFFFFFB47LLU:
17437	17617	/* SP = 7LLU */
17438	17618	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
17439		-{ /* JUMP / fnaddr = 18446744073709550421LLU; break; } / skip consequent */
	17619	+{ /* JUMP / fnaddr = 18446744073709550409LLU; break; } / skip consequent */
17440	17620	/* consequent */
17441	17621	{
17442	17622	/* CALLBEGIN */

		@@ -17447,12 +17627,12 @@
17447	17627	{
17448	17628	/CALLEND/
17449	17629	stackbase += 8LLU;
17450		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB52LLU;
	17630	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB46LLU;
17451	17631	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
17452	17632	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
17453	17633	break;
17454	17634	}
17455		-case 0xFFFFFFFFFFFFFB52LLU:
	17635	+case 0xFFFFFFFFFFFFFB46LLU:
17456	17636	/* SP = 6LLU */
17457	17637	{
17458	17638	/* CALLBEGIN */

		@@ -17463,12 +17643,12 @@
17463	17643	{
17464	17644	/CALLEND/
17465	17645	stackbase += 9LLU;
17466		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB51LLU;
	17646	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB45LLU;
17467	17647	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
17468	17648	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
17469	17649	break;
17470	17650	}
17471		-case 0xFFFFFFFFFFFFFB51LLU:
	17651	+case 0xFFFFFFFFFFFFFB45LLU:
17472	17652	/* SP = 7LLU // SP = 6LLU */
17473	17653	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR */ stack[stackbase + 6LLU]; }
17474	17654	{

		@@ -17482,12 +17662,12 @@
17482	17662	{
17483	17663	/CALLEND/
17484	17664	stackbase += 9LLU;
17485		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB50LLU;
	17665	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB44LLU;
17486	17666	fnaddr = /findvaro__/0x864A5FC5CB6A0000LLU;/* SP = 0LLU */
17487	17667	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /findvaro__/\n"); exit(-1); }
17488	17668	break;
17489	17669	}
17490		-case 0xFFFFFFFFFFFFFB50LLU:
	17670	+case 0xFFFFFFFFFFFFFB44LLU:
17491	17671	/* SP = 7LLU */
17492	17672	{
17493	17673	/* CALLBEGIN */

		@@ -17500,12 +17680,12 @@
17500	17680	{
17501	17681	/CALLEND/
17502	17682	stackbase += 10LLU;
17503		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4FLLU;
	17683	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB43LLU;
17504	17684	fnaddr = /findvart__/0x864A5FC5CB6F0000LLU;/* SP = 0LLU */
17505	17685	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /findvart__/\n"); exit(-1); }
17506	17686	break;
17507	17687	}
17508		-case 0xFFFFFFFFFFFFFB4FLLU:
	17688	+case 0xFFFFFFFFFFFFFB43LLU:
17509	17689	/* SP = 8LLU // predicate */
17510	17690
17511	17691	{

		@@ -17518,15 +17698,15 @@
17518	17698	{
17519	17699	/CALLEND/
17520	17700	stackbase += 11LLU;
17521		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4CLLU;
	17701	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB40LLU;
17522	17702	fnaddr = /typeislist/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
17523	17703	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeislist/\n"); exit(-1); }
17524	17704	break;
17525	17705	}
17526		-case 0xFFFFFFFFFFFFFB4CLLU:
	17706	+case 0xFFFFFFFFFFFFFB40LLU:
17527	17707	/* SP = 9LLU */
17528	17708	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
17529		-{ /* JUMP / fnaddr = 18446744073709550414LLU; break; } / skip consequent */
	17709	+{ /* JUMP / fnaddr = 18446744073709550402LLU; break; } / skip consequent */
17530	17710	/* consequent */
17531	17711	{ /* PUSH / stack[stackbase + 8LLU] = 0LLU; }/ SP + 1LLU = 9LLU */
17532	17712	{ /* PUSH / stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU */

		@@ -17555,22 +17735,22 @@
17555	17735	{
17556	17736	/CALLEND/
17557	17737	stackbase += 17LLU;
17558		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4BLLU;
	17738	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3FLLU;
17559	17739	fnaddr = /ADDRNEXT__/0x441123856140000LLU;/* SP = 0LLU */
17560	17740	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRNEXT__/\n"); exit(-1); }
17561	17741	break;
17562	17742	}
17563		-case 0xFFFFFFFFFFFFFB4BLLU:
	17743	+case 0xFFFFFFFFFFFFFB3FLLU:
17564	17744	/* SP = 15LLU */
17565	17745	{
17566	17746	/CALLEND/
17567	17747	stackbase += 14LLU;
17568		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB4ALLU;
	17748	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3ELLU;
17569	17749	fnaddr = /printhexnr/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
17570	17750	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printhexnr/\n"); exit(-1); }
17571	17751	break;
17572	17752	}
17573		-case 0xFFFFFFFFFFFFFB4ALLU:
	17753	+case 0xFFFFFFFFFFFFFB3ELLU:
17574	17754	/* SP = 12LLU /fputs(": / loop to here */", stdout);
17575	17755	{
17576	17756	/* CALLBEGIN */

		@@ -17581,12 +17761,12 @@
17581	17761	{
17582	17762	/CALLEND/
17583	17763	stackbase += 15LLU;
17584		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB49LLU;
	17764	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3DLLU;
17585	17765	fnaddr = /ADDRNEXT__/0x441123856140000LLU;/* SP = 0LLU */
17586	17766	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRNEXT__/\n"); exit(-1); }
17587	17767	break;
17588	17768	}
17589		-case 0xFFFFFFFFFFFFFB49LLU:
	17769	+case 0xFFFFFFFFFFFFFB3DLLU:
17590	17770	/* SP = 13LLU */
17591	17771	{
17592	17772	/* CALLBEGIN */

		@@ -17597,12 +17777,12 @@
17597	17777	{
17598	17778	/CALLEND/
17599	17779	stackbase += 15LLU;
17600		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB48LLU;
	17780	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3CLLU;
17601	17781	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
17602	17782	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
17603	17783	break;
17604	17784	}
17605		-case 0xFFFFFFFFFFFFFB48LLU:
	17785	+case 0xFFFFFFFFFFFFFB3CLLU:
17606	17786	/* SP = 13LLU /fputs("/ predicate: list non-empty? */\n", stdout);
17607	17787	{
17608	17788	/* CALLBEGIN */

		@@ -17613,12 +17793,12 @@
17613	17793	{
17614	17794	/CALLEND/
17615	17795	stackbase += 15LLU;
17616		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB47LLU;
	17796	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3BLLU;
17617	17797	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
17618	17798	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); }
17619	17799	break;
17620	17800	}
17621		-case 0xFFFFFFFFFFFFFB47LLU:
	17801	+case 0xFFFFFFFFFFFFFB3BLLU:
17622	17802	/* SP = 13LLU */
17623	17803	{
17624	17804	/* CALLBEGIN */

		@@ -17630,12 +17810,12 @@
17630	17810	{
17631	17811	/CALLEND/
17632	17812	stackbase += 15LLU;
17633		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB46LLU;
	17813	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3ALLU;
17634	17814	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
17635	17815	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
17636	17816	break;
17637	17817	}
17638		-case 0xFFFFFFFFFFFFFB46LLU:
	17818	+case 0xFFFFFFFFFFFFFB3ALLU:
17639	17819	/* SP = 13LLU */
17640	17820	{
17641	17821	/* CALLBEGIN */

		@@ -17646,12 +17826,12 @@
17646	17826	{
17647	17827	/CALLEND/
17648	17828	stackbase += 15LLU;
17649		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB45LLU;
	17829	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB39LLU;
17650	17830	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
17651	17831	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); }
17652	17832	break;
17653	17833	}
17654		-case 0xFFFFFFFFFFFFFB45LLU:
	17834	+case 0xFFFFFFFFFFFFFB39LLU:
17655	17835	/* SP = 13LLU */fputs("\nif(!", stdout);
17656	17836	{
17657	17837	/* CALLBEGIN */

		@@ -17662,12 +17842,12 @@
17662	17842	{
17663	17843	/CALLEND/
17664	17844	stackbase += 15LLU;
17665		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB44LLU;
	17845	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB38LLU;
17666	17846	fnaddr = /POP_START_/0x40F4004D40525000LLU;/* SP = 0LLU */
17667	17847	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_START_/\n"); exit(-1); }
17668	17848	break;
17669	17849	}
17670		-case 0xFFFFFFFFFFFFFB44LLU:
	17850	+case 0xFFFFFFFFFFFFFB38LLU:
17671	17851	/* SP = 13LLU */fputs(")", stdout);
17672	17852	{
17673	17853	/* CALLBEGIN */

		@@ -17679,12 +17859,12 @@
17679	17859	{
17680	17860	/CALLEND/
17681	17861	stackbase += 15LLU;
17682		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB43LLU;
	17862	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB37LLU;
17683	17863	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
17684	17864	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
17685	17865	break;
17686	17866	}
17687		-case 0xFFFFFFFFFFFFFB43LLU:
	17867	+case 0xFFFFFFFFFFFFFB37LLU:
17688	17868	/* SP = 13LLU /fputs(" / skip loop /", stdout); fputs("\n/ loop */", stdout);
17689	17869	{
17690	17870	/* CALLBEGIN */

		@@ -17695,12 +17875,12 @@
17695	17875	{
17696	17876	/CALLEND/
17697	17877	stackbase += 15LLU;
17698		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB42LLU;
	17878	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB36LLU;
17699	17879	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
17700	17880	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
17701	17881	break;
17702	17882	}
17703		-case 0xFFFFFFFFFFFFFB42LLU:
	17883	+case 0xFFFFFFFFFFFFFB36LLU:
17704	17884	/* SP = 13LLU */
17705	17885	{
17706	17886	/* CALLBEGIN */

		@@ -17712,12 +17892,12 @@
17712	17892	{
17713	17893	/CALLEND/
17714	17894	stackbase += 15LLU;
17715		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB41LLU;
	17895	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB35LLU;
17716	17896	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
17717	17897	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
17718	17898	break;
17719	17899	}
17720		-case 0xFFFFFFFFFFFFFB41LLU:
	17900	+case 0xFFFFFFFFFFFFFB35LLU:
17721	17901	/* SP = 13LLU */
17722	17902	{ /* PUSH / stack[stackbase + 13LLU] = (/ REF TO LINK / stackbase + 14LLU); }/ SP + 1LLU = 14LLU */
17723	17903	{ /* PUSH / stack[stackbase + 14LLU] = / LOCAL VAR / stack[stackbase + 2LLU]; }/ SP + 1LLU = 15LLU */

		@@ -17745,12 +17925,12 @@
17745	17925	{
17746	17926	/CALLEND/
17747	17927	stackbase += 28LLU;
17748		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB40LLU;
	17928	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB34LLU;
17749	17929	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
17750	17930	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
17751	17931	break;
17752	17932	}
17753		-case 0xFFFFFFFFFFFFFB40LLU:
	17933	+case 0xFFFFFFFFFFFFFB34LLU:
17754	17934	/* SP = 26LLU */
17755	17935	{
17756	17936	/* CALLBEGIN */

		@@ -17761,22 +17941,22 @@
17761	17941	{
17762	17942	/CALLEND/
17763	17943	stackbase += 29LLU;
17764		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3FLLU;
	17944	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB33LLU;
17765	17945	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
17766	17946	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
17767	17947	break;
17768	17948	}
17769		-case 0xFFFFFFFFFFFFFB3FLLU:
	17949	+case 0xFFFFFFFFFFFFFB33LLU:
17770	17950	/* SP = 27LLU */
17771	17951	{
17772	17952	/CALLEND/
17773	17953	stackbase += 21LLU;
17774		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3ELLU;
	17954	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB32LLU;
17775	17955	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
17776	17956	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
17777	17957	break;
17778	17958	}
17779		-case 0xFFFFFFFFFFFFFB3ELLU:
	17959	+case 0xFFFFFFFFFFFFFB32LLU:
17780	17960	/* SP = 19LLU */
17781	17961	{
17782	17962	/* CALLBEGIN */

		@@ -17788,12 +17968,12 @@
17788	17968	{
17789	17969	/CALLEND/
17790	17970	stackbase += 21LLU;
17791		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3DLLU;
	17971	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB31LLU;
17792	17972	fnaddr = /LISTNEXT__/0x3094D43856140000LLU;/* SP = 0LLU */
17793	17973	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /LISTNEXT__/\n"); exit(-1); }
17794	17974	break;
17795	17975	}
17796		-case 0xFFFFFFFFFFFFFB3DLLU:
	17976	+case 0xFFFFFFFFFFFFFB31LLU:
17797	17977	/* SP = 19LLU */
17798	17978	{
17799	17979	/* CALLBEGIN */

		@@ -17812,22 +17992,22 @@
17812	17992	{
17813	17993	/CALLEND/
17814	17994	stackbase += 24LLU;
17815		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3CLLU;
	17995	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB30LLU;
17816	17996	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
17817	17997	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
17818	17998	break;
17819	17999	}
17820		-case 0xFFFFFFFFFFFFFB3CLLU:
	18000	+case 0xFFFFFFFFFFFFFB30LLU:
17821	18001	/* SP = 22LLU */
17822	18002	{
17823	18003	/CALLEND/
17824	18004	stackbase += 21LLU;
17825		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3BLLU;
	18005	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2FLLU;
17826	18006	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
17827	18007	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
17828	18008	break;
17829	18009	}
17830		-case 0xFFFFFFFFFFFFFB3BLLU:
	18010	+case 0xFFFFFFFFFFFFFB2FLLU:
17831	18011	/* SP = 19LLU /fputs(" / loop */", stdout); fputs("\ncase ", stdout);
17832	18012	{
17833	18013	/* CALLBEGIN */

		@@ -17839,12 +18019,12 @@
17839	18019	{
17840	18020	/CALLEND/
17841	18021	stackbase += 21LLU;
17842		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB3ALLU;
	18022	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2ELLU;
17843	18023	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
17844	18024	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
17845	18025	break;
17846	18026	}
17847		-case 0xFFFFFFFFFFFFFB3ALLU:
	18027	+case 0xFFFFFFFFFFFFFB2ELLU:
17848	18028	/* SP = 19LLU /fputs(": / skip to here */", stdout);
17849	18029	{ /* PUSH / stack[stackbase + 19LLU] = 0LLU; }/ SP + 1LLU = 20LLU // SP = 19LLU */
17850	18030	{ /* assign / / LOCAL VAR / stack[stackbase + 11LLU] = / LOCAL VAR */ stack[stackbase + 19LLU]; }

		@@ -17864,20 +18044,20 @@
17864	18044	{ /* PUSH / stack[stackbase + 28LLU] = / LOCAL VAR / stack[stackbase + 1LLU]; }/ SP + 1LLU = 29LLU */
17865	18045	{ /* PUSH / stack[stackbase + 29LLU] = / LOCAL VAR / stack[stackbase + 19LLU]; }/ SP + 1LLU = 30LLU */
17866	18046	{ /* PUSH / stack[stackbase + 30LLU] = 0LLU; }/ SP + 1LLU = 31LLU */
17867		-{ /* PUSH / stack[stackbase + 31LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 32LLU // SPMAX = 32LLU */
17868		-{ /* PUSH / stack[stackbase + 32LLU] = / LOCAL VAR / stack[stackbase + 5LLU]; }/ SP + 1LLU = 33LLU // SPMAX = 33LLU */
	18047	+{ /* PUSH / stack[stackbase + 31LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 32LLU */
	18048	+{ /* PUSH / stack[stackbase + 32LLU] = / LOCAL VAR / stack[stackbase + 5LLU]; }/ SP + 1LLU = 33LLU */
17869	18049	{
17870	18050	/CALLEND/
17871	18051	stackbase += 27LLU;
17872		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB39LLU;
	18052	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2DLLU;
17873	18053	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
17874	18054	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
17875	18055	break;
17876	18056	}
17877		-case 0xFFFFFFFFFFFFFB39LLU:
	18057	+case 0xFFFFFFFFFFFFFB2DLLU:
17878	18058	/* SP = 25LLU // SP = 8LLU // SP = 8LLU */
17879		-{ /* JUMP / fnaddr = 18446744073709550413LLU; break; } / skip alternative */
17880		-case 18446744073709550414LLU: /* alternative */
	18059	+{ /* JUMP / fnaddr = 18446744073709550401LLU; break; } / skip alternative */
	18060	+case 18446744073709550402LLU: /* alternative */
17881	18061	{
17882	18062	/* CALLBEGIN */
17883	18063	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -17887,12 +18067,12 @@
17887	18067	{
17888	18068	/CALLEND/
17889	18069	stackbase += 10LLU;
17890		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB38LLU;
	18070	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2CLLU;
17891	18071	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
17892	18072	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
17893	18073	break;
17894	18074	}
17895		-case 0xFFFFFFFFFFFFFB38LLU:
	18075	+case 0xFFFFFFFFFFFFFB2CLLU:
17896	18076	/* SP = 8LLU */fputs("for_list needs list-type but found ", stderr);
17897	18077	{
17898	18078	/* CALLBEGIN */

		@@ -17904,17 +18084,17 @@
17904	18084	{
17905	18085	/CALLEND/
17906	18086	stackbase += 10LLU;
17907		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB37LLU;
	18087	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2BLLU;
17908	18088	fnaddr = /debugtype_/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
17909	18089	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugtype_/\n"); exit(-1); }
17910	18090	break;
17911	18091	}
17912		-case 0xFFFFFFFFFFFFFB37LLU:
	18092	+case 0xFFFFFFFFFFFFFB2BLLU:
17913	18093	/* SP = 8LLU /exit(-1);/ SP = 8LLU */
17914		-case 18446744073709550413LLU: /* skip to here */
	18094	+case 18446744073709550401LLU: /* skip to here */
17915	18095	/* SP = 6LLU // SP = 6LLU */
17916		-{ /* JUMP / fnaddr = 18446744073709550420LLU; break; } / skip alternative */
17917		-case 18446744073709550421LLU: /* alternative // predicate */
	18096	+{ /* JUMP / fnaddr = 18446744073709550408LLU; break; } / skip alternative */
	18097	+case 18446744073709550409LLU: /* alternative // predicate */
17918	18098
17919	18099	{
17920	18100	/* CALLBEGIN */

		@@ -17933,12 +18113,12 @@
17933	18113	{
17934	18114	/CALLEND/
17935	18115	stackbase += 12LLU;
17936		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB34LLU;
	18116	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB28LLU;
17937	18117	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
17938	18118	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
17939	18119	break;
17940	18120	}
17941		-case 0xFFFFFFFFFFFFFB34LLU:
	18121	+case 0xFFFFFFFFFFFFFB28LLU:
17942	18122	/* SP = 10LLU */
17943	18123	{
17944	18124	/* CALLBEGIN */

		@@ -17951,25 +18131,25 @@
17951	18131	{
17952	18132	/CALLEND/
17953	18133	stackbase += 13LLU;
17954		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB33LLU;
	18134	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB27LLU;
17955	18135	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
17956	18136	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
17957	18137	break;
17958	18138	}
17959		-case 0xFFFFFFFFFFFFFB33LLU:
	18139	+case 0xFFFFFFFFFFFFFB27LLU:
17960	18140	/* SP = 11LLU */
17961	18141	{
17962	18142	/CALLEND/
17963	18143	stackbase += 9LLU;
17964		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB32LLU;
	18144	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB26LLU;
17965	18145	fnaddr = /or________/0xAAD0000000000000LLU;/* SP = 0LLU */
17966	18146	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /or________/\n"); exit(-1); }
17967	18147	break;
17968	18148	}
17969		-case 0xFFFFFFFFFFFFFB32LLU:
	18149	+case 0xFFFFFFFFFFFFFB26LLU:
17970	18150	/* SP = 7LLU */
17971	18151	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
17972		-{ /* JUMP / fnaddr = 18446744073709550390LLU; break; } / skip consequent */
	18152	+{ /* JUMP / fnaddr = 18446744073709550378LLU; break; } / skip consequent */
17973	18153	/* consequent */
17974	18154	{
17975	18155	/* CALLBEGIN */

		@@ -17980,12 +18160,12 @@
17980	18160	{
17981	18161	/CALLEND/
17982	18162	stackbase += 8LLU;
17983		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB31LLU;
	18163	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB25LLU;
17984	18164	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
17985	18165	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
17986	18166	break;
17987	18167	}
17988		-case 0xFFFFFFFFFFFFFB31LLU:
	18168	+case 0xFFFFFFFFFFFFFB25LLU:
17989	18169	/* SP = 6LLU // predicate */
17990	18170
17991	18171	{

		@@ -17999,19 +18179,19 @@
17999	18179	{
18000	18180	/CALLEND/
18001	18181	stackbase += 9LLU;
18002		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2ELLU;
	18182	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB22LLU;
18003	18183	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
18004	18184	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
18005	18185	break;
18006	18186	}
18007		-case 0xFFFFFFFFFFFFFB2ELLU:
	18187	+case 0xFFFFFFFFFFFFFB22LLU:
18008	18188	/* SP = 7LLU */
18009	18189	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18010		-{ /* JUMP / fnaddr = 18446744073709550384LLU; break; } / skip consequent */
	18190	+{ /* JUMP / fnaddr = 18446744073709550372LLU; break; } / skip consequent */
18011	18191	/* consequent */
18012	18192	{ /* PUSH / stack[stackbase + 6LLU] = 1LLU; }/ SP + 1LLU = 7LLU // SP = 6LLU */
18013		-{ /* JUMP / fnaddr = 18446744073709550383LLU; break; } / skip alternative */
18014		-case 18446744073709550384LLU: /* alternative // predicate */
	18193	+{ /* JUMP / fnaddr = 18446744073709550371LLU; break; } / skip alternative */
	18194	+case 18446744073709550372LLU: /* alternative // predicate */
18015	18195
18016	18196	{
18017	18197	/* CALLBEGIN */

		@@ -18024,19 +18204,19 @@
18024	18204	{
18025	18205	/CALLEND/
18026	18206	stackbase += 9LLU;
18027		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2BLLU;
	18207	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB1FLLU;
18028	18208	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
18029	18209	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
18030	18210	break;
18031	18211	}
18032		-case 0xFFFFFFFFFFFFFB2BLLU:
	18212	+case 0xFFFFFFFFFFFFFB1FLLU:
18033	18213	/* SP = 7LLU */
18034	18214	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18035		-{ /* JUMP / fnaddr = 18446744073709550381LLU; break; } / skip consequent */
	18215	+{ /* JUMP / fnaddr = 18446744073709550369LLU; break; } / skip consequent */
18036	18216	/* consequent */
18037	18217	{ /* PUSH / stack[stackbase + 6LLU] = 2LLU; }/ SP + 1LLU = 7LLU // SP = 6LLU */
18038		-{ /* JUMP / fnaddr = 18446744073709550380LLU; break; } / skip alternative */
18039		-case 18446744073709550381LLU: /* alternative */
	18218	+{ /* JUMP / fnaddr = 18446744073709550368LLU; break; } / skip alternative */
	18219	+case 18446744073709550369LLU: /* alternative */
18040	18220	{
18041	18221	/* CALLBEGIN */
18042	18222	/* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */

		@@ -18052,28 +18232,28 @@
18052	18232	{
18053	18233	/CALLEND/
18054	18234	stackbase += 11LLU;
18055		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB2ALLU;
	18235	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB1ELLU;
18056	18236	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
18057	18237	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
18058	18238	break;
18059	18239	}
18060		-case 0xFFFFFFFFFFFFFB2ALLU:
	18240	+case 0xFFFFFFFFFFFFFB1ELLU:
18061	18241	/* SP = 9LLU */
18062	18242	{
18063	18243	/CALLEND/
18064	18244	stackbase += 8LLU;
18065		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB29LLU;
	18245	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB1DLLU;
18066	18246	fnaddr = /unexpected/0xC29833AE07AF81F0LLU;/* SP = 0LLU */
18067	18247	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /unexpected/\n"); exit(-1); }
18068	18248	break;
18069	18249	}
18070		-case 0xFFFFFFFFFFFFFB29LLU:
	18250	+case 0xFFFFFFFFFFFFFB1DLLU:
18071	18251	/* SP = 6LLU */fputs(" - need either 1 (out) or 2 (err)", stderr); exit(-1);
18072	18252	{ /* PUSH / stack[stackbase + 6LLU] = 0LLU; }/ SP + 1LLU = 7LLU // SP - 1LLU = 6LLU */
18073	18253	{ /* RESULT // LOCAL VAR / stack[stackbase + 6LLU] = / LOCAL VAR / stack[stackbase + 6LLU]; }/ SP = 7LLU */
18074		-case 18446744073709550380LLU: /* skip to here */
	18254	+case 18446744073709550368LLU: /* skip to here */
18075	18255
18076		-case 18446744073709550383LLU: /* skip to here */
	18256	+case 18446744073709550371LLU: /* skip to here */
18077	18257
18078	18258	{
18079	18259	/* CALLBEGIN */

		@@ -18084,12 +18264,12 @@
18084	18264	{
18085	18265	/CALLEND/
18086	18266	stackbase += 9LLU;
18087		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB28LLU;
	18267	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB1CLLU;
18088	18268	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
18089	18269	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
18090	18270	break;
18091	18271	}
18092		-case 0xFFFFFFFFFFFFFB28LLU:
	18272	+case 0xFFFFFFFFFFFFFB1CLLU:
18093	18273	/* SP = 7LLU // predicate */
18094	18274
18095	18275	{

		@@ -18102,17 +18282,17 @@
18102	18282	{
18103	18283	/CALLEND/
18104	18284	stackbase += 10LLU;
18105		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB25LLU;
	18285	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB19LLU;
18106	18286	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
18107	18287	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
18108	18288	break;
18109	18289	}
18110		-case 0xFFFFFFFFFFFFFB25LLU:
	18290	+case 0xFFFFFFFFFFFFFB19LLU:
18111	18291	/* SP = 8LLU */
18112	18292	if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
18113		-{ /* JUMP / fnaddr = 18446744073709550375LLU; break; } / skip consequent */
	18293	+{ /* JUMP / fnaddr = 18446744073709550363LLU; break; } / skip consequent */
18114	18294	/* consequent */fputs("fputs(\"", stdout);
18115		-case 0xFFFFFFFFFFFFFB24LLU: /* loop to here // predicate */
	18295	+case 0xFFFFFFFFFFFFFB18LLU: /* loop to here // predicate */
18116	18296
18117	18297	{
18118	18298	/* CALLBEGIN */

		@@ -18130,25 +18310,25 @@
18130	18310	{
18131	18311	/CALLEND/
18132	18312	stackbase += 13LLU;
18133		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB22LLU;
	18313	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB16LLU;
18134	18314	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
18135	18315	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
18136	18316	break;
18137	18317	}
18138		-case 0xFFFFFFFFFFFFFB22LLU:
	18318	+case 0xFFFFFFFFFFFFFB16LLU:
18139	18319	/* SP = 11LLU */
18140	18320	{
18141	18321	/CALLEND/
18142	18322	stackbase += 10LLU;
18143		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB21LLU;
	18323	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB15LLU;
18144	18324	fnaddr = /not_______/0xA6ABC00000000000LLU;/* SP = 0LLU */
18145	18325	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /not_______/\n"); exit(-1); }
18146	18326	break;
18147	18327	}
18148		-case 0xFFFFFFFFFFFFFB21LLU:
	18328	+case 0xFFFFFFFFFFFFFB15LLU:
18149	18329	/* SP = 8LLU */
18150	18330	if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
18151		-{ /* JUMP / fnaddr = 18446744073709550371LLU; break; } / skip loop */
	18331	+{ /* JUMP / fnaddr = 18446744073709550359LLU; break; } / skip loop */
18152	18332	/* loop */
18153	18333	{
18154	18334	/* CALLBEGIN */

		@@ -18159,12 +18339,12 @@
18159	18339	{
18160	18340	/CALLEND/
18161	18341	stackbase += 10LLU;
18162		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB20LLU;
	18342	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB14LLU;
18163	18343	fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
18164	18344	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); }
18165	18345	break;
18166	18346	}
18167		-case 0xFFFFFFFFFFFFFB20LLU:
	18347	+case 0xFFFFFFFFFFFFFB14LLU:
18168	18348	/* SP = 8LLU // predicate */
18169	18349
18170	18350	{

		@@ -18178,15 +18358,15 @@
18178	18358	{
18179	18359	/CALLEND/
18180	18360	stackbase += 11LLU;
18181		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB1ELLU;
	18361	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB12LLU;
18182	18362	fnaddr = /gtr_______/0x8AFB400000000000LLU;/* SP = 0LLU */
18183	18363	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /gtr_______/\n"); exit(-1); }
18184	18364	break;
18185	18365	}
18186		-case 0xFFFFFFFFFFFFFB1ELLU:
	18366	+case 0xFFFFFFFFFFFFFB12LLU:
18187	18367	/* SP = 9LLU */
18188	18368	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
18189		-{ /* JUMP / fnaddr = 18446744073709550367LLU; break; } / skip consequent */
	18369	+{ /* JUMP / fnaddr = 18446744073709550355LLU; break; } / skip consequent */
18190	18370	/* consequent */
18191	18371	{
18192	18372	/* CALLBEGIN */

		@@ -18203,24 +18383,24 @@
18203	18383	{
18204	18384	/CALLEND/
18205	18385	stackbase += 13LLU;
18206		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB1DLLU;
	18386	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB11LLU;
18207	18387	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
18208	18388	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
18209	18389	break;
18210	18390	}
18211		-case 0xFFFFFFFFFFFFFB1DLLU:
	18391	+case 0xFFFFFFFFFFFFFB11LLU:
18212	18392	/* SP = 11LLU */
18213	18393	{
18214	18394	/CALLEND/
18215	18395	stackbase += 10LLU;
18216		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB1CLLU;
	18396	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB10LLU;
18217	18397	fnaddr = /unexpected/0xC29833AE07AF81F0LLU;/* SP = 0LLU */
18218	18398	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /unexpected/\n"); exit(-1); }
18219	18399	break;
18220	18400	}
18221		-case 0xFFFFFFFFFFFFFB1CLLU:
	18401	+case 0xFFFFFFFFFFFFFB10LLU:
18222	18402	/* SP = 8LLU /fputs("end-of-stream in string constant", stderr); exit(-1);/ SP = 8LLU */
18223		-case 18446744073709550367LLU: /* alternative // predicate */
	18403	+case 18446744073709550355LLU: /* alternative // predicate */
18224	18404
18225	18405	{
18226	18406	/* CALLBEGIN */

		@@ -18233,15 +18413,15 @@
18233	18413	{
18234	18414	/CALLEND/
18235	18415	stackbase += 11LLU;
18236		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB19LLU;
	18416	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0DLLU;
18237	18417	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
18238	18418	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
18239	18419	break;
18240	18420	}
18241		-case 0xFFFFFFFFFFFFFB19LLU:
	18421	+case 0xFFFFFFFFFFFFFB0DLLU:
18242	18422	/* SP = 9LLU */
18243	18423	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
18244		-{ /* JUMP / fnaddr = 18446744073709550363LLU; break; } / skip consequent */
	18424	+{ /* JUMP / fnaddr = 18446744073709550351LLU; break; } / skip consequent */
18245	18425	/* consequent */
18246	18426	{
18247	18427	/* CALLBEGIN */

		@@ -18253,12 +18433,12 @@
18253	18433	{
18254	18434	/CALLEND/
18255	18435	stackbase += 11LLU;
18256		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB18LLU;
	18436	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0CLLU;
18257	18437	fnaddr = /put_______/0xAF0BC00000000000LLU;/* SP = 0LLU */
18258	18438	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /put_______/\n"); exit(-1); }
18259	18439	break;
18260	18440	}
18261		-case 0xFFFFFFFFFFFFFB18LLU:
	18441	+case 0xFFFFFFFFFFFFFB0CLLU:
18262	18442	/* SP = 9LLU /(void)/ SP - 1LLU = 8LLU /stack[stackbase + 8LLU]; / POP */
18263	18443
18264	18444	{

		@@ -18276,26 +18456,26 @@
18276	18456	{
18277	18457	/CALLEND/
18278	18458	stackbase += 14LLU;
18279		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB17LLU;
	18459	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0BLLU;
18280	18460	fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
18281	18461	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); }
18282	18462	break;
18283	18463	}
18284		-case 0xFFFFFFFFFFFFFB17LLU:
	18464	+case 0xFFFFFFFFFFFFFB0BLLU:
18285	18465	/* SP = 12LLU */
18286	18466	{
18287	18467	/CALLEND/
18288	18468	stackbase += 11LLU;
18289		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB16LLU;
	18469	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0ALLU;
18290	18470	fnaddr = /put_______/0xAF0BC00000000000LLU;/* SP = 0LLU */
18291	18471	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /put_______/\n"); exit(-1); }
18292	18472	break;
18293	18473	}
18294		-case 0xFFFFFFFFFFFFFB16LLU:
	18474	+case 0xFFFFFFFFFFFFFB0ALLU:
18295	18475	/* SP = 9LLU /(void)/ SP - 1LLU = 8LLU /stack[stackbase + 8LLU]; / POP */
18296	18476	/* SP = 8LLU // SP = 8LLU */
18297		-{ /* JUMP / fnaddr = 18446744073709550362LLU; break; } / skip alternative */
18298		-case 18446744073709550363LLU: /* alternative */
	18477	+{ /* JUMP / fnaddr = 18446744073709550350LLU; break; } / skip alternative */
	18478	+case 18446744073709550351LLU: /* alternative */
18299	18479	{
18300	18480	/* CALLBEGIN */
18301	18481	/* reserve space for 1LLU returned values // SP + 1LLU = 9LLU */

		@@ -18306,18 +18486,18 @@
18306	18486	{
18307	18487	/CALLEND/
18308	18488	stackbase += 11LLU;
18309		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB15LLU;
	18489	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB09LLU;
18310	18490	fnaddr = /put_______/0xAF0BC00000000000LLU;/* SP = 0LLU */
18311	18491	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /put_______/\n"); exit(-1); }
18312	18492	break;
18313	18493	}
18314		-case 0xFFFFFFFFFFFFFB15LLU:
	18494	+case 0xFFFFFFFFFFFFFB09LLU:
18315	18495	/* SP = 9LLU /(void)/ SP - 1LLU = 8LLU /stack[stackbase + 8LLU]; / POP */
18316	18496	/* SP = 8LLU */
18317		-case 18446744073709550362LLU: /* skip to here */
	18497	+case 18446744073709550350LLU: /* skip to here */
18318	18498	/* SP = 7LLU */
18319		-{ /* JUMP / fnaddr = 18446744073709550372LLU; break; } / loop */
18320		-case 18446744073709550371LLU: /* skip to here /fputs("\", ", stdout); / predicate */
	18499	+{ /* JUMP / fnaddr = 18446744073709550360LLU; break; } / loop */
	18500	+case 18446744073709550359LLU: /* skip to here /fputs("\", ", stdout); / predicate */
18321	18501
18322	18502	{
18323	18503	/* CALLBEGIN */

		@@ -18330,22 +18510,22 @@
18330	18510	{
18331	18511	/CALLEND/
18332	18512	stackbase += 10LLU;
18333		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB12LLU;
	18513	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB06LLU;
18334	18514	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
18335	18515	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
18336	18516	break;
18337	18517	}
18338		-case 0xFFFFFFFFFFFFFB12LLU:
	18518	+case 0xFFFFFFFFFFFFFB06LLU:
18339	18519	/* SP = 8LLU */
18340	18520	if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
18341		-{ /* JUMP / fnaddr = 18446744073709550356LLU; break; } / skip consequent */
	18521	+{ /* JUMP / fnaddr = 18446744073709550344LLU; break; } / skip consequent */
18342	18522	/* consequent /fputs("stdout", stdout); / SP = 7LLU // SP = 7LLU */
18343		-{ /* JUMP / fnaddr = 18446744073709550355LLU; break; } / skip alternative */
18344		-case 18446744073709550356LLU: /* alternative /fputs("stderr", stdout); / SP = 7LLU */
18345		-case 18446744073709550355LLU: /* skip to here */
	18523	+{ /* JUMP / fnaddr = 18446744073709550343LLU; break; } / skip alternative */
	18524	+case 18446744073709550344LLU: /* alternative /fputs("stderr", stdout); / SP = 7LLU */
	18525	+case 18446744073709550343LLU: /* skip to here */
18346	18526	fputs("); ", stdout); /* SP = 7LLU // SP = 7LLU */
18347		-{ /* JUMP / fnaddr = 18446744073709550374LLU; break; } / skip alternative */
18348		-case 18446744073709550375LLU: /* alternative */
	18527	+{ /* JUMP / fnaddr = 18446744073709550362LLU; break; } / skip alternative */
	18528	+case 18446744073709550363LLU: /* alternative */
18349	18529	{
18350	18530	/* CALLBEGIN */
18351	18531	/* reserve space for 0LLU returned values // SP + 0LLU = 7LLU */

		@@ -18361,24 +18541,24 @@
18361	18541	{
18362	18542	/CALLEND/
18363	18543	stackbase += 12LLU;
18364		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB11LLU;
	18544	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB05LLU;
18365	18545	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
18366	18546	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
18367	18547	break;
18368	18548	}
18369		-case 0xFFFFFFFFFFFFFB11LLU:
	18549	+case 0xFFFFFFFFFFFFFB05LLU:
18370	18550	/* SP = 10LLU */
18371	18551	{
18372	18552	/CALLEND/
18373	18553	stackbase += 9LLU;
18374		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB10LLU;
	18554	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB04LLU;
18375	18555	fnaddr = /unexpected/0xC29833AE07AF81F0LLU;/* SP = 0LLU */
18376	18556	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /unexpected/\n"); exit(-1); }
18377	18557	break;
18378	18558	}
18379		-case 0xFFFFFFFFFFFFFB10LLU:
	18559	+case 0xFFFFFFFFFFFFFB04LLU:
18380	18560	/* SP = 7LLU /fputs("print-construct requires string constant", stderr); exit(-1);/ SP = 7LLU */
18381		-case 18446744073709550374LLU: /* skip to here */
	18561	+case 18446744073709550362LLU: /* skip to here */
18382	18562
18383	18563	{
18384	18564	/* CALLBEGIN */

		@@ -18395,15 +18575,15 @@
18395	18575	{
18396	18576	/CALLEND/
18397	18577	stackbase += 9LLU;
18398		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0FLLU;
	18578	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB03LLU;
18399	18579	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
18400	18580	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
18401	18581	break;
18402	18582	}
18403		-case 0xFFFFFFFFFFFFFB0FLLU:
	18583	+case 0xFFFFFFFFFFFFFB03LLU:
18404	18584	/* SP = 7LLU // SP = 6LLU // SP = 6LLU */
18405		-{ /* JUMP / fnaddr = 18446744073709550389LLU; break; } / skip alternative */
18406		-case 18446744073709550390LLU: /* alternative */
	18585	+{ /* JUMP / fnaddr = 18446744073709550377LLU; break; } / skip alternative */
	18586	+case 18446744073709550378LLU: /* alternative */
18407	18587	{
18408	18588	/* CALLBEGIN */
18409	18589	/* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */

		@@ -18413,12 +18593,12 @@
18413	18593	{
18414	18594	/CALLEND/
18415	18595	stackbase += 8LLU;
18416		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0ELLU;
	18596	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB02LLU;
18417	18597	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
18418	18598	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
18419	18599	break;
18420	18600	}
18421		-case 0xFFFFFFFFFFFFFB0ELLU:
	18601	+case 0xFFFFFFFFFFFFFB02LLU:
18422	18602	/* SP = 6LLU */
18423	18603	{
18424	18604	/* CALLBEGIN */

		@@ -18440,23 +18620,23 @@
18440	18620	{
18441	18621	/CALLEND/
18442	18622	stackbase += 15LLU;
18443		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0DLLU;
	18623	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB01LLU;
18444	18624	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
18445	18625	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
18446	18626	break;
18447	18627	}
18448		-case 0xFFFFFFFFFFFFFB0DLLU:
	18628	+case 0xFFFFFFFFFFFFFB01LLU:
18449	18629	/* SP = 13LLU */
18450	18630	{ /* PUSH / stack[stackbase + 13LLU] = 0LLU; }/ SP + 1LLU = 14LLU */
18451	18631	{
18452	18632	/CALLEND/
18453	18633	stackbase += 8LLU;
18454		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0CLLU;
	18634	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFB00LLU;
18455	18635	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
18456	18636	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
18457	18637	break;
18458	18638	}
18459		-case 0xFFFFFFFFFFFFFB0CLLU:
	18639	+case 0xFFFFFFFFFFFFFB00LLU:
18460	18640	/* SP = 6LLU */
18461	18641	{
18462	18642	/* CALLBEGIN */

		@@ -18473,31 +18653,31 @@
18473	18653	{
18474	18654	/CALLEND/
18475	18655	stackbase += 8LLU;
18476		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0BLLU;
	18656	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAFFLLU;
18477	18657	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
18478	18658	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
18479	18659	break;
18480	18660	}
18481		-case 0xFFFFFFFFFFFFFB0BLLU:
	18661	+case 0xFFFFFFFFFFFFFAFFLLU:
18482	18662	/* SP = 6LLU // SP = 6LLU */
18483		-case 18446744073709550389LLU: /* skip to here */
	18663	+case 18446744073709550377LLU: /* skip to here */
18484	18664
18485		-case 18446744073709550420LLU: /* skip to here */
	18665	+case 18446744073709550408LLU: /* skip to here */
18486	18666
18487		-case 18446744073709550445LLU: /* skip to here */
	18667	+case 18446744073709550433LLU: /* skip to here */
18488	18668
18489		-case 18446744073709550474LLU: /* skip to here */
	18669	+case 18446744073709550462LLU: /* skip to here */
18490	18670
18491		-case 18446744073709550496LLU: /* skip to here */
	18671	+case 18446744073709550484LLU: /* skip to here */
18492	18672
18493		-case 18446744073709550514LLU: /* skip to here */
	18673	+case 18446744073709550502LLU: /* skip to here */
18494	18674
18495		-case 18446744073709550543LLU: /* skip to here */
	18675	+case 18446744073709550531LLU: /* skip to here */
18496	18676
18497		-case 18446744073709550568LLU: /* skip to here */
	18677	+case 18446744073709550555LLU: /* skip to here */
18498	18678	/* SP = 6LLU // SP = 6LLU */
18499		-{ /* JUMP / fnaddr = 18446744073709550573LLU; break; } / skip alternative */
18500		-case 18446744073709550574LLU: /* alternative */
	18679	+{ /* JUMP / fnaddr = 18446744073709550560LLU; break; } / skip alternative */
	18680	+case 18446744073709550561LLU: /* alternative */
18501	18681	{
18502	18682	/* CALLBEGIN */
18503	18683	/* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */

		@@ -18507,12 +18687,12 @@
18507	18687	{
18508	18688	/CALLEND/
18509	18689	stackbase += 8LLU;
18510		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB0ALLU;
	18690	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAFELLU;
18511	18691	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
18512	18692	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
18513	18693	break;
18514	18694	}
18515		-case 0xFFFFFFFFFFFFFB0ALLU:
	18695	+case 0xFFFFFFFFFFFFFAFELLU:
18516	18696	/* SP = 6LLU // predicate */
18517	18697
18518	18698	{

		@@ -18525,15 +18705,15 @@
18525	18705	{
18526	18706	/CALLEND/
18527	18707	stackbase += 9LLU;
18528		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB07LLU;
	18708	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAFBLLU;
18529	18709	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
18530	18710	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
18531	18711	break;
18532	18712	}
18533		-case 0xFFFFFFFFFFFFFB07LLU:
	18713	+case 0xFFFFFFFFFFFFFAFBLLU:
18534	18714	/* SP = 7LLU */
18535	18715	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18536		-{ /* JUMP / fnaddr = 18446744073709550345LLU; break; } / skip consequent */
	18716	+{ /* JUMP / fnaddr = 18446744073709550333LLU; break; } / skip consequent */
18537	18717	/* consequent // predicate */
18538	18718
18539	18719	{

		@@ -18552,26 +18732,26 @@
18552	18732	{
18553	18733	/CALLEND/
18554	18734	stackbase += 12LLU;
18555		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB05LLU;
	18735	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF9LLU;
18556	18736	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
18557	18737	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
18558	18738	break;
18559	18739	}
18560		-case 0xFFFFFFFFFFFFFB05LLU:
	18740	+case 0xFFFFFFFFFFFFFAF9LLU:
18561	18741	/* SP = 10LLU */
18562	18742	{ /* PUSH / stack[stackbase + 10LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 11LLU */
18563	18743	{
18564	18744	/CALLEND/
18565	18745	stackbase += 9LLU;
18566		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB04LLU;
	18746	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF8LLU;
18567	18747	fnaddr = /neq_______/0xA60B000000000000LLU;/* SP = 0LLU */
18568	18748	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /neq_______/\n"); exit(-1); }
18569	18749	break;
18570	18750	}
18571		-case 0xFFFFFFFFFFFFFB04LLU:
	18751	+case 0xFFFFFFFFFFFFFAF8LLU:
18572	18752	/* SP = 7LLU */
18573	18753	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18574		-{ /* JUMP / fnaddr = 18446744073709550342LLU; break; } / skip consequent */
	18754	+{ /* JUMP / fnaddr = 18446744073709550330LLU; break; } / skip consequent */
18575	18755	/* consequent */
18576	18756	{
18577	18757	/* CALLBEGIN */

		@@ -18582,12 +18762,12 @@
18582	18762	{
18583	18763	/CALLEND/
18584	18764	stackbase += 8LLU;
18585		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB03LLU;
	18765	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF7LLU;
18586	18766	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
18587	18767	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
18588	18768	break;
18589	18769	}
18590		-case 0xFFFFFFFFFFFFFB03LLU:
	18770	+case 0xFFFFFFFFFFFFFAF7LLU:
18591	18771	/* SP = 6LLU */fputs("missing result of type ", stderr);
18592	18772	{
18593	18773	/* CALLBEGIN */

		@@ -18599,14 +18779,14 @@
18599	18779	{
18600	18780	/CALLEND/
18601	18781	stackbase += 8LLU;
18602		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB02LLU;
	18782	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF6LLU;
18603	18783	fnaddr = /debugtype_/0x7E07708AFD2B8000LLU;/* SP = 0LLU */
18604	18784	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugtype_/\n"); exit(-1); }
18605	18785	break;
18606	18786	}
18607		-case 0xFFFFFFFFFFFFFB02LLU:
	18787	+case 0xFFFFFFFFFFFFFAF6LLU:
18608	18788	/* SP = 6LLU /fputs("\n", stderr); exit(-1);/ SP = 6LLU */
18609		-case 18446744073709550342LLU: /* alternative */
	18789	+case 18446744073709550330LLU: /* alternative */
18610	18790	{
18611	18791	/* CALLBEGIN */
18612	18792	/* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */

		@@ -18617,15 +18797,15 @@
18617	18797	{
18618	18798	/CALLEND/
18619	18799	stackbase += 8LLU;
18620		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFB01LLU;
	18800	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF5LLU;
18621	18801	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
18622	18802	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
18623	18803	break;
18624	18804	}
18625		-case 0xFFFFFFFFFFFFFB01LLU:
	18805	+case 0xFFFFFFFFFFFFFAF5LLU:
18626	18806	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
18627		-{ /* JUMP / fnaddr = 18446744073709550344LLU; break; } / skip alternative */
18628		-case 18446744073709550345LLU: /* alternative // predicate */
	18807	+{ /* JUMP / fnaddr = 18446744073709550332LLU; break; } / skip alternative */
	18808	+case 18446744073709550333LLU: /* alternative // predicate */
18629	18809
18630	18810	{
18631	18811	/* CALLBEGIN */

		@@ -18637,15 +18817,15 @@
18637	18817	{
18638	18818	/CALLEND/
18639	18819	stackbase += 9LLU;
18640		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAFELLU;
	18820	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF2LLU;
18641	18821	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
18642	18822	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
18643	18823	break;
18644	18824	}
18645		-case 0xFFFFFFFFFFFFFAFELLU:
	18825	+case 0xFFFFFFFFFFFFFAF2LLU:
18646	18826	/* SP = 7LLU */
18647	18827	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18648		-{ /* JUMP / fnaddr = 18446744073709550336LLU; break; } / skip consequent */
	18828	+{ /* JUMP / fnaddr = 18446744073709550324LLU; break; } / skip consequent */
18649	18829	/* consequent */
18650	18830	{
18651	18831	/* CALLBEGIN */

		@@ -18667,12 +18847,12 @@
18667	18847	{
18668	18848	/CALLEND/
18669	18849	stackbase += 15LLU;
18670		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAFDLLU;
	18850	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF1LLU;
18671	18851	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
18672	18852	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
18673	18853	break;
18674	18854	}
18675		-case 0xFFFFFFFFFFFFFAFDLLU:
	18855	+case 0xFFFFFFFFFFFFFAF1LLU:
18676	18856	/* SP = 13LLU */
18677	18857	{
18678	18858	/* CALLBEGIN */

		@@ -18683,25 +18863,25 @@
18683	18863	{
18684	18864	/CALLEND/
18685	18865	stackbase += 16LLU;
18686		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAFCLLU;
	18866	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF0LLU;
18687	18867	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
18688	18868	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
18689	18869	break;
18690	18870	}
18691		-case 0xFFFFFFFFFFFFFAFCLLU:
	18871	+case 0xFFFFFFFFFFFFFAF0LLU:
18692	18872	/* SP = 14LLU */
18693	18873	{
18694	18874	/CALLEND/
18695	18875	stackbase += 8LLU;
18696		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAFBLLU;
	18876	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAEFLLU;
18697	18877	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
18698	18878	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
18699	18879	break;
18700	18880	}
18701		-case 0xFFFFFFFFFFFFFAFBLLU:
	18881	+case 0xFFFFFFFFFFFFFAEFLLU:
18702	18882	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
18703		-{ /* JUMP / fnaddr = 18446744073709550335LLU; break; } / skip alternative */
18704		-case 18446744073709550336LLU: /* alternative // predicate */
	18883	+{ /* JUMP / fnaddr = 18446744073709550323LLU; break; } / skip alternative */
	18884	+case 18446744073709550324LLU: /* alternative // predicate */
18705	18885
18706	18886	{
18707	18887	/* CALLBEGIN */

		@@ -18713,15 +18893,15 @@
18713	18893	{
18714	18894	/CALLEND/
18715	18895	stackbase += 9LLU;
18716		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF8LLU;
	18896	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAECLLU;
18717	18897	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
18718	18898	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
18719	18899	break;
18720	18900	}
18721		-case 0xFFFFFFFFFFFFFAF8LLU:
	18901	+case 0xFFFFFFFFFFFFFAECLLU:
18722	18902	/* SP = 7LLU */
18723	18903	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18724		-{ /* JUMP / fnaddr = 18446744073709550330LLU; break; } / skip consequent */
	18904	+{ /* JUMP / fnaddr = 18446744073709550318LLU; break; } / skip consequent */
18725	18905	/* consequent */
18726	18906	{
18727	18907	/* CALLBEGIN */

		@@ -18732,15 +18912,15 @@
18732	18912	{
18733	18913	/CALLEND/
18734	18914	stackbase += 8LLU;
18735		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF7LLU;
	18915	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAEBLLU;
18736	18916	fnaddr = /verbatim__/0xC60B5D72F9280000LLU;/* SP = 0LLU */
18737	18917	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /verbatim__/\n"); exit(-1); }
18738	18918	break;
18739	18919	}
18740		-case 0xFFFFFFFFFFFFFAF7LLU:
	18920	+case 0xFFFFFFFFFFFFFAEBLLU:
18741	18921	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
18742		-{ /* JUMP / fnaddr = 18446744073709550329LLU; break; } / skip alternative */
18743		-case 18446744073709550330LLU: /* alternative // predicate */
	18922	+{ /* JUMP / fnaddr = 18446744073709550317LLU; break; } / skip alternative */
	18923	+case 18446744073709550318LLU: /* alternative // predicate */
18744	18924
18745	18925	{
18746	18926	/* CALLBEGIN */

		@@ -18752,15 +18932,15 @@
18752	18932	{
18753	18933	/CALLEND/
18754	18934	stackbase += 9LLU;
18755		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF4LLU;
	18935	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE8LLU;
18756	18936	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
18757	18937	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
18758	18938	break;
18759	18939	}
18760		-case 0xFFFFFFFFFFFFFAF4LLU:
	18940	+case 0xFFFFFFFFFFFFFAE8LLU:
18761	18941	/* SP = 7LLU */
18762	18942	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18763		-{ /* JUMP / fnaddr = 18446744073709550326LLU; break; } / skip consequent */
	18943	+{ /* JUMP / fnaddr = 18446744073709550314LLU; break; } / skip consequent */
18764	18944	/* consequent */
18765	18945	{
18766	18946	/* CALLBEGIN */

		@@ -18771,12 +18951,12 @@
18771	18951	{
18772	18952	/CALLEND/
18773	18953	stackbase += 8LLU;
18774		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF3LLU;
	18954	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE7LLU;
18775	18955	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
18776	18956	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
18777	18957	break;
18778	18958	}
18779		-case 0xFFFFFFFFFFFFFAF3LLU:
	18959	+case 0xFFFFFFFFFFFFFAE7LLU:
18780	18960	/* SP = 6LLU */
18781	18961	{
18782	18962	/* CALLBEGIN */

		@@ -18788,12 +18968,12 @@
18788	18968	{
18789	18969	/CALLEND/
18790	18970	stackbase += 8LLU;
18791		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF2LLU;
	18971	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE6LLU;
18792	18972	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
18793	18973	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
18794	18974	break;
18795	18975	}
18796		-case 0xFFFFFFFFFFFFFAF2LLU:
	18976	+case 0xFFFFFFFFFFFFFAE6LLU:
18797	18977	/* SP = 6LLU */
18798	18978	{
18799	18979	/* CALLBEGIN */

		@@ -18804,12 +18984,12 @@
18804	18984	{
18805	18985	/CALLEND/
18806	18986	stackbase += 8LLU;
18807		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF1LLU;
	18987	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE5LLU;
18808	18988	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
18809	18989	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
18810	18990	break;
18811	18991	}
18812		-case 0xFFFFFFFFFFFFFAF1LLU:
	18992	+case 0xFFFFFFFFFFFFFAE5LLU:
18813	18993	/* SP = 6LLU */
18814	18994	{
18815	18995	/* CALLBEGIN */

		@@ -18829,12 +19009,12 @@
18829	19009	{
18830	19010	/CALLEND/
18831	19011	stackbase += 14LLU;
18832		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAF0LLU;
	19012	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE4LLU;
18833	19013	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
18834	19014	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
18835	19015	break;
18836	19016	}
18837		-case 0xFFFFFFFFFFFFFAF0LLU:
	19017	+case 0xFFFFFFFFFFFFFAE4LLU:
18838	19018	/* SP = 12LLU */
18839	19019	{
18840	19020	/* CALLBEGIN */

		@@ -18846,23 +19026,23 @@
18846	19026	{
18847	19027	/CALLEND/
18848	19028	stackbase += 15LLU;
18849		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAEFLLU;
	19029	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE3LLU;
18850	19030	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
18851	19031	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
18852	19032	break;
18853	19033	}
18854		-case 0xFFFFFFFFFFFFFAEFLLU:
	19034	+case 0xFFFFFFFFFFFFFAE3LLU:
18855	19035	/* SP = 13LLU */
18856	19036	{ /* PUSH / stack[stackbase + 13LLU] = 0LLU; }/ SP + 1LLU = 14LLU */
18857	19037	{
18858	19038	/CALLEND/
18859	19039	stackbase += 8LLU;
18860		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAEELLU;
	19040	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE2LLU;
18861	19041	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
18862	19042	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
18863	19043	break;
18864	19044	}
18865		-case 0xFFFFFFFFFFFFFAEELLU:
	19045	+case 0xFFFFFFFFFFFFFAE2LLU:
18866	19046	/* SP = 6LLU */fputs("(void)", stdout);
18867	19047	{
18868	19048	/* CALLBEGIN */

		@@ -18873,15 +19053,15 @@
18873	19053	{
18874	19054	/CALLEND/
18875	19055	stackbase += 8LLU;
18876		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAEDLLU;
	19056	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE1LLU;
18877	19057	fnaddr = /POP_______/0x40F4000000000000LLU;/* SP = 0LLU */
18878	19058	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_______/\n"); exit(-1); }
18879	19059	break;
18880	19060	}
18881		-case 0xFFFFFFFFFFFFFAEDLLU:
	19061	+case 0xFFFFFFFFFFFFFAE1LLU:
18882	19062	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
18883		-{ /* JUMP / fnaddr = 18446744073709550325LLU; break; } / skip alternative */
18884		-case 18446744073709550326LLU: /* alternative // predicate */
	19063	+{ /* JUMP / fnaddr = 18446744073709550313LLU; break; } / skip alternative */
	19064	+case 18446744073709550314LLU: /* alternative // predicate */
18885	19065
18886	19066	{
18887	19067	/* CALLBEGIN */

		@@ -18893,15 +19073,15 @@
18893	19073	{
18894	19074	/CALLEND/
18895	19075	stackbase += 9LLU;
18896		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAEALLU;
	19076	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFADELLU;
18897	19077	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
18898	19078	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
18899	19079	break;
18900	19080	}
18901		-case 0xFFFFFFFFFFFFFAEALLU:
	19081	+case 0xFFFFFFFFFFFFFADELLU:
18902	19082	/* SP = 7LLU */
18903	19083	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
18904		-{ /* JUMP / fnaddr = 18446744073709550316LLU; break; } / skip consequent */
	19084	+{ /* JUMP / fnaddr = 18446744073709550304LLU; break; } / skip consequent */
18905	19085	/* consequent */
18906	19086	{
18907	19087	/* CALLBEGIN */

		@@ -18912,12 +19092,12 @@
18912	19092	{
18913	19093	/CALLEND/
18914	19094	stackbase += 9LLU;
18915		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE9LLU;
	19095	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFADDLLU;
18916	19096	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
18917	19097	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
18918	19098	break;
18919	19099	}
18920		-case 0xFFFFFFFFFFFFFAE9LLU:
	19100	+case 0xFFFFFFFFFFFFFADDLLU:
18921	19101	/* SP = 7LLU // predicate */
18922	19102
18923	19103	{

		@@ -18936,25 +19116,25 @@
18936	19116	{
18937	19117	/CALLEND/
18938	19118	stackbase += 14LLU;
18939		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE7LLU;
	19119	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFADBLLU;
18940	19120	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
18941	19121	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
18942	19122	break;
18943	19123	}
18944		-case 0xFFFFFFFFFFFFFAE7LLU:
	19124	+case 0xFFFFFFFFFFFFFADBLLU:
18945	19125	/* SP = 12LLU */
18946	19126	{
18947	19127	/CALLEND/
18948	19128	stackbase += 10LLU;
18949		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE6LLU;
	19129	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFADALLU;
18950	19130	fnaddr = /geq_______/0x8A0B000000000000LLU;/* SP = 0LLU */
18951	19131	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /geq_______/\n"); exit(-1); }
18952	19132	break;
18953	19133	}
18954		-case 0xFFFFFFFFFFFFFAE6LLU:
	19134	+case 0xFFFFFFFFFFFFFADALLU:
18955	19135	/* SP = 8LLU */
18956	19136	if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
18957		-{ /* JUMP / fnaddr = 18446744073709550312LLU; break; } / skip consequent */
	19137	+{ /* JUMP / fnaddr = 18446744073709550300LLU; break; } / skip consequent */
18958	19138	/* consequent */
18959	19139	{
18960	19140	/* CALLBEGIN */

		@@ -18965,12 +19145,12 @@
18965	19145	{
18966	19146	/CALLEND/
18967	19147	stackbase += 9LLU;
18968		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE5LLU;
	19148	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD9LLU;
18969	19149	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
18970	19150	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
18971	19151	break;
18972	19152	}
18973		-case 0xFFFFFFFFFFFFFAE5LLU:
	19153	+case 0xFFFFFFFFFFFFFAD9LLU:
18974	19154	/* SP = 7LLU */fputs("variable not in scope (", stderr);
18975	19155	{
18976	19156	/* CALLBEGIN */

		@@ -18982,12 +19162,12 @@
18982	19162	{
18983	19163	/CALLEND/
18984	19164	stackbase += 9LLU;
18985		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE4LLU;
	19165	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD8LLU;
18986	19166	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
18987	19167	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
18988	19168	break;
18989	19169	}
18990		-case 0xFFFFFFFFFFFFFAE4LLU:
	19170	+case 0xFFFFFFFFFFFFFAD8LLU:
18991	19171	/* SP = 7LLU */fputs(" >= ", stderr);
18992	19172	{
18993	19173	/* CALLBEGIN */

		@@ -19004,24 +19184,24 @@
19004	19184	{
19005	19185	/CALLEND/
19006	19186	stackbase += 12LLU;
19007		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE3LLU;
	19187	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD7LLU;
19008	19188	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
19009	19189	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
19010	19190	break;
19011	19191	}
19012		-case 0xFFFFFFFFFFFFFAE3LLU:
	19192	+case 0xFFFFFFFFFFFFFAD7LLU:
19013	19193	/* SP = 10LLU */
19014	19194	{
19015	19195	/CALLEND/
19016	19196	stackbase += 9LLU;
19017		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE2LLU;
	19197	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD6LLU;
19018	19198	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
19019	19199	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
19020	19200	break;
19021	19201	}
19022		-case 0xFFFFFFFFFFFFFAE2LLU:
	19202	+case 0xFFFFFFFFFFFFFAD6LLU:
19023	19203	/* SP = 7LLU /fputs(")\n", stderr); exit(-1);/ SP = 7LLU */
19024		-case 18446744073709550312LLU: /* alternative */
	19204	+case 18446744073709550300LLU: /* alternative */
19025	19205	{
19026	19206	/* CALLBEGIN */
19027	19207	/* reserve space for 0LLU returned values // SP + 0LLU = 7LLU */

		@@ -19031,12 +19211,12 @@
19031	19211	{
19032	19212	/CALLEND/
19033	19213	stackbase += 9LLU;
19034		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE1LLU;
	19214	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD5LLU;
19035	19215	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19036	19216	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19037	19217	break;
19038	19218	}
19039		-case 0xFFFFFFFFFFFFFAE1LLU:
	19219	+case 0xFFFFFFFFFFFFFAD5LLU:
19040	19220	/* SP = 7LLU */
19041	19221	{
19042	19222	/* CALLBEGIN */

		@@ -19048,12 +19228,12 @@
19048	19228	{
19049	19229	/CALLEND/
19050	19230	stackbase += 9LLU;
19051		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAE0LLU;
	19231	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD4LLU;
19052	19232	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
19053	19233	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
19054	19234	break;
19055	19235	}
19056		-case 0xFFFFFFFFFFFFFAE0LLU:
	19236	+case 0xFFFFFFFFFFFFFAD4LLU:
19057	19237	/* SP = 7LLU */
19058	19238	{
19059	19239	/* CALLBEGIN */

		@@ -19064,12 +19244,12 @@
19064	19244	{
19065	19245	/CALLEND/
19066	19246	stackbase += 9LLU;
19067		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFADFLLU;
	19247	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD3LLU;
19068	19248	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19069	19249	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19070	19250	break;
19071	19251	}
19072		-case 0xFFFFFFFFFFFFFADFLLU:
	19252	+case 0xFFFFFFFFFFFFFAD3LLU:
19073	19253	/* SP = 7LLU */
19074	19254	{
19075	19255	/* CALLBEGIN */

		@@ -19089,12 +19269,12 @@
19089	19269	{
19090	19270	/CALLEND/
19091	19271	stackbase += 15LLU;
19092		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFADELLU;
	19272	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD2LLU;
19093	19273	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
19094	19274	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
19095	19275	break;
19096	19276	}
19097		-case 0xFFFFFFFFFFFFFADELLU:
	19277	+case 0xFFFFFFFFFFFFFAD2LLU:
19098	19278	/* SP = 13LLU */
19099	19279	{
19100	19280	/* CALLBEGIN */

		@@ -19106,23 +19286,23 @@
19106	19286	{
19107	19287	/CALLEND/
19108	19288	stackbase += 16LLU;
19109		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFADDLLU;
	19289	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD1LLU;
19110	19290	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
19111	19291	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
19112	19292	break;
19113	19293	}
19114		-case 0xFFFFFFFFFFFFFADDLLU:
	19294	+case 0xFFFFFFFFFFFFFAD1LLU:
19115	19295	/* SP = 14LLU */
19116	19296	{ /* PUSH / stack[stackbase + 14LLU] = 0LLU; }/ SP + 1LLU = 15LLU */
19117	19297	{
19118	19298	/CALLEND/
19119	19299	stackbase += 9LLU;
19120		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFADCLLU;
	19300	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD0LLU;
19121	19301	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
19122	19302	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
19123	19303	break;
19124	19304	}
19125		-case 0xFFFFFFFFFFFFFADCLLU:
	19305	+case 0xFFFFFFFFFFFFFAD0LLU:
19126	19306	/* SP = 7LLU */
19127	19307	{
19128	19308	/* CALLBEGIN */

		@@ -19134,12 +19314,12 @@
19134	19314	{
19135	19315	/CALLEND/
19136	19316	stackbase += 9LLU;
19137		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFADBLLU;
	19317	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFACFLLU;
19138	19318	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
19139	19319	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
19140	19320	break;
19141	19321	}
19142		-case 0xFFFFFFFFFFFFFADBLLU:
	19322	+case 0xFFFFFFFFFFFFFACFLLU:
19143	19323	/* SP = 7LLU */fputs(" = ", stdout);
19144	19324	{
19145	19325	/* CALLBEGIN */

		@@ -19150,15 +19330,15 @@
19150	19330	{
19151	19331	/CALLEND/
19152	19332	stackbase += 9LLU;
19153		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFADALLU;
	19333	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFACELLU;
19154	19334	fnaddr = /POP_______/0x40F4000000000000LLU;/* SP = 0LLU */
19155	19335	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_______/\n"); exit(-1); }
19156	19336	break;
19157	19337	}
19158		-case 0xFFFFFFFFFFFFFADALLU:
	19338	+case 0xFFFFFFFFFFFFFACELLU:
19159	19339	/* SP = 7LLU // SP = 6LLU // SP = 6LLU */
19160		-{ /* JUMP / fnaddr = 18446744073709550315LLU; break; } / skip alternative */
19161		-case 18446744073709550316LLU: /* alternative // predicate */
	19340	+{ /* JUMP / fnaddr = 18446744073709550303LLU; break; } / skip alternative */
	19341	+case 18446744073709550304LLU: /* alternative // predicate */
19162	19342
19163	19343	{
19164	19344	/* CALLBEGIN */

		@@ -19170,15 +19350,15 @@
19170	19350	{
19171	19351	/CALLEND/
19172	19352	stackbase += 9LLU;
19173		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD7LLU;
	19353	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFACBLLU;
19174	19354	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
19175	19355	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
19176	19356	break;
19177	19357	}
19178		-case 0xFFFFFFFFFFFFFAD7LLU:
	19358	+case 0xFFFFFFFFFFFFFACBLLU:
19179	19359	/* SP = 7LLU */
19180	19360	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
19181		-{ /* JUMP / fnaddr = 18446744073709550297LLU; break; } / skip consequent */
	19361	+{ /* JUMP / fnaddr = 18446744073709550285LLU; break; } / skip consequent */
19182	19362	/* consequent */
19183	19363	{
19184	19364	/* CALLBEGIN */

		@@ -19189,12 +19369,12 @@
19189	19369	{
19190	19370	/CALLEND/
19191	19371	stackbase += 9LLU;
19192		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD6LLU;
	19372	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFACALLU;
19193	19373	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
19194	19374	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
19195	19375	break;
19196	19376	}
19197		-case 0xFFFFFFFFFFFFFAD6LLU:
	19377	+case 0xFFFFFFFFFFFFFACALLU:
19198	19378	/* SP = 7LLU // predicate */
19199	19379
19200	19380	{

		@@ -19213,25 +19393,25 @@
19213	19393	{
19214	19394	/CALLEND/
19215	19395	stackbase += 14LLU;
19216		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD4LLU;
	19396	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC8LLU;
19217	19397	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
19218	19398	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
19219	19399	break;
19220	19400	}
19221		-case 0xFFFFFFFFFFFFFAD4LLU:
	19401	+case 0xFFFFFFFFFFFFFAC8LLU:
19222	19402	/* SP = 12LLU */
19223	19403	{
19224	19404	/CALLEND/
19225	19405	stackbase += 10LLU;
19226		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD3LLU;
	19406	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC7LLU;
19227	19407	fnaddr = /geq_______/0x8A0B000000000000LLU;/* SP = 0LLU */
19228	19408	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /geq_______/\n"); exit(-1); }
19229	19409	break;
19230	19410	}
19231		-case 0xFFFFFFFFFFFFFAD3LLU:
	19411	+case 0xFFFFFFFFFFFFFAC7LLU:
19232	19412	/* SP = 8LLU */
19233	19413	if(!/* SP - 1LLU = 7LLU */stack[stackbase + 7LLU])
19234		-{ /* JUMP / fnaddr = 18446744073709550293LLU; break; } / skip consequent */
	19414	+{ /* JUMP / fnaddr = 18446744073709550281LLU; break; } / skip consequent */
19235	19415	/* consequent */
19236	19416	{
19237	19417	/* CALLBEGIN */

		@@ -19242,12 +19422,12 @@
19242	19422	{
19243	19423	/CALLEND/
19244	19424	stackbase += 9LLU;
19245		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD2LLU;
	19425	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC6LLU;
19246	19426	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
19247	19427	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
19248	19428	break;
19249	19429	}
19250		-case 0xFFFFFFFFFFFFFAD2LLU:
	19430	+case 0xFFFFFFFFFFFFFAC6LLU:
19251	19431	/* SP = 7LLU */fputs("global ", stderr);
19252	19432	{
19253	19433	/* CALLBEGIN */

		@@ -19259,12 +19439,12 @@
19259	19439	{
19260	19440	/CALLEND/
19261	19441	stackbase += 9LLU;
19262		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD1LLU;
	19442	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC5LLU;
19263	19443	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
19264	19444	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
19265	19445	break;
19266	19446	}
19267		-case 0xFFFFFFFFFFFFFAD1LLU:
	19447	+case 0xFFFFFFFFFFFFFAC5LLU:
19268	19448	/* SP = 7LLU */fputs(" exceeds global limit ", stderr);
19269	19449	{
19270	19450	/* CALLBEGIN */

		@@ -19281,24 +19461,24 @@
19281	19461	{
19282	19462	/CALLEND/
19283	19463	stackbase += 12LLU;
19284		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAD0LLU;
	19464	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC4LLU;
19285	19465	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
19286	19466	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
19287	19467	break;
19288	19468	}
19289		-case 0xFFFFFFFFFFFFFAD0LLU:
	19469	+case 0xFFFFFFFFFFFFFAC4LLU:
19290	19470	/* SP = 10LLU */
19291	19471	{
19292	19472	/CALLEND/
19293	19473	stackbase += 9LLU;
19294		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFACFLLU;
	19474	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC3LLU;
19295	19475	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
19296	19476	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
19297	19477	break;
19298	19478	}
19299		-case 0xFFFFFFFFFFFFFACFLLU:
	19479	+case 0xFFFFFFFFFFFFFAC3LLU:
19300	19480	/* SP = 7LLU /fputs("\n", stderr); exit(-1);/ SP = 7LLU */
19301		-case 18446744073709550293LLU: /* alternative */
	19481	+case 18446744073709550281LLU: /* alternative */
19302	19482	{
19303	19483	/* CALLBEGIN */
19304	19484	/* reserve space for 0LLU returned values // SP + 0LLU = 7LLU */

		@@ -19308,12 +19488,12 @@
19308	19488	{
19309	19489	/CALLEND/
19310	19490	stackbase += 9LLU;
19311		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFACELLU;
	19491	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC2LLU;
19312	19492	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19313	19493	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19314	19494	break;
19315	19495	}
19316		-case 0xFFFFFFFFFFFFFACELLU:
	19496	+case 0xFFFFFFFFFFFFFAC2LLU:
19317	19497	/* SP = 7LLU */
19318	19498	{
19319	19499	/* CALLBEGIN */

		@@ -19325,12 +19505,12 @@
19325	19505	{
19326	19506	/CALLEND/
19327	19507	stackbase += 9LLU;
19328		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFACDLLU;
	19508	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC1LLU;
19329	19509	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
19330	19510	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
19331	19511	break;
19332	19512	}
19333		-case 0xFFFFFFFFFFFFFACDLLU:
	19513	+case 0xFFFFFFFFFFFFFAC1LLU:
19334	19514	/* SP = 7LLU */
19335	19515	{
19336	19516	/* CALLBEGIN */

		@@ -19341,12 +19521,12 @@
19341	19521	{
19342	19522	/CALLEND/
19343	19523	stackbase += 9LLU;
19344		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFACCLLU;
	19524	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC0LLU;
19345	19525	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19346	19526	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19347	19527	break;
19348	19528	}
19349		-case 0xFFFFFFFFFFFFFACCLLU:
	19529	+case 0xFFFFFFFFFFFFFAC0LLU:
19350	19530	/* SP = 7LLU */
19351	19531	{
19352	19532	/* CALLBEGIN */

		@@ -19366,12 +19546,12 @@
19366	19546	{
19367	19547	/CALLEND/
19368	19548	stackbase += 15LLU;
19369		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFACBLLU;
	19549	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFABFLLU;
19370	19550	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
19371	19551	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
19372	19552	break;
19373	19553	}
19374		-case 0xFFFFFFFFFFFFFACBLLU:
	19554	+case 0xFFFFFFFFFFFFFABFLLU:
19375	19555	/* SP = 13LLU */
19376	19556	{
19377	19557	/* CALLBEGIN */

		@@ -19383,23 +19563,23 @@
19383	19563	{
19384	19564	/CALLEND/
19385	19565	stackbase += 16LLU;
19386		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFACALLU;
	19566	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFABELLU;
19387	19567	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
19388	19568	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
19389	19569	break;
19390	19570	}
19391		-case 0xFFFFFFFFFFFFFACALLU:
	19571	+case 0xFFFFFFFFFFFFFABELLU:
19392	19572	/* SP = 14LLU */
19393	19573	{ /* PUSH / stack[stackbase + 14LLU] = 0LLU; }/ SP + 1LLU = 15LLU */
19394	19574	{
19395	19575	/CALLEND/
19396	19576	stackbase += 9LLU;
19397		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC9LLU;
	19577	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFABDLLU;
19398	19578	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
19399	19579	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
19400	19580	break;
19401	19581	}
19402		-case 0xFFFFFFFFFFFFFAC9LLU:
	19582	+case 0xFFFFFFFFFFFFFABDLLU:
19403	19583	/* SP = 7LLU */
19404	19584	{
19405	19585	/* CALLBEGIN */

		@@ -19411,12 +19591,12 @@
19411	19591	{
19412	19592	/CALLEND/
19413	19593	stackbase += 9LLU;
19414		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC8LLU;
	19594	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFABCLLU;
19415	19595	fnaddr = /ACCESSGLOB/0x430C54D31CC3C20LLU;/* SP = 0LLU */
19416	19596	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSGLOB/\n"); exit(-1); }
19417	19597	break;
19418	19598	}
19419		-case 0xFFFFFFFFFFFFFAC8LLU:
	19599	+case 0xFFFFFFFFFFFFFABCLLU:
19420	19600	/* SP = 7LLU */fputs(" = ", stdout);
19421	19601	{
19422	19602	/* CALLBEGIN */

		@@ -19427,15 +19607,15 @@
19427	19607	{
19428	19608	/CALLEND/
19429	19609	stackbase += 9LLU;
19430		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC7LLU;
	19610	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFABBLLU;
19431	19611	fnaddr = /POP_______/0x40F4000000000000LLU;/* SP = 0LLU */
19432	19612	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_______/\n"); exit(-1); }
19433	19613	break;
19434	19614	}
19435		-case 0xFFFFFFFFFFFFFAC7LLU:
	19615	+case 0xFFFFFFFFFFFFFABBLLU:
19436	19616	/* SP = 7LLU // SP = 6LLU // SP = 6LLU */
19437		-{ /* JUMP / fnaddr = 18446744073709550296LLU; break; } / skip alternative */
19438		-case 18446744073709550297LLU: /* alternative // predicate */
	19617	+{ /* JUMP / fnaddr = 18446744073709550284LLU; break; } / skip alternative */
	19618	+case 18446744073709550285LLU: /* alternative // predicate */
19439	19619
19440	19620	{
19441	19621	/* CALLBEGIN */

		@@ -19447,15 +19627,15 @@
19447	19627	{
19448	19628	/CALLEND/
19449	19629	stackbase += 9LLU;
19450		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC4LLU;
	19630	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB8LLU;
19451	19631	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
19452	19632	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
19453	19633	break;
19454	19634	}
19455		-case 0xFFFFFFFFFFFFFAC4LLU:
	19635	+case 0xFFFFFFFFFFFFFAB8LLU:
19456	19636	/* SP = 7LLU */
19457	19637	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
19458		-{ /* JUMP / fnaddr = 18446744073709550278LLU; break; } / skip consequent */
	19638	+{ /* JUMP / fnaddr = 18446744073709550266LLU; break; } / skip consequent */
19459	19639	/* consequent */
19460	19640	{
19461	19641	/* CALLBEGIN */

		@@ -19466,12 +19646,12 @@
19466	19646	{
19467	19647	/CALLEND/
19468	19648	stackbase += 9LLU;
19469		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC3LLU;
	19649	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB7LLU;
19470	19650	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
19471	19651	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
19472	19652	break;
19473	19653	}
19474		-case 0xFFFFFFFFFFFFFAC3LLU:
	19654	+case 0xFFFFFFFFFFFFFAB7LLU:
19475	19655	/* SP = 7LLU */
19476	19656	{
19477	19657	/* CALLBEGIN */

		@@ -19482,12 +19662,12 @@
19482	19662	{
19483	19663	/CALLEND/
19484	19664	stackbase += 9LLU;
19485		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC2LLU;
	19665	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB6LLU;
19486	19666	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19487	19667	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19488	19668	break;
19489	19669	}
19490		-case 0xFFFFFFFFFFFFFAC2LLU:
	19670	+case 0xFFFFFFFFFFFFFAB6LLU:
19491	19671	/* SP = 7LLU */
19492	19672	{
19493	19673	/* CALLBEGIN */

		@@ -19499,12 +19679,12 @@
19499	19679	{
19500	19680	/CALLEND/
19501	19681	stackbase += 9LLU;
19502		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC1LLU;
	19682	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB5LLU;
19503	19683	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
19504	19684	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
19505	19685	break;
19506	19686	}
19507		-case 0xFFFFFFFFFFFFFAC1LLU:
	19687	+case 0xFFFFFFFFFFFFFAB5LLU:
19508	19688	/* SP = 7LLU */
19509	19689	{
19510	19690	/* CALLBEGIN */

		@@ -19515,12 +19695,12 @@
19515	19695	{
19516	19696	/CALLEND/
19517	19697	stackbase += 9LLU;
19518		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAC0LLU;
	19698	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB4LLU;
19519	19699	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19520	19700	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19521	19701	break;
19522	19702	}
19523		-case 0xFFFFFFFFFFFFFAC0LLU:
	19703	+case 0xFFFFFFFFFFFFFAB4LLU:
19524	19704	/* SP = 7LLU */
19525	19705	{
19526	19706	/* CALLBEGIN */

		@@ -19540,12 +19720,12 @@
19540	19720	{
19541	19721	/CALLEND/
19542	19722	stackbase += 15LLU;
19543		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFABFLLU;
	19723	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB3LLU;
19544	19724	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
19545	19725	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
19546	19726	break;
19547	19727	}
19548		-case 0xFFFFFFFFFFFFFABFLLU:
	19728	+case 0xFFFFFFFFFFFFFAB3LLU:
19549	19729	/* SP = 13LLU */
19550	19730	{
19551	19731	/* CALLBEGIN */

		@@ -19557,23 +19737,23 @@
19557	19737	{
19558	19738	/CALLEND/
19559	19739	stackbase += 16LLU;
19560		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFABELLU;
	19740	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB2LLU;
19561	19741	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
19562	19742	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
19563	19743	break;
19564	19744	}
19565		-case 0xFFFFFFFFFFFFFABELLU:
	19745	+case 0xFFFFFFFFFFFFFAB2LLU:
19566	19746	/* SP = 14LLU */
19567	19747	{ /* PUSH / stack[stackbase + 14LLU] = 0LLU; }/ SP + 1LLU = 15LLU */
19568	19748	{
19569	19749	/CALLEND/
19570	19750	stackbase += 9LLU;
19571		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFABDLLU;
	19751	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB1LLU;
19572	19752	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
19573	19753	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
19574	19754	break;
19575	19755	}
19576		-case 0xFFFFFFFFFFFFFABDLLU:
	19756	+case 0xFFFFFFFFFFFFFAB1LLU:
19577	19757	/* SP = 7LLU */
19578	19758	{
19579	19759	/* CALLBEGIN */

		@@ -19585,12 +19765,12 @@
19585	19765	{
19586	19766	/CALLEND/
19587	19767	stackbase += 9LLU;
19588		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFABCLLU;
	19768	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB0LLU;
19589	19769	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
19590	19770	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
19591	19771	break;
19592	19772	}
19593		-case 0xFFFFFFFFFFFFFABCLLU:
	19773	+case 0xFFFFFFFFFFFFFAB0LLU:
19594	19774	/* SP = 7LLU */fputs(" = ", stdout);
19595	19775	{
19596	19776	/* CALLBEGIN */

		@@ -19601,15 +19781,15 @@
19601	19781	{
19602	19782	/CALLEND/
19603	19783	stackbase += 9LLU;
19604		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFABBLLU;
	19784	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAAFLLU;
19605	19785	fnaddr = /POP_______/0x40F4000000000000LLU;/* SP = 0LLU */
19606	19786	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_______/\n"); exit(-1); }
19607	19787	break;
19608	19788	}
19609		-case 0xFFFFFFFFFFFFFABBLLU:
	19789	+case 0xFFFFFFFFFFFFFAAFLLU:
19610	19790	/* SP = 7LLU // SP = 6LLU // SP = 6LLU */
19611		-{ /* JUMP / fnaddr = 18446744073709550277LLU; break; } / skip alternative */
19612		-case 18446744073709550278LLU: /* alternative // predicate */
	19791	+{ /* JUMP / fnaddr = 18446744073709550265LLU; break; } / skip alternative */
	19792	+case 18446744073709550266LLU: /* alternative // predicate */
19613	19793
19614	19794	{
19615	19795	/* CALLBEGIN */

		@@ -19621,15 +19801,15 @@
19621	19801	{
19622	19802	/CALLEND/
19623	19803	stackbase += 9LLU;
19624		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB8LLU;
	19804	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAACLLU;
19625	19805	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
19626	19806	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
19627	19807	break;
19628	19808	}
19629		-case 0xFFFFFFFFFFFFFAB8LLU:
	19809	+case 0xFFFFFFFFFFFFFAACLLU:
19630	19810	/* SP = 7LLU */
19631	19811	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
19632		-{ /* JUMP / fnaddr = 18446744073709550266LLU; break; } / skip consequent */
	19812	+{ /* JUMP / fnaddr = 18446744073709550254LLU; break; } / skip consequent */
19633	19813	/* consequent */
19634	19814	{
19635	19815	/* CALLBEGIN */

		@@ -19641,12 +19821,12 @@
19641	19821	{
19642	19822	/CALLEND/
19643	19823	stackbase += 8LLU;
19644		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB7LLU;
	19824	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAABLLU;
19645	19825	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
19646	19826	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
19647	19827	break;
19648	19828	}
19649		-case 0xFFFFFFFFFFFFFAB7LLU:
	19829	+case 0xFFFFFFFFFFFFFAABLLU:
19650	19830	/* SP = 6LLU */
19651	19831	{
19652	19832	/* CALLBEGIN */

		@@ -19657,12 +19837,12 @@
19657	19837	{
19658	19838	/CALLEND/
19659	19839	stackbase += 8LLU;
19660		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB6LLU;
	19840	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAAALLU;
19661	19841	fnaddr = /checklevel/0x7A381E9A78318270LLU;/* SP = 0LLU */
19662	19842	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /checklevel/\n"); exit(-1); }
19663	19843	break;
19664	19844	}
19665		-case 0xFFFFFFFFFFFFFAB6LLU:
	19845	+case 0xFFFFFFFFFFFFFAAALLU:
19666	19846	/* SP = 6LLU */
19667	19847	{
19668	19848	/* CALLBEGIN */

		@@ -19674,12 +19854,12 @@
19674	19854	{
19675	19855	/CALLEND/
19676	19856	stackbase += 8LLU;
19677		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB5LLU;
	19857	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA9LLU;
19678	19858	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
19679	19859	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
19680	19860	break;
19681	19861	}
19682		-case 0xFFFFFFFFFFFFFAB5LLU:
	19862	+case 0xFFFFFFFFFFFFFAA9LLU:
19683	19863	/* SP = 6LLU */
19684	19864	{
19685	19865	/* CALLBEGIN */

		@@ -19691,15 +19871,15 @@
19691	19871	{
19692	19872	/CALLEND/
19693	19873	stackbase += 8LLU;
19694		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB4LLU;
	19874	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA8LLU;
19695	19875	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
19696	19876	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
19697	19877	break;
19698	19878	}
19699		-case 0xFFFFFFFFFFFFFAB4LLU:
	19879	+case 0xFFFFFFFFFFFFFAA8LLU:
19700	19880	/* SP = 6LLU // SP = 6LLU // SP = 6LLU */
19701		-{ /* JUMP / fnaddr = 18446744073709550265LLU; break; } / skip alternative */
19702		-case 18446744073709550266LLU: /* alternative // predicate */
	19881	+{ /* JUMP / fnaddr = 18446744073709550253LLU; break; } / skip alternative */
	19882	+case 18446744073709550254LLU: /* alternative // predicate */
19703	19883
19704	19884	{
19705	19885	/* CALLBEGIN */

		@@ -19711,15 +19891,15 @@
19711	19891	{
19712	19892	/CALLEND/
19713	19893	stackbase += 9LLU;
19714		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB1LLU;
	19894	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA5LLU;
19715	19895	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
19716	19896	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
19717	19897	break;
19718	19898	}
19719		-case 0xFFFFFFFFFFFFFAB1LLU:
	19899	+case 0xFFFFFFFFFFFFFAA5LLU:
19720	19900	/* SP = 7LLU */
19721	19901	if(!/* SP - 1LLU = 6LLU */stack[stackbase + 6LLU])
19722		-{ /* JUMP / fnaddr = 18446744073709550259LLU; break; } / skip consequent */
	19902	+{ /* JUMP / fnaddr = 18446744073709550247LLU; break; } / skip consequent */
19723	19903	/* consequent */
19724	19904	{
19725	19905	/* CALLBEGIN */

		@@ -19730,15 +19910,15 @@
19730	19910	{
19731	19911	/CALLEND/
19732	19912	stackbase += 8LLU;
19733		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAB0LLU;
	19913	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA4LLU;
19734	19914	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
19735	19915	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
19736	19916	break;
19737	19917	}
19738		-case 0xFFFFFFFFFFFFFAB0LLU:
	19918	+case 0xFFFFFFFFFFFFFAA4LLU:
19739	19919	/* SP = 6LLU /fputs("assignment to reference not implemented\n", stderr); exit(-1);/ SP = 6LLU // SP = 6LLU */
19740		-{ /* JUMP / fnaddr = 18446744073709550258LLU; break; } / skip alternative */
19741		-case 18446744073709550259LLU: /* alternative */
	19920	+{ /* JUMP / fnaddr = 18446744073709550246LLU; break; } / skip alternative */
	19921	+case 18446744073709550247LLU: /* alternative */
19742	19922	{
19743	19923	/* CALLBEGIN */
19744	19924	/* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */

		@@ -19748,12 +19928,12 @@
19748	19928	{
19749	19929	/CALLEND/
19750	19930	stackbase += 8LLU;
19751		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAAFLLU;
	19931	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA3LLU;
19752	19932	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
19753	19933	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
19754	19934	break;
19755	19935	}
19756		-case 0xFFFFFFFFFFFFFAAFLLU:
	19936	+case 0xFFFFFFFFFFFFFAA3LLU:
19757	19937	/* SP = 6LLU */fputs("unexpected ", stderr);
19758	19938	{
19759	19939	/* CALLBEGIN */

		@@ -19770,39 +19950,39 @@
19770	19950	{
19771	19951	/CALLEND/
19772	19952	stackbase += 11LLU;
19773		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAAELLU;
	19953	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA2LLU;
19774	19954	fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
19775	19955	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); }
19776	19956	break;
19777	19957	}
19778		-case 0xFFFFFFFFFFFFFAAELLU:
	19958	+case 0xFFFFFFFFFFFFFAA2LLU:
19779	19959	/* SP = 9LLU */
19780	19960	{
19781	19961	/CALLEND/
19782	19962	stackbase += 8LLU;
19783		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAADLLU;
	19963	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA1LLU;
19784	19964	fnaddr = /debugchar_/0x7E077089E8DCB400LLU;/* SP = 0LLU */
19785	19965	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugchar_/\n"); exit(-1); }
19786	19966	break;
19787	19967	}
19788		-case 0xFFFFFFFFFFFFFAADLLU:
	19968	+case 0xFFFFFFFFFFFFFAA1LLU:
19789	19969	/* SP = 6LLU /fputs("\n", stderr); exit(-1);/ SP = 6LLU */
19790		-case 18446744073709550258LLU: /* skip to here */
	19970	+case 18446744073709550246LLU: /* skip to here */
19791	19971
	19972	+case 18446744073709550253LLU: /* skip to here */
	19973	+
19792	19974	case 18446744073709550265LLU: /* skip to here */
19793	19975
19794		-case 18446744073709550277LLU: /* skip to here */
	19976	+case 18446744073709550284LLU: /* skip to here */
19795	19977
19796		-case 18446744073709550296LLU: /* skip to here */
	19978	+case 18446744073709550303LLU: /* skip to here */
19797	19979
19798		-case 18446744073709550315LLU: /* skip to here */
	19980	+case 18446744073709550313LLU: /* skip to here */
19799	19981
19800		-case 18446744073709550325LLU: /* skip to here */
	19982	+case 18446744073709550317LLU: /* skip to here */
19801	19983
19802		-case 18446744073709550329LLU: /* skip to here */
	19984	+case 18446744073709550323LLU: /* skip to here */
19803	19985
19804		-case 18446744073709550335LLU: /* skip to here */
19805		-
19806	19986	{
19807	19987	/* CALLBEGIN */
19808	19988	/* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */

		@@ -19818,18 +19998,18 @@
19818	19998	{
19819	19999	/CALLEND/
19820	20000	stackbase += 8LLU;
19821		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAACLLU;
	20001	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA0LLU;
19822	20002	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
19823	20003	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
19824	20004	break;
19825	20005	}
19826		-case 0xFFFFFFFFFFFFFAACLLU:
	20006	+case 0xFFFFFFFFFFFFFAA0LLU:
19827	20007	/* SP = 6LLU // SP = 6LLU */
19828		-case 18446744073709550344LLU: /* skip to here */
	20008	+case 18446744073709550332LLU: /* skip to here */
19829	20009	/* SP = 6LLU */
19830		-case 18446744073709550573LLU: /* skip to here */
	20010	+case 18446744073709550560LLU: /* skip to here */
19831	20011	/* SP = 6LLU */
19832		-case 18446744073709550577LLU: /* alternative // SP = 6LLU */
	20012	+case 18446744073709550564LLU: /* alternative // SP = 6LLU */
19833	20013	case 18446744073709550970LLU: /* skip to here */
19834	20014	/* SP = 6LLU */
19835	20015	case 18446744073709550972LLU: /* skipped consequent // SP = 6LLU // SP - 0LLU = 6LLU */

		@@ -19845,12 +20025,12 @@
19845	20025	{
19846	20026	/CALLEND/
19847	20027	stackbase += 3LLU;
19848		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAABLLU;
	20028	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9FLLU;
19849	20029	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19850	20030	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19851	20031	break;
19852	20032	}
19853		-case 0xFFFFFFFFFFFFFAABLLU:
	20033	+case 0xFFFFFFFFFFFFFA9FLLU:
19854	20034	/* SP = 1LLU */
19855	20035	{
19856	20036	/* CALLBEGIN */

		@@ -19861,12 +20041,12 @@
19861	20041	{
19862	20042	/CALLEND/
19863	20043	stackbase += 4LLU;
19864		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAAALLU;
	20044	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9ELLU;
19865	20045	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
19866	20046	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
19867	20047	break;
19868	20048	}
19869		-case 0xFFFFFFFFFFFFFAAALLU:
	20049	+case 0xFFFFFFFFFFFFFA9ELLU:
19870	20050	/* SP = 2LLU // predicate */
19871	20051
19872	20052	{

		@@ -19880,15 +20060,15 @@
19880	20060	{
19881	20061	/CALLEND/
19882	20062	stackbase += 5LLU;
19883		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA8LLU;
	20063	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9CLLU;
19884	20064	fnaddr = /existsdef_/0x83392EBEE7E08400LLU;/* SP = 0LLU */
19885	20065	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsdef_/\n"); exit(-1); }
19886	20066	break;
19887	20067	}
19888		-case 0xFFFFFFFFFFFFFAA8LLU:
	20068	+case 0xFFFFFFFFFFFFFA9CLLU:
19889	20069	/* SP = 3LLU */
19890	20070	if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
19891		-{ /* JUMP / fnaddr = 18446744073709550249LLU; break; } / skip consequent */
	20071	+{ /* JUMP / fnaddr = 18446744073709550237LLU; break; } / skip consequent */
19892	20072	/* consequent */
19893	20073	{
19894	20074	/* CALLBEGIN */

		@@ -19899,12 +20079,12 @@
19899	20079	{
19900	20080	/CALLEND/
19901	20081	stackbase += 4LLU;
19902		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA7LLU;
	20082	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9BLLU;
19903	20083	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
19904	20084	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
19905	20085	break;
19906	20086	}
19907		-case 0xFFFFFFFFFFFFFAA7LLU:
	20087	+case 0xFFFFFFFFFFFFFA9BLLU:
19908	20088	/* SP = 2LLU */fputs("redefinition of data-constructor ", stderr);
19909	20089	{
19910	20090	/* CALLBEGIN */

		@@ -19916,14 +20096,14 @@
19916	20096	{
19917	20097	/CALLEND/
19918	20098	stackbase += 4LLU;
19919		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA6LLU;
	20099	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9ALLU;
19920	20100	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
19921	20101	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
19922	20102	break;
19923	20103	}
19924		-case 0xFFFFFFFFFFFFFAA6LLU:
	20104	+case 0xFFFFFFFFFFFFFA9ALLU:
19925	20105	/* SP = 2LLU /exit(-1);/ SP = 2LLU */
19926		-case 18446744073709550249LLU: /* alternative */
	20106	+case 18446744073709550237LLU: /* alternative */
19927	20107	{
19928	20108	/* CALLBEGIN */
19929	20109	/* reserve space for 1LLU returned values // SP + 1LLU = 3LLU */

		@@ -19934,12 +20114,12 @@
19934	20114	{
19935	20115	/CALLEND/
19936	20116	stackbase += 5LLU;
19937		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA5LLU;
	20117	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA99LLU;
19938	20118	fnaddr = /markunion_/0xA1CB66C2992AA400LLU;/* SP = 0LLU */
19939	20119	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /markunion_/\n"); exit(-1); }
19940	20120	break;
19941	20121	}
19942		-case 0xFFFFFFFFFFFFFAA5LLU:
	20122	+case 0xFFFFFFFFFFFFFA99LLU:
19943	20123	/* SP = 3LLU // SP - 1LLU = 2LLU */
19944	20124	{ /* RESULT // LOCAL VAR / stack[stackbase + 1LLU] = / LOCAL VAR / stack[stackbase + 2LLU]; }/ SP = 2LLU // SP - 1LLU = 1LLU */
19945	20125	{ /* RESULT // LOCAL VAR / stack[stackbase + 18446744073709551613LLU] = / LOCAL VAR */ stack[stackbase + 1LLU]; }

		@@ -19955,12 +20135,12 @@
19955	20135	{
19956	20136	/CALLEND/
19957	20137	stackbase += 2LLU;
19958		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA4LLU;
	20138	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA98LLU;
19959	20139	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
19960	20140	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
19961	20141	break;
19962	20142	}
19963		-case 0xFFFFFFFFFFFFFAA4LLU:
	20143	+case 0xFFFFFFFFFFFFFA98LLU:
19964	20144	/* SP = 0LLU */
19965	20145	{
19966	20146	/* CALLBEGIN */

		@@ -19972,12 +20152,12 @@
19972	20152	{
19973	20153	/CALLEND/
19974	20154	stackbase += 2LLU;
19975		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA3LLU;
	20155	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA97LLU;
19976	20156	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
19977	20157	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
19978	20158	break;
19979	20159	}
19980		-case 0xFFFFFFFFFFFFFAA3LLU:
	20160	+case 0xFFFFFFFFFFFFFA97LLU:
19981	20161	/* SP = 0LLU */
19982	20162	{ /* PUSH / stack[stackbase + 0LLU] = 0LLU; }/ SP + 1LLU = 1LLU */
19983	20163	{ /* PUSH / stack[stackbase + 1LLU] = 0LLU; }/ SP + 1LLU = 2LLU */

		@@ -19997,12 +20177,12 @@
19997	20177	{
19998	20178	/CALLEND/
19999	20179	stackbase += 7LLU;
20000		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFAA2LLU;
	20180	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA96LLU;
20001	20181	fnaddr = /encodeval_/0x8297AA7E0C5C9C00LLU;/* SP = 0LLU */
20002	20182	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeval_/\n"); exit(-1); }
20003	20183	break;
20004	20184	}
20005		-case 0xFFFFFFFFFFFFFAA2LLU:
	20185	+case 0xFFFFFFFFFFFFFA96LLU:
20006	20186	/* SP = 5LLU // SP = 4LLU */
20007	20187	{ /* assign / / LOCAL VAR / stack[stackbase + 2LLU] = / LOCAL VAR */ stack[stackbase + 4LLU]; }
20008	20188	{ /* PUSH / stack[stackbase + 4LLU] = 0LLU; }/ SP + 1LLU = 5LLU // SP = 4LLU */

		@@ -20034,15 +20214,15 @@
20034	20214	{
20035	20215	/CALLEND/
20036	20216	stackbase += 11LLU;
20037		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9FLLU;
	20217	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA93LLU;
20038	20218	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
20039	20219	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
20040	20220	break;
20041	20221	}
20042		-case 0xFFFFFFFFFFFFFA9FLLU:
	20222	+case 0xFFFFFFFFFFFFFA93LLU:
20043	20223	/* SP = 9LLU */
20044	20224	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
20045		-{ /* JUMP / fnaddr = 18446744073709550241LLU; break; } / skip consequent */
	20225	+{ /* JUMP / fnaddr = 18446744073709550229LLU; break; } / skip consequent */
20046	20226	/* consequent */
20047	20227	{
20048	20228	/* CALLBEGIN */

		@@ -20053,12 +20233,12 @@
20053	20233	{
20054	20234	/CALLEND/
20055	20235	stackbase += 10LLU;
20056		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9ELLU;
	20236	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA92LLU;
20057	20237	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20058	20238	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20059	20239	break;
20060	20240	}
20061		-case 0xFFFFFFFFFFFFFA9ELLU:
	20241	+case 0xFFFFFFFFFFFFFA92LLU:
20062	20242	/* SP = 8LLU // predicate */
20063	20243
20064	20244	{

		@@ -20076,26 +20256,26 @@
20076	20256	{
20077	20257	/CALLEND/
20078	20258	stackbase += 14LLU;
20079		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9BLLU;
	20259	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8FLLU;
20080	20260	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
20081	20261	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
20082	20262	break;
20083	20263	}
20084		-case 0xFFFFFFFFFFFFFA9BLLU:
	20264	+case 0xFFFFFFFFFFFFFA8FLLU:
20085	20265	/* SP = 12LLU */
20086	20266	{ /* PUSH / stack[stackbase + 12LLU] = 255LLU; }/ SP + 1LLU = 13LLU */
20087	20267	{
20088	20268	/CALLEND/
20089	20269	stackbase += 11LLU;
20090		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA9ALLU;
	20270	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8ELLU;
20091	20271	fnaddr = /leq_______/0x9E0B000000000000LLU;/* SP = 0LLU */
20092	20272	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /leq_______/\n"); exit(-1); }
20093	20273	break;
20094	20274	}
20095		-case 0xFFFFFFFFFFFFFA9ALLU:
	20275	+case 0xFFFFFFFFFFFFFA8ELLU:
20096	20276	/* SP = 9LLU */
20097	20277	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
20098		-{ /* JUMP / fnaddr = 18446744073709550237LLU; break; } / skip consequent */
	20278	+{ /* JUMP / fnaddr = 18446744073709550225LLU; break; } / skip consequent */
20099	20279	/* consequent // predicate */
20100	20280
20101	20281	{

		@@ -20113,25 +20293,25 @@
20113	20293	{
20114	20294	/CALLEND/
20115	20295	stackbase += 14LLU;
20116		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA97LLU;
	20296	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8BLLU;
20117	20297	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
20118	20298	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
20119	20299	break;
20120	20300	}
20121		-case 0xFFFFFFFFFFFFFA97LLU:
	20301	+case 0xFFFFFFFFFFFFFA8BLLU:
20122	20302	/* SP = 12LLU */
20123	20303	{
20124	20304	/CALLEND/
20125	20305	stackbase += 11LLU;
20126		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA96LLU;
	20306	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8ALLU;
20127	20307	fnaddr = /isalpha___/0x92E727AE37000000LLU;/* SP = 0LLU */
20128	20308	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /isalpha___/\n"); exit(-1); }
20129	20309	break;
20130	20310	}
20131		-case 0xFFFFFFFFFFFFFA96LLU:
	20311	+case 0xFFFFFFFFFFFFFA8ALLU:
20132	20312	/* SP = 9LLU */
20133	20313	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
20134		-{ /* JUMP / fnaddr = 18446744073709550233LLU; break; } / skip consequent */
	20314	+{ /* JUMP / fnaddr = 18446744073709550221LLU; break; } / skip consequent */
20135	20315	/* consequent */
20136	20316	{
20137	20317	/* CALLBEGIN */

		@@ -20142,12 +20322,12 @@
20142	20322	{
20143	20323	/CALLEND/
20144	20324	stackbase += 10LLU;
20145		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA95LLU;
	20325	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA89LLU;
20146	20326	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20147	20327	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20148	20328	break;
20149	20329	}
20150		-case 0xFFFFFFFFFFFFFA95LLU:
	20330	+case 0xFFFFFFFFFFFFFA89LLU:
20151	20331	/* SP = 8LLU */
20152	20332	{
20153	20333	/* CALLBEGIN */

		@@ -20158,12 +20338,12 @@
20158	20338	{
20159	20339	/CALLEND/
20160	20340	stackbase += 11LLU;
20161		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA94LLU;
	20341	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA88LLU;
20162	20342	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
20163	20343	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
20164	20344	break;
20165	20345	}
20166		-case 0xFFFFFFFFFFFFFA94LLU:
	20346	+case 0xFFFFFFFFFFFFFA88LLU:
20167	20347	/* SP = 9LLU */
20168	20348	{ /* PUSH / stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU // SP = 9LLU */
20169	20349	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR */ stack[stackbase + 9LLU]; }

		@@ -20181,15 +20361,15 @@
20181	20361	{
20182	20362	/CALLEND/
20183	20363	stackbase += 12LLU;
20184		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA91LLU;
	20364	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA85LLU;
20185	20365	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
20186	20366	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
20187	20367	break;
20188	20368	}
20189		-case 0xFFFFFFFFFFFFFA91LLU:
	20369	+case 0xFFFFFFFFFFFFFA85LLU:
20190	20370	/* SP = 10LLU */
20191	20371	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
20192		-{ /* JUMP / fnaddr = 18446744073709550227LLU; break; } / skip consequent */
	20372	+{ /* JUMP / fnaddr = 18446744073709550215LLU; break; } / skip consequent */
20193	20373	/* consequent */
20194	20374	{
20195	20375	/* CALLBEGIN */

		@@ -20200,12 +20380,12 @@
20200	20380	{
20201	20381	/CALLEND/
20202	20382	stackbase += 11LLU;
20203		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA90LLU;
	20383	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA84LLU;
20204	20384	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20205	20385	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20206	20386	break;
20207	20387	}
20208		-case 0xFFFFFFFFFFFFFA90LLU:
	20388	+case 0xFFFFFFFFFFFFFA84LLU:
20209	20389	/* SP = 9LLU */
20210	20390	{
20211	20391	/* CALLBEGIN */

		@@ -20222,22 +20402,22 @@
20222	20402	{
20223	20403	/CALLEND/
20224	20404	stackbase += 15LLU;
20225		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8FLLU;
	20405	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA83LLU;
20226	20406	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
20227	20407	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
20228	20408	break;
20229	20409	}
20230		-case 0xFFFFFFFFFFFFFA8FLLU:
	20410	+case 0xFFFFFFFFFFFFFA83LLU:
20231	20411	/* SP = 13LLU */
20232	20412	{
20233	20413	/CALLEND/
20234	20414	stackbase += 12LLU;
20235		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8ELLU;
	20415	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA82LLU;
20236	20416	fnaddr = /markstruct/0xA1CB66BAFB707AF0LLU;/* SP = 0LLU */
20237	20417	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /markstruct/\n"); exit(-1); }
20238	20418	break;
20239	20419	}
20240		-case 0xFFFFFFFFFFFFFA8ELLU:
	20420	+case 0xFFFFFFFFFFFFFA82LLU:
20241	20421	/* SP = 10LLU // SP = 9LLU */
20242	20422	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR */ stack[stackbase + 9LLU]; }
20243	20423	{

		@@ -20250,12 +20430,12 @@
20250	20430	{
20251	20431	/CALLEND/
20252	20432	stackbase += 12LLU;
20253		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8DLLU;
	20433	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA81LLU;
20254	20434	fnaddr = /idtosub___/0x91FBEABB07400000LLU;/* SP = 0LLU */
20255	20435	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /idtosub___/\n"); exit(-1); }
20256	20436	break;
20257	20437	}
20258		-case 0xFFFFFFFFFFFFFA8DLLU:
	20438	+case 0xFFFFFFFFFFFFFA81LLU:
20259	20439	/* SP = 10LLU // SP = 9LLU */
20260	20440	{ /* assign / / LOCAL VAR / stack[stackbase + 4LLU] = / LOCAL VAR / stack[stackbase + 9LLU]; }/ predicate */
20261	20441

		@@ -20270,15 +20450,15 @@
20270	20450	{
20271	20451	/CALLEND/
20272	20452	stackbase += 12LLU;
20273		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8BLLU;
	20453	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7FLLU;
20274	20454	fnaddr = /existsdef_/0x83392EBEE7E08400LLU;/* SP = 0LLU */
20275	20455	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsdef_/\n"); exit(-1); }
20276	20456	break;
20277	20457	}
20278		-case 0xFFFFFFFFFFFFFA8BLLU:
	20458	+case 0xFFFFFFFFFFFFFA7FLLU:
20279	20459	/* SP = 10LLU */
20280	20460	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
20281		-{ /* JUMP / fnaddr = 18446744073709550220LLU; break; } / skip consequent */
	20461	+{ /* JUMP / fnaddr = 18446744073709550208LLU; break; } / skip consequent */
20282	20462	/* consequent */
20283	20463	{
20284	20464	/* CALLBEGIN */

		@@ -20289,12 +20469,12 @@
20289	20469	{
20290	20470	/CALLEND/
20291	20471	stackbase += 11LLU;
20292		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA8ALLU;
	20472	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7ELLU;
20293	20473	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
20294	20474	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
20295	20475	break;
20296	20476	}
20297		-case 0xFFFFFFFFFFFFFA8ALLU:
	20477	+case 0xFFFFFFFFFFFFFA7ELLU:
20298	20478	/* SP = 9LLU */fputs("redefinition of struct ", stderr);
20299	20479	{
20300	20480	/* CALLBEGIN */

		@@ -20306,14 +20486,14 @@
20306	20486	{
20307	20487	/CALLEND/
20308	20488	stackbase += 11LLU;
20309		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA89LLU;
	20489	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7DLLU;
20310	20490	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
20311	20491	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
20312	20492	break;
20313	20493	}
20314		-case 0xFFFFFFFFFFFFFA89LLU:
	20494	+case 0xFFFFFFFFFFFFFA7DLLU:
20315	20495	/* SP = 9LLU /exit(-1);/ SP = 9LLU */
20316		-case 18446744073709550220LLU: /* alternative */
	20496	+case 18446744073709550208LLU: /* alternative */
20317	20497	{
20318	20498	/* CALLBEGIN */
20319	20499	/* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */

		@@ -20323,12 +20503,12 @@
20323	20503	{
20324	20504	/CALLEND/
20325	20505	stackbase += 11LLU;
20326		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA88LLU;
	20506	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7CLLU;
20327	20507	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20328	20508	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20329	20509	break;
20330	20510	}
20331		-case 0xFFFFFFFFFFFFFA88LLU:
	20511	+case 0xFFFFFFFFFFFFFA7CLLU:
20332	20512	/* SP = 9LLU */
20333	20513	{
20334	20514	/* CALLBEGIN */

		@@ -20340,12 +20520,12 @@
20340	20520	{
20341	20521	/CALLEND/
20342	20522	stackbase += 11LLU;
20343		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA87LLU;
	20523	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7BLLU;
20344	20524	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
20345	20525	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
20346	20526	break;
20347	20527	}
20348		-case 0xFFFFFFFFFFFFFA87LLU:
	20528	+case 0xFFFFFFFFFFFFFA7BLLU:
20349	20529	/* SP = 9LLU */
20350	20530	{
20351	20531	/* CALLBEGIN */

		@@ -20364,15 +20544,15 @@
20364	20544	{
20365	20545	/CALLEND/
20366	20546	stackbase += 11LLU;
20367		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA86LLU;
	20547	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7ALLU;
20368	20548	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
20369	20549	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
20370	20550	break;
20371	20551	}
20372		-case 0xFFFFFFFFFFFFFA86LLU:
	20552	+case 0xFFFFFFFFFFFFFA7ALLU:
20373	20553	/* SP = 9LLU // SP = 9LLU // SP = 9LLU */
20374		-{ /* JUMP / fnaddr = 18446744073709550226LLU; break; } / skip alternative */
20375		-case 18446744073709550227LLU: /* alternative // predicate */
	20554	+{ /* JUMP / fnaddr = 18446744073709550214LLU; break; } / skip alternative */
	20555	+case 18446744073709550215LLU: /* alternative // predicate */
20376	20556
20377	20557	{
20378	20558	/* CALLBEGIN */

		@@ -20385,15 +20565,15 @@
20385	20565	{
20386	20566	/CALLEND/
20387	20567	stackbase += 12LLU;
20388		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA83LLU;
	20568	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA77LLU;
20389	20569	fnaddr = /equ_______/0x82CC000000000000LLU;/* SP = 0LLU */
20390	20570	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /equ_______/\n"); exit(-1); }
20391	20571	break;
20392	20572	}
20393		-case 0xFFFFFFFFFFFFFA83LLU:
	20573	+case 0xFFFFFFFFFFFFFA77LLU:
20394	20574	/* SP = 10LLU */
20395	20575	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
20396		-{ /* JUMP / fnaddr = 18446744073709550213LLU; break; } / skip consequent */
	20576	+{ /* JUMP / fnaddr = 18446744073709550201LLU; break; } / skip consequent */
20397	20577	/* consequent */
20398	20578	{
20399	20579	/* CALLBEGIN */

		@@ -20404,12 +20584,12 @@
20404	20584	{
20405	20585	/CALLEND/
20406	20586	stackbase += 11LLU;
20407		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA82LLU;
	20587	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA76LLU;
20408	20588	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20409	20589	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20410	20590	break;
20411	20591	}
20412		-case 0xFFFFFFFFFFFFFA82LLU:
	20592	+case 0xFFFFFFFFFFFFFA76LLU:
20413	20593	/* SP = 9LLU */
20414	20594	{
20415	20595	/* CALLBEGIN */

		@@ -20420,12 +20600,12 @@
20420	20600	{
20421	20601	/CALLEND/
20422	20602	stackbase += 12LLU;
20423		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA81LLU;
	20603	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA75LLU;
20424	20604	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
20425	20605	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
20426	20606	break;
20427	20607	}
20428		-case 0xFFFFFFFFFFFFFA81LLU:
	20608	+case 0xFFFFFFFFFFFFFA75LLU:
20429	20609	/* SP = 10LLU */
20430	20610	{
20431	20611	/* CALLBEGIN */

		@@ -20443,22 +20623,22 @@
20443	20623	{
20444	20624	/CALLEND/
20445	20625	stackbase += 16LLU;
20446		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA80LLU;
	20626	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA74LLU;
20447	20627	fnaddr = /markdata__/0xA1CB667DCBDC0000LLU;/* SP = 0LLU */
20448	20628	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /markdata__/\n"); exit(-1); }
20449	20629	break;
20450	20630	}
20451		-case 0xFFFFFFFFFFFFFA80LLU:
	20631	+case 0xFFFFFFFFFFFFFA74LLU:
20452	20632	/* SP = 14LLU */
20453	20633	{
20454	20634	/CALLEND/
20455	20635	stackbase += 13LLU;
20456		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7FLLU;
	20636	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA73LLU;
20457	20637	fnaddr = /idtosub___/0x91FBEABB07400000LLU;/* SP = 0LLU */
20458	20638	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /idtosub___/\n"); exit(-1); }
20459	20639	break;
20460	20640	}
20461		-case 0xFFFFFFFFFFFFFA7FLLU:
	20641	+case 0xFFFFFFFFFFFFFA73LLU:
20462	20642	/* SP = 11LLU // SP = 10LLU */
20463	20643	{ /* assign / / LOCAL VAR / stack[stackbase + 4LLU] = / LOCAL VAR / stack[stackbase + 10LLU]; }/ predicate */
20464	20644

		@@ -20473,15 +20653,15 @@
20473	20653	{
20474	20654	/CALLEND/
20475	20655	stackbase += 13LLU;
20476		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7DLLU;
	20656	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA71LLU;
20477	20657	fnaddr = /existsdef_/0x83392EBEE7E08400LLU;/* SP = 0LLU */
20478	20658	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsdef_/\n"); exit(-1); }
20479	20659	break;
20480	20660	}
20481		-case 0xFFFFFFFFFFFFFA7DLLU:
	20661	+case 0xFFFFFFFFFFFFFA71LLU:
20482	20662	/* SP = 11LLU */
20483	20663	if(!/* SP - 1LLU = 10LLU */stack[stackbase + 10LLU])
20484		-{ /* JUMP / fnaddr = 18446744073709550206LLU; break; } / skip consequent */
	20664	+{ /* JUMP / fnaddr = 18446744073709550194LLU; break; } / skip consequent */
20485	20665	/* consequent */
20486	20666	{
20487	20667	/* CALLBEGIN */

		@@ -20492,12 +20672,12 @@
20492	20672	{
20493	20673	/CALLEND/
20494	20674	stackbase += 12LLU;
20495		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7CLLU;
	20675	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA70LLU;
20496	20676	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
20497	20677	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
20498	20678	break;
20499	20679	}
20500		-case 0xFFFFFFFFFFFFFA7CLLU:
	20680	+case 0xFFFFFFFFFFFFFA70LLU:
20501	20681	/* SP = 10LLU */fputs("redefinition of data-type ", stderr);
20502	20682	{
20503	20683	/* CALLBEGIN */

		@@ -20509,14 +20689,14 @@
20509	20689	{
20510	20690	/CALLEND/
20511	20691	stackbase += 12LLU;
20512		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7BLLU;
	20692	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6FLLU;
20513	20693	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
20514	20694	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
20515	20695	break;
20516	20696	}
20517		-case 0xFFFFFFFFFFFFFA7BLLU:
	20697	+case 0xFFFFFFFFFFFFFA6FLLU:
20518	20698	/* SP = 10LLU /exit(-1);/ SP = 10LLU */
20519		-case 18446744073709550206LLU: /* alternative */
	20699	+case 18446744073709550194LLU: /* alternative */
20520	20700	{
20521	20701	/* CALLBEGIN */
20522	20702	/* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */

		@@ -20526,12 +20706,12 @@
20526	20706	{
20527	20707	/CALLEND/
20528	20708	stackbase += 12LLU;
20529		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA7ALLU;
	20709	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6ELLU;
20530	20710	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20531	20711	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20532	20712	break;
20533	20713	}
20534		-case 0xFFFFFFFFFFFFFA7ALLU:
	20714	+case 0xFFFFFFFFFFFFFA6ELLU:
20535	20715	/* SP = 10LLU */
20536	20716	{
20537	20717	/* CALLBEGIN */

		@@ -20543,12 +20723,12 @@
20543	20723	{
20544	20724	/CALLEND/
20545	20725	stackbase += 12LLU;
20546		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA79LLU;
	20726	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6DLLU;
20547	20727	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
20548	20728	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
20549	20729	break;
20550	20730	}
20551		-case 0xFFFFFFFFFFFFFA79LLU:
	20731	+case 0xFFFFFFFFFFFFFA6DLLU:
20552	20732	/* SP = 10LLU */
20553	20733	{
20554	20734	/* CALLBEGIN */

		@@ -20559,12 +20739,12 @@
20559	20739	{
20560	20740	/CALLEND/
20561	20741	stackbase += 12LLU;
20562		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA78LLU;
	20742	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6CLLU;
20563	20743	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20564	20744	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20565	20745	break;
20566	20746	}
20567		-case 0xFFFFFFFFFFFFFA78LLU:
	20747	+case 0xFFFFFFFFFFFFFA6CLLU:
20568	20748	/* SP = 10LLU */
20569	20749	{
20570	20750	/* CALLBEGIN */

		@@ -20576,12 +20756,12 @@
20576	20756	{
20577	20757	/CALLEND/
20578	20758	stackbase += 13LLU;
20579		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA77LLU;
	20759	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6BLLU;
20580	20760	fnaddr = /nameconstr/0xA5CA207AAA6EBED0LLU;/* SP = 0LLU */
20581	20761	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /nameconstr/\n"); exit(-1); }
20582	20762	break;
20583	20763	}
20584		-case 0xFFFFFFFFFFFFFA77LLU:
	20764	+case 0xFFFFFFFFFFFFFA6BLLU:
20585	20765	/* SP = 11LLU // SP = 10LLU */
20586	20766	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR */ stack[stackbase + 10LLU]; }
20587	20767	{ /* PUSH / stack[stackbase + 10LLU] = (/ REF TO LINK / stackbase + 11LLU); }/ SP + 1LLU = 11LLU */

		@@ -20595,12 +20775,12 @@
20595	20775	{
20596	20776	/CALLEND/
20597	20777	stackbase += 18LLU;
20598		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA76LLU;
	20778	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6ALLU;
20599	20779	fnaddr = /initconstr/0x92992F7AAA6EBED0LLU;/* SP = 0LLU */
20600	20780	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /initconstr/\n"); exit(-1); }
20601	20781	break;
20602	20782	}
20603		-case 0xFFFFFFFFFFFFFA76LLU:
	20783	+case 0xFFFFFFFFFFFFFA6ALLU:
20604	20784	/* SP = 16LLU */
20605	20785	{
20606	20786	/* CALLBEGIN */

		@@ -20619,15 +20799,15 @@
20619	20799	{
20620	20800	/CALLEND/
20621	20801	stackbase += 18LLU;
20622		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA75LLU;
	20802	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA69LLU;
20623	20803	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
20624	20804	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
20625	20805	break;
20626	20806	}
20627		-case 0xFFFFFFFFFFFFFA75LLU:
	20807	+case 0xFFFFFFFFFFFFFA69LLU:
20628	20808	/* SP = 16LLU // SP = 9LLU // SP = 9LLU */
20629		-{ /* JUMP / fnaddr = 18446744073709550212LLU; break; } / skip alternative */
20630		-case 18446744073709550213LLU: /* alternative */
	20809	+{ /* JUMP / fnaddr = 18446744073709550200LLU; break; } / skip alternative */
	20810	+case 18446744073709550201LLU: /* alternative */
20631	20811	{
20632	20812	/* CALLBEGIN */
20633	20813	/* reserve space for 1LLU returned values // SP + 1LLU = 10LLU */

		@@ -20638,12 +20818,12 @@
20638	20818	{
20639	20819	/CALLEND/
20640	20820	stackbase += 12LLU;
20641		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA74LLU;
	20821	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA68LLU;
20642	20822	fnaddr = /parsestype/0xADCB6E82EBF4AE00LLU;/* SP = 0LLU */
20643	20823	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestype/\n"); exit(-1); }
20644	20824	break;
20645	20825	}
20646		-case 0xFFFFFFFFFFFFFA74LLU:
	20826	+case 0xFFFFFFFFFFFFFA68LLU:
20647	20827	/* SP = 10LLU // SP = 9LLU */
20648	20828	{ /* assign / / LOCAL VAR / stack[stackbase + 4LLU] = / LOCAL VAR */ stack[stackbase + 9LLU]; }
20649	20829	{

		@@ -20655,12 +20835,12 @@
20655	20835	{
20656	20836	/CALLEND/
20657	20837	stackbase += 11LLU;
20658		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA73LLU;
	20838	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA67LLU;
20659	20839	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20660	20840	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20661	20841	break;
20662	20842	}
20663		-case 0xFFFFFFFFFFFFFA73LLU:
	20843	+case 0xFFFFFFFFFFFFFA67LLU:
20664	20844	/* SP = 9LLU */
20665	20845	{
20666	20846	/* CALLBEGIN */

		@@ -20671,12 +20851,12 @@
20671	20851	{
20672	20852	/CALLEND/
20673	20853	stackbase += 12LLU;
20674		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA72LLU;
	20854	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA66LLU;
20675	20855	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
20676	20856	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
20677	20857	break;
20678	20858	}
20679		-case 0xFFFFFFFFFFFFFA72LLU:
	20859	+case 0xFFFFFFFFFFFFFA66LLU:
20680	20860	/* SP = 10LLU // SP = 9LLU */
20681	20861	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR / stack[stackbase + 9LLU]; }/ predicate */
20682	20862

		@@ -20691,15 +20871,15 @@
20691	20871	{
20692	20872	/CALLEND/
20693	20873	stackbase += 12LLU;
20694		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA70LLU;
	20874	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA64LLU;
20695	20875	fnaddr = /existsdef_/0x83392EBEE7E08400LLU;/* SP = 0LLU */
20696	20876	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsdef_/\n"); exit(-1); }
20697	20877	break;
20698	20878	}
20699		-case 0xFFFFFFFFFFFFFA70LLU:
	20879	+case 0xFFFFFFFFFFFFFA64LLU:
20700	20880	/* SP = 10LLU */
20701	20881	if(!/* SP - 1LLU = 9LLU */stack[stackbase + 9LLU])
20702		-{ /* JUMP / fnaddr = 18446744073709550193LLU; break; } / skip consequent */
	20882	+{ /* JUMP / fnaddr = 18446744073709550181LLU; break; } / skip consequent */
20703	20883	/* consequent */
20704	20884	{
20705	20885	/* CALLBEGIN */

		@@ -20710,12 +20890,12 @@
20710	20890	{
20711	20891	/CALLEND/
20712	20892	stackbase += 11LLU;
20713		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6FLLU;
	20893	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA63LLU;
20714	20894	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
20715	20895	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
20716	20896	break;
20717	20897	}
20718		-case 0xFFFFFFFFFFFFFA6FLLU:
	20898	+case 0xFFFFFFFFFFFFFA63LLU:
20719	20899	/* SP = 9LLU */fputs("redefinition of function ", stderr);
20720	20900	{
20721	20901	/* CALLBEGIN */

		@@ -20727,14 +20907,14 @@
20727	20907	{
20728	20908	/CALLEND/
20729	20909	stackbase += 11LLU;
20730		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6ELLU;
	20910	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA62LLU;
20731	20911	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
20732	20912	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
20733	20913	break;
20734	20914	}
20735		-case 0xFFFFFFFFFFFFFA6ELLU:
	20915	+case 0xFFFFFFFFFFFFFA62LLU:
20736	20916	/* SP = 9LLU /exit(-1);/ SP = 9LLU */
20737		-case 18446744073709550193LLU: /* alternative */fputs("\ncase ", stdout);
	20917	+case 18446744073709550181LLU: /* alternative */fputs("\ncase ", stdout);
20738	20918	{
20739	20919	/* CALLBEGIN */
20740	20920	/* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */

		@@ -20758,33 +20938,33 @@
20758	20938	{
20759	20939	/CALLEND/
20760	20940	stackbase += 17LLU;
20761		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6DLLU;
	20941	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA61LLU;
20762	20942	fnaddr = /div_______/0x7E4C400000000000LLU;/* SP = 0LLU */
20763	20943	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /div_______/\n"); exit(-1); }
20764	20944	break;
20765	20945	}
20766		-case 0xFFFFFFFFFFFFFA6DLLU:
	20946	+case 0xFFFFFFFFFFFFFA61LLU:
20767	20947	/* SP = 15LLU */
20768	20948	{ /* PUSH / stack[stackbase + 15LLU] = 16LLU; }/ SP + 1LLU = 16LLU */
20769	20949	{
20770	20950	/CALLEND/
20771	20951	stackbase += 14LLU;
20772		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6CLLU;
	20952	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA60LLU;
20773	20953	fnaddr = /mul_______/0xA309C00000000000LLU;/* SP = 0LLU */
20774	20954	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /mul_______/\n"); exit(-1); }
20775	20955	break;
20776	20956	}
20777		-case 0xFFFFFFFFFFFFFA6CLLU:
	20957	+case 0xFFFFFFFFFFFFFA60LLU:
20778	20958	/* SP = 12LLU */
20779	20959	{
20780	20960	/CALLEND/
20781	20961	stackbase += 11LLU;
20782		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6BLLU;
	20962	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5FLLU;
20783	20963	fnaddr = /printid___/0xAED929BE47C00000LLU;/* SP = 0LLU */
20784	20964	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printid___/\n"); exit(-1); }
20785	20965	break;
20786	20966	}
20787		-case 0xFFFFFFFFFFFFFA6BLLU:
	20967	+case 0xFFFFFFFFFFFFFA5FLLU:
20788	20968	/* SP = 9LLU */fputs(":", stdout);
20789	20969	{
20790	20970	/* CALLBEGIN */

		@@ -20795,12 +20975,12 @@
20795	20975	{
20796	20976	/CALLEND/
20797	20977	stackbase += 11LLU;
20798		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA6ALLU;
	20978	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5ELLU;
20799	20979	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
20800	20980	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
20801	20981	break;
20802	20982	}
20803		-case 0xFFFFFFFFFFFFFA6ALLU:
	20983	+case 0xFFFFFFFFFFFFFA5ELLU:
20804	20984	/* SP = 9LLU */
20805	20985	{
20806	20986	/* CALLBEGIN */

		@@ -20812,12 +20992,12 @@
20812	20992	{
20813	20993	/CALLEND/
20814	20994	stackbase += 11LLU;
20815		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA69LLU;
	20995	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5DLLU;
20816	20996	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
20817	20997	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
20818	20998	break;
20819	20999	}
20820		-case 0xFFFFFFFFFFFFFA69LLU:
	21000	+case 0xFFFFFFFFFFFFFA5DLLU:
20821	21001	/* SP = 9LLU */
20822	21002	{
20823	21003	/* CALLBEGIN */

		@@ -20836,19 +21016,19 @@
20836	21016	{
20837	21017	/CALLEND/
20838	21018	stackbase += 11LLU;
20839		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA68LLU;
	21019	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5CLLU;
20840	21020	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
20841	21021	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
20842	21022	break;
20843	21023	}
20844		-case 0xFFFFFFFFFFFFFA68LLU:
	21024	+case 0xFFFFFFFFFFFFFA5CLLU:
20845	21025	/* SP = 9LLU // SP = 9LLU */
20846		-case 18446744073709550212LLU: /* skip to here */
	21026	+case 18446744073709550200LLU: /* skip to here */
20847	21027
20848		-case 18446744073709550226LLU: /* skip to here */
	21028	+case 18446744073709550214LLU: /* skip to here */
20849	21029	/* SP = 8LLU // SP = 8LLU */
20850		-{ /* JUMP / fnaddr = 18446744073709550232LLU; break; } / skip alternative */
20851		-case 18446744073709550233LLU: /* alternative */
	21030	+{ /* JUMP / fnaddr = 18446744073709550220LLU; break; } / skip alternative */
	21031	+case 18446744073709550221LLU: /* alternative */
20852	21032	{
20853	21033	/* CALLBEGIN */
20854	21034	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -20858,12 +21038,12 @@
20858	21038	{
20859	21039	/CALLEND/
20860	21040	stackbase += 10LLU;
20861		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA67LLU;
	21041	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5BLLU;
20862	21042	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
20863	21043	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
20864	21044	break;
20865	21045	}
20866		-case 0xFFFFFFFFFFFFFA67LLU:
	21046	+case 0xFFFFFFFFFFFFFA5BLLU:
20867	21047	/* SP = 8LLU */fputs("expected function definition but found unexpected ", stderr);
20868	21048	{
20869	21049	/* CALLBEGIN */

		@@ -20880,22 +21060,22 @@
20880	21060	{
20881	21061	/CALLEND/
20882	21062	stackbase += 13LLU;
20883		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA66LLU;
	21063	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5ALLU;
20884	21064	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
20885	21065	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
20886	21066	break;
20887	21067	}
20888		-case 0xFFFFFFFFFFFFFA66LLU:
	21068	+case 0xFFFFFFFFFFFFFA5ALLU:
20889	21069	/* SP = 11LLU */
20890	21070	{
20891	21071	/CALLEND/
20892	21072	stackbase += 10LLU;
20893		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA65LLU;
	21073	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA59LLU;
20894	21074	fnaddr = /debugchar_/0x7E077089E8DCB400LLU;/* SP = 0LLU */
20895	21075	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugchar_/\n"); exit(-1); }
20896	21076	break;
20897	21077	}
20898		-case 0xFFFFFFFFFFFFFA65LLU:
	21078	+case 0xFFFFFFFFFFFFFA59LLU:
20899	21079	/* SP = 8LLU */fputs(" (", stderr);
20900	21080	{
20901	21081	/* CALLBEGIN */

		@@ -20912,27 +21092,27 @@
20912	21092	{
20913	21093	/CALLEND/
20914	21094	stackbase += 13LLU;
20915		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA64LLU;
	21095	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA58LLU;
20916	21096	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
20917	21097	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
20918	21098	break;
20919	21099	}
20920		-case 0xFFFFFFFFFFFFFA64LLU:
	21100	+case 0xFFFFFFFFFFFFFA58LLU:
20921	21101	/* SP = 11LLU */
20922	21102	{
20923	21103	/CALLEND/
20924	21104	stackbase += 10LLU;
20925		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA63LLU;
	21105	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA57LLU;
20926	21106	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
20927	21107	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
20928	21108	break;
20929	21109	}
20930		-case 0xFFFFFFFFFFFFFA63LLU:
	21110	+case 0xFFFFFFFFFFFFFA57LLU:
20931	21111	/* SP = 8LLU /fputs(")\n", stderr); exit(-1);/ SP = 8LLU */
20932		-case 18446744073709550232LLU: /* skip to here */
	21112	+case 18446744073709550220LLU: /* skip to here */
20933	21113	/* SP = 8LLU // SP = 8LLU */
20934		-{ /* JUMP / fnaddr = 18446744073709550236LLU; break; } / skip alternative */
20935		-case 18446744073709550237LLU: /* alternative */
	21114	+{ /* JUMP / fnaddr = 18446744073709550224LLU; break; } / skip alternative */
	21115	+case 18446744073709550225LLU: /* alternative */
20936	21116	{ /* PUSH / stack[stackbase + 8LLU] = 11657894190401978368LLU; }/ SP + 1LLU = 9LLU */
20937	21117	{
20938	21118	/* CALLBEGIN */

		@@ -20945,12 +21125,12 @@
20945	21125	{
20946	21126	/CALLEND/
20947	21127	stackbase += 14LLU;
20948		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA62LLU;
	21128	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA56LLU;
20949	21129	fnaddr = /finddef___/0x864A5F7E08400000LLU;/* SP = 0LLU */
20950	21130	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /finddef___/\n"); exit(-1); }
20951	21131	break;
20952	21132	}
20953		-case 0xFFFFFFFFFFFFFA62LLU:
	21133	+case 0xFFFFFFFFFFFFFA56LLU:
20954	21134	/* SP = 12LLU */fputs("\ncase ", stdout);
20955	21135	{
20956	21136	/* CALLBEGIN */

		@@ -20962,12 +21142,12 @@
20962	21142	{
20963	21143	/CALLEND/
20964	21144	stackbase += 14LLU;
20965		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA61LLU;
	21145	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA55LLU;
20966	21146	fnaddr = /printhexnr/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
20967	21147	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printhexnr/\n"); exit(-1); }
20968	21148	break;
20969	21149	}
20970		-case 0xFFFFFFFFFFFFFA61LLU:
	21150	+case 0xFFFFFFFFFFFFFA55LLU:
20971	21151	/* SP = 12LLU */fputs(":", stdout);
20972	21152	{
20973	21153	/* CALLBEGIN */

		@@ -20980,12 +21160,12 @@
20980	21160	{
20981	21161	/CALLEND/
20982	21162	stackbase += 14LLU;
20983		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA60LLU;
	21163	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA54LLU;
20984	21164	fnaddr = /STACKCHECK/0x4D40432C32050CB0LLU;/* SP = 0LLU */
20985	21165	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /STACKCHECK/\n"); exit(-1); }
20986	21166	break;
20987	21167	}
20988		-case 0xFFFFFFFFFFFFFA60LLU:
	21168	+case 0xFFFFFFFFFFFFFA54LLU:
20989	21169	/* SP = 12LLU */
20990	21170	{
20991	21171	/* CALLBEGIN */

		@@ -20997,17 +21177,17 @@
20997	21177	{
20998	21178	/CALLEND/
20999	21179	stackbase += 14LLU;
21000		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5FLLU;
	21180	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA53LLU;
21001	21181	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
21002	21182	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); }
21003	21183	break;
21004	21184	}
21005		-case 0xFFFFFFFFFFFFFA5FLLU:
	21185	+case 0xFFFFFFFFFFFFFA53LLU:
21006	21186	/* SP = 12LLU // SP = 8LLU */
21007		-case 18446744073709550236LLU: /* skip to here */
	21187	+case 18446744073709550224LLU: /* skip to here */
21008	21188	/* SP = 8LLU // SP = 8LLU */
21009		-{ /* JUMP / fnaddr = 18446744073709550240LLU; break; } / skip alternative */
21010		-case 18446744073709550241LLU: /* alternative */
	21189	+{ /* JUMP / fnaddr = 18446744073709550228LLU; break; } / skip alternative */
	21190	+case 18446744073709550229LLU: /* alternative */
21011	21191	{
21012	21192	/* CALLBEGIN */
21013	21193	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -21017,12 +21197,12 @@
21017	21197	{
21018	21198	/CALLEND/
21019	21199	stackbase += 10LLU;
21020		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5ELLU;
	21200	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA52LLU;
21021	21201	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
21022	21202	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
21023	21203	break;
21024	21204	}
21025		-case 0xFFFFFFFFFFFFFA5ELLU:
	21205	+case 0xFFFFFFFFFFFFFA52LLU:
21026	21206	/* SP = 8LLU // predicate */
21027	21207
21028	21208	{

		@@ -21040,26 +21220,26 @@
21040	21220	{
21041	21221	/CALLEND/
21042	21222	stackbase += 14LLU;
21043		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5BLLU;
	21223	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4FLLU;
21044	21224	fnaddr = /peek______/0xAE08260000000000LLU;/* SP = 0LLU */
21045	21225	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /peek______/\n"); exit(-1); }
21046	21226	break;
21047	21227	}
21048		-case 0xFFFFFFFFFFFFFA5BLLU:
	21228	+case 0xFFFFFFFFFFFFFA4FLLU:
21049	21229	/* SP = 12LLU */
21050	21230	{ /* PUSH / stack[stackbase + 12LLU] = 255LLU; }/ SP + 1LLU = 13LLU */
21051	21231	{
21052	21232	/CALLEND/
21053	21233	stackbase += 11LLU;
21054		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA5ALLU;
	21234	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4ELLU;
21055	21235	fnaddr = /leq_______/0x9E0B000000000000LLU;/* SP = 0LLU */
21056	21236	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /leq_______/\n"); exit(-1); }
21057	21237	break;
21058	21238	}
21059		-case 0xFFFFFFFFFFFFFA5ALLU:
	21239	+case 0xFFFFFFFFFFFFFA4ELLU:
21060	21240	/* SP = 9LLU */
21061	21241	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
21062		-{ /* JUMP / fnaddr = 18446744073709550173LLU; break; } / skip consequent */
	21242	+{ /* JUMP / fnaddr = 18446744073709550161LLU; break; } / skip consequent */
21063	21243	/* consequent // predicate */
21064	21244
21065	21245	{

		@@ -21078,25 +21258,25 @@
21078	21258	{
21079	21259	/CALLEND/
21080	21260	stackbase += 14LLU;
21081		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA57LLU;
	21261	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4BLLU;
21082	21262	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
21083	21263	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
21084	21264	break;
21085	21265	}
21086		-case 0xFFFFFFFFFFFFFA57LLU:
	21266	+case 0xFFFFFFFFFFFFFA4BLLU:
21087	21267	/* SP = 12LLU */
21088	21268	{
21089	21269	/CALLEND/
21090	21270	stackbase += 11LLU;
21091		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA56LLU;
	21271	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4ALLU;
21092	21272	fnaddr = /not_______/0xA6ABC00000000000LLU;/* SP = 0LLU */
21093	21273	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /not_______/\n"); exit(-1); }
21094	21274	break;
21095	21275	}
21096		-case 0xFFFFFFFFFFFFFA56LLU:
	21276	+case 0xFFFFFFFFFFFFFA4ALLU:
21097	21277	/* SP = 9LLU */
21098	21278	if(!/* SP - 1LLU = 8LLU */stack[stackbase + 8LLU])
21099		-{ /* JUMP / fnaddr = 18446744073709550169LLU; break; } / skip consequent */
	21279	+{ /* JUMP / fnaddr = 18446744073709550157LLU; break; } / skip consequent */
21100	21280	/* consequent */
21101	21281	{ /* PUSH / stack[stackbase + 8LLU] = 0LLU; }/ SP + 1LLU = 9LLU */
21102	21282	{ /* PUSH / stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU */

		@@ -21115,12 +21295,12 @@
21115	21295	{
21116	21296	/CALLEND/
21117	21297	stackbase += 15LLU;
21118		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA55LLU;
	21298	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA49LLU;
21119	21299	fnaddr = /parsetype_/0xADCB6E82FD2B8000LLU;/* SP = 0LLU */
21120	21300	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetype_/\n"); exit(-1); }
21121	21301	break;
21122	21302	}
21123		-case 0xFFFFFFFFFFFFFA55LLU:
	21303	+case 0xFFFFFFFFFFFFFA49LLU:
21124	21304	/* SP = 13LLU // SP = 12LLU */
21125	21305	{ /* assign / / LOCAL VAR / stack[stackbase + 10LLU] = / LOCAL VAR */ stack[stackbase + 12LLU]; }
21126	21306	{ /* PUSH / stack[stackbase + 12LLU] = 0LLU; }/ SP + 1LLU = 13LLU // SP = 12LLU */

		@@ -21142,12 +21322,12 @@
21142	21322	{
21143	21323	/CALLEND/
21144	21324	stackbase += 18LLU;
21145		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA53LLU;
	21325	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA47LLU;
21146	21326	fnaddr = /isstruct__/0x92EBAFB707AF0000LLU;/* SP = 0LLU */
21147	21327	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /isstruct__/\n"); exit(-1); }
21148	21328	break;
21149	21329	}
21150		-case 0xFFFFFFFFFFFFFA53LLU:
	21330	+case 0xFFFFFFFFFFFFFA47LLU:
21151	21331	/* SP = 16LLU */
21152	21332	{
21153	21333	/* CALLBEGIN */

		@@ -21159,25 +21339,25 @@
21159	21339	{
21160	21340	/CALLEND/
21161	21341	stackbase += 19LLU;
21162		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA52LLU;
	21342	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA46LLU;
21163	21343	fnaddr = /typeislist/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
21164	21344	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeislist/\n"); exit(-1); }
21165	21345	break;
21166	21346	}
21167		-case 0xFFFFFFFFFFFFFA52LLU:
	21347	+case 0xFFFFFFFFFFFFFA46LLU:
21168	21348	/* SP = 17LLU */
21169	21349	{
21170	21350	/CALLEND/
21171	21351	stackbase += 15LLU;
21172		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA51LLU;
	21352	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA45LLU;
21173	21353	fnaddr = /and_______/0x7297C00000000000LLU;/* SP = 0LLU */
21174	21354	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /and_______/\n"); exit(-1); }
21175	21355	break;
21176	21356	}
21177		-case 0xFFFFFFFFFFFFFA51LLU:
	21357	+case 0xFFFFFFFFFFFFFA45LLU:
21178	21358	/* SP = 13LLU */
21179	21359	if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU])
21180		-{ /* JUMP / fnaddr = 18446744073709550164LLU; break; } / skip consequent */
	21360	+{ /* JUMP / fnaddr = 18446744073709550152LLU; break; } / skip consequent */
21181	21361	/* consequent */
21182	21362	{
21183	21363	/* CALLBEGIN */

		@@ -21188,12 +21368,12 @@
21188	21368	{
21189	21369	/CALLEND/
21190	21370	stackbase += 14LLU;
21191		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA50LLU;
	21371	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA44LLU;
21192	21372	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
21193	21373	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
21194	21374	break;
21195	21375	}
21196		-case 0xFFFFFFFFFFFFFA50LLU:
	21376	+case 0xFFFFFFFFFFFFFA44LLU:
21197	21377	/* SP = 12LLU */fputs("in parameter ", stderr);
21198	21378	{
21199	21379	/* CALLBEGIN */

		@@ -21205,12 +21385,12 @@
21205	21385	{
21206	21386	/CALLEND/
21207	21387	stackbase += 14LLU;
21208		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4FLLU;
	21388	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA43LLU;
21209	21389	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
21210	21390	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
21211	21391	break;
21212	21392	}
21213		-case 0xFFFFFFFFFFFFFA4FLLU:
	21393	+case 0xFFFFFFFFFFFFFA43LLU:
21214	21394	/* SP = 12LLU */fputs(" of struct ", stderr);
21215	21395	{
21216	21396	/* CALLBEGIN */

		@@ -21222,14 +21402,14 @@
21222	21402	{
21223	21403	/CALLEND/
21224	21404	stackbase += 14LLU;
21225		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4ELLU;
	21405	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA42LLU;
21226	21406	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
21227	21407	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
21228	21408	break;
21229	21409	}
21230		-case 0xFFFFFFFFFFFFFA4ELLU:
	21410	+case 0xFFFFFFFFFFFFFA42LLU:
21231	21411	/* SP = 12LLU /fputs(": structs cannot contain lists (yet)\n", stderr); exit(-1);/ SP = 12LLU */
21232		-case 18446744073709550164LLU: /* alternative */
	21412	+case 18446744073709550152LLU: /* alternative */
21233	21413	{
21234	21414	/* CALLBEGIN */
21235	21415	/* reserve space for 0LLU returned values // SP + 0LLU = 12LLU */

		@@ -21239,12 +21419,12 @@
21239	21419	{
21240	21420	/CALLEND/
21241	21421	stackbase += 14LLU;
21242		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4DLLU;
	21422	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA41LLU;
21243	21423	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
21244	21424	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
21245	21425	break;
21246	21426	}
21247		-case 0xFFFFFFFFFFFFFA4DLLU:
	21427	+case 0xFFFFFFFFFFFFFA41LLU:
21248	21428	/* SP = 12LLU // predicate */
21249	21429
21250	21430	{

		@@ -21257,15 +21437,15 @@
21257	21437	{
21258	21438	/CALLEND/
21259	21439	stackbase += 15LLU;
21260		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA4ALLU;
	21440	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3ELLU;
21261	21441	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
21262	21442	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
21263	21443	break;
21264	21444	}
21265		-case 0xFFFFFFFFFFFFFA4ALLU:
	21445	+case 0xFFFFFFFFFFFFFA3ELLU:
21266	21446	/* SP = 13LLU */
21267	21447	if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU])
21268		-{ /* JUMP / fnaddr = 18446744073709550156LLU; break; } / skip consequent */
	21448	+{ /* JUMP / fnaddr = 18446744073709550144LLU; break; } / skip consequent */
21269	21449	/* consequent */
21270	21450	{
21271	21451	/* CALLBEGIN */

		@@ -21276,12 +21456,12 @@
21276	21456	{
21277	21457	/CALLEND/
21278	21458	stackbase += 14LLU;
21279		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA49LLU;
	21459	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3DLLU;
21280	21460	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
21281	21461	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
21282	21462	break;
21283	21463	}
21284		-case 0xFFFFFFFFFFFFFA49LLU:
	21464	+case 0xFFFFFFFFFFFFFA3DLLU:
21285	21465	/* SP = 12LLU // predicate */
21286	21466
21287	21467	{

		@@ -21299,26 +21479,26 @@
21299	21479	{
21300	21480	/CALLEND/
21301	21481	stackbase += 18LLU;
21302		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA47LLU;
	21482	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3BLLU;
21303	21483	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
21304	21484	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
21305	21485	break;
21306	21486	}
21307		-case 0xFFFFFFFFFFFFFA47LLU:
	21487	+case 0xFFFFFFFFFFFFFA3BLLU:
21308	21488	/* SP = 16LLU */
21309	21489	{ /* PUSH / stack[stackbase + 16LLU] = / LOCAL VAR / stack[stackbase + 5LLU]; }/ SP + 1LLU = 17LLU */
21310	21490	{
21311	21491	/CALLEND/
21312	21492	stackbase += 15LLU;
21313		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA46LLU;
	21493	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3ALLU;
21314	21494	fnaddr = /neq_______/0xA60B000000000000LLU;/* SP = 0LLU */
21315	21495	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /neq_______/\n"); exit(-1); }
21316	21496	break;
21317	21497	}
21318		-case 0xFFFFFFFFFFFFFA46LLU:
	21498	+case 0xFFFFFFFFFFFFFA3ALLU:
21319	21499	/* SP = 13LLU */
21320	21500	if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU])
21321		-{ /* JUMP / fnaddr = 18446744073709550152LLU; break; } / skip consequent */
	21501	+{ /* JUMP / fnaddr = 18446744073709550140LLU; break; } / skip consequent */
21322	21502	/* consequent */
21323	21503	{
21324	21504	/* CALLBEGIN */

		@@ -21329,12 +21509,12 @@
21329	21509	{
21330	21510	/CALLEND/
21331	21511	stackbase += 14LLU;
21332		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA45LLU;
	21512	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA39LLU;
21333	21513	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
21334	21514	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
21335	21515	break;
21336	21516	}
21337		-case 0xFFFFFFFFFFFFFA45LLU:
	21517	+case 0xFFFFFFFFFFFFFA39LLU:
21338	21518	/* SP = 12LLU */fputs("expected parameter ", stderr);
21339	21519	{
21340	21520	/* CALLBEGIN */

		@@ -21346,16 +21526,16 @@
21346	21526	{
21347	21527	/CALLEND/
21348	21528	stackbase += 14LLU;
21349		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA44LLU;
	21529	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA38LLU;
21350	21530	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
21351	21531	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
21352	21532	break;
21353	21533	}
21354		-case 0xFFFFFFFFFFFFFA44LLU:
	21534	+case 0xFFFFFFFFFFFFFA38LLU:
21355	21535	/* SP = 12LLU /fputs("\n", stderr); exit(-1);/ SP = 12LLU */
21356		-case 18446744073709550152LLU: /* alternative // SP = 12LLU // SP = 12LLU */
21357		-{ /* JUMP / fnaddr = 18446744073709550155LLU; break; } / skip alternative */
21358		-case 18446744073709550156LLU: /* alternative */
	21536	+case 18446744073709550140LLU: /* alternative // SP = 12LLU // SP = 12LLU */
	21537	+{ /* JUMP / fnaddr = 18446744073709550143LLU; break; } / skip alternative */
	21538	+case 18446744073709550144LLU: /* alternative */
21359	21539	{
21360	21540	/* CALLBEGIN */
21361	21541	/* reserve space for 1LLU returned values // SP + 1LLU = 13LLU */

		@@ -21365,12 +21545,12 @@
21365	21545	{
21366	21546	/CALLEND/
21367	21547	stackbase += 15LLU;
21368		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA43LLU;
	21548	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA37LLU;
21369	21549	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
21370	21550	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); }
21371	21551	break;
21372	21552	}
21373		-case 0xFFFFFFFFFFFFFA43LLU:
	21553	+case 0xFFFFFFFFFFFFFA37LLU:
21374	21554	/* SP = 13LLU // SP = 12LLU */
21375	21555	{ /* assign / / LOCAL VAR / stack[stackbase + 8LLU] = / LOCAL VAR / stack[stackbase + 12LLU]; }/ predicate */
21376	21556

		@@ -21385,15 +21565,15 @@
21385	21565	{
21386	21566	/CALLEND/
21387	21567	stackbase += 15LLU;
21388		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA41LLU;
	21568	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA35LLU;
21389	21569	fnaddr = /existsvar_/0x83392EBEEC5CB400LLU;/* SP = 0LLU */
21390	21570	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsvar_/\n"); exit(-1); }
21391	21571	break;
21392	21572	}
21393		-case 0xFFFFFFFFFFFFFA41LLU:
	21573	+case 0xFFFFFFFFFFFFFA35LLU:
21394	21574	/* SP = 13LLU */
21395	21575	if(!/* SP - 1LLU = 12LLU */stack[stackbase + 12LLU])
21396		-{ /* JUMP / fnaddr = 18446744073709550146LLU; break; } / skip consequent */
	21576	+{ /* JUMP / fnaddr = 18446744073709550134LLU; break; } / skip consequent */
21397	21577	/* consequent */
21398	21578	{
21399	21579	/* CALLBEGIN */

		@@ -21404,12 +21584,12 @@
21404	21584	{
21405	21585	/CALLEND/
21406	21586	stackbase += 14LLU;
21407		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA40LLU;
	21587	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA34LLU;
21408	21588	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
21409	21589	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
21410	21590	break;
21411	21591	}
21412		-case 0xFFFFFFFFFFFFFA40LLU:
	21592	+case 0xFFFFFFFFFFFFFA34LLU:
21413	21593	/* SP = 12LLU */fputs("re-definition of parameter ", stderr);
21414	21594	{
21415	21595	/* CALLBEGIN */

		@@ -21421,15 +21601,15 @@
21421	21601	{
21422	21602	/CALLEND/
21423	21603	stackbase += 14LLU;
21424		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3FLLU;
	21604	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA33LLU;
21425	21605	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
21426	21606	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
21427	21607	break;
21428	21608	}
21429		-case 0xFFFFFFFFFFFFFA3FLLU:
	21609	+case 0xFFFFFFFFFFFFFA33LLU:
21430	21610	/* SP = 12LLU /fputs("\n", stderr); exit(-1);/ SP = 12LLU */
21431		-case 18446744073709550146LLU: /* alternative // SP = 12LLU */
21432		-case 18446744073709550155LLU: /* skip to here */
	21611	+case 18446744073709550134LLU: /* alternative // SP = 12LLU */
	21612	+case 18446744073709550143LLU: /* skip to here */
21433	21613
21434	21614	{
21435	21615	/* CALLBEGIN */

		@@ -21442,12 +21622,12 @@
21442	21622	{
21443	21623	/CALLEND/
21444	21624	stackbase += 15LLU;
21445		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3ELLU;
	21625	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA32LLU;
21446	21626	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
21447	21627	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
21448	21628	break;
21449	21629	}
21450		-case 0xFFFFFFFFFFFFFA3ELLU:
	21630	+case 0xFFFFFFFFFFFFFA32LLU:
21451	21631	/* SP = 13LLU // SP = 12LLU */
21452	21632	{ /* assign / / LOCAL VAR / stack[stackbase + 5LLU] = / LOCAL VAR */ stack[stackbase + 12LLU]; }
21453	21633	{

		@@ -21468,22 +21648,22 @@
21468	21648	{
21469	21649	/CALLEND/
21470	21650	stackbase += 19LLU;
21471		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3DLLU;
	21651	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA31LLU;
21472	21652	fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
21473	21653	if(stackbase + 14LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); }
21474	21654	break;
21475	21655	}
21476		-case 0xFFFFFFFFFFFFFA3DLLU:
	21656	+case 0xFFFFFFFFFFFFFA31LLU:
21477	21657	/* SP = 17LLU */
21478	21658	{
21479	21659	/CALLEND/
21480	21660	stackbase += 15LLU;
21481		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3CLLU;
	21661	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA30LLU;
21482	21662	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
21483	21663	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
21484	21664	break;
21485	21665	}
21486		-case 0xFFFFFFFFFFFFFA3CLLU:
	21666	+case 0xFFFFFFFFFFFFFA30LLU:
21487	21667	/* SP = 13LLU // SP = 12LLU */
21488	21668	{ /* assign / / LOCAL VAR / stack[stackbase + 6LLU] = / LOCAL VAR */ stack[stackbase + 12LLU]; }
21489	21669	{

		@@ -21495,12 +21675,12 @@
21495	21675	{
21496	21676	/CALLEND/
21497	21677	stackbase += 14LLU;
21498		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3BLLU;
	21678	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2FLLU;
21499	21679	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
21500	21680	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
21501	21681	break;
21502	21682	}
21503		-case 0xFFFFFFFFFFFFFA3BLLU:
	21683	+case 0xFFFFFFFFFFFFFA2FLLU:
21504	21684	/* SP = 12LLU */
21505	21685	{
21506	21686	/* CALLBEGIN */

		@@ -21512,12 +21692,12 @@
21512	21692	{
21513	21693	/CALLEND/
21514	21694	stackbase += 15LLU;
21515		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA3ALLU;
	21695	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2ELLU;
21516	21696	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
21517	21697	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
21518	21698	break;
21519	21699	}
21520		-case 0xFFFFFFFFFFFFFA3ALLU:
	21700	+case 0xFFFFFFFFFFFFFA2ELLU:
21521	21701	/* SP = 13LLU /(void)/ SP - 1LLU = 12LLU /stack[stackbase + 12LLU]; / POP */
21522	21702
21523	21703	{ /* PUSH / stack[stackbase + 12LLU] = (/ REF TO LINK / stackbase + 13LLU); }/ SP + 1LLU = 13LLU */

		@@ -21549,15 +21729,15 @@
21549	21729	{
21550	21730	/CALLEND/
21551	21731	stackbase += 26LLU;
21552		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA39LLU;
	21732	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2DLLU;
21553	21733	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
21554	21734	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
21555	21735	break;
21556	21736	}
21557		-case 0xFFFFFFFFFFFFFA39LLU:
	21737	+case 0xFFFFFFFFFFFFFA2DLLU:
21558	21738	/* SP = 24LLU // SP = 8LLU // SP = 8LLU */
21559		-{ /* JUMP / fnaddr = 18446744073709550168LLU; break; } / skip alternative */
21560		-case 18446744073709550169LLU: /* alternative */
	21739	+{ /* JUMP / fnaddr = 18446744073709550156LLU; break; } / skip alternative */
	21740	+case 18446744073709550157LLU: /* alternative */
21561	21741	{ /* PUSH / stack[stackbase + 8LLU] = 0LLU; }/ SP + 1LLU = 9LLU */
21562	21742	{ /* PUSH / stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU */
21563	21743	{ /* PUSH / stack[stackbase + 10LLU] = 0LLU; }/ SP + 1LLU = 11LLU */

		@@ -21573,12 +21753,12 @@
21573	21753	{
21574	21754	/CALLEND/
21575	21755	stackbase += 14LLU;
21576		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA38LLU;
	21756	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2CLLU;
21577	21757	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
21578	21758	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
21579	21759	break;
21580	21760	}
21581		-case 0xFFFFFFFFFFFFFA38LLU:
	21761	+case 0xFFFFFFFFFFFFFA2CLLU:
21582	21762	/* SP = 12LLU */
21583	21763	{
21584	21764	/* CALLBEGIN */

		@@ -21589,12 +21769,12 @@
21589	21769	{
21590	21770	/CALLEND/
21591	21771	stackbase += 15LLU;
21592		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA37LLU;
	21772	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2BLLU;
21593	21773	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
21594	21774	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
21595	21775	break;
21596	21776	}
21597		-case 0xFFFFFFFFFFFFFA37LLU:
	21777	+case 0xFFFFFFFFFFFFFA2BLLU:
21598	21778	/* SP = 13LLU // SP = 12LLU */
21599	21779	{ /* assign / / LOCAL VAR / stack[stackbase + 9LLU] = / LOCAL VAR */ stack[stackbase + 12LLU]; }
21600	21780	{ /* PUSH / stack[stackbase + 12LLU] = / LOCAL VAR / stack[stackbase + 4LLU]; }/ SP + 1LLU = 13LLU // SP = 12LLU */

		@@ -21618,15 +21798,15 @@
21618	21798	{
21619	21799	/CALLEND/
21620	21800	stackbase += 21LLU;
21621		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA34LLU;
	21801	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA28LLU;
21622	21802	fnaddr = /isunion___/0x92EC2992AA400000LLU;/* SP = 0LLU */
21623	21803	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /isunion___/\n"); exit(-1); }
21624	21804	break;
21625	21805	}
21626		-case 0xFFFFFFFFFFFFFA34LLU:
	21806	+case 0xFFFFFFFFFFFFFA28LLU:
21627	21807	/* SP = 19LLU */
21628	21808	if(!/* SP - 1LLU = 18LLU */stack[stackbase + 18LLU])
21629		-{ /* JUMP / fnaddr = 18446744073709550134LLU; break; } / skip consequent */
	21809	+{ /* JUMP / fnaddr = 18446744073709550122LLU; break; } / skip consequent */
21630	21810	/* consequent // predicate */
21631	21811
21632	21812	{

		@@ -21639,15 +21819,15 @@
21639	21819	{
21640	21820	/CALLEND/
21641	21821	stackbase += 21LLU;
21642		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA31LLU;
	21822	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA25LLU;
21643	21823	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
21644	21824	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); }
21645	21825	break;
21646	21826	}
21647		-case 0xFFFFFFFFFFFFFA31LLU:
	21827	+case 0xFFFFFFFFFFFFFA25LLU:
21648	21828	/* SP = 19LLU */
21649	21829	if(!/* SP - 1LLU = 18LLU */stack[stackbase + 18LLU])
21650		-{ /* JUMP / fnaddr = 18446744073709550131LLU; break; } / skip consequent */
	21830	+{ /* JUMP / fnaddr = 18446744073709550119LLU; break; } / skip consequent */
21651	21831	/* consequent */
21652	21832	{
21653	21833	/* CALLBEGIN */

		@@ -21659,12 +21839,12 @@
21659	21839	{
21660	21840	/CALLEND/
21661	21841	stackbase += 21LLU;
21662		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA30LLU;
	21842	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA24LLU;
21663	21843	fnaddr = /nameconstr/0xA5CA207AAA6EBED0LLU;/* SP = 0LLU */
21664	21844	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /nameconstr/\n"); exit(-1); }
21665	21845	break;
21666	21846	}
21667		-case 0xFFFFFFFFFFFFFA30LLU:
	21847	+case 0xFFFFFFFFFFFFFA24LLU:
21668	21848	/* SP = 19LLU // SP = 18LLU */
21669	21849	{ /* assign / / LOCAL VAR / stack[stackbase + 3LLU] = / LOCAL VAR */ stack[stackbase + 18LLU]; }
21670	21850	{ /* PUSH / stack[stackbase + 18LLU] = (/ REF TO LINK / stackbase + 19LLU); }/ SP + 1LLU = 19LLU */

		@@ -21678,12 +21858,12 @@
21678	21858	{
21679	21859	/CALLEND/
21680	21860	stackbase += 26LLU;
21681		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2FLLU;
	21861	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA23LLU;
21682	21862	fnaddr = /initconstr/0x92992F7AAA6EBED0LLU;/* SP = 0LLU */
21683	21863	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /initconstr/\n"); exit(-1); }
21684	21864	break;
21685	21865	}
21686		-case 0xFFFFFFFFFFFFFA2FLLU:
	21866	+case 0xFFFFFFFFFFFFFA23LLU:
21687	21867	/* SP = 24LLU */
21688	21868	{
21689	21869	/* CALLBEGIN */

		@@ -21709,25 +21889,25 @@
21709	21889	{
21710	21890	/CALLEND/
21711	21891	stackbase += 36LLU;
21712		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2ELLU;
	21892	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA22LLU;
21713	21893	fnaddr = /max_______/0xA1CCC00000000000LLU;/* SP = 0LLU */
21714	21894	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /max_______/\n"); exit(-1); }
21715	21895	break;
21716	21896	}
21717		-case 0xFFFFFFFFFFFFFA2ELLU:
	21897	+case 0xFFFFFFFFFFFFFA22LLU:
21718	21898	/* SP = 34LLU */
21719	21899	{
21720	21900	/CALLEND/
21721	21901	stackbase += 26LLU;
21722		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2DLLU;
	21902	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA21LLU;
21723	21903	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
21724	21904	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
21725	21905	break;
21726	21906	}
21727		-case 0xFFFFFFFFFFFFFA2DLLU:
	21907	+case 0xFFFFFFFFFFFFFA21LLU:
21728	21908	/* SP = 24LLU // SP = 18LLU // SP = 18LLU */
21729		-{ /* JUMP / fnaddr = 18446744073709550130LLU; break; } / skip alternative */
21730		-case 18446744073709550131LLU: /* alternative */
	21909	+{ /* JUMP / fnaddr = 18446744073709550118LLU; break; } / skip alternative */
	21910	+case 18446744073709550119LLU: /* alternative */
21731	21911	{ /* PUSH / stack[stackbase + 18LLU] = 0LLU; }/ SP + 1LLU = 19LLU */
21732	21912	{ /* PUSH / stack[stackbase + 19LLU] = 0LLU; }/ SP + 1LLU = 20LLU */
21733	21913	{ /* PUSH / stack[stackbase + 20LLU] = 0LLU; }/ SP + 1LLU = 21LLU */

		@@ -21748,22 +21928,22 @@
21748	21928	{
21749	21929	/CALLEND/
21750	21930	stackbase += 28LLU;
21751		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2CLLU;
	21931	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA20LLU;
21752	21932	fnaddr = /subtoid___/0xBB076FAA47C00000LLU;/* SP = 0LLU */
21753	21933	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtoid___/\n"); exit(-1); }
21754	21934	break;
21755	21935	}
21756		-case 0xFFFFFFFFFFFFFA2CLLU:
	21936	+case 0xFFFFFFFFFFFFFA20LLU:
21757	21937	/* SP = 26LLU */
21758	21938	{
21759	21939	/CALLEND/
21760	21940	stackbase += 25LLU;
21761		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2BLLU;
	21941	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1FLLU;
21762	21942	fnaddr = /markdata__/0xA1CB667DCBDC0000LLU;/* SP = 0LLU */
21763	21943	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /markdata__/\n"); exit(-1); }
21764	21944	break;
21765	21945	}
21766		-case 0xFFFFFFFFFFFFFA2BLLU:
	21946	+case 0xFFFFFFFFFFFFFA1FLLU:
21767	21947	/* SP = 23LLU // SP = 22LLU */
21768	21948	{ /* assign / / LOCAL VAR / stack[stackbase + 18LLU] = / LOCAL VAR */ stack[stackbase + 22LLU]; }
21769	21949	{ /* PUSH / stack[stackbase + 22LLU] = / LOCAL VAR / stack[stackbase + 7LLU]; }/ SP + 1LLU = 23LLU // SP = 22LLU */

		@@ -21795,17 +21975,17 @@
21795	21975	{
21796	21976	/CALLEND/
21797	21977	stackbase += 30LLU;
21798		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA2ALLU;
	21978	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1ELLU;
21799	21979	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
21800	21980	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
21801	21981	break;
21802	21982	}
21803		-case 0xFFFFFFFFFFFFFA2ALLU:
	21983	+case 0xFFFFFFFFFFFFFA1ELLU:
21804	21984	/* SP = 28LLU // SP = 18LLU */
21805		-case 18446744073709550130LLU: /* skip to here */
	21985	+case 18446744073709550118LLU: /* skip to here */
21806	21986	/* SP = 18LLU // SP = 18LLU */
21807		-{ /* JUMP / fnaddr = 18446744073709550133LLU; break; } / skip alternative */
21808		-case 18446744073709550134LLU: /* alternative // predicate */
	21987	+{ /* JUMP / fnaddr = 18446744073709550121LLU; break; } / skip alternative */
	21988	+case 18446744073709550122LLU: /* alternative // predicate */
21809	21989
21810	21990	{
21811	21991	/* CALLBEGIN */

		@@ -21817,15 +21997,15 @@
21817	21997	{
21818	21998	/CALLEND/
21819	21999	stackbase += 21LLU;
21820		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA28LLU;
	22000	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1CLLU;
21821	22001	fnaddr = /isclear___/0x92E7A781CB400000LLU;/* SP = 0LLU */
21822	22002	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /isclear___/\n"); exit(-1); }
21823	22003	break;
21824	22004	}
21825		-case 0xFFFFFFFFFFFFFA28LLU:
	22005	+case 0xFFFFFFFFFFFFFA1CLLU:
21826	22006	/* SP = 19LLU */
21827	22007	if(!/* SP - 1LLU = 18LLU */stack[stackbase + 18LLU])
21828		-{ /* JUMP / fnaddr = 18446744073709550121LLU; break; } / skip consequent */
	22008	+{ /* JUMP / fnaddr = 18446744073709550109LLU; break; } / skip consequent */
21829	22009	/* consequent */
21830	22010	{
21831	22011	/* CALLBEGIN */

		@@ -21836,12 +22016,12 @@
21836	22016	{
21837	22017	/CALLEND/
21838	22018	stackbase += 20LLU;
21839		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA27LLU;
	22019	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1BLLU;
21840	22020	fnaddr = /SPMAX_INIT/0x4D034160024E2540LLU;/* SP = 0LLU */
21841	22021	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_INIT/\n"); exit(-1); }
21842	22022	break;
21843	22023	}
21844		-case 0xFFFFFFFFFFFFFA27LLU:
	22024	+case 0xFFFFFFFFFFFFFA1BLLU:
21845	22025	/* SP = 18LLU */
21846	22026	{
21847	22027	/* CALLBEGIN */

		@@ -21853,12 +22033,12 @@
21853	22033	{
21854	22034	/CALLEND/
21855	22035	stackbase += 20LLU;
21856		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA26LLU;
	22036	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1ALLU;
21857	22037	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
21858	22038	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
21859	22039	break;
21860	22040	}
21861		-case 0xFFFFFFFFFFFFFA26LLU:
	22041	+case 0xFFFFFFFFFFFFFA1ALLU:
21862	22042	/* SP = 18LLU */
21863	22043	{
21864	22044	/* CALLBEGIN */

		@@ -21869,12 +22049,12 @@
21869	22049	{
21870	22050	/CALLEND/
21871	22051	stackbase += 20LLU;
21872		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA25LLU;
	22052	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA19LLU;
21873	22053	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
21874	22054	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); }
21875	22055	break;
21876	22056	}
21877		-case 0xFFFFFFFFFFFFFA25LLU:
	22057	+case 0xFFFFFFFFFFFFFA19LLU:
21878	22058	/* SP = 18LLU */
21879	22059	{
21880	22060	/* CALLBEGIN */

		@@ -21885,12 +22065,12 @@
21885	22065	{
21886	22066	/CALLEND/
21887	22067	stackbase += 21LLU;
21888		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA24LLU;
	22068	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA18LLU;
21889	22069	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
21890	22070	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); }
21891	22071	break;
21892	22072	}
21893		-case 0xFFFFFFFFFFFFFA24LLU:
	22073	+case 0xFFFFFFFFFFFFFA18LLU:
21894	22074	/* SP = 19LLU */
21895	22075	{
21896	22076	/* CALLBEGIN */

		@@ -21902,12 +22082,12 @@
21902	22082	{
21903	22083	/CALLEND/
21904	22084	stackbase += 21LLU;
21905		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA23LLU;
	22085	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA17LLU;
21906	22086	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
21907	22087	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); }
21908	22088	break;
21909	22089	}
21910		-case 0xFFFFFFFFFFFFFA23LLU:
	22090	+case 0xFFFFFFFFFFFFFA17LLU:
21911	22091	/* SP = 19LLU */
21912	22092	{
21913	22093	/* CALLBEGIN */

		@@ -21929,23 +22109,23 @@
21929	22109	{
21930	22110	/CALLEND/
21931	22111	stackbase += 28LLU;
21932		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA22LLU;
	22112	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA16LLU;
21933	22113	fnaddr = /encodeVAL_/0x8297AA7E05813000LLU;/* SP = 0LLU */
21934	22114	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /encodeVAL_/\n"); exit(-1); }
21935	22115	break;
21936	22116	}
21937		-case 0xFFFFFFFFFFFFFA22LLU:
	22117	+case 0xFFFFFFFFFFFFFA16LLU:
21938	22118	/* SP = 26LLU */
21939	22119	{ /* PUSH / stack[stackbase + 26LLU] = / LOCAL VAR / stack[stackbase + 18LLU]; }/ SP + 1LLU = 27LLU */
21940	22120	{
21941	22121	/CALLEND/
21942	22122	stackbase += 21LLU;
21943		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA21LLU;
	22123	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA15LLU;
21944	22124	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
21945	22125	if(stackbase + 33LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); }
21946	22126	break;
21947	22127	}
21948		-case 0xFFFFFFFFFFFFFA21LLU:
	22128	+case 0xFFFFFFFFFFFFFA15LLU:
21949	22129	/* SP = 19LLU */
21950	22130	{ /* PUSH / stack[stackbase + 19LLU] = 0LLU; }/ SP + 1LLU = 20LLU */
21951	22131	{

		@@ -21959,12 +22139,12 @@
21959	22139	{
21960	22140	/CALLEND/
21961	22141	stackbase += 23LLU;
21962		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA20LLU;
	22142	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA14LLU;
21963	22143	fnaddr = /subsize___/0xBB076E9358000000LLU;/* SP = 0LLU */
21964	22144	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subsize___/\n"); exit(-1); }
21965	22145	break;
21966	22146	}
21967		-case 0xFFFFFFFFFFFFFA20LLU:
	22147	+case 0xFFFFFFFFFFFFFA14LLU:
21968	22148	/* SP = 21LLU */
21969	22149	{
21970	22150	/* CALLBEGIN */

		@@ -21976,14 +22156,14 @@
21976	22156	{
21977	22157	/CALLEND/
21978	22158	stackbase += 23LLU;
21979		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1FLLU;
	22159	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA13LLU;
21980	22160	fnaddr = /SP_SUB____/0x4D00135420000000LLU;/* SP = 0LLU */
21981	22161	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SUB____/\n"); exit(-1); }
21982	22162	break;
21983	22163	}
21984		-case 0xFFFFFFFFFFFFFA1FLLU:
	22164	+case 0xFFFFFFFFFFFFFA13LLU:
21985	22165	/* SP = 21LLU */
21986		-case 0xFFFFFFFFFFFFFA1ELLU: /* loop to here // predicate */
	22166	+case 0xFFFFFFFFFFFFFA12LLU: /* loop to here // predicate */
21987	22167
21988	22168	{
21989	22169	/* CALLBEGIN */

		@@ -21996,15 +22176,15 @@
21996	22176	{
21997	22177	/CALLEND/
21998	22178	stackbase += 24LLU;
21999		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1CLLU;
	22179	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA10LLU;
22000	22180	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
22001	22181	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
22002	22182	break;
22003	22183	}
22004		-case 0xFFFFFFFFFFFFFA1CLLU:
	22184	+case 0xFFFFFFFFFFFFFA10LLU:
22005	22185	/* SP = 22LLU */
22006	22186	if(!/* SP - 1LLU = 21LLU */stack[stackbase + 21LLU])
22007		-{ /* JUMP / fnaddr = 18446744073709550109LLU; break; } / skip loop */
	22187	+{ /* JUMP / fnaddr = 18446744073709550097LLU; break; } / skip loop */
22008	22188	/* loop /fputs("\n{ / RESULT */", stdout);
22009	22189	{
22010	22190	/* CALLBEGIN */

		@@ -22036,43 +22216,43 @@
22036	22216	{
22037	22217	/CALLEND/
22038	22218	stackbase += 33LLU;
22039		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1BLLU;
	22219	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0FLLU;
22040	22220	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22041	22221	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22042	22222	break;
22043	22223	}
22044		-case 0xFFFFFFFFFFFFFA1BLLU:
	22224	+case 0xFFFFFFFFFFFFFA0FLLU:
22045	22225	/* SP = 31LLU */
22046	22226	{
22047	22227	/CALLEND/
22048	22228	stackbase += 29LLU;
22049		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA1ALLU;
	22229	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0ELLU;
22050	22230	fnaddr = /sub_______/0xBB07400000000000LLU;/* SP = 0LLU */
22051	22231	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /sub_______/\n"); exit(-1); }
22052	22232	break;
22053	22233	}
22054		-case 0xFFFFFFFFFFFFFA1ALLU:
	22234	+case 0xFFFFFFFFFFFFFA0ELLU:
22055	22235	/* SP = 27LLU */
22056	22236	{ /* PUSH / stack[stackbase + 27LLU] = / LOCAL VAR / stack[stackbase + 19LLU]; }/ SP + 1LLU = 28LLU */
22057	22237	{
22058	22238	/CALLEND/
22059	22239	stackbase += 26LLU;
22060		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA19LLU;
	22240	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0DLLU;
22061	22241	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22062	22242	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22063	22243	break;
22064	22244	}
22065		-case 0xFFFFFFFFFFFFFA19LLU:
	22245	+case 0xFFFFFFFFFFFFFA0DLLU:
22066	22246	/* SP = 24LLU */
22067	22247	{
22068	22248	/CALLEND/
22069	22249	stackbase += 23LLU;
22070		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA18LLU;
	22250	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0CLLU;
22071	22251	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
22072	22252	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
22073	22253	break;
22074	22254	}
22075		-case 0xFFFFFFFFFFFFFA18LLU:
	22255	+case 0xFFFFFFFFFFFFFA0CLLU:
22076	22256	/* SP = 21LLU */fputs(" = ", stdout);
22077	22257	{
22078	22258	/* CALLBEGIN */

		@@ -22091,22 +22271,22 @@
22091	22271	{
22092	22272	/CALLEND/
22093	22273	stackbase += 26LLU;
22094		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA17LLU;
	22274	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0BLLU;
22095	22275	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22096	22276	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22097	22277	break;
22098	22278	}
22099		-case 0xFFFFFFFFFFFFFA17LLU:
	22279	+case 0xFFFFFFFFFFFFFA0BLLU:
22100	22280	/* SP = 24LLU */
22101	22281	{
22102	22282	/CALLEND/
22103	22283	stackbase += 23LLU;
22104		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA16LLU;
	22284	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0ALLU;
22105	22285	fnaddr = /ACCESSVAR_/0x430C54D35814800LLU;/* SP = 0LLU */
22106	22286	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); }
22107	22287	break;
22108	22288	}
22109		-case 0xFFFFFFFFFFFFFA16LLU:
	22289	+case 0xFFFFFFFFFFFFFA0ALLU:
22110	22290	/* SP = 21LLU */fputs("; }", stdout);
22111	22291	{
22112	22292	/* CALLBEGIN */

		@@ -22119,16 +22299,16 @@
22119	22299	{
22120	22300	/CALLEND/
22121	22301	stackbase += 24LLU;
22122		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA15LLU;
	22302	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA09LLU;
22123	22303	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22124	22304	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22125	22305	break;
22126	22306	}
22127		-case 0xFFFFFFFFFFFFFA15LLU:
	22307	+case 0xFFFFFFFFFFFFFA09LLU:
22128	22308	/* SP = 22LLU // SP = 21LLU */
22129	22309	{ /* assign / / LOCAL VAR / stack[stackbase + 19LLU] = / LOCAL VAR / stack[stackbase + 21LLU]; }/ SP = 21LLU */
22130		-{ /* JUMP / fnaddr = 18446744073709550110LLU; break; } / loop */
22131		-case 18446744073709550109LLU: /* skip to here // SP = 18LLU */
	22310	+{ /* JUMP / fnaddr = 18446744073709550098LLU; break; } / loop */
	22311	+case 18446744073709550097LLU: /* skip to here // SP = 18LLU */
22132	22312	{
22133	22313	/* CALLBEGIN */
22134	22314	/* reserve space for 0LLU returned values // SP + 0LLU = 18LLU */

		@@ -22138,12 +22318,12 @@
22138	22318	{
22139	22319	/CALLEND/
22140	22320	stackbase += 20LLU;
22141		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA14LLU;
	22321	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA08LLU;
22142	22322	fnaddr = /RET_______/0x4855000000000000LLU;/* SP = 0LLU */
22143	22323	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /RET_______/\n"); exit(-1); }
22144	22324	break;
22145	22325	}
22146		-case 0xFFFFFFFFFFFFFA14LLU:
	22326	+case 0xFFFFFFFFFFFFFA08LLU:
22147	22327	/* SP = 18LLU /fputs("\n/ function requires ", stdout);
22148	22328	{
22149	22329	/* CALLBEGIN */

		@@ -22160,22 +22340,22 @@
22160	22340	{
22161	22341	/CALLEND/
22162	22342	stackbase += 23LLU;
22163		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA13LLU;
	22343	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA07LLU;
22164	22344	fnaddr = /SPMAX_GET_/0x4D03416001C55000LLU;/* SP = 0LLU */
22165	22345	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_GET_/\n"); exit(-1); }
22166	22346	break;
22167	22347	}
22168		-case 0xFFFFFFFFFFFFFA13LLU:
	22348	+case 0xFFFFFFFFFFFFFA07LLU:
22169	22349	/* SP = 21LLU */
22170	22350	{
22171	22351	/CALLEND/
22172	22352	stackbase += 20LLU;
22173		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA12LLU;
	22353	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA06LLU;
22174	22354	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
22175	22355	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
22176	22356	break;
22177	22357	}
22178		-case 0xFFFFFFFFFFFFFA12LLU:
	22358	+case 0xFFFFFFFFFFFFFA06LLU:
22179	22359	/* SP = 18LLU */fputs(" 64-bit chunks of memory (including ", stdout);
22180	22360	{
22181	22361	/* CALLBEGIN */

		@@ -22187,12 +22367,12 @@
22187	22367	{
22188	22368	/CALLEND/
22189	22369	stackbase += 20LLU;
22190		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA11LLU;
	22370	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA05LLU;
22191	22371	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
22192	22372	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
22193	22373	break;
22194	22374	}
22195		-case 0xFFFFFFFFFFFFFA11LLU:
	22375	+case 0xFFFFFFFFFFFFFA05LLU:
22196	22376	/* SP = 18LLU /fputs(" for parameters) /", stdout); /* predicate */
22197	22377
22198	22378	{

		@@ -22212,12 +22392,12 @@
22212	22392	{
22213	22393	/CALLEND/
22214	22394	stackbase += 24LLU;
22215		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0ELLU;
	22395	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA02LLU;
22216	22396	fnaddr = /neq_______/0xA60B000000000000LLU;/* SP = 0LLU */
22217	22397	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /neq_______/\n"); exit(-1); }
22218	22398	break;
22219	22399	}
22220		-case 0xFFFFFFFFFFFFFA0ELLU:
	22400	+case 0xFFFFFFFFFFFFFA02LLU:
22221	22401	/* SP = 22LLU */
22222	22402	{
22223	22403	/* CALLBEGIN */

		@@ -22235,35 +22415,35 @@
22235	22415	{
22236	22416	/CALLEND/
22237	22417	stackbase += 29LLU;
22238		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0DLLU;
	22418	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA01LLU;
22239	22419	fnaddr = /SPMAX_GET_/0x4D03416001C55000LLU;/* SP = 0LLU */
22240	22420	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_GET_/\n"); exit(-1); }
22241	22421	break;
22242	22422	}
22243		-case 0xFFFFFFFFFFFFFA0DLLU:
	22423	+case 0xFFFFFFFFFFFFFA01LLU:
22244	22424	/* SP = 27LLU */
22245	22425	{
22246	22426	/CALLEND/
22247	22427	stackbase += 25LLU;
22248		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0CLLU;
	22428	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFA00LLU;
22249	22429	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
22250	22430	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
22251	22431	break;
22252	22432	}
22253		-case 0xFFFFFFFFFFFFFA0CLLU:
	22433	+case 0xFFFFFFFFFFFFFA00LLU:
22254	22434	/* SP = 23LLU */
22255	22435	{
22256	22436	/CALLEND/
22257	22437	stackbase += 21LLU;
22258		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0BLLU;
	22438	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FFLLU;
22259	22439	fnaddr = /and_______/0x7297C00000000000LLU;/* SP = 0LLU */
22260	22440	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /and_______/\n"); exit(-1); }
22261	22441	break;
22262	22442	}
22263		-case 0xFFFFFFFFFFFFFA0BLLU:
	22443	+case 0xFFFFFFFFFFFFF9FFLLU:
22264	22444	/* SP = 19LLU */
22265	22445	if(!/* SP - 1LLU = 18LLU */stack[stackbase + 18LLU])
22266		-{ /* JUMP / fnaddr = 18446744073709550096LLU; break; } / skip consequent */
	22446	+{ /* JUMP / fnaddr = 18446744073709550084LLU; break; } / skip consequent */
22267	22447	/* consequent */
22268	22448	{
22269	22449	/* CALLBEGIN */

		@@ -22274,12 +22454,12 @@
22274	22454	{
22275	22455	/CALLEND/
22276	22456	stackbase += 20LLU;
22277		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA0ALLU;
	22457	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FELLU;
22278	22458	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
22279	22459	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
22280	22460	break;
22281	22461	}
22282		-case 0xFFFFFFFFFFFFFA0ALLU:
	22462	+case 0xFFFFFFFFFFFFF9FELLU:
22283	22463	/* SP = 18LLU */fputs("wrong size, function ", stderr);
22284	22464	{
22285	22465	/* CALLBEGIN */

		@@ -22291,12 +22471,12 @@
22291	22471	{
22292	22472	/CALLEND/
22293	22473	stackbase += 20LLU;
22294		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA09LLU;
	22474	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FDLLU;
22295	22475	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
22296	22476	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
22297	22477	break;
22298	22478	}
22299		-case 0xFFFFFFFFFFFFFA09LLU:
	22479	+case 0xFFFFFFFFFFFFF9FDLLU:
22300	22480	/* SP = 18LLU */fputs(" requires ", stderr);
22301	22481	{
22302	22482	/* CALLBEGIN */

		@@ -22313,25 +22493,25 @@
22313	22493	{
22314	22494	/CALLEND/
22315	22495	stackbase += 23LLU;
22316		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA08LLU;
	22496	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FCLLU;
22317	22497	fnaddr = /SPMAX_GET_/0x4D03416001C55000LLU;/* SP = 0LLU */
22318	22498	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_GET_/\n"); exit(-1); }
22319	22499	break;
22320	22500	}
22321		-case 0xFFFFFFFFFFFFFA08LLU:
	22501	+case 0xFFFFFFFFFFFFF9FCLLU:
22322	22502	/* SP = 21LLU */
22323	22503	{
22324	22504	/CALLEND/
22325	22505	stackbase += 20LLU;
22326		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA07LLU;
	22506	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FBLLU;
22327	22507	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
22328	22508	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
22329	22509	break;
22330	22510	}
22331		-case 0xFFFFFFFFFFFFFA07LLU:
	22511	+case 0xFFFFFFFFFFFFF9FBLLU:
22332	22512	/* SP = 18LLU /fputs(" 64-bit chunks\n", stderr); exit(-1);/ SP = 18LLU // SP = 18LLU */
22333		-{ /* JUMP / fnaddr = 18446744073709550095LLU; break; } / skip alternative */
22334		-case 18446744073709550096LLU: /* alternative // predicate */
	22513	+{ /* JUMP / fnaddr = 18446744073709550083LLU; break; } / skip alternative */
	22514	+case 18446744073709550084LLU: /* alternative // predicate */
22335	22515
22336	22516	{
22337	22517	/* CALLBEGIN */

		@@ -22349,25 +22529,25 @@
22349	22529	{
22350	22530	/CALLEND/
22351	22531	stackbase += 25LLU;
22352		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA04LLU;
	22532	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F8LLU;
22353	22533	fnaddr = /SPMAX_GET_/0x4D03416001C55000LLU;/* SP = 0LLU */
22354	22534	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_GET_/\n"); exit(-1); }
22355	22535	break;
22356	22536	}
22357		-case 0xFFFFFFFFFFFFFA04LLU:
	22537	+case 0xFFFFFFFFFFFFF9F8LLU:
22358	22538	/* SP = 23LLU */
22359	22539	{
22360	22540	/CALLEND/
22361	22541	stackbase += 21LLU;
22362		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA03LLU;
	22542	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F7LLU;
22363	22543	fnaddr = /gtr_______/0x8AFB400000000000LLU;/* SP = 0LLU */
22364	22544	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /gtr_______/\n"); exit(-1); }
22365	22545	break;
22366	22546	}
22367		-case 0xFFFFFFFFFFFFFA03LLU:
	22547	+case 0xFFFFFFFFFFFFF9F7LLU:
22368	22548	/* SP = 19LLU */
22369	22549	if(!/* SP - 1LLU = 18LLU */stack[stackbase + 18LLU])
22370		-{ /* JUMP / fnaddr = 18446744073709550086LLU; break; } / skip consequent */
	22550	+{ /* JUMP / fnaddr = 18446744073709550074LLU; break; } / skip consequent */
22371	22551	/* consequent */
22372	22552	{
22373	22553	/* CALLBEGIN */

		@@ -22378,12 +22558,12 @@
22378	22558	{
22379	22559	/CALLEND/
22380	22560	stackbase += 20LLU;
22381		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA02LLU;
	22561	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F6LLU;
22382	22562	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
22383	22563	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
22384	22564	break;
22385	22565	}
22386		-case 0xFFFFFFFFFFFFFA02LLU:
	22566	+case 0xFFFFFFFFFFFFF9F6LLU:
22387	22567	/* SP = 18LLU */fputs("size overestimated, function ", stderr);
22388	22568	{
22389	22569	/* CALLBEGIN */

		@@ -22395,12 +22575,12 @@
22395	22575	{
22396	22576	/CALLEND/
22397	22577	stackbase += 20LLU;
22398		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA01LLU;
	22578	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F5LLU;
22399	22579	fnaddr = /debugid___/0x7E07708A47C00000LLU;/* SP = 0LLU */
22400	22580	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugid___/\n"); exit(-1); }
22401	22581	break;
22402	22582	}
22403		-case 0xFFFFFFFFFFFFFA01LLU:
	22583	+case 0xFFFFFFFFFFFFF9F5LLU:
22404	22584	/* SP = 18LLU */fputs(" requires only ", stderr);
22405	22585	{
22406	22586	/* CALLBEGIN */

		@@ -22417,25 +22597,25 @@
22417	22597	{
22418	22598	/CALLEND/
22419	22599	stackbase += 23LLU;
22420		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFA00LLU;
	22600	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F4LLU;
22421	22601	fnaddr = /SPMAX_GET_/0x4D03416001C55000LLU;/* SP = 0LLU */
22422	22602	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_GET_/\n"); exit(-1); }
22423	22603	break;
22424	22604	}
22425		-case 0xFFFFFFFFFFFFFA00LLU:
	22605	+case 0xFFFFFFFFFFFFF9F4LLU:
22426	22606	/* SP = 21LLU */
22427	22607	{
22428	22608	/CALLEND/
22429	22609	stackbase += 20LLU;
22430		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FFLLU;
	22610	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F3LLU;
22431	22611	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
22432	22612	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
22433	22613	break;
22434	22614	}
22435		-case 0xFFFFFFFFFFFFF9FFLLU:
	22615	+case 0xFFFFFFFFFFFFF9F3LLU:
22436	22616	/* SP = 18LLU /fputs(" 64-bit chunks\n", stderr); / SP = 18LLU // SP = 18LLU */
22437		-{ /* JUMP / fnaddr = 18446744073709550085LLU; break; } / skip alternative */
22438		-case 18446744073709550086LLU: /* alternative */
	22617	+{ /* JUMP / fnaddr = 18446744073709550073LLU; break; } / skip alternative */
	22618	+case 18446744073709550074LLU: /* alternative */
22439	22619	{
22440	22620	/* CALLBEGIN */
22441	22621	/* reserve space for 1LLU returned values // SP + 1LLU = 19LLU */

		@@ -22445,19 +22625,19 @@
22445	22625	{
22446	22626	/CALLEND/
22447	22627	stackbase += 21LLU;
22448		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FELLU;
	22628	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F2LLU;
22449	22629	fnaddr = /SPMAX_GET_/0x4D03416001C55000LLU;/* SP = 0LLU */
22450	22630	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_GET_/\n"); exit(-1); }
22451	22631	break;
22452	22632	}
22453		-case 0xFFFFFFFFFFFFF9FELLU:
	22633	+case 0xFFFFFFFFFFFFF9F2LLU:
22454	22634	/* SP = 19LLU // SP = 18LLU */
22455	22635	{ /* assign / / LOCAL VAR / stack[stackbase + 9LLU] = / LOCAL VAR / stack[stackbase + 18LLU]; }/ SP = 18LLU */
22456		-case 18446744073709550085LLU: /* skip to here */
	22636	+case 18446744073709550073LLU: /* skip to here */
22457	22637
22458		-case 18446744073709550095LLU: /* skip to here */
	22638	+case 18446744073709550083LLU: /* skip to here */
22459	22639	/* SP = 18LLU */
22460		-case 18446744073709550121LLU: /* alternative */
	22640	+case 18446744073709550109LLU: /* alternative */
22461	22641	{
22462	22642	/* CALLBEGIN */
22463	22643	/* reserve space for 0LLU returned values // SP + 0LLU = 18LLU */

		@@ -22475,19 +22655,19 @@
22475	22655	{
22476	22656	/CALLEND/
22477	22657	stackbase += 20LLU;
22478		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FDLLU;
	22658	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F1LLU;
22479	22659	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
22480	22660	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
22481	22661	break;
22482	22662	}
22483		-case 0xFFFFFFFFFFFFF9FDLLU:
	22663	+case 0xFFFFFFFFFFFFF9F1LLU:
22484	22664	/* SP = 18LLU // SP = 18LLU */
22485		-case 18446744073709550133LLU: /* skip to here */
	22665	+case 18446744073709550121LLU: /* skip to here */
22486	22666	/* SP = 8LLU */
22487		-case 18446744073709550168LLU: /* skip to here */
	22667	+case 18446744073709550156LLU: /* skip to here */
22488	22668	/* SP = 8LLU // SP = 8LLU */
22489		-{ /* JUMP / fnaddr = 18446744073709550172LLU; break; } / skip alternative */
22490		-case 18446744073709550173LLU: /* alternative */
	22669	+{ /* JUMP / fnaddr = 18446744073709550160LLU; break; } / skip alternative */
	22670	+case 18446744073709550161LLU: /* alternative */
22491	22671	{
22492	22672	/* CALLBEGIN */
22493	22673	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -22497,16 +22677,16 @@
22497	22677	{
22498	22678	/CALLEND/
22499	22679	stackbase += 10LLU;
22500		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FCLLU;
	22680	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F0LLU;
22501	22681	fnaddr = /DEBUGLINE_/0x1050951CC24E1400LLU;/* SP = 0LLU */
22502	22682	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEBUGLINE_/\n"); exit(-1); }
22503	22683	break;
22504	22684	}
22505		-case 0xFFFFFFFFFFFFF9FCLLU:
	22685	+case 0xFFFFFFFFFFFFF9F0LLU:
22506	22686	/* SP = 8LLU /fputs("end-of-stream in function-definition\n", stderr); exit(-1);/ SP = 8LLU */
22507		-case 18446744073709550172LLU: /* skip to here */
	22687	+case 18446744073709550160LLU: /* skip to here */
22508	22688	/* SP = 8LLU */
22509		-case 18446744073709550240LLU: /* skip to here */
	22689	+case 18446744073709550228LLU: /* skip to here */
22510	22690	/* SP = 8LLU // SP - 0LLU = 8LLU */
22511	22691	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
22512	22692	/* function requires 38LLU 64-bit chunks of memory (including 8LLU for parameters) */

		@@ -22532,12 +22712,12 @@
22532	22712	{
22533	22713	/CALLEND/
22534	22714	stackbase += 3LLU;
22535		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FBLLU;
	22715	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EFLLU;
22536	22716	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
22537	22717	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
22538	22718	break;
22539	22719	}
22540		-case 0xFFFFFFFFFFFFF9FBLLU:
	22720	+case 0xFFFFFFFFFFFFF9EFLLU:
22541	22721	/* SP = 1LLU */
22542	22722	{
22543	22723	/* CALLBEGIN */

		@@ -22548,12 +22728,12 @@
22548	22728	{
22549	22729	/CALLEND/
22550	22730	stackbase += 4LLU;
22551		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9FALLU;
	22731	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EELLU;
22552	22732	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
22553	22733	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); }
22554	22734	break;
22555	22735	}
22556		-case 0xFFFFFFFFFFFFF9FALLU:
	22736	+case 0xFFFFFFFFFFFFF9EELLU:
22557	22737	/* SP = 2LLU */fputs("allocated ", stderr);
22558	22738	{
22559	22739	/* CALLBEGIN */

		@@ -22565,12 +22745,12 @@
22565	22745	{
22566	22746	/CALLEND/
22567	22747	stackbase += 4LLU;
22568		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F9LLU;
	22748	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EDLLU;
22569	22749	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
22570	22750	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
22571	22751	break;
22572	22752	}
22573		-case 0xFFFFFFFFFFFFF9F9LLU:
	22753	+case 0xFFFFFFFFFFFFF9EDLLU:
22574	22754	/* SP = 2LLU */fputs(" 64-bit words of memory\n", stderr); fputs("reserved ", stderr);
22575	22755	{
22576	22756	/* CALLBEGIN */

		@@ -22582,12 +22762,12 @@
22582	22762	{
22583	22763	/CALLEND/
22584	22764	stackbase += 4LLU;
22585		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F8LLU;
	22765	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9ECLLU;
22586	22766	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
22587	22767	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
22588	22768	break;
22589	22769	}
22590		-case 0xFFFFFFFFFFFFF9F8LLU:
	22770	+case 0xFFFFFFFFFFFFF9ECLLU:
22591	22771	/* SP = 2LLU /fputs(" global 64-bit words\n", stderr); / predicate */
22592	22772
22593	22773	{

		@@ -22608,25 +22788,25 @@
22608	22788	{
22609	22789	/CALLEND/
22610	22790	stackbase += 9LLU;
22611		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F5LLU;
	22791	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E9LLU;
22612	22792	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22613	22793	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22614	22794	break;
22615	22795	}
22616		-case 0xFFFFFFFFFFFFF9F5LLU:
	22796	+case 0xFFFFFFFFFFFFF9E9LLU:
22617	22797	/* SP = 7LLU */
22618	22798	{
22619	22799	/CALLEND/
22620	22800	stackbase += 5LLU;
22621		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F4LLU;
	22801	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E8LLU;
22622	22802	fnaddr = /lss_______/0x9EEB800000000000LLU;/* SP = 0LLU */
22623	22803	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /lss_______/\n"); exit(-1); }
22624	22804	break;
22625	22805	}
22626		-case 0xFFFFFFFFFFFFF9F4LLU:
	22806	+case 0xFFFFFFFFFFFFF9E8LLU:
22627	22807	/* SP = 3LLU */
22628	22808	if(!/* SP - 1LLU = 2LLU */stack[stackbase + 2LLU])
22629		-{ /* JUMP / fnaddr = 18446744073709550071LLU; break; } / skip consequent */
	22809	+{ /* JUMP / fnaddr = 18446744073709550059LLU; break; } / skip consequent */
22630	22810	/* consequent */fputs("not enough memory - need at least ", stderr);
22631	22811	{
22632	22812	/* CALLBEGIN */

		@@ -22645,25 +22825,25 @@
22645	22825	{
22646	22826	/CALLEND/
22647	22827	stackbase += 7LLU;
22648		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F3LLU;
	22828	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E7LLU;
22649	22829	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22650	22830	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22651	22831	break;
22652	22832	}
22653		-case 0xFFFFFFFFFFFFF9F3LLU:
	22833	+case 0xFFFFFFFFFFFFF9E7LLU:
22654	22834	/* SP = 5LLU */
22655	22835	{
22656	22836	/CALLEND/
22657	22837	stackbase += 4LLU;
22658		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F2LLU;
	22838	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E6LLU;
22659	22839	fnaddr = /debugnr___/0x7E07708A9B400000LLU;/* SP = 0LLU */
22660	22840	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /debugnr___/\n"); exit(-1); }
22661	22841	break;
22662	22842	}
22663		-case 0xFFFFFFFFFFFFF9F2LLU:
	22843	+case 0xFFFFFFFFFFFFF9E6LLU:
22664	22844	/* SP = 2LLU /fputs(" 64-bit chunks\n", stderr); exit(-1);/ SP = 2LLU // SP = 2LLU */
22665		-{ /* JUMP / fnaddr = 18446744073709550070LLU; break; } / skip alternative */
22666		-case 18446744073709550071LLU: /* alternative */
	22845	+{ /* JUMP / fnaddr = 18446744073709550058LLU; break; } / skip alternative */
	22846	+case 18446744073709550059LLU: /* alternative */
22667	22847	{
22668	22848	/* CALLBEGIN */
22669	22849	/* reserve space for 1LLU returned values // SP + 1LLU = 3LLU */

		@@ -22674,12 +22854,12 @@
22674	22854	{
22675	22855	/CALLEND/
22676	22856	stackbase += 5LLU;
22677		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F1LLU;
	22857	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E5LLU;
22678	22858	fnaddr = /GLOBMAXSET/0x1CC3C23416131540LLU;/* SP = 0LLU */
22679	22859	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXSET/\n"); exit(-1); }
22680	22860	break;
22681	22861	}
22682		-case 0xFFFFFFFFFFFFF9F1LLU:
	22862	+case 0xFFFFFFFFFFFFF9E5LLU:
22683	22863	/* SP = 3LLU /(void)/ SP - 1LLU = 2LLU /stack[stackbase + 2LLU]; / POP */
22684	22864
22685	22865	{

		@@ -22692,12 +22872,12 @@
22692	22872	{
22693	22873	/CALLEND/
22694	22874	stackbase += 5LLU;
22695		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9F0LLU;
	22875	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E4LLU;
22696	22876	fnaddr = /ADDRINIT__/0x4411224E2540000LLU;/* SP = 0LLU */
22697	22877	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRINIT__/\n"); exit(-1); }
22698	22878	break;
22699	22879	}
22700		-case 0xFFFFFFFFFFFFF9F0LLU:
	22880	+case 0xFFFFFFFFFFFFF9E4LLU:
22701	22881	/* SP = 3LLU /(void)/ SP - 1LLU = 2LLU /stack[stackbase + 2LLU]; / POP */
22702	22882
22703	22883	{

		@@ -22710,12 +22890,12 @@
22710	22890	{
22711	22891	/CALLEND/
22712	22892	stackbase += 5LLU;
22713		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EFLLU;
	22893	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E3LLU;
22714	22894	fnaddr = /MEMSIZESET/0x34535325A1531540LLU;/* SP = 0LLU */
22715	22895	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /MEMSIZESET/\n"); exit(-1); }
22716	22896	break;
22717	22897	}
22718		-case 0xFFFFFFFFFFFFF9EFLLU:
	22898	+case 0xFFFFFFFFFFFFF9E3LLU:
22719	22899	/* SP = 3LLU /(void)/ SP - 1LLU = 2LLU /stack[stackbase + 2LLU]; / POP */
22720	22900	fputs("#include <ctype.h>\n", stdout); fputs("#include <stdbool.h>\n", stdout); fputs("#include <stdint.h>\n", stdout); fputs("#include <stdio.h>\n", stdout); fputs("#include <stdlib.h>\n", stdout); fputs("#include <string.h>\n", stdout); fputs("\n", stdout); fputs("/* NOTE: multiple return-values accessed in REVERSE order! /\n", stdout); fputs("#define ACCESS_VAR(var_nr) stack[stackbase + var_nr]\n", stdout); fputs("\n", stdout); fputs("int32_t main()\n", stdout); fputs("{\n", stdout); fputs(" uint64_t stack = malloc(8 * ", stdout);
22721	22901	{

		@@ -22728,12 +22908,12 @@
22728	22908	{
22729	22909	/CALLEND/
22730	22910	stackbase += 4LLU;
22731		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EELLU;
	22911	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E2LLU;
22732	22912	fnaddr = /printhexnr/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
22733	22913	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printhexnr/\n"); exit(-1); }
22734	22914	break;
22735	22915	}
22736		-case 0xFFFFFFFFFFFFF9EELLU:
	22916	+case 0xFFFFFFFFFFFFF9E2LLU:
22737	22917	/* SP = 2LLU */fputs(");\n", stdout); fputs(" register uint64_t stackbase = ", stdout);
22738	22918	{
22739	22919	/* CALLBEGIN */

		@@ -22757,32 +22937,32 @@
22757	22937	{
22758	22938	/CALLEND/
22759	22939	stackbase += 11LLU;
22760		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EDLLU;
	22940	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E1LLU;
22761	22941	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
22762	22942	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
22763	22943	break;
22764	22944	}
22765		-case 0xFFFFFFFFFFFFF9EDLLU:
	22945	+case 0xFFFFFFFFFFFFF9E1LLU:
22766	22946	/* SP = 9LLU */
22767	22947	{
22768	22948	/CALLEND/
22769	22949	stackbase += 7LLU;
22770		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9ECLLU;
	22950	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E0LLU;
22771	22951	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22772	22952	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22773	22953	break;
22774	22954	}
22775		-case 0xFFFFFFFFFFFFF9ECLLU:
	22955	+case 0xFFFFFFFFFFFFF9E0LLU:
22776	22956	/* SP = 5LLU */
22777	22957	{
22778	22958	/CALLEND/
22779	22959	stackbase += 4LLU;
22780		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EBLLU;
	22960	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DFLLU;
22781	22961	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
22782	22962	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
22783	22963	break;
22784	22964	}
22785		-case 0xFFFFFFFFFFFFF9EBLLU:
	22965	+case 0xFFFFFFFFFFFFF9DFLLU:
22786	22966	/* SP = 2LLU /fputs("; / skip space reserved for globals, return-value & dummy stack-base & dummy return-addr /\n", stdout); fputs(" / prepare call to main /\n", stdout); fputs(" / at ", stdout);
22787	22967	{
22788	22968	/* CALLBEGIN */

		@@ -22806,32 +22986,32 @@
22806	22986	{
22807	22987	/CALLEND/
22808	22988	stackbase += 11LLU;
22809		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9EALLU;
	22989	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DELLU;
22810	22990	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
22811	22991	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
22812	22992	break;
22813	22993	}
22814		-case 0xFFFFFFFFFFFFF9EALLU:
	22994	+case 0xFFFFFFFFFFFFF9DELLU:
22815	22995	/* SP = 9LLU */
22816	22996	{
22817	22997	/CALLEND/
22818	22998	stackbase += 7LLU;
22819		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E9LLU;
	22999	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DDLLU;
22820	23000	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22821	23001	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22822	23002	break;
22823	23003	}
22824		-case 0xFFFFFFFFFFFFF9E9LLU:
	23004	+case 0xFFFFFFFFFFFFF9DDLLU:
22825	23005	/* SP = 5LLU */
22826	23006	{
22827	23007	/CALLEND/
22828	23008	stackbase += 4LLU;
22829		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E8LLU;
	23009	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DCLLU;
22830	23010	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
22831	23011	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
22832	23012	break;
22833	23013	}
22834		-case 0xFFFFFFFFFFFFF9E8LLU:
	23014	+case 0xFFFFFFFFFFFFF9DCLLU:
22835	23015	/* SP = 2LLU /fputs(" space for result returned by main /\n", stdout); fputs(" stack[", stdout);
22836	23016	{
22837	23017	/* CALLBEGIN */

		@@ -22855,32 +23035,32 @@
22855	23035	{
22856	23036	/CALLEND/
22857	23037	stackbase += 11LLU;
22858		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E7LLU;
	23038	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DBLLU;
22859	23039	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
22860	23040	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
22861	23041	break;
22862	23042	}
22863		-case 0xFFFFFFFFFFFFF9E7LLU:
	23043	+case 0xFFFFFFFFFFFFF9DBLLU:
22864	23044	/* SP = 9LLU */
22865	23045	{
22866	23046	/CALLEND/
22867	23047	stackbase += 7LLU;
22868		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E6LLU;
	23048	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DALLU;
22869	23049	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22870	23050	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22871	23051	break;
22872	23052	}
22873		-case 0xFFFFFFFFFFFFF9E6LLU:
	23053	+case 0xFFFFFFFFFFFFF9DALLU:
22874	23054	/* SP = 5LLU */
22875	23055	{
22876	23056	/CALLEND/
22877	23057	stackbase += 4LLU;
22878		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E5LLU;
	23058	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D9LLU;
22879	23059	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
22880	23060	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
22881	23061	break;
22882	23062	}
22883		-case 0xFFFFFFFFFFFFF9E5LLU:
	23063	+case 0xFFFFFFFFFFFFF9D9LLU:
22884	23064	/* SP = 2LLU */fputs("] = ", stdout);
22885	23065	{
22886	23066	/* CALLBEGIN */

		@@ -22897,22 +23077,22 @@
22897	23077	{
22898	23078	/CALLEND/
22899	23079	stackbase += 7LLU;
22900		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E4LLU;
	23080	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D8LLU;
22901	23081	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
22902	23082	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
22903	23083	break;
22904	23084	}
22905		-case 0xFFFFFFFFFFFFF9E4LLU:
	23085	+case 0xFFFFFFFFFFFFF9D8LLU:
22906	23086	/* SP = 5LLU */
22907	23087	{
22908	23088	/CALLEND/
22909	23089	stackbase += 4LLU;
22910		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E3LLU;
	23090	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D7LLU;
22911	23091	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
22912	23092	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
22913	23093	break;
22914	23094	}
22915		-case 0xFFFFFFFFFFFFF9E3LLU:
	23095	+case 0xFFFFFFFFFFFFF9D7LLU:
22916	23096	/* SP = 2LLU /fputs("; / reset stack-base on return from main */\n", stdout); fputs(" stack[", stdout);
22917	23097	{
22918	23098	/* CALLBEGIN */

		@@ -22936,32 +23116,32 @@
22936	23116	{
22937	23117	/CALLEND/
22938	23118	stackbase += 11LLU;
22939		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E2LLU;
	23119	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D6LLU;
22940	23120	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
22941	23121	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
22942	23122	break;
22943	23123	}
22944		-case 0xFFFFFFFFFFFFF9E2LLU:
	23124	+case 0xFFFFFFFFFFFFF9D6LLU:
22945	23125	/* SP = 9LLU */
22946	23126	{
22947	23127	/CALLEND/
22948	23128	stackbase += 7LLU;
22949		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E1LLU;
	23129	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D5LLU;
22950	23130	fnaddr = /add_______/0x71F7C00000000000LLU;/* SP = 0LLU */
22951	23131	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /add_______/\n"); exit(-1); }
22952	23132	break;
22953	23133	}
22954		-case 0xFFFFFFFFFFFFF9E1LLU:
	23134	+case 0xFFFFFFFFFFFFF9D5LLU:
22955	23135	/* SP = 5LLU */
22956	23136	{
22957	23137	/CALLEND/
22958	23138	stackbase += 4LLU;
22959		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9E0LLU;
	23139	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D4LLU;
22960	23140	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
22961	23141	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
22962	23142	break;
22963	23143	}
22964		-case 0xFFFFFFFFFFFFF9E0LLU:
	23144	+case 0xFFFFFFFFFFFFF9D4LLU:
22965	23145	/* SP = 2LLU /fputs("] = 0; / clear function-addr on return from main /\n", stdout); fputs(" register uint64_t fnaddr = 0; / start-addr: verifies stack-space & jumps into main - NOTE: jumping to 0 at any other point in the program terminates it! */\n", stdout);
22966	23146	{
22967	23147	/* CALLBEGIN */

		@@ -22973,14 +23153,14 @@
22973	23153	{
22974	23154	/CALLEND/
22975	23155	stackbase += 4LLU;
22976		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DFLLU;
	23156	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D3LLU;
22977	23157	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
22978	23158	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); }
22979	23159	break;
22980	23160	}
22981		-case 0xFFFFFFFFFFFFF9DFLLU:
	23161	+case 0xFFFFFFFFFFFFF9D3LLU:
22982	23162	/* SP = 2LLU /fputs("\n", stdout); fputs(" do\n", stdout); fputs(" {\n", stdout); fputs(" switch(fnaddr)\n", stdout); fputs(" {\n", stdout); / SP = 2LLU */
22983		-case 18446744073709550070LLU: /* skip to here */
	23163	+case 18446744073709550058LLU: /* skip to here */
22984	23164	/* SP = 0LLU // SP - 0LLU = 0LLU */
22985	23165	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
22986	23166	/* function requires 11LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -23000,22 +23180,22 @@
23000	23180	{
23001	23181	/CALLEND/
23002	23182	stackbase += 5LLU;
23003		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DELLU;
	23183	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D2LLU;
23004	23184	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
23005	23185	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); }
23006	23186	break;
23007	23187	}
23008		-case 0xFFFFFFFFFFFFF9DELLU:
	23188	+case 0xFFFFFFFFFFFFF9D2LLU:
23009	23189	/* SP = 3LLU */
23010	23190	{
23011	23191	/CALLEND/
23012	23192	stackbase += 2LLU;
23013		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DDLLU;
	23193	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D1LLU;
23014	23194	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
23015	23195	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); }
23016	23196	break;
23017	23197	}
23018		-case 0xFFFFFFFFFFFFF9DDLLU:
	23198	+case 0xFFFFFFFFFFFFF9D1LLU:
23019	23199	/* SP = 0LLU /fputs("];\n", stdout); fputs("\n", stdout); fputs(" free(stack);\n", stdout); fputs("\n", stdout); fputs(" return result;\n", stdout); fputs("}\n", stdout); fputs("\n", stdout); / SP = 0LLU // SP - 0LLU = 0LLU */
23020	23200	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
23021	23201	/* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -23029,12 +23209,12 @@
23029	23209	{
23030	23210	/CALLEND/
23031	23211	stackbase += 2LLU;
23032		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DCLLU;
	23212	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9D0LLU;
23033	23213	fnaddr = /prologue__/0xAEDAA7AA2C200000LLU;/* SP = 0LLU */
23034	23214	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /prologue__/\n"); exit(-1); }
23035	23215	break;
23036	23216	}
23037		-case 0xFFFFFFFFFFFFF9DCLLU:
	23217	+case 0xFFFFFFFFFFFFF9D0LLU:
23038	23218	/* SP = 0LLU */
23039	23219	{
23040	23220	/* CALLBEGIN */

		@@ -23053,12 +23233,12 @@
23053	23233	{
23054	23234	/CALLEND/
23055	23235	stackbase += 2LLU;
23056		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DBLLU;
	23236	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9CFLLU;
23057	23237	fnaddr = /parsedefs_/0xADCB6E81F821B800LLU;/* SP = 0LLU */
23058	23238	if(stackbase + 38LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsedefs_/\n"); exit(-1); }
23059	23239	break;
23060	23240	}
23061		-case 0xFFFFFFFFFFFFF9DBLLU:
	23241	+case 0xFFFFFFFFFFFFF9CFLLU:
23062	23242	/* SP = 0LLU */
23063	23243	{
23064	23244	/* CALLBEGIN */

		@@ -23069,12 +23249,12 @@
23069	23249	{
23070	23250	/CALLEND/
23071	23251	stackbase += 2LLU;
23072		- stack[stackbase - 1] = 0xFFFFFFFFFFFFF9DALLU;
	23252	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFF9CELLU;
23073	23253	fnaddr = /epilogue__/0x82B927AA2C200000LLU;/* SP = 0LLU */
23074	23254	if(stackbase + 0LLU >= 0x100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /epilogue__/\n"); exit(-1); }
23075	23255	break;
23076	23256	}
23077		-case 0xFFFFFFFFFFFFF9DALLU:
	23257	+case 0xFFFFFFFFFFFFF9CELLU:
23078	23258	/* SP = 0LLU */
23079	23259	{ /* PUSH / stack[stackbase + 0LLU] = 0LLU; }/ SP + 1LLU = 1LLU // SP - 1LLU = 0LLU */
23080	23260	{ /* RESULT // LOCAL VAR / stack[stackbase + 0LLU] = / LOCAL VAR / stack[stackbase + 0LLU]; }/ SP = 1LLU // SP - 1LLU = 0LLU */

--- trunk/experimental/compiler.source.c (revision 242)

+++ trunk/experimental/compiler.source.c (revision 243)

		@@ -2062,12 +2062,27 @@
2062	2062
2063	2063	skipcmnts()
2064	2064	parsestep(0/parseexpr/, deflist, newvarlist, parseid(), /blk/retype, /blk/0/dummy_addr/)
2065		- SP_SET(dataoffset) // make data inaccessible (remove data from stack)
	2065	+
	2066	+
	2067	+ // SAFE BUT SLOW: COPY RESULT (if any)
	2068	+ let u64 size = typesize(deflist, retype)
	2069	+ SP_SUB(size)
	2070	+ let u64 n = 0
	2071	+ while lss(n, size) // copy result - NOTE: copy from low to high indices to prevent copied values overwriting source-values before copy!
	2072	+ {
	2073	+ print "\n{ /* MATCH-RESULT */" ACCESSVAR(add(dataoffset, n)) print " = " ACCESSVAR(add(SP_GET(), n)) print "; }"
	2074	+ n = add(n, 1)
	2075	+ }
	2076	+
	2077	+ SP_SET(add(dataoffset, size)) // make data inaccessible (overwrite/remove data from stack)
	2078	+
	2079	+
2066	2080	JUMP(addr) print " /* skip other */"
2067	2081	print "\ncase " printnr(add(addr, 1)) print ": /* other */"
2068	2082	skipcmnts()
2069	2083	if matchoptid(12319843844370726912) then // other
2070	2084	{
	2085	+ SP_SET(dataoffset) // reset for result of THIS "other" branch
2071	2086	skipcmnts()
2072	2087	parsestep(0/parseexpr/, deflist, varlist, parseid(), /blk/retype, /blk/0/dummy_addr/)
2073	2088	print "\ncase " printnr(addr) print ": /* skip to here */\n"

		@@ -2453,7 +2468,7 @@
2453	2468	n = add(n, 1)
2454	2469	}
2455	2470
2456		- SP_SET(add(blockbase, typesize(deflist, retype)))
	2471	+ SP_SET(add(blockbase, size))
2457	2472
2458	2473	skipcmnts()
2459	2474	when not(matchopt(125)) // '}'

--- trunk/experimental/unit_tests/unit_test_list_head_union.c (revision 242)

+++ trunk/experimental/unit_tests/unit_test_list_head_union.c (revision 243)

		@@ -46,6 +46,30 @@
46	46	}
47	47	}
48	48
	49	+alpha incalpha(data alpha var)
	50	+{
	51	+==4==
	52	+ result
	53	+ match beta var as b:
	54	+ {
	55	+ result union beta(add(3, b.x), add(3, b.y), add(3, b.z))
	56	+ }
	57	+ other match gamma var as g:
	58	+ {
	59	+ result union gamma(add(3, g.a))
	60	+ }
	61	+ other match delta var as d:
	62	+ {
	63	+ result union delta(add(3, d.u), add(3, d.v))
	64	+ }
	65	+ other
	66	+ {
	67	+ print "UNKNOWN CONSTRUCTOR - THIS SHOULD NOT HAPPEN!\n"
	68	+ `exit(-1);`
	69	+ result union gamma(12345)
	70	+ }
	71	+}
	72	+
49	73	struct vec3(u64 x, u64 y, u64 z)
50	74
51	75	unit printvec3(vec3 var)

		@@ -86,12 +110,26 @@
86	110	==18== // verify PADDING: even though variants have different sizes union must always occupy MAX to allow assignment without stack-corruption!
87	111	for_list list2
88	112	{
	113	+==18==
	114	+ print "===============\n"
	115	+==18==
89	116	let data alpha var = (list2.head)
	117	+==22==
90	118	test(list2.head)
	119	+==22==
	120	+ //test(incalpha(list2.head))
	121	+ list2.head = incalpha(list2.head)
	122	+==22==
	123	+ test(list2.head)
	124	+==22==
91	125	list2.head = union beta(57, 56, 55) // verify PADDING: if missing, assigning a larger variant to a smaller one corrupts the stack!
	126	+==22==
92	127	test(list2.head)
	128	+==22==
93	129	}
	130	+==18==
94	131	}
	132	+==0==
95	133
96	134	result 0
97	135	}

--- trunk/experimental/unit_tests/unit_test_list_head_union.txt (revision 242)

+++ trunk/experimental/unit_tests/unit_test_list_head_union.txt (revision 243)

		@@ -4,9 +4,15 @@
4	4	(D,E,F)
5	5	(0,1,2)
6	6	(3,4,5)
	7	+===============
7	8	delta: AB
	9	+delta: DE
8	10	beta: 987
	11	+===============
9	12	gamma: *
	13	+gamma: -
10	14	beta: 987
	15	+===============
11	16	beta: abc
	17	+beta: def
12	18	beta: 987

旧リポジトリブラウザで表示